Living Off the Land

LOLBAS Findings: Six Signed Microsoft Binaries That Proxy Execution

By

A Microsoft signature buys a lot of trust. Application-control policies allow it, analysts skim past it in a process tree, and the binary is often already installed wherever developers or administrators work. When one of those binaries can be steered into running code the caller supplies, it becomes a way to execute that code under a trusted name.

This article covers six such binaries that I found and submitted to the LOLBAS Project. Five are new to the catalog; the sixth, Dxcap.exe, is already listed, and the finding adds a new technique to its entry. For each one I describe what the binary is for, how the technique works, what a defender can detect, and what the technique does not do. Full validation evidence and benign proofs of concept are in my lolbas-findings repository.

What LOLBAS Tracks

LOLBAS (Living Off The Land Binaries, Scripts and Libraries) catalogs Microsoft-signed files with functionality an attacker can misuse: executing code, downloading files, bypassing application allowlisting, and similar. Each entry documents the binary, the command line, the ATT&CK technique it maps to, and detection guidance. Red teams use the catalog to plan, and blue teams use it to decide what to monitor, which is why detection guidance is part of every finding here.

How Each Finding Was Validated

Every finding was checked against the same standard before submission:

  • Identity: installed path, file and product version, SHA-256, signer, and Windows build.
  • Context: run as a standard user at medium integrity, from the binary's installed location.
  • Benign proof: a source-available payload that only shows a message box or writes a marker file, with no persistence, credential access, networking, or destructive action.
  • Execution path: the observed route from command-line input to code execution.
  • Detection and limits: the telemetry a defender can use, and what the technique does not achieve.

None of these findings cross a privilege boundary, and none is a universal application-control bypass: application-control products may still evaluate and block the module or assembly being loaded.

At a Glance

Binary Ships with Technique Code runs LOLBAS PR
VcxprojReader.exe Visual Studio 2022 MSBuild inline task In-process #542
NuGet.Build.Tasks.Console.exe Visual Studio 2022 MSBuild inline task In-process #543
Dxcap.exe -expdll Windows (System32) Caller-selected DLL load In-process #544
Lc.exe Windows SDK (.NET 4.8.1 tools) Assembly load and component instantiation In-process #545
Infgate.exe /WTT Windows Driver Kit Bare-name assembly load from the working directory In-process #548
Xperf.exe -PidNewProcess Windows Performance Toolkit Child launched before ETW setup fails Child process #546

VcxprojReader.exe

VcxprojReader.exe is the Visual Studio C++ design-time project reader. It evaluates an MSBuild project and invokes a fixed set of design-time targets, such as GetProjectDirectories and GetClCommandLines, to collect project data for the IDE.

Because the project file is caller-controlled, those target names can be redefined. A redefined target can run inline C# through CodeTaskFactory inside the signed process, or start a child with Exec. The input does not need a .vcxproj extension: the same XML executed under other extensions and with no extension, and an input still carrying Internet-zone Mark-of-the-Web executed on the command-line path.

"C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\VcxprojReader.exe" "/DataBase:%TEMP%\VcxprojReader-%RANDOM%.db" /WriteProjectData /WriteDynamicConfigData "/p:Configuration=Debug;Platform=x64" "<path-to-project>"

Detection opportunities

  • VcxprojReader.exe started by a parent other than Visual Studio, such as a shell or script host.
  • /WriteDynamicConfigData, especially with /WriteProjectData and a fresh database or project path in a user-writable directory.
  • Project content containing UsingTask, CodeTaskFactory, RoslynCodeTaskFactory, or Exec inside a design-time target name. Inspect content, not just .vcxproj files.
  • Child processes, network activity, or file writes outside normal Visual Studio project-cache locations.

Limits: same-user execution at medium integrity; no elevation or privilege boundary crossing was observed.

NuGet.Build.Tasks.Console.exe

NuGet.Build.Tasks.Console.exe is the NuGet static-graph restore console that ships with Visual Studio. It loads a project with MSBuild and builds the _CollectRestoreInputs target to gather restore inputs.

