Your Eyes in the DarkYour Eyes in the Dark — Proactive Intelligence

Threat Intelligence/Knowledge

The Pyramid of Pain Explained: How to Actually Hurt an Attacker

3 min read

If your security program is measured by how many bad IP addresses and file hashes you blocked this month, you may be working hard while barely inconveniencing your adversaries. The Pyramid of Pain, a model created by security researcher David Bianco, explains why, and it remains one of the most useful ways to think about threat detection.

The core idea
The Pyramid of Pain ranks the types of indicators you can detect and block by one measure: how much pain it causes the attacker when you take that indicator away. The indicators at the bottom are trivial for an attacker to change. The ones at the top force them to rethink their entire operation.

The goal isn't just to detect threats. It's to detect them in a way that makes your adversary's life as difficult and expensive as possible.

The six levels, from bottom to top

1. Hash Values — Trivial
A hash is a unique fingerprint of a specific file. Blocking a known malicious hash feels like a win, but it's the weakest control there is. An attacker only has to change a single byte and recompile, and the file gets a completely new hash while behaving exactly the same. You've cost them seconds.

2. IP Addresses — Easy
Blocking the IP addresses that malware communicates with is slightly better, but attackers rotate through cheap, disposable infrastructure constantly. Block one address and they move to another, often within minutes. Still worth doing at scale, but it won't stop a determined actor for long.

3. Domain Names — Simple
Domains take a little more effort to change than IPs, because the attacker has to register and configure new ones. But bulk registration and domain generation algorithms make this close to automatic for well-resourced groups. You're adding friction, not a real barrier.

4. Network and Host Artifacts — Annoying
This is where it starts to hurt. Artifacts are the traces an attacker's activity leaves behind: distinctive user-agent strings, registry keys, dropped files in specific paths, service names, or particular patterns in network traffic. Detecting these forces the attacker to go back and modify their tooling, which is real work.

5. Tools — Challenging
If you can detect and block a specific tool the attacker relies on, such as a particular remote access trojan, credential dumper, or command-and-control framework, you take away a capability. Now they have to find a replacement or build a new one, which costs time, money, and sometimes operational security.

6. TTPs — Tough
At the top sit Tactics, Techniques, and Procedures: not the tools an attacker uses, but how they operate. This covers the behaviors behind an intrusion, such as how they move laterally, escalate privileges, or exfiltrate data. If you can detect the behavior itself, the attacker has to relearn their entire craft to evade you. This is so costly that many simply move on to an easier target.

Why it matters for defenders
Most organizations concentrate their effort at the bottom of the pyramid, ingesting huge feeds of hashes, IPs, and domains. It feels productive and it's easy to measure, but it produces the least pain for a capable adversary, who can swap those indicators out faster than you can block them.

The teams that build real resilience climb the pyramid. They invest in detecting behavior, host and network artifacts, tooling, and ultimately TTPs. Frameworks like MITRE ATT&CK are so valuable precisely because they help defenders operate at the top of the pyramid, focusing on techniques rather than disposable indicators.

The takeaway
Lower-level indicators still have their place. They're cheap, fast, and good for catching commodity threats and automated attacks at scale. But they should be the floor of your detection strategy, not the ceiling.

The real question to ask about your program isn't "how many indicators did we block?" It's "how much pain are we actually causing our adversaries?" The higher up the pyramid you can operate, the harder it becomes for an attacker to succeed against you, and the more likely they are to give up and look elsewhere.

Credit to David Bianco, who created the Pyramid of Pain model.

Get the latest dark web news in your inbox

Ransomware, breaches and exploited vulnerabilities, from The Darkweb News.

Free. No spam. Unsubscribe in one click.

Latest news

FBI Investigating Apparent Hack of National Crime Information Center (NCIC) Database

Threat Intelligence

The FBI is investigating an apparent hack of the National Crime Information Center (NCIC), a national law enforcement database it maintains, according to a person familiar with the matter. What the NCIC is The NCIC is a computerized database of criminal justice information available to local, state, and federal law enforcement agencies. It includes records on: * Fugitives * Missing persons * Criminal history data * Stolen property * And other topics Maintained by the FBI's Criminal Justi

Microsoft Entra Connect Health Flaw Exposed Tenant Admin Emails and Metadata

Threat Intelligence

Microsoft has fixed a vulnerability in Microsoft Entra Connect Health that attackers exploited to read tenant-level metadata, and it has begun notifying affected organizations. Microsoft deployed a server-side fix on 19 November 2026. It then reviewed its telemetry for unauthorized API calls and finished the investigation on 20 November. Affected customers are being told through Azure Service Health that unauthorized read-only access to their tenant metadata took place. Microsoft says it found

Ruby Patches “Ruby2Shell” Vulnerability That Could Lead to Remote Code Execution

Zero-Day / Patch

Fresh security updates for the Ruby programming language fix seven vulnerabilities in its regular expression engine and in string case conversion. Proof-of-concept (PoC) code demonstrating remote code execution (RCE) exists for five of them. The main flaw: Ruby2Shell (CVE-2026-132825) The top vulnerability, CVE-2026-132825 (CVSS 7.4), is a heap-based buffer overflow in string case conversion that could lead to RCE in certain scenarios. It’s been dubbed Ruby2Shell. How it works The flaw affects