SyntaxPilot
Courses/Cybersecurity Fundamentals/Lesson 74
Video coming soonThis lesson’s video is being made

Start with the notes below; the video appears here as soon as it is on YouTube.

Cybersecurity Fundamentals · Lesson 74 of 90

The SOC, threat intelligence and threat hunting

security operations centre (SOC)SOC tierstriageescalationrunbooksplaybooksMTTDMTTRthreat intelligence (strategic, tactical, operational)IoC feedsSTIX and TAXIIISACsPyramid of Painthreat hunting

These are the notes for Cybersecurity Fundamentals (defensive), episode 74. Episode 73 built a SIEM that turns a billion log lines into a few alerts. But an alert is only a beep: at 3 a.m., who answers it? This episode invents the team that answers (the SOC), how it decides what to look at first, how it learns from other defenders (threat intelligence), and how it goes looking for attackers no alert has found (threat hunting). Every term is defined the first time it appears; the Glossary collects them.

Scope. Defensive and educational only. Every program is a toy simulation on made-up data; IP addresses come from documentation ranges and domains end in .example. Samples were run on 14 Nov 2026 in Python 3, the same code as in the SyntaxPilot compiler in the video.

The emergency room

Real-life example: a hospital emergency room at night. Patients arrive all the time, sometimes ten at once: a sprained finger, a fever, a man with chest pain. The triage nurse does not take them in arrival order: chest pain first. Junior doctors handle most cases; hard ones go up to specialists. It is open 24 hours, with a written procedure for each emergency.

  • SOC (Security Operations Centre): the team (and often the room) that monitors an organisation's systems around the clock, handles alerts, investigates and responds. A SOC is people + process + technology (the SIEM, EDR and SOAR of earlier episodes).

Step 1: who answers, and in what order?

Demo 1: first come, first served vs triage

# 02:00 a.m. The SIEM's alert queue. One analyst, 15 minutes per alert.
queue = [("01:52", "failed login, 1 time", "low",      "test laptop"),
         ("01:54", "port scan from outside", "low",    "web server"),
         ("01:55", "new browser extension", "low",     "intern laptop"),
         ("01:57", "files renamed .locked x900", "critical", "payroll server"),
         ("01:58", "impossible travel", "medium",      "sales laptop")]

print("first come, first served:")
for n, (t, what, sev, asset) in enumerate(queue):
    print(f"   +{n * 15:2} min  {sev:8} {what:28} {asset}")

SEV = {"critical": 4, "high": 3, "medium": 2, "low": 1}
CRIT = {"payroll server": 3, "web server": 2, "sales laptop": 2}
def priority(a): return SEV[a[2]] * CRIT.get(a[3], 1)
print("triaged (severity x asset criticality):")
for n, (t, what, sev, asset) in enumerate(sorted(queue, key=priority, reverse=True)):
    print(f"   +{n * 15:2} min  {sev:8} {what:28} {asset}")

Real output:

first come, first served:
   + 0 min  low      failed login, 1 time         test laptop
   +15 min  low      port scan from outside       web server
   +30 min  low      new browser extension        intern laptop
   +45 min  critical files renamed .locked x900   payroll server
   +60 min  medium   impossible travel            sales laptop
triaged (severity x asset criticality):
   + 0 min  critical files renamed .locked x900   payroll server
   +15 min  medium   impossible travel            sales laptop
   +30 min  low      port scan from outside       web server
   +45 min  low      failed login, 1 time         test laptop
   +60 min  low      new browser extension        intern laptop
  • First come, first served makes the ransomware alert (900 files renamed .locked on the payroll server) wait 45 minutes behind a single failed login, a port scan and a browser extension.
  • Triage: quickly sorting alerts by urgency and deciding which are real, so the most dangerous are handled first.
  • Asset criticality: how important the affected system is to the business (payroll server 3, test laptop 1).
  • Priority here = severity × asset criticality; real SOCs also weigh confidence, data sensitivity and whether the activity is still happening.

SOC tiers and escalation

Tier Typical work
Tier 1 (triage analyst) watch the alert queue, triage, close false positives with a reason, escalate real ones
Tier 2 (incident responder) deep investigation: what happened, how far it spread, containment
Tier 3 (expert / threat hunter) malware analysis, forensics, threat hunting, building detections
SOC manager shifts, metrics, reporting to the CISO
  • SOC tiers: levels of skill and responsibility inside a SOC.
  • Escalation: handing a case up a tier (or to another team) with your notes, so nobody starts from zero.
  • CISO (Chief Information Security Officer): the senior leader responsible for security.
  • Closing a false positive with the reason written down feeds back into tuning (episode 73).

