tfMITRE ATT&CK sub-technique

Compile After Delivery T1027.004

sub-technique of T1027 Obfuscated Files or Information

Tactic: Stealth
Platforms: Linux, macOS, Windows
Version: 2.0
Created: 16 March 2020
Last modified: 12 May 2026
Contributors: Liran Ravich, CardinalOps; Praetorian; Ye Yint Min Thu Htut, Offensive Security Team, DBS Bank

Adversaries may attempt to make payloads difficult to discover and analyze by delivering files to victims as uncompiled code. Text-based source code files may subvert analysis and scrutiny from protections targeting executables/binaries. These payloads will need to be compiled before execution; typically via native utilities such as ilasm.exe[1], csc.exe, or GCC/MinGW.[2]

ReconResource DevInitial AccessExecutionPersistencePriv EscStealthDef ImpairmentCred AccessDiscoveryLateral MoveCollectionC2ExfiltrationImpact

Threat groups70th pct

Threat groups70th percentile · 70% of ATT&CK techniques have this many threat groups attributed or fewer.

CampaignsNone recorded

CampaignsNone recorded · 54% of ATT&CK techniques have none either.

Tools & malware68th pct

Tools & malware68th percentile · 68% of ATT&CK techniques have this many tools implementing them or fewer.

Detection rules71st pct

Detection rules71st percentile · 71% of ATT&CK techniques have this many detection rules written or fewer.

Compile After Delivery MITRE reference T1027.004

70th pctamong all ATT&CK techniques for number of groups

4 groups have been recorded using this technique. Newest first; each entry carries MITRE’s procedure text and a link to the group’s full record. Click a name to filter the rules below.

Sea TurtleG1041 ↗

Downloaded source code files from remote addresses then compiled them locally via GCC in victim environments.1

created 2024-11-201 referenceaka Teal Kurma

RockeG0106 ↗

Has compiled malware, delivered to victims as .c files, with the GNU Compiler Collection (GCC).1

created 2020-05-261 reference

MuddyWaterG0069 ↗

Has used the .NET csc.exe tool to compile executables from downloaded C# code.1

created 2018-04-181 referenceaka Earth Vetala

Gamaredon GroupG0047 ↗

Has compiled the source code for a downloader directly on the infected system using the built-in Microsoft.CSharp.CSharpCodeProvider class.1

created 2017-05-311 referenceaka IRON TILDEN

All 4 groups for this technique

6 software entries are documented implementing this technique. MITRE files each as a tool or as malware; newest first, then by how many groups carry them.

SamuraiS1099 ↗

Can compile and execute downloaded modules at runtime.1

created 2024-01-04MALWAREcarried by 1 group

DarkWatchmanS0673 ↗

Has used the csc.exe tool to compile a C# executable.1

created 2022-01-10MALWARE

FoggyWebS0661 ↗

Can compile and execute source code sent to the compromised AD FS server via a specific HTTP POST.1

created 2021-11-16MALWAREcarried by 1 group

SliverS0633 ↗

Includes functionality to retrieve source code and compile locally prior to execution in victim environments.1

created 2021-07-30TOOLcarried by 3 groups

njRATS0385 ↗

Has used AutoIt to compile the payload and main script into a single executable after delivery.1

created 2019-06-04MALWAREcarried by 8 groups

Cardinal RATS0348 ↗

And its watchdog component are compiled and executed after being delivered to victims as embedded, uncompiled source code.1

created 2019-01-30MALWARE

All 6 software entries for this technique

Offense vs defense T1027.004

Is defensive coverage keeping up with adversary use? Eight counts, each ranked against all 697 ATT&CK techniques. Attack sits left, defense right, so a shape leaning left means adversaries are better documented here than defenders are equipped. Hover any spoke for its percentile and the share of techniques that have more. The timeline below shows when each side arrived.

How it got here

Range

Adversary activity (campaign spans) over cumulative rule output. Each source is plotted independently from zero, so neither line includes the other. Campaign dates are year-granularity.

Campaigns · 0Sigma rules (cumulative) · 6Splunk ESCU (cumulative) · 2

