Living Off the Land
LOLBAS Findings: Six Signed Microsoft Binaries That Proxy Execution
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.exestarted by a parent other than Visual Studio, such as a shell or script host./WriteDynamicConfigData, especially with/WriteProjectDataand a fresh database or project path in a user-writable directory.- Project content containing
UsingTask,CodeTaskFactory,RoslynCodeTaskFactory, orExecinside a design-time target name. Inspect content, not just.vcxprojfiles. - 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.exewith-expdllon its command line.- DLL loads by
dxcap.exefrom user-writable, temporary, download, archive, or network paths. - A module load followed by the missing-
ListExperimentserror 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
/ior/complistpaths under user-writable, temporary, or download locations.- Unsigned or user-writable assemblies loaded into
lc.exe. lc.exestarted 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.exewith/WTT, especially outside a WDK validation or build process tree, or under an interactive, Office, browser, or script-host parent.infgate.exeloadingMicrosoft.Wtt.Log.dllfrom its working directory or anywhere outside Windows Kits, TAEF, or GAC locations.- A loaded
Microsoft.Wtt.Log.dllthat is unsigned, has a non-Microsoft signer, lacks the strong-name token399d95e6b32b7391, or has a different internal assembly name. - An
infgate.exeenvironment whosewindirdiffers 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.execommand lines containing-PidNewProcess.- Unexpected children of
xperf.exe, especially from user-writable paths. xperf.exestarted 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
UsingTaskand 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.