Step 2: doing it the same way every time

Demo 2: two analysts, one alert, no runbook

# Two analysts, same 'phishing reported' alert. Without a runbook:
asha = ["read email", "delete email"]
ravi = ["read email", "check sender", "block sender domain", "search who else got it"]

RUNBOOK = ["read email", "check sender", "check links and attachments in a sandbox",
           "search who else got it", "pull it from every inbox",
           "block sender domain", "reset password if anyone clicked", "write notes"]

for name, steps in (("asha", asha), ("ravi", ravi)):
    missed = [s for s in RUNBOOK if s not in steps]
    print(f"{name}: did {len(steps)} steps, MISSED {len(missed)}, e.g. '{missed[-2]}'")

print("with the runbook, every analyst, every time:")
for i, step in enumerate(RUNBOOK, 1): print(f"   [x] {i}. {step}")

Real output:

asha: did 2 steps, MISSED 7, e.g. 'reset password if anyone clicked'
ravi: did 4 steps, MISSED 4, e.g. 'reset password if anyone clicked'
with the runbook, every analyst, every time:
   [x] 1. read email
   [x] 2. check sender
   [x] 3. check links and attachments in a sandbox
   [x] 4. search who else got it
   [x] 5. pull it from every inbox
   [x] 6. block sender domain
   [x] 7. reset password if anyone clicked
   [x] 8. write notes
  • Runbook: a written, step-by-step checklist for one specific task ("handle a reported phishing email"), so every analyst does every step every time. Like the hospital's procedure card for a heart attack.
  • Playbook: the bigger plan for a whole kind of situation (phishing, ransomware, lost laptop): who is involved, which decisions to take, which runbooks to use at each stage. A SOAR playbook (episode 73) automates some of its steps.
  • Sandbox: an isolated environment where a suspicious link or attachment can be opened safely to see what it does.

Step 3: are we getting better?

Demo 3: MTTD and MTTR

# Are we getting better? Time from attack start to detection, and to response.
from datetime import datetime
incidents = [("2026-11-01 02:00", "2026-11-01 02:40", "2026-11-01 04:10"),  # start, detected, contained
             ("2026-11-05 10:00", "2026-11-05 10:20", "2026-11-05 11:00"),
             ("2026-11-09 23:00", "2026-11-11 09:00", "2026-11-11 15:00"),
             ("2026-11-12 14:00", "2026-11-12 14:15", "2026-11-12 14:45")]
def hours(a, b):
    return (datetime.fromisoformat(b) - datetime.fromisoformat(a)).total_seconds() / 3600

detect = [hours(s, d) for s, d, c in incidents]
respond = [hours(d, c) for s, d, c in incidents]
for (s, d, c), x, y in zip(incidents, detect, respond):
    print(f"{s}  detected after {x:5.1f} h, contained {y:4.1f} h later")
print(f"MTTD = {sum(detect) / len(detect):.1f} hours   MTTR = {sum(respond) / len(respond):.1f} hours")
print("worst detection:", incidents[detect.index(max(detect))][0], "-> why so slow?")

Real output:

2026-11-01 02:00  detected after   0.7 h, contained  1.5 h later
2026-11-05 10:00  detected after   0.3 h, contained  0.7 h later
2026-11-09 23:00  detected after  34.0 h, contained  6.0 h later
2026-11-12 14:00  detected after   0.2 h, contained  0.5 h later
MTTD = 8.8 hours   MTTR = 2.2 hours
worst detection: 2026-11-09 23:00 -> why so slow?
  • MTTD (Mean Time To Detect): the average time from when an attack starts to when it is detected; how long attackers are inside before you notice.
  • MTTR (Mean Time To Respond, sometimes "to Recover/Resolve"): the average time from detection to containment (or full recovery). Always state which one you mean.
  • Mean: the average; one 34-hour detection pulls the average to 8.8 hours, which is exactly why you look at the worst case and ask why (a missing log source? a rule that did not fire?).
  • Measure to improve, not to push analysts into closing alerts unread.

Step 4: learning from other defenders

Threat intelligence

