MITRE ATT&CK Enterprise · TA0002
Execution: the moment the attack runs
ExecutionTA0002
Everything before this was preparation. This is the minute the payload runs — and the last minute where the outcome is still mostly yours to decide.
For the owner
Everything before this was preparation: research, shopping, staging. Execution is the minute the payload actually runs. A script, a command line, a service that starts, a scheduled job that fires, a file somebody opened.
This is the point where an incident stops being theoretical. Until something executes, the business has a suspicious email and an odd sign-in. After something executes, there may be an employee paying a supplier from a forged invoice, a workstation whose contents are being copied out, a customer list being assembled for sale, or a ransomware note nobody has seen yet.
What it looks like from the outside is usually nothing at all. That is the problem. The last moment before consequences is a process starting, and most organisations find out about it days later — from a customer, from a bank, or from a notice about data that was already taken.
There is one honest piece of good news in this. Execution is the last tactic where the outcome is still mostly in your hands. Once something has run, your decisions are about damage and notification. Before it runs, your decisions are about noticing. That window is usually hours, sometimes minutes, and it is almost always open.
Three questions are worth asking your own team:
- When something unusual runs on a finance or engineering workstation, who finds out the same day? Not the next morning. The answer "nobody" is more common than anyone expects.
- Which accounts are allowed to run administrative scripts and to schedule recurring jobs, and when was that list last reviewed? The list exists somewhere. It is almost never the list currently running.
- If a file appeared in a temporary folder, ran, and disappeared within a minute, would we still hold the evidence a week later? Plenty of organisations would answer no, and that answer is a retention decision nobody made deliberately.
None of this requires new software to answer. It requires that somebody is looking at the events while they are still happening.
For the analyst
The tactic
MITRE ATT&CK files Execution under TA0002. It covers the adversary running their own code on your systems: through an interpreter, through a service, through a scheduled job, through a hijacked library, or by convincing a person to run it. The matrix files 66 techniques under it, and the pinned SigmaHQ corpus carries 656 rules — the heaviest block in the whole corpus, by a wide margin.
That weight is not an accident. The other tactics in this series mostly happen somewhere else: outside your estate, on somebody else's server, in an adversary's development environment. Execution happens here. A process starts on a machine you own, in a session you control, with a user you can name — the first tactic where the telemetry is guaranteed to exist.
What the corpus detects
| Technique | Name | Rules in the corpus |
|---|---|---|
T1059.001 | Command and Scripting Interpreter: PowerShell | 182 |
T1574.001 | Hijack Execution Flow: DLL | 80 |
T1059 | Command and Scripting Interpreter | 74 |
T1047 | Windows Management Instrumentation | 47 |
T1569.002 | System Services: Service Execution | 39 |
T1053.005 | Scheduled Task/Job: Scheduled Task | 33 |
T1204.002 | User Execution: Malicious File | 29 |
T1059.003 | Command and Scripting Interpreter: Windows Command Shell | 28 |
T1059.005 | Command and Scripting Interpreter: Visual Basic | 24 |
T1059.007 | Command and Scripting Interpreter: JavaScript | 23 |
T1127 | Trusted Developer Utilities Proxy Execution | 19 |
T1203 | Exploitation for Client Execution | 19 |
T1059.004 | Command and Scripting Interpreter: Unix Shell | 16 |
T1197 | BITS Jobs | 15 |
T1106 | Native API | 11 |
T1574.011 | Hijack Execution Flow: Services Registry Permissions Weakness | 11 |
T1053 | Scheduled Task/Job | 9 |
T1059.012 | Command and Scripting Interpreter: Hypervisor CLI | 9 |
T1053.002 | Scheduled Task/Job: At | 8 |
T1059.002 | Command and Scripting Interpreter: AppleScript | 7 |
T1204 | User Execution | 7 |
T1053.003 | Scheduled Task/Job: Cron | 6 |
T1204.004 | User Execution: Malicious Copy and Paste | 6 |
T1059.006 | Command and Scripting Interpreter: Python | 5 |
T1574 | Hijack Execution Flow | 5 |
T1072 | Software Deployment Tools | 4 |
T1204.001 | User Execution: Malicious Link | 4 |
T1059.009 | Command and Scripting Interpreter: Cloud API | 3 |
T1559.001 | Inter-Process Communication: Component Object Model | 3 |
T1609 | Container Administration Command | 3 |
T1574.005 | Hijack Execution Flow: Executable Installer File Permissions Weakness | 2 |
T1574.006 | Hijack Execution Flow: Dynamic Linker Hijacking | 2 |
T1574.007 | Hijack Execution Flow: Path Interception by PATH Environment Variable | 2 |
T1574.012 | Hijack Execution Flow: COR_PROFILER | 2 |
T1127.001 | Trusted Developer Utilities Proxy Execution: MSBuild | 1 |
T1129 | Shared Modules | 1 |
T1559.002 | Inter-Process Communication: Dynamic Data Exchange | 1 |
T1569 | System Services | 1 |
T1569.001 | System Services: Launchctl | 1 |
T1574.008 | Hijack Execution Flow: Path Interception by Search Order Hijacking | 1 |
The families, and why they behave differently
Command and Scripting Interpreter (T1059 and its sub-techniques). The largest block in the matrix: T1059.001 (PowerShell) alone accounts for 182 rules, ahead of T1059.003 (Windows Command Shell, 28), T1059.005 (Visual Basic, 24), T1059.007 (JavaScript, 23), T1059.004 (Unix Shell, 16) and T1059.006 (Python, 5). Interpreters are popular with defenders and adversaries for the same reason: every modern operating system already contains one, so nothing needs to be installed and nothing looks out of place.
Hijack Execution Flow (T1574 and its sub-techniques). The second heaviest: T1574.001 (DLL) carries 80 rules, with T1574.011 (Services Registry Permissions Weakness) at 11. The technique is elegant from the adversary's point of view: a legitimate, signed program loads a library the adversary wrote. Nothing about the program is wrong. The path the library came from is.
System Services (T1569, T1569.001, T1569.002) and Scheduled Task/Job (T1053, T1053.002, T1053.003, T1053.005). Persistence and execution in one, which is why they appear in two tactics of this series. T1569.002 (Service Execution) carries 39 rules and T1053.005 (Scheduled Task) 33. The service and the scheduled task are the two mechanisms an adversary uses to make code run again without a person.
User Execution (T1204, T1204.001, T1204.002, T1204.004). The human in the loop. T1204.002 (Malicious File) carries 29 rules because "somebody opened the thing" is the most common way an intrusion completes in a well-defended organisation.
The rest. T1047 (Windows Management Instrumentation, 47 rules) is inherently administrative and inherently abused. T1127 (Trusted Developer Utilities Proxy Execution) covers signed build tools abused as a proxy, and T1203, T1197 (BITS Jobs), T1106 (Native API), T1072 (Software Deployment Tools), T1609, T1559 and T1129 cover the paths where the payload is not a script at all.
Where the telemetry comes from
Execution is where the collectors earn their keep, and the source types map directly onto the families:
| Source type | Signal | Columns that carry it |
|---|---|---|
windows_sysmon | Process creation and library loads | process_name, parent_process, command_line, file_path, user_name |
linux_auditd | Process creation, service and schedule changes | process_name, parent_process, command_line, file_path |
firewall_syslog | The payload's outbound traffic | src_ip, dst_ip, dst_port, event_type |
keycloak | Sign-ins that follow the execution | user_name, src_ip, event_type |
m365_audit | Cloud actions after the execution | user_name, service_name, event_type |
gworkspace | The Google workspace equivalents | user_name, service_name, event_type |
cloud | Object access from the executed workload | dst_ip, service_name, event_type |
The full normalised row for one process-creation event looks like this:
event_type: process_create
source_type: windows_sysmon
host_id: fin-ws-014
user_name: CORP\svc_ops
process_name: powershell.exe
parent_process: winword.exe
command_line: powershell.exe -w hidden -enc SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQA...
file_path: C:\Program Files\PowerShell\7\pwsh.exe
severity: medium
Every field in that row is a column a rule can filter on, and the mapping is the same whether the event arrived from a Windows host, a Linux host or a cloud audit trail.
What makes an event rare, and what makes it wrong
A process creation is the most common event in most estates. What is rare is the shape of the process tree, not the process.
- The parent.
powershell.exeis not remarkable.powershell.exewhose parent iswinword.exeis remarkable. Word does not run PowerShell. - The path. A signed binary is not remarkable. The same binary running from a user-writable directory is — the entire detection surface of
T1574.001. - The account. A scheduled task created by an account that has never created one, on a server that has never had one.
- The argument. The same signed tool, run by the same administrator, with an argument list no administrator has ever used.
- The sequence. A file written to a temporary directory, executed, and removed inside a minute.
And what makes an event wrong is the ordinary work of an ordinary estate: build pipelines running compilers and scripts, system management agents, backup software, deployment tools, and the IT team's own scripting. T1072 and T1127 exist specifically because these things look like attacks.
Detection engineering notes
- Anchor on the pair, not the single field.
process_namealone is a vocabulary.parent_processpluscommand_lineis a statement about what happened. Almost every usable rule in this tactic is a conjunction. - Read the grandparent. The chain
winword.exe→cmd.exe→powershell.exeis plausible one step at a time and absurd end to end. Ancestry reasoning is what turns a stream of events into a story. - Weight the command line by the binary.
-enconpowershell.exeis noise on a build server and an alert on a finance workstation. Same string, different meaning; the asset tier is part of the rule. - Remember that secrets are redacted before storage. The normalizer strips credential-shaped strings out of
command_line, so a rule can rely on the shape of a line but not on the secret in it. - Scope the corpus before you enable it. 656 rules on this tactic, evaluated against every host, is how a team ends up ignoring the queue. Enable by asset tier: internet-facing servers first, then identity systems, then the general estate last.
- Tune on the host, not on the user. "This account runs scripts" breaks the day the person leaves. "This host runs scheduled tasks it was built with" survives.
Where analysts get this wrong
The first error is alerting on the interpreter instead of the intent. 182 rules against PowerShell is a firing rate, not a coverage measure. A team that enables them all and watches the volume learn nothing.
The second is assuming the payload is a script. It frequently is not. An in-memory .NET assembly, a native binary, a signed installer, a library loaded into a legitimate process — these belong to T1106 (Native API), T1129 (Shared Modules) and T1574.001 (DLL), and they leave no interpreter in the process tree at all. A rule set with no coverage of those families will look healthy and miss the adversary who used them.
The third is trusting the parent process. Signed does not mean safe, and "it was our deployment tool that ran it" does not mean the deployment tool was given a benign argument. T1072 exists precisely because the parent process is one you trust.
The false negative to picture is the one where everything looks correct: a signed management agent, running from its usual path, under a service account, with an argument list you have never seen. Per-host alerting sees nothing; only an argument-aware rule, or a comparison against what that host normally does, catches it. And one case is not a detection failure at all: T1204.002 (User Execution: Malicious File) is the user who did everything right and clicked anyway. No rule set replaces a person reading an email.
Where DetectMonkey fits
Execution is the noisiest tactic in the matrix, and the one where counting beats guessing. A single endpoint log tells you what happened on one host. Normalised telemetry across the estate tells you something an owner can act on: which parent processes have never been seen on a server, how many scheduled tasks exist per host, and whether a script ran at three in the morning that has no counterpart in the same host's history.
DetectMonkey does that and stops there. Every event arrives in the same columns regardless of the source that produced it, the pinned corpus of 3164 rules is evaluated as events arrive rather than after indexing, and the last 72 hours stay queryable so an analyst can walk the process tree backwards from an alert to the user who started it. It does not isolate, quarantine or block anything on your systems, and it changes no configuration on them. Telemetry is processed and stored on private servers operated by Codein in New Brunswick, Canada, and the analysts work in English and French.
Early access is 90 days at no charge for up to 100 seats, with founder-led onboarding and no card required.
See it on your own telemetry
Early access is 90 days at no charge, for up to 100 seats, founder-led onboarding, no card required.