first rule: 2019 Q1

Compile After Delivery detection strategy DET0501

MITRE names one behaviour worth catching for this technique and breaks it into 3 analytics, one per platform. Each carries the log sources it needs and the fields you tune per environment.

Detection Strategy for Compile After Delivery - Source Code to Executable Transformation

Enterprise

3 platforms

AN1381 · Windows

Detects compilation activity using csc.exe, ilasm.exe, or msbuild.exe initiated by user-space processes outside typical development environments, followed by execution or network activity from newly written binaries.

Log sources

The data this analytic draws on. You do not need every component — each one you already collect covers part of it. Each links to its ATT&CK record.

Data component	Name	Channel
Process CreationDC0032	WinEventLog:Sysmon	EventCode=1
File CreationDC0039	WinEventLog:Sysmon	EventCode=11
Network Connection CreationDC0082	WinEventLog:Sysmon	EventCode=3, 22

Tunable fields

MITRE calls these the analytic’s mutable elements: the thresholds and filters you set for your own environment.

Field	What you tune
ParentProcessName	Filter for unexpected users (non-dev) launching compilers like csc.exe or msbuild.exe
OutputDirectoryPath	Adjust paths for sensitive file write zones (e.g., `C:\Users\Public\`, `%TEMP%`, or Desktop)
TimeWindow	Tune the correlation window between compilation and subsequent execution or C2

AN1382 · Linux

Detects GCC or Clang invoked on suspicious file paths (e.g., /tmp/, ~/Downloads) with output to executable binaries, followed by execution or outbound traffic from these binaries.

Log sources

The data this analytic draws on. You do not need every component — each one you already collect covers part of it. Each links to its ATT&CK record.

Data component	Name	Channel
Process CreationDC0032	auditd:SYSCALL	execve
File CreationDC0039	auditd:SYSCALL	open,create
Network Connection CreationDC0082	NSM:Flow	conn.log

Tunable fields

MITRE calls these the analytic’s mutable elements: the thresholds and filters you set for your own environment.

Field	What you tune
CompilerBinaryPath	Specify path and binaries for detection (e.g., `/usr/bin/gcc`, `/opt/mingw/bin/gcc`)
FilePermissionProfile	Match uncommon chmod behavior post-compilation (e.g., +x in `/tmp` or home directories)

AN1383 · macOS

Detects non-standard compilation activity via Xcode CLI tools or bundled GCC/MONO packages writing new executable files and executing them outside dev environments (e.g., user Downloads folder).

Log sources

The data this analytic draws on. You do not need every component — each one you already collect covers part of it. Each links to its ATT&CK record.

Data component	Name	Channel
Process CreationDC0032	macos:unifiedlog	process activity, exec events
File CreationDC0039	macos:osquery	file_events
Network Connection CreationDC0082	macos:unifiedlog	networkd or socket

Tunable fields

MITRE calls these the analytic’s mutable elements: the thresholds and filters you set for your own environment.

Field	What you tune
CompilerInvocationPattern	Detect calls to `xcodebuild`, `clang`, or `/Applications/Mono.app/...` from non-admin users
OutputBinaryPath	Monitor for output files in user-writable paths (e.g., `~/Library/Caches`, `~/Downloads`)

Tests5Executorssh 3 · cmd 1 · PowerShell 1Need elevation0 of 5Have prerequisites5Have cleanup1Platformswindows, linux, macos

Test

Platform

Executor

Elevation

Prereqs

Cleanup

Ref

Compile After Delivery using csc.exe

windows

cmd

—

Yes

Compile C# code using csc.exe binary used by .NET Upon execution an exe named T1027.004.exe will be placed in the temp folder

Input arguments

Name	Type	Default	Description
input_file	path	PathToAtomicsFolder\T1027.004\src\calc.cs	C# code that launches calc.exe from a hidden cmd.exe Window
output_file	path	C:\Windows\Temp\T1027.004.exe	Output compiled binary

Attack command

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /out:#{output_file} "#{input_file}"

Cleanup command

del #{output_file} >nul 2>&1

Prerequisite

C# file must exist on disk at specified location (#{input_file})

Check

if (Test-Path "#{input_file}") {exit 0} else {exit 1}

Satisfy

New-Item -Type Directory (split-path "#{input_file}") -ErrorAction ignore | Out-Null
Invoke-WebRequest "https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1027.004/src/calc.cs" -OutFile "#{input_file}"

GUID54d2e3dd-d13a-4807-9ee3-e9d5ccca5bbd

Dynamic C# Compile

windows

PowerShell

—

When C# is compiled dynamically, a .cmdline file will be created as a part of the process. Certain processes are not typically observed compiling C# code, but can do so without touching disk. This can be used to unpack a payload for execution. The exe file that will be executed is named as T1027.004_DynamicCompile.exe is contained in the 'bin' folder of this atomic, and the source code to the file is in the 'src' folder. Upon execution, the exe will print 'T1027.004 Dynamic Compile'.

Input arguments

Name	Type	Default	Description
input_file	path	PathToAtomicsFolder\T1027.004\bin\T1027.004_DynamicCompile.exe	exe program containing dynamically compiled C# code

Attack command

Invoke-Expression "#{input_file}"

Prerequisite

exe file must exist on disk at specified location (#{input_file})

Check

if (Test-Path "#{input_file}") {exit 0} else {exit 1}

Satisfy

Invoke-WebRequest https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1027.004/bin/T1027.004_DynamicCompile.exe -OutFile "#{input_file}"

GUID2e8e9aa1-3915-4325-9b61-5eb25cff6ea3

C compile

linux, macos

—

Compile a c file with either gcc or clang on FreeBSD, Linux or Macos.

Input arguments

Name	Type	Default	Description
input_file	path	PathToAtomicsFolder/T1027.004/src/T1027-004-test.c	source file

Attack command

gcc #{input_file} && ./a.out
clang #{input_file} && ./a.out

Prerequisite

the source file must exist on disk at specified location (#{input_file})

Check

if [ -e  #{input_file} ]; then exit 0; else exit 1; fi

Satisfy

wget https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1027.004/src/T1027-004-test.c -O "#{input_file}"

GUID5c4955fc-31c3-4621-adbe-7502aa5435af

CC compile

linux, macos

—

Compile a c file with either gcc or clang on FreeBSD, Linux or Macos.

Input arguments

Name	Type	Default	Description
input_file	path	PathToAtomicsFolder/T1027.004/src/T1027-004-test.cc	source file

Attack command

g++ #{input_file} && ./a.out
clang++ #{input_file} && ./a.out

Prerequisite

the source file must exist on disk at specified location (#{input_file})

Check

if [ -e  #{input_file} ]; then exit 0; else exit 1; fi

Satisfy

wget https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1027.004/src/T1027-004-test.cc -O #{input_file}

GUIDbef3883a-1682-4ec1-a80a-acc82725a0be

Go compile

linux, macos

—

Compile a go file with golang on FreeBSD, Linux or Macos.

Input arguments

Name	Type	Default	Description
input_file	path	PathToAtomicsFolder/T1027.004/src/T1027-004-test.go	source file

Attack command

go run #{input_file}

Prerequisite

the source file must exist on disk at specified location (#{input_file})

Check

if [ -e  #{input_file} ]; then exit 0; else exit 1; fi

Satisfy

wget https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1027.004/src/T1027-004-test.go -O #{input_file}

GUID337accff-82db-4ba1-9ef4-c524c097e983

Tests from Atomic Red Team (MIT licence) · technique definition

Compile After Delivery detections T1027.004

8 rules are mapped to this technique. Parent techniques also include their sub-techniques’ rules. Click a slice or key entry to filter the table.

71st pctamong all ATT&CK techniques for number of rules

Product

Severity

Library

Drag headers to reorder | Drag edges to resize

Loading detections...

Select	Title	Description	Category	Status	Event	Product	MITRE ATT&CK	CVEs	Severity	Author	Created	Updated	ID	Refs