Threat intelligence: evidence-based information about threats (who, what, how, indicators) that helps you make decisions and act. Like weather information it comes in three kinds:

Kind Weather analogy Example Audience
Strategic season outlook: "heavy monsoon this year" ransomware gangs are targeting hospitals this year leaders, budgets, risk
Operational cyclone warning: "landfall Thursday, these districts" a campaign of fake KYC messages targeting bank customers this week SOC leads, incident responders
Tactical street alert: "MG Road underpass flooded" bad IPs, domains, file hashes; attacker TTPs analysts and tools
  • IoC (Indicator of Compromise): an observable sign that a system may be compromised: a malicious IP address, domain, file hash, registry key.
  • TTPs (Tactics, Techniques and Procedures): how an attacker operates, from the goal (tactic) to the method (technique) to their specific way of doing it (procedure).

Demo 4: an IoC feed

IoC feed: a regularly updated list of indicators that other defenders have already seen, delivered so tools can use it automatically.

# Threat intelligence feed: indicators other defenders have already seen.
feed = {"ip":     {"192.0.2.44", "198.51.100.23"},
        "domain": {"paytm-kyc-update.example", "chai-invoice.example"},
        "sha256": {"9f86d081884c7d65"}}                 # shortened for the screen

our_logs = [("ip", "203.0.113.9"), ("domain", "chai-invoice.example"),
            ("ip", "192.0.2.44"), ("sha256", "2c26b46b68ffc68f"),
            ("domain", "mail.google.com"), ("sha256", "9f86d081884c7d65")]

for kind, value in our_logs:
    hit = value in feed[kind]
    print(f"{kind:6} {value:27}", "<- MATCH: seen elsewhere" if hit else "")
print("matches:", sum(v in feed[k] for k, v in our_logs), "of", len(our_logs))

Real output:

ip     203.0.113.9                 
domain chai-invoice.example        <- MATCH: seen elsewhere
ip     192.0.2.44                  <- MATCH: seen elsewhere
sha256 2c26b46b68ffc68f            
domain mail.google.com             
sha256 9f86d081884c7d65            <- MATCH: seen elsewhere
matches: 3 of 6

Feed quality matters: stale entries or a popular site added by mistake cause floods of false positives. Good feeds record where each indicator came from, a confidence level and an expiry date.

Demo 5: STIX and TAXII

A hundred organisations sending intelligence as spreadsheets, PDFs and emails cannot be read by tools. The fix is a shared, machine-readable format.

  • STIX (Structured Threat Information Expression): the OASIS standard for sharing cyber threat intelligence; STIX 2 uses JSON as its mandatory format. Objects include indicators, malware, threat actors, campaigns and their relationships.
  • TAXII (Trusted Automated Exchange of Intelligence Information): the protocol for exchanging STIX, "an application layer protocol on top of HTTPS"; tools fetch new intelligence automatically from a TAXII server. STIX is the letter, TAXII the postal service.
  • OASIS: a standards organisation that maintains STIX and TAXII.
# STIX 2.1: threat intelligence in a standard JSON format (simplified indicator).
import json, re
received = '''{"type": "indicator", "spec_version": "2.1",
  "id": "indicator--a1b2c3", "name": "Fake KYC update phishing server",
  "pattern": "[ipv4-addr:value = '198.51.100.23']", "pattern_type": "stix",
  "valid_from": "2026-11-13T00:00:00Z", "indicator_types": ["malicious-activity"]}'''

ind = json.loads(received)
ip = re.search(r"value = '([^']+)'", ind["pattern"])[1]
print("type     :", ind["type"], ind["spec_version"])
print("name     :", ind["name"])
print("indicator:", ip, "| valid from", ind["valid_from"][:10])

firewall_log = ["203.0.113.9", "198.51.100.23", "192.0.2.10"]
print("seen in our firewall log:", [x for x in firewall_log if x == ip])

Real output:

type     : indicator 2.1
name     : Fake KYC update phishing server
indicator: 198.51.100.23 | valid from 2026-11-13
seen in our firewall log: ['198.51.100.23']

Real STIX IDs are a type plus a UUID (indicator-- followed by 36 characters); the toy shortens it. The pattern uses the STIX Patterning Language.

  • ISAC (Information Sharing and Analysis Centre): a group where organisations in the same industry (banks, hospitals, energy companies) share threat information with each other, because an attack on one bank today is often an attack on the next bank tomorrow.

