Awesome

inject-assembly - Execute .NET in an Existing Process

This tool is an alternative to traditional fork and run execution for Cobalt Strike. The loader can be injected into any process, including the current Beacon. Long-running assemblies will continue to run and send output back to the Beacon, similar to the behavior of execute-assembly.

There are two components of inject-assembly:

1. BOF initializer: A small program responsible for injecting the assembly loader into a remote process with any arguments passed. It uses BeaconInjectProcess to perform the injection, meaning this behavior can be customized in a Malleable C2 profile or with process injection BOFs (as of version 4.5).

2. PIC assembly loader: The bulk of the project. The loader will initialize the .NET runtime, load the provided assembly, and execute the assembly. The loader will create a new AppDomain in the target process so that the loaded assembly can be totally unloaded when execution is complete.

Communication between the remote process and Beacon occurs through a named pipe. The Aggressor script generates a pipe name and then passes it to the BOF initializer.

Notable Features

• Patches Environment.Exit() to prevent the remote process from exiting.
• .NET assembly header stomping (MZ bytes, e_lfanew, DOS Header, Rich Text, PE Header).
• Random pipe name generation based on SourcePoint.
• No blocking of the Beacon, even if the assembly is loaded into the current process.

Usage

Download and load the inject-assembly.cna Aggressor script into Cobalt Strike. You can then execute assemblies using the following command:

inject-assembly pid assembly [args...]

Specify 0 as the PID to execute in the current Beacon process.

It is recommended to use another tool, like FindObjects-BOF, to locate a process that already loads the .NET runtime, but this is not a requirement for inject-assembly to function.

Warnings

• Currently only supports x64 remote processes.
• There are several checks throughout the program to reduce the likelihood of crashing the remote process, but it could still happen.
• The default Cobalt Strike process injection may get you caught. Consider a custom injection BOF or UDRL IAT hook.
• Some assemblies rely on Environment.Exit() to finish executing. This will prevent the loader's cleanup phase from occurring, but you can still disconnect the named pipe using jobkill.
• Uncomment lines 3 or 4 of scmain.c to enable error or verbose modes, respectively. These are disabled by default to reduce the shellcode size.

References

This project would not have been possible without the following projects:

• CLR-related definitions and implementation - https://github.com/TheWover/donut
• Beacon job interface and project structure - https://github.com/SecIdiot/netntlm

Other features and inspiration were taken from the following resources:

• https://github.com/med0x2e/ExecuteAssembly
• https://github.com/anthemtotheego/InlineExecute-Assembly
• https://www.mdsec.co.uk/2020/08/massaging-your-clr-preventing-environment-exit-in-in-process-net-assemblies