# MITRE ATT&CK

> MITRE ATT&CK is a public knowledge base that catalogs adversary tactics and techniques, observed in real attacks, under stable IDs such as T1195.001.

Also known as: Adversarial Tactics, Techniques, and Common Knowledge, MITRE ATT&CK framework, ATT&CK matrix

Source: https://socket.dev/glossary/adversarial-tactics-techniques-and-common-knowledge-att-and-ck

Last updated: 2026-11-05

MITRE ATT&CK (Adversarial Tactics, Techniques, and Common Knowledge) is a free knowledge base of attacker behavior observed in real intrusions. It sorts each behavior into a tactic, the goal, and a technique, the method, under stable IDs like T1195.001. Defenders use those IDs to tag threat reports, map detections, and measure coverage.

As of [version 20](https://attack.mitre.org/resources/updates/updates-october-2026/), released October 13, 2026, the Enterprise matrix holds 15 tactics, 227 techniques, and 479 sub-techniques. Open source [supply chain attacks](https://socket.dev/glossary/supply-chain-attack) enter it through one sub-technique, T1195.001, Compromise Software Dependencies and Development Tools. That single cell undersells the problem. MITRE's own record for the [Shai-Hulud](https://socket.dev/blog/happy-birthday-shai-hulud) npm worm links 33 techniques across all 15 tactics, which you can reproduce with one `jq` query. Our position: ATT&CK is the best shared vocabulary for describing package malware after the fact, and a weak guide to stopping it. Its supply chain detection logic fires only after the malicious code has already run.

## What is the MITRE ATT&CK framework?

The MITRE ATT&CK framework is a catalog of what adversaries do once they act, built from public incident reporting rather than theory. MITRE, a US not-for-profit research organization, created the first model in September 2013 to describe adversary behavior inside Windows enterprise networks. It went public in May 2015 with 96 techniques under 9 tactics, according to MITRE's [Design and Philosophy paper](https://www.mitre.org/sites/default/files/2021-11/prs-19-01075-28-mitre-attack-design-and-philosophy.pdf). The [ATT&CK homepage](https://attack.mitre.org/) states the premise in one line: "MITRE ATT&CK® is a globally-accessible knowledge base of adversary tactics and techniques based on real-world observations."

The model has three core layers, which is where the term TTPs (tactics, techniques, and procedures) comes from:

- **Tactics** are the "why": an adversary's short-term goal, such as Credential Access (TA0006).
- **Techniques** and sub-techniques are the "how": T1552 Unsecured Credentials, and beneath it T1552.001 Credentials In Files.
- **Procedures** are what a specific actor actually did, recorded as a cited sentence on the link between that actor and a technique.

Around those layers sit Groups (G IDs), which include most named [advanced persistent threat](https://socket.dev/glossary/advanced-persistent-threat-apt) actors, Software (S IDs), Campaigns (C IDs), Mitigations (M IDs), and Detection Strategies (DET IDs). Detection Strategies arrived in version 18, released October 28, 2025. Each one bundles platform-specific Analytics (AN IDs), and together they replaced the older data source model. ATT&CK ships three matrices: Enterprise, Mobile, and ICS.

| ATT&CK v20 | Enterprise | Mobile | ICS |
| --- | --- | --- | --- |
| Tactics | 15 | 12 | 12 |
| Techniques | 227 | 78 | 78 |
| Sub-techniques | 479 | 47 | 26 |
| Groups | 178 | 20 | 14 |
| Software | 842 | 128 | 25 |
| Campaigns | 57 | 3 | 10 |

ATT&CK v20 object counts, from MITRE's October 2026 release notes. Counted from the v20 STIX bundle, Enterprise also carries 44 mitigations, 703 detection strategies, and 1,770 analytics.

The 15 Enterprise tactics, in matrix order, are Reconnaissance, Resource Development, Initial Access, Execution, Persistence, Privilege Escalation, Stealth, Defense Impairment, Credential Access, Discovery, Lateral Movement, Collection, Command and Control, Exfiltration, and Impact. The 15th is new. Version 19, released April 28, 2026, split Defense Evasion into Stealth, which kept the ID TA0005, and Defense Impairment, a new tactic with ID TA0112.

The column order suggests a timeline, but ATT&CK does not enforce one. A technique can serve several tactics. T1078.004 Cloud Accounts, for example, sits under Initial Access, Persistence, Privilege Escalation, and Stealth at once.

## How is ATT&CK different from the Cyber Kill Chain and CAPEC?

ATT&CK differs from the [Lockheed Martin Cyber Kill Chain](https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html) in granularity and in order. The Kill Chain is a seven-phase linear model of one intrusion, from reconnaissance to actions on objectives. ATT&CK keeps a similar arc in its tactic columns but adds hundreds of citable techniques and no required sequence. The Kill Chain explains an intrusion to a board. ATT&CK tags what each artifact did.

CAPEC, the Common Attack Pattern Enumeration and Classification, is MITRE's catalog of attack patterns against software and systems. It sits closer to the weakness being exploited. The two catalogs link where they overlap: [CAPEC-538](https://capec.mitre.org/data/definitions/538.html), Open-Source Library Manipulation, maps to T1195.001.

MITRE also operates the [CVE](https://socket.dev/glossary/common-vulnerabilities-and-exposures-cve) program. A CVE names a flaw in a product. An ATT&CK technique names a behavior. A malicious package typically has no CVE because nothing in it is a flaw: the package works exactly as its author intended. That is why threat reports on package malware carry ATT&CK IDs and why CVE scanners miss it.

## How does MITRE ATT&CK map a software supply chain attack?

MITRE ATT&CK maps software supply chain attacks to T1195 Supply Chain Compromise, an Initial Access technique with three sub-techniques. T1195.001 covers software dependencies and development tools. T1195.002 covers application software and its update channels. T1195.003 covers hardware. A malicious npm, PyPI, or crates.io package belongs in T1195.001. Trojanized vendor software, such as the [3CX](https://attack.mitre.org/campaigns/C0057/) and [SolarWinds](https://attack.mitre.org/campaigns/C0024/) compromises, belongs in T1195.002.

T1195.001 changed more in v20 than most techniques. MITRE bumped it from version 1.3 to 2.0 and widened the description from pip and npm packages to GitHub Actions, IDE project files such as `tasks.json`, and AI [agent skills](https://socket.dev/glossary/agent-skills) files (`SKILL.md`). The new text warns that because these artifacts are natural language or configuration, "they may pass registry screening and signature-based scanning."

The boundaries between neighboring IDs blur in practice. T1195.001's own text names [typosquatting](https://socket.dev/glossary/typosquatting). So does T1204.005 Malicious Library, an Execution technique added in v18 for packages a user installs by mistake. T1608.001 Upload Malware covers the act of publishing to npm or PyPI. MITRE's data straddles these lines. It maps the [BeaverTail](https://socket.dev/blog/north-korea-contagious-interview-campaign-338-malicious-npm-packages) malware from North Korea's [Contagious Interview](https://socket.dev/supply-chain-attacks/north-korea-s-contagious-interview-campaign) campaign to T1195.001 and the Contagious Interview group to T1204.005. Our own reports have not been consistent either. We tagged the [AsyncAPI compromise](https://socket.dev/blog/asyncapi-supply-chain-attack) as T1195.002 and the [LiteLLM compromise](https://socket.dev/blog/litellm-compromise) as T1195.001, though both were hijacked registry packages.

| Package attack | Primary ID | Add | Example or note |
| --- | --- | --- | --- |
| Maintainer account or token hijacked, legitimate package republished | T1195.001 | T1550.001 or T1078.004 for the publish; T1608.001 | Shai-Hulud; LiteLLM 1.107.0 |
| Typosquat or slopsquat: a new attacker-owned package | T1195.001 | T1608.001, T1036.005; T1204.005 if a person was lured | Contagious Interview packages |
| Dependency confusion: a public package shadows an internal name | T1195.001 | T1608.001 | The resolver picks it, not a person |
| Install-time hook (preinstall, postinstall) | T1546.016 Installer Packages | T1059.007 JavaScript | Shai-Hulud |
| Python .pth file or sitecustomize.py | T1546.018 Python Startup Hooks | T1059.006 Python | LiteLLM 1.107.0 |
| Compromised GitHub Action or CI workflow | T1195.001 | T1677 Poisoned Pipeline Execution | Mini Shai-Hulud |
| Trojanized vendor application or updater | T1195.002 |  | 3CX; SolarWinds Orion |

Verdict: tag T1195.001 whenever a package manager, registry, or CI resolver delivered the code, whether the package was hijacked or attacker-created. Add T1204.005 only when a person was lured into choosing the package, as in fake job interview tests. Reserve T1195.002 for end-user applications and their updaters. Always tag install-time execution separately, as T1546.016 or T1546.018, because that is the step you can block.

## One npm worm, fifteen tactics

Shai-Hulud shows why T1195.001 alone undersells supply chain risk. The first wave, in September 2025, began with a [malicious release of @ctrl/tinycolor](https://socket.dev/blog/tinycolor-supply-chain-attack-affects-40-packages), a package with 2.2 million weekly downloads at the time. The payload ran TruffleHog, a legitimate secret scanner, to sweep the host for npm tokens, GitHub credentials, and cloud keys. It committed what it found to a public repository named Shai-Hulud on the victim's own GitHub account. Then it used the stolen npm tokens to republish the maintainer's other packages. A function named `NpmModule.updatePackage` downloaded each tarball, modified `package.json`, injected `bundle.js`, repacked the archive, and republished it. A [second wave in November 2025](https://socket.dev/blog/shai-hulud-strikes-again-v2) moved execution to the preinstall step and added a fallback that tried to wipe the user's home directory.

> The Shai-Hulud worm loop mapped to MITRE ATT&CK technique IDs: install script, credential harvest, exfiltration, token reuse, republish, and the next victim's install

The figure traces one turn of the loop. In step 1, npm runs the injected lifecycle script during install, which MITRE tags T1546.016 Installer Packages (Persistence, Privilege Escalation). In step 2, the script harvests npm tokens, GitHub credentials, and cloud keys: T1552.001 Credentials In Files and T1528 Steal Application Access Token (Credential Access). In step 3, it commits a JSON dump to a repository named Shai-Hulud: T1567.001 Exfiltration to Code Repository (Exfiltration). In step 4, it uses the stolen npm token to enumerate the maintainer's packages: T1550.001 Application Access Token (Lateral Movement). In step 5, it publishes infected tarballs: T1608.001 Upload Malware (Resource Development). In step 6, a downstream consumer installs one of those packages: T1195.001 (Initial Access). Step 6 on one machine is step 1 on the next.

The loop breaks an assumption built into ATT&CK: one adversary, one victim enterprise, tactics flowing left to right. A worm turns Credential Access on one maintainer's laptop into Lateral Movement through the registry. That move becomes Resource Development for the attacker and Initial Access for every downstream consumer. Steps 5 and 6 are the same `npm publish`, tagged T1608.001 from the attacker's side and T1195.001 from yours.

The lineage keeps growing. MITRE added [Mini Shai-Hulud](https://socket.dev/supply-chain-attacks/mini-shai-hulud) and its operator, [TeamPCP](https://socket.dev/blog/teampcp-targeting-security-tools-across-oss-ecosystem), in version 19.2, released August 5, 2026. Mini Shai-Hulud maps to 55 techniques. One burst in May 2026, which hit [TanStack](https://socket.dev/blog/tanstack-npm-packages-compromised-mini-shai-hulud-supply-chain-attack) among others, pushed more than 400 malicious versions across 172 packages in about five hours, [per our one-year retrospective](https://socket.dev/blog/happy-birthday-shai-hulud). It used no stolen long-lived credential. MITRE's procedure text says it "scraped runner process memory to extract short-lived identity tokens," then exchanged them for npm trusted publisher tokens. Packages published that way come out of a legitimate pipeline and can carry valid provenance. Provenance tells you which pipeline built a package. It does not tell you whether that pipeline was hijacked.

## ATT&CK is a dataset, not a poster

Most people meet ATT&CK as a matrix image. The canonical form is STIX 2.1 JSON in MITRE's [attack-stix-data](https://github.com/mitre-attack/attack-stix-data) repository, one versioned bundle per release. Tactics are encoded as STIX kill chain phases, techniques as `attack-pattern` objects, and every procedure as a `relationship` object of type `uses`. The v20 Enterprise bundle is 55 MB and holds 21,819 active relationships. Here is T1195.001, trimmed:

```json
{
  "type": "attack-pattern",
  "id": "attack-pattern--191cc6af-1bb2-4344-ab5f-28e496638720",
  "name": "Compromise Software Dependencies and Development Tools",
  "x_mitre_version": "2.0",
  "modified": "2026-10-06T16:05:56.514Z",
  "kill_chain_phases": [
    { "kill_chain_name": "mitre-attack", "phase_name": "initial-access" }
  ],
  "x_mitre_is_subtechnique": true,
  "x_mitre_platforms": ["Linux", "macOS", "Windows"],
  "external_references": [
    { "source_name": "mitre-attack", "external_id": "T1195.001",
      "url": "https://attack.mitre.org/techniques/T1195/001" }
  ]
}
```

Because procedures are relationships, the data answers questions the website makes tedious. This query lists every technique MITRE links to Shai-Hulud. It runs in about a second:

```sh
curl -sL -O https://raw.githubusercontent.com/mitre-attack/attack-stix-data/master/enterprise-attack/enterprise-attack-20.0.json

jq -r '
  (.objects | map({key: .id, value: .}) | from_entries) as $by
  | (.objects[] | select(.type == "malware" and .name == "Shai-Hulud") | .id) as $sh
  | .objects[]
  | select(.type == "relationship" and .relationship_type == "uses"
           and .source_ref == $sh and (.revoked | not))
  | $by[.target_ref]
  | select(.type == "attack-pattern")
  | [(.external_references[] | select(.source_name == "mitre-attack").external_id),
     .name,
     (.kill_chain_phases | map(.phase_name) | join(","))]
  | @tsv' enterprise-attack-20.0.json | sort

# T1027      Obfuscated Files or Information             stealth
# T1036.005  Match Legitimate Resource Name or Location  stealth
# ...
# T1195.001  Compromise Software Dependencies and Development Tools  initial-access
# ...
# T1685      Disable or Modify Tools                     defense-impairment
```

It prints 33 techniques. Grouped by tactic, the result covers the entire matrix:

| Tactic | ID | Shai-Hulud techniques (S9008) |
| --- | --- | --- |
| Reconnaissance | TA0043 | T1593.003 |
| Resource Development | TA0042 | T1608.001 |
| Initial Access | TA0001 | T1078.004, T1195.001 |
| Execution | TA0002 | T1059.001, T1059.004, T1059.007, T1677 |
| Persistence | TA0003 | T1078.004, T1098, T1543.002, T1546.016 |
| Privilege Escalation | TA0004 | T1078.004, T1098, T1543.002, T1546.016, T1548.003 |
| Stealth | TA0005 | T1027, T1036.005, T1036.009, T1078.004, T1564.011, T1678 |
| Defense Impairment | TA0112 | T1553, T1685 |
| Credential Access | TA0006 | T1528, T1552.001, T1552.005, T1555.006 |
| Discovery | TA0007 | T1082 |
| Lateral Movement | TA0008 | T1550.001 |
| Collection | TA0009 | T1119, T1213.003 |
| Command and Control | TA0011 | T1071.001, T1105 |
| Exfiltration | TA0010 | T1041, T1567.001, T1567.004 |
| Impact | TA0040 | T1485 |

A technique that serves several tactics counts once in each row, so the rows sum to 39.

Pin the version in your tooling, as the filename above does. ATT&CK IDs are stable but not permanent. Version 19 revoked T1562.001 Disable or Modify Tools and replaced it with T1685. A detection rule still tagged T1562.001 now points at a revoked object. Treat ATT&CK like any other dependency: lock the version, read the [changelog](https://attack.mitre.org/docs/changelogs/v19.2-v20.0/changelog-detailed.html), and migrate on purpose.

## Where ATT&CK's supply chain guidance falls short

ATT&CK attaches four mitigations to T1195.001. Read against Shai-Hulud, each one has a gap:

- **M1033 Limit Software Installation** says to pull from internal repositories of "verified and approved packages." The instinct is right. But an internal mirror that syncs from npm also syncs the worm, unless something inspects each new version before it lands.
- **M1016 Vulnerability Scanning** asks for monitoring of vulnerability sources. A worm-infected release has no CVE when it ships, so a CVE scanner sees nothing. The useful part of M1016 is its passing mention of code review tools.
- **M1051 Update Software** asks for a patch process that weeds out unused and unmaintained dependencies. Every Shai-Hulud wave rode freshly published versions into installs that resolved to the newest match. Updating fast with no quarantine period is the exposure.
- **M1013 Application Developer Guidance** recommends locking dependencies to specific versions and pinning GitHub Actions to commit hashes. Lockfiles keep existing installs deterministic. They do not cover [code that `npx` or a global install fetches at run time](https://socket.dev/blog/hidden-blast-radius-of-the-axios-compromise), as the [Axios compromise](https://socket.dev/blog/axios-npm-package-compromised) showed.

None of the four mentions disabling [install scripts](https://socket.dev/glossary/postinstall-scripts), waiting out a release-age cooldown, or analyzing a package's contents before install. The package managers moved first. [pnpm 10 blocked lifecycle scripts by default](https://socket.dev/blog/pnpm-10-0-0-blocks-lifecycle-scripts-by-default) in January 2025. [npm v12](https://socket.dev/blog/npm-12) shipped with `allowScripts` off by default on July 8, 2026.

The technique catalog has a matching hole. As of v20, no technique description mentions package manager lifecycle hooks. T1546.016 Installer Packages was written for operating system installers, and its text cites macOS `postinstall` scripts. MITRE stretches it to cover npm hooks in the Shai-Hulud entry. Almost every npm worm and credential stealer since late 2025 ran at install time, before any application code loaded. Install-time execution deserves its own technique.

Detection has the same timing problem. The detection strategy for T1195.001 is DET0009, named "Supply-chain tamper in dependencies/dev-tools (manager→write/install→first-run→egress)." Its three analytics, for Windows, Linux, and macOS, look for a package manager writing files, a lifecycle hook spawning a shell or `curl`, and then outbound traffic to an unfamiliar registry or domain. That is an accurate description of package malware. It is also a post-execution detection: every condition requires the payload to have already run.

> Timeline of a malicious package from publish to exfiltration, showing that pre-install controls act before the install script runs and ATT&CK detection strategy DET0009 acts after it runs

The figure splits a malicious npm release into five steps. Steps 1 to 3 happen before any attacker code runs: the attacker publishes the version (T1608.001), the package manager resolves a version range to it, and the tarball downloads. Package analysis, firewall blocking, release-age cooldowns, and install-script gating all act in this window. Step 4 is the install script executing (T1546.016), and step 5 is credential theft and exfiltration (T1552 and T1567). DET0009 can only fire in steps 4 and 5, after the payload runs.

The behaviors DET0009 watches for at runtime are usually visible in the tarball beforehand. Socket's static analysis raises [alerts](https://socket.dev/alerts) such as Install scripts, Network access, Shell access, and Environment variable access from a package's code before it is installed, and a [package firewall](https://socket.dev/glossary/package-firewall) can block known-malicious versions at the registry request. In the LiteLLM compromise, our AI scanner flagged all seven malicious wheels seven minutes after they were published. Pre-install analysis has a limit, too. It judges the code that ships, so a small loader that fetches its real payload at run time can look like an ordinary network call. Runtime detection in the spirit of DET0009 remains a useful second layer. It should not be the first.

## How do you use MITRE ATT&CK?

You use MITRE ATT&CK by tagging observed behavior with technique IDs, then querying those tags across reports, detections, and tests. For a team defending a software supply chain, four uses pay off.

**Tag [threat intelligence](https://socket.dev/glossary/threat-intelligence).** Our threat reports end with an ATT&CK list. The LiteLLM report lists nine techniques, including T1546.018 Python Startup Hooks and T1552.005 Cloud Instance Metadata API. Shared IDs let you join a vendor report to your own detections and to MITRE's group and software pages without rereading prose.

**Map detections to analytics, not to tactics.** Pull the DET and AN objects for the techniques you care about. Then check whether your CI runners and developer laptops produce the telemetry those analytics assume: process lineage from `npm` or `pip`, file writes under `node_modules` or `site-packages`, and outbound connections. Check ephemeral build runners first. They are where package malware runs, and they are easy to leave out of endpoint telemetry.

**Emulate.** Replay a mapped behavior in a disposable runner. A test package with a `postinstall` hook that reads environment variables and makes one outbound request exercises T1546.016, T1552.001, and T1071.001. Confirm that something fires, and note which step it fired at.

**Measure coverage honestly.** Heatmaps in ATT&CK Navigator tempt teams to paint cells green. MITRE's own paper warns: "ATT&CK is not an exhaustive enumeration of attack vectors against software." A green T1195.001 cell says nothing about whether you would catch a worm's preinstall hook in CI, or a [maintainer account takeover](https://socket.dev/glossary/maintainer-account-takeover) that publishes through a legitimate pipeline.

ATT&CK's leftmost tactics, Reconnaissance and Resource Development, are the ones defenders usually cannot see, because they happen on attacker infrastructure. Package malware inverts that. T1608.001 Upload Malware happens on a public registry, the tarball is downloadable by anyone, and it sits there before T1195.001 ever reaches you. Open source is the rare case where the attacker's resource development is public and inspectable before initial access. That window is where supply chain detection belongs, and it is the one ATT&CK's own T1195.001 guidance never mentions.