Step 5: what actually hurts attackers

Demo 6: one byte and one IP later

# The attacker changes ONE byte of the malware and moves to a new IP.
from hashlib import sha256
malware_v1 = b"toy-sample: open payroll.xlsx, rename to .locked"
malware_v2 = malware_v1 + b" "                         # one extra byte
known_bad = {"hash": sha256(malware_v1).hexdigest()[:16], "ip": "192.0.2.44"}

today = {"hash": sha256(malware_v2).hexdigest()[:16], "ip": "192.0.2.45",
         "behaviour": "winword.exe -> powershell.exe -enc ..."}
print("yesterday's hash:", known_bad["hash"])
print("today's hash    :", today["hash"])
print("hash rule fires?", today["hash"] == known_bad["hash"])
print("IP rule fires?  ", today["ip"] == known_bad["ip"])
ttp = "winword.exe -> powershell.exe" in today["behaviour"]      # T1059.001
print("behaviour rule (Word starts PowerShell) fires?", ttp)

Real output:

yesterday's hash: 21f8a876a1d7eb94
today's hash    : 726605a36a0df737
hash rule fires? False
IP rule fires?   False
behaviour rule (Word starts PowerShell) fires? True

Adding one byte changes the hash completely (the avalanche effect, episode 13), and moving to the next IP costs the attacker a second. The behaviour, Word starting PowerShell (ATT&CK T1059.001), is still caught.

The Pyramid of Pain (David Bianco, 2013)

Level (bottom to top) Cost to the attacker of changing it
Hash values trivial
IP addresses easy
Domain names simple
Network and host artifacts annoying
Tools challenging
TTPs tough
  • Artifacts: traces the attacker's activity leaves on the network (a distinctive URL path, a user-agent string) or on hosts (a registry key, a file name, a service).
  • The higher up you detect, the more pain you cause, because the attacker must change how they work, not just what they use. Feeds of hashes and IPs are still useful (cheap, fast), but invest in behaviour detections near the top.

Step 6: looking, not waiting

Demo 7: a hypothesis-driven hunt with stack counting

# Hypothesis: "an attacker added a scheduled task to survive reboots".
# Hunt: count every (parent -> child) process pair across 500 laptops; look at the RARE ones.
from collections import Counter
pairs = (["explorer.exe -> chrome.exe"] * 4120 + ["services.exe -> svchost.exe"] * 3900 +
         ["explorer.exe -> excel.exe"] * 860 + ["svchost.exe -> taskhostw.exe"] * 500 +
         ["schtasks.exe -> powershell.exe"] * 1 +           # one laptop, 3:04 a.m.
         ["explorer.exe -> notepad.exe"] * 214)

counts = Counter(pairs)
print("most common (normal):")
for pair, n in counts.most_common(2): print(f"   {n:5}  {pair}")
print("rarest (look here first):")
for pair, n in sorted(counts.items(), key=lambda kv: kv[1])[:2]: print(f"   {n:5}  {pair}")
print("no alert ever fired for it: no rule was looking.")

Real output:

most common (normal):
    4120  explorer.exe -> chrome.exe
    3900  services.exe -> svchost.exe
rarest (look here first):
       1  schtasks.exe -> powershell.exe
     214  explorer.exe -> notepad.exe
no alert ever fired for it: no rule was looking.
  • Threat hunting: proactively searching your data for attackers who slipped past your detections, instead of waiting for an alert.
  • Hypothesis: a testable guess, e.g. "an attacker added a scheduled task to survive reboots" (ATT&CK Persistence).
  • Hypothesis-driven hunting: start from a hypothesis based on intelligence, ATT&CK or a recent incident; test it with data; whatever the result, document it and turn what you learned into a new detection rule.
  • Stack counting (least frequency analysis): count how often each value appears (here parent → child process pairs) and examine the rarest first. Attackers are usually rare.
  • Persistence: an attacker's way of surviving reboots and logouts (scheduled tasks, new services, startup entries).

MDR

  • MDR (Managed Detection and Response): a service where a provider's SOC monitors your systems 24 × 7, triages, hunts and helps respond. Useful when you cannot staff round-the-clock shifts yourself.
  • You still own the risk and the decisions. Ask: which of our logs will you see? How quickly will you call us? Which actions (such as isolating a laptop) can you take without asking? How do we get the data back if we leave?

The whole chain

  1. Who answers at 3 a.m.? → SOC, tiers, escalation.
  2. Ransomware waits behind noise → triage.
  3. Same alert, different steps → runbooks, playbooks.
  4. Are we getting better? → MTTD, MTTR.
  5. Others saw it first → threat intelligence, IoC feeds, STIX, TAXII, ISACs.
  6. One byte dodges the feed → the Pyramid of Pain.
  7. No rule was looking → threat hunting; no team → MDR.

Common mistakes (and the fix)

Mistake What you see Why Fix
alerts in arrival order ransomware waits 45 minutes no triage severity × asset criticality
every analyst improvises MISSED 7, e.g. 'reset password if anyone clicked' no runbook runbooks per task, playbooks per situation
closing false positives silently the same noise every night no feedback to tuning close with a reason, tune the rule
only averages MTTD 8.8 h hides a 34 h miss outliers hidden look at the worst cases and ask why
blocking only hashes and IPs hash rule fires? False bottom of the Pyramid of Pain detect behaviour (TTPs)
trusting every feed entry a popular site blocked low-quality intelligence source, confidence, expiry for each IoC
only waiting for alerts 1 schtasks.exe -> powershell.exe, no alert rules see only what we expect hypothesis-driven hunting

Mini project: a mini SOC day

Simulate 20 alerts with severity, asset and timestamps. (1) Triage them into a priority queue, (2) route each to Tier 1, 2 or 3 by priority, (3) run a runbook checklist for phishing alerts and report skipped steps, (4) match their indicators against a small STIX-like feed, and (5) compute MTTD and MTTR and print the slowest incident.

Practice

1. Add "asset owner" to the triage toy and print it next to each alert.

Solution
OWNER = {"payroll server": "finance", "web server": "it-ops", "sales laptop": "sales"}
for n, a in enumerate(sorted(queue, key=priority, reverse=True)):
    print(f"   +{n * 15:2} min  {a[2]:8} {a[1]:28} {a[3]:15} owner={OWNER.get(a[3], '?')}")

2. Write a runbook for "a laptop is reported lost".

Solution
  1. Record who, when, where, which device. 2. Check disk encryption status in device management. 3. Lock or wipe the device remotely. 4. Revoke its sessions and certificates; reset the user's password. 5. Check for logins from that device after the loss time. 6. Decide if personal data was on it (legal/DPDP review). 7. Report to police if required; write notes and close.

3. Add an expiry date to each feed entry and ignore expired ones.

Solution
from datetime import date
feed = {"192.0.2.44": date(2026, 12, 1), "198.51.100.23": date(2026, 10, 1)}
today = date(2026, 11, 14)
live = {ioc for ioc, expires in feed.items() if expires >= today}
print(live)   # {'192.0.2.44'}

4. Hunt: find each user's rarest login hour.

Solution
from collections import Counter
logins = {"ravi": [9, 10, 9, 11, 10, 3], "neha": [14, 15, 14, 14]}
for user, hours in logins.items():
    hour, n = min(Counter(hours).items(), key=lambda kv: kv[1])
    print(user, "rarest hour:", hour, f"({n}x)")
# ravi rarest hour: 11 (1x)   <- ties: also check 3 a.m.!
# neha rarest hour: 15 (1x)

Ties matter: print every value with the minimum count, not just one.

5. Strategic, operational or tactical? (a) "SHA-256 of this loader"; (b) "this gang's campaign hits Indian NBFCs next week via fake KYC SMS"; (c) "ransomware losses doubled in healthcare".

Answer(a) tactical, (b) operational, (c) strategic.

Quick quiz

A: a file hash
B: an IP address
C: a domain name
D: a behaviour, like Word starting PowerShell

Which detection causes the attacker the MOST pain to get around?

Answer

D. A behaviour is a TTP, the top of the Pyramid of Pain: the attacker must change how they work. Hashes, IPs and domains change in seconds.

