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

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.