A caller-supplied project can define _CollectRestoreInputs, or attach a target to it with BeforeTargets, and run inline C# through RoslynCodeTaskFactory or CodeTaskFactory inside the signed host. An external unsigned task assembly and Exec also worked. The same XML executed under nine different file extensions and none, so this is extension-independent MSBuild parsing.

"C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\CommonExtensions\Microsoft\NuGet\NuGet.Build.Tasks.Console.exe" "RestoreRecursive=false" "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" "<path-to-project>" "TargetFramework=net472"

A minimal project fails later in restore and the process exits with code 1, but only after the inline task has already run.

Detection opportunities

  • Launches outside an expected Visual Studio, MSBuild, or NuGet restore process chain.
  • Entry projects or global properties sourced from user-writable directories.
  • Project content containing _CollectRestoreInputs, _IsProjectRestoreSupported, UsingTask, or inline task factories.
  • Roslyn compiler or generated task assemblies loaded into the host.
  • Unexpected child processes. Do not require a successful exit code: execution happens before the failure.

Limits: same-user execution at medium integrity.

Dxcap.exe -expdll

Dxcap.exe is the DirectX diagnostic capture tool in System32. LOLBAS already lists it for its -c option, which launches an executable. This finding is a separate technique: an undocumented -expdll option that loads a caller-selected DLL.

Static analysis shows the option's value going straight to LoadLibraryExW, and only afterwards, with -explist, does Dxcap look up the ListExperiments export it expects. A DLL's entry point runs during the load, so the DLL needs no Dxcap-specific export for its code to execute inside the signed host. The payload-free check below loads a signed system DLL and produces the expected post-load error:

& C:\Windows\System32\dxcap.exe -measure -expdll C:\Windows\System32\version.dll -explist
The specified experiment DLL (C:\Windows\System32\version.dll) does not export
the ListExperiments entry point.

With an unsigned test DLL from an arbitrary directory, the DLL's DllMain ran first and the same missing-export error followed, confirming the order: load, execute, then fail.

Detection opportunities

  • dxcap.exe with -expdll on its command line.
  • DLL loads by dxcap.exe from user-writable, temporary, download, archive, or network paths.
  • A module load followed by the missing-ListExperiments error or a nonzero exit.
  • Keep existing coverage for dxcap.exe -c; it is a separate technique.

Limits: application control may still evaluate and block the DLL load; this is not a universal WDAC, AppLocker DLL-rule, or Smart App Control bypass.

Lc.exe (License Compiler)

lc.exe is the .NET Framework License Compiler from the Windows SDK. It reads a .licx file listing licensed components, loads the assemblies passed with /i, and instantiates each component to generate license resources.

Instantiating a component runs its constructor, so an unsigned assembly supplied through /i gets its code executed inside lc.exe while the host stays in its installed SDK directory. Validation used an assembly compiled into a user-writable temporary directory; no relocation, elevation, or child process was needed.

"C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8.1 Tools\lc.exe" /nologo /target:fake.exe /complist:"<path-to-licx>" /outdir:"<output-dir>" /i:"<path-to-assembly>"

Detection opportunities

  • /i or /complist paths under user-writable, temporary, or download locations.
  • Unsigned or user-writable assemblies loaded into lc.exe.
  • lc.exe started by an interactive or non-build parent, or producing unexpected child or network activity.

Limits: application control may still evaluate and block the assembly load.

Infgate.exe /WTT

infgate.exe is a Windows Driver Kit tool that checks printer INF files for conformance. Its /WTT option enables logging through Microsoft.Wtt.Log.dll, which it loads with Assembly.LoadFrom by bare name. On a default install, where the expected GAC directory is absent, that name resolves from the current working directory.

An unsigned assembly named Microsoft.Wtt.Log.dll in the working directory is loaded, and its TestLogger constructor runs inside the signed host. Infgate checks only the file version, not the assembly name, strong name, or Authenticode signature; validation succeeded with an assembly whose internal identity was unrelated. Because the code runs in-process rather than as a child, this also bypasses AppLocker when DLL rules are not enabled.

cd /d "<directory containing Microsoft.Wtt.Log.dll>"
"C:\Program Files (x86)\Windows Kits\10\Tools\10.0.26100.0\x64\infgate.exe" "<path-to-inf>" /WTT "/O=<fresh-output-dir>"

Infgate then reports that Microsoft.Wtt.Log.dll was not found or failed to load, because a minimal assembly lacks the rest of the logging API. That message appears after the constructor has run. A Mark-of-the-Web Zone.Identifier stream on the DLL blocked the load during testing.

Detection opportunities

  • infgate.exe with /WTT, especially outside a WDK validation or build process tree, or under an interactive, Office, browser, or script-host parent.
  • infgate.exe loading Microsoft.Wtt.Log.dll from its working directory or anywhere outside Windows Kits, TAEF, or GAC locations.
  • A loaded Microsoft.Wtt.Log.dll that is unsigned, has a non-Microsoft signer, lacks the strong-name token 399d95e6b32b7391, or has a different internal assembly name.
  • An infgate.exe environment whose windir differs from the real Windows directory, an alternate placement path.

Limits: same-user, same-token execution; application control with DLL rules enabled may still block the load.

Xperf.exe -PidNewProcess

xperf.exe is the Windows Performance Toolkit trace controller. Its documented -PidNewProcess option starts a process to trace. The finding is about ordering: Xperf starts the child before it creates the private ETW logger, so when a standard user lacks the rights to create that logger, the child has already run by the time Xperf fails with access denied (0x80070005).

"C:\Program Files (x86)\Windows Kits\10\Windows Performance Toolkit\xperf.exe" -start XperfValidation -heap -PidNewProcess "<path-to-executable>" -WaitForNewProcess

Detection opportunities

  • xperf.exe command lines containing -PidNewProcess.
  • Unexpected children of xperf.exe, especially from user-writable paths.
  • xperf.exe started by an interactive or non-diagnostic parent.

Limits: this is parent-process proxy execution, not an application-control bypass. Policy still applies to the child, and starting a process is an intended option, so the value is in the misleading parent and the failed-but-executed ordering.

Detection Summary

The six findings share patterns, and so do the detections that catch them:

  • Know where developer tooling lives. Five of the six ship with Visual Studio, the Windows SDK, the WDK, or the Windows Performance Toolkit. On endpoints that should not have those installed, any execution of these binaries is worth an alert.
  • Watch parent processes. Each binary has a normal parent: the IDE, MSBuild, or a build or diagnostic pipeline. A shell, script host, Office application, or browser as the parent is the strongest single signal.
  • Watch what gets loaded in-process. Four techniques run code inside the signed host. Image-load telemetry for unsigned or user-writable DLLs and assemblies loaded into these binaries catches them regardless of command line.
  • Inspect MSBuild content, not file extensions. Both MSBuild-based findings accept any extension. Look for UsingTask and inline task factories in files these hosts read.
  • Do not trust exit codes. Several hosts fail or report an error after the payload runs. A failed or nonzero process is not evidence that nothing executed.
Binary Command-line signal Process or image-load signal
VcxprojReader.exe /WriteDynamicConfigData with user-writable paths Non-Visual Studio parent; children from the host
NuGet.Build.Tasks.Console.exe Project path in a user-writable directory Roslyn or generated task assemblies loaded; unexpected children
Dxcap.exe -expdll DLL loaded from a user-writable or network path
Lc.exe /i or /complist in user-writable paths Unsigned assembly loaded into lc.exe
Infgate.exe /WTT Microsoft.Wtt.Log.dll loaded from the working directory, unsigned or without the expected strong name
Xperf.exe -PidNewProcess Unexpected child of xperf.exe

Submission Status

As of November 18, 2026, all six pull requests to the LOLBAS Project are open and under review: #542, #543, #544, #545, #546, and #548. I will update this article as they are reviewed.

The validation details, benign proof-of-concept source, and proposed catalog entries for each finding are in the lolbas-findings repository, and a summary lives on the LOLBAS Findings project page.