Interview questions

  1. What is a SOC and what does it do? A team that monitors, triages, investigates and responds to security events around the clock, using people, process and technology.
  2. Describe SOC tiers. Tier 1 triage, Tier 2 investigation and response, Tier 3 expert analysis and hunting; a manager runs shifts and metrics.
  3. How do you triage alerts? By severity, asset criticality, confidence, data involved and whether it is ongoing; close false positives with a reason.
  4. Runbook vs playbook? A runbook is a step-by-step checklist for one task; a playbook is the overall plan and decisions for a type of incident, referencing runbooks.
  5. Define MTTD and MTTR. Mean time to detect (attack start → detection) and mean time to respond/recover (detection → containment/recovery).
  6. Three types of threat intelligence? Strategic (trends, for leaders), operational (specific campaigns), tactical (IoCs and TTPs for tools and analysts).
  7. What are STIX and TAXII? STIX is the JSON standard for describing threat intelligence; TAXII is the HTTPS-based protocol to exchange it.
  8. What is an ISAC? An industry group for sharing threat information between member organisations.
  9. Explain the Pyramid of Pain. Indicators ranked by how hard they are for attackers to change: hashes, IPs, domains, artifacts, tools, TTPs; detect higher up.
  10. What is threat hunting? Proactive, hypothesis-driven searching for threats that evaded detection, ending in new detections.
  11. When would you choose MDR? When you cannot staff a 24×7 SOC; check log coverage, response times, allowed actions and data ownership.

Glossary

Term Meaning
SOC Security Operations Centre: the team that monitors, triages and responds 24×7
triage quickly sorting alerts by urgency and deciding which are real
asset criticality how important an affected system is to the business
priority the order to handle alerts (here severity × asset criticality)
SOC tiers levels of skill and responsibility: Tier 1, 2, 3
escalation handing a case up a tier or to another team, with notes
CISO Chief Information Security Officer
runbook a step-by-step checklist for one task
playbook the plan and decisions for a type of situation, using runbooks
sandbox an isolated place to open suspicious files or links safely
MTTD Mean Time To Detect
MTTR Mean Time To Respond (or Recover/Resolve)
mean the average of a set of numbers
threat intelligence evidence-based information about threats that supports decisions and action
strategic intelligence high-level trends and risks, for leaders
operational intelligence details of specific campaigns: who, when, how
tactical intelligence IoCs and TTPs used directly by analysts and tools
IoC Indicator of Compromise: an observable sign of compromise (IP, domain, hash)
TTPs Tactics, Techniques and Procedures: how an attacker operates
IoC feed a regularly updated list of indicators for tools to use
confidence, expiry how sure a feed is about an indicator; when it stops being valid
STIX Structured Threat Information Expression: the OASIS JSON standard for threat intelligence
TAXII Trusted Automated Exchange of Intelligence Information: the HTTPS protocol to exchange STIX
OASIS the standards body that maintains STIX and TAXII
ISAC Information Sharing and Analysis Centre: an industry sharing group
Pyramid of Pain David Bianco's ranking of indicators by how painful they are for attackers to change
artifact a trace an attacker's activity leaves on the network or a host
threat hunting proactively searching for attackers who evaded detection
hypothesis a testable guess about attacker activity
hypothesis-driven hunting hunting that starts from a hypothesis and ends in a detection
stack counting counting values and examining the rarest (least frequency analysis)
persistence an attacker's method of surviving reboots and logouts
MDR Managed Detection and Response: an outsourced 24×7 detection and response service

Summary

  • A SOC answers alerts 24×7: triage by urgency, tiers and escalation with notes.
  • Runbooks (checklists) and playbooks (plans) make every response complete and consistent.
  • MTTD and MTTR show whether you are improving; study the worst cases.
  • Threat intelligence (strategic, operational, tactical) arrives as IoC feeds, in STIX over TAXII, often via ISACs.
  • The Pyramid of Pain: detect behaviour (TTPs), not just hashes and IPs.
  • Threat hunting finds what no rule catches; MDR gives a SOC to those who cannot staff one.
  • Next episode: incident response.

Sources (fetched 14 Nov 2026)

  • OASIS CTI documentation, The transition to STIX/TAXII 2: https://oasis-open.github.io/cti-documentation/stix/compare
  • Sqrrl / threathunting.net, A Framework for Cyber Threat Hunting Part 1: The Pyramid of Pain: https://www.threathunting.net/files/A%20Framework%20for%20Cyber%20Threat%20Hunting%20Part%201_%20The%20Pyramid%20of%20Pain%20_%20Sqrrl.pdf
  • MITRE ATT&CK, T1059.001 Command and Scripting Interpreter: PowerShell: https://attack.mitre.org/techniques/T1059/001/
  • SOCRadar, What is the Pyramid of Pain (difficulty labels): https://socradar.io/cyber-faq/what-is-the-pyramid-of-pain/