These are the notes for Cybersecurity Fundamentals (defensive), episode 4. Last time we invented the design principles (least privilege, defence in depth, fail secure and more), always imagining "the attacker". Today we meet them: who attacks, why, and how an attack unfolds step by step. You'll invent each idea by breaking a small Python program and fixing it: opportunistic vs targeted attacks and script kiddies, the threat actors (hacktivists, cybercriminals, organised crime, insiders, nation-states) and their motives, insider threats (malicious and negligent) caught with a behaviour baseline, APTs, the Lockheed Martin cyber kill chain, MITRE ATT&CK with tactics, techniques and procedures (TTPs), and indicators of compromise vs indicators of attack. Every term is explained the first time it appears, and the Glossary at the end defines them all again. Every code sample runs as-is; outputs are real (Python 3). All sites, people and files are made up.
The problems you'll solve
| Problem | Idea it teaches |
|---|---|
| "Who would hack a chai stall?" | Opportunistic vs targeted attacks, script kiddies, bots |
| Who attacks, and what do they want? | Threat actors and motives (money, espionage, disruption) |
| Dev downloads 480 files and every check says "allowed" | Insider threats (malicious, negligent), behaviour baselines |
| A spy who moves in next door | APT (advanced persistent threat) |
| "We only noticed at the end" | The cyber kill chain: break one link, early |
| "Exploitation" is too vague to act on | MITRE ATT&CK tactics, techniques, procedures (TTPs) |
| The blocked file is back with one byte changed | Indicator of compromise (IoC) vs indicator of attack (IoA) |
Problem 1: "we're too small to be attacked"
Raju puts his chai stall's orders on a small website and keeps the admin password as admin. "Who would hack a chai stall?" But nobody needs to choose Raju: a bot (a program that runs by itself, short for robot) goes through thousands of sites trying the same few passwords on each.
Demo 1: the bot doesn't care about size
A safe simulation on made-up sites: each site's real password is stored in a dictionary, and we check whether it's one of three very common passwords.
# one bot, a list of sites, three common passwords
sites = {"bigbank.in": "Vq7#mR2!pL9z",
"chai-stall.in": "admin",
"school.org": "Gh4$wN8@kT1x",
"dentist.in": "123456"}
common = ["123456", "password", "admin"]
for site, real in sites.items(): # nobody chose them
if real in common:
print(f"{site:14} broken: '{real}'")
else:
print(f"{site:14} failed")
Output:
bigbank.in failed
chai-stall.in broken: 'admin'
school.org failed
dentist.in broken: '123456'
The bot never looked at size. It looked for the weakest password.
Opportunistic vs targeted
- An opportunistic attack hits anyone who happens to be weak. Like a thief walking down a street trying every car door and taking whichever is unlocked.
- A targeted attack picks one victim, studies it, then strikes.
- A script kiddie is an attacker with little skill who runs ready-made tools and scripts written by others. Many opportunistic attacks are this kind.
Lesson: nobody is too small. The good news: the basics (a strong unique password, updates, no default credentials) stop most bots.
Problem 2: who attacks, and why
A threat actor is any person or group that could carry out a threat (episode 1: a threat is anything that could cause harm). Think of the people who break into a city:
| In a city | Online | What they want |
|---|---|---|
| A kid trying door handles for fun | Script kiddie: little skill, ready-made tools | Fun, fame, curiosity |
| A protester with spray paint | Hacktivist (hacker + activist): attacks to make a political or social point, e.g. defacing a website or leaking documents | Attention for a cause |
| A pickpocket | Cybercriminal: attacks for money (stolen cards, fraud, ransomware) | Money |
| A gang with a boss, roles and a budget | Organised crime: cybercrime run like a business, with developers, sellers, even "customer support" | Money at scale |
| An employee who has the keys | Insider: someone with legitimate access | Revenge, money, or simply a mistake |
| A foreign spy | Nation-state actor: a government's hacking team | Espionage (spying) or disruption |
Motives. Three cover almost everything: money (by far the most common), espionage (stealing secrets) and disruption (breaking things, causing chaos). Add ideology for hacktivists and fun/fame for script kiddies.
Ransomware (episode 5 in detail): malware that locks your files and demands payment to unlock them.
Problem 3: the attacker already has a key (insider threats)
Dev works in sales, resigns, and will join a competitor next month. In his last week he downloads the whole customer list, 480 files in one evening. Every permission check says yes, and the firewall (the wall between the company network and the internet) sees nothing, because Dev is already inside.
Demo 2: permission checks miss insiders
allowed = {"asha", "ravi", "dev"}
usual = {"asha": 12, "ravi": 9, "dev": 10} # a day
today = {"asha": 14, "ravi": 8, "dev": 480}
for user, n in today.items():
ok = user in allowed # check 1: permission
print(f"{user:5} {n:3} allowed={ok}")
Output:
asha 14 allowed=True
ravi 8 allowed=True
dev 480 allowed=True
Permission checks ask who you are. They never ask whether what you're doing is normal.
Demo 2b: add a behaviour baseline
allowed = {"asha", "ravi", "dev"}
usual = {"asha": 12, "ravi": 9, "dev": 10} # a day
today = {"asha": 14, "ravi": 8, "dev": 480}
for user, n in today.items():
ok = user in allowed # check 1: permission
odd = n > 5 * usual[user] # check 2: behaviour
print(f"{user:5} {n:3} allowed={ok} odd={odd}")
Output:
asha 14 allowed=True odd=False
ravi 8 allowed=True odd=False
dev 480 allowed=True odd=True
A baseline is the usual pattern of behaviour (here, about 10 files a day for Dev). Spotting what breaks the baseline is how defenders catch insiders. Real tools for this are called UEBA (user and entity behaviour analytics).
Malicious vs negligent insiders
- An insider threat comes from someone with legitimate access: an employee, contractor or partner.
- A malicious insider causes harm on purpose (Dev).
- A negligent insider causes harm by mistake: sends the salary file to the wrong email address, clicks a fake link, leaves a laptop in a taxi. Negligent insiders are far more common than malicious ones.
- Defences: least privilege (episode 3), behaviour baselines, and offboarding: removing access the moment someone leaves.
Problem 4: attackers who stay (APT)
A burglar is in and out in ten minutes and takes whatever is there. A spy rents the flat next door and listens quietly for months.
An APT (advanced persistent threat) is a skilled, well-funded attacker, usually a nation-state or a group it sponsors, that gets into a network and stays undetected for a long time.
- Advanced: skilled, with a full range of tools and good operational security.
- Persistent: has a specific objective, stays for a long time and keeps coming back ("low and slow").
- Threat: has both the capability and the intent.
The term is credited to the United States Air Force in 2006 (Colonel Greg Rattray).
Problem 5: "we only noticed at the end" (the cyber kill chain)
A company is breached. Week 1: a strange email; nobody looked. Week 3: a new program starting at every boot; nobody looked. Week 9: customer data on the internet. The team only watched for the final damage, but an attack is a chain of steps, and every step is a chance to stop it.
In March 2011, Eric Hutchins, Michael Cloppert and Rohan Amin of Lockheed Martin described intrusions as a seven-step kill chain (a military term for the steps of an attack), in the paper Intelligence-Driven Computer Network Defense Informed by Analysis of Adversary Campaigns and Intrusion Kill Chains.
1 Reconnaissance → 2 Weaponisation → 3 Delivery → 4 Exploitation
→ 5 Installation → 6 Command and control → 7 Actions on objectives
| # | Step | What the attacker does | Example defence |
|---|---|---|---|
| 1 | Reconnaissance | Studies the target: staff emails from the website, technologies used | Limit what you publish; watch for scanning |
| 2 | Weaponisation | Builds the attack file, e.g. a document with a malicious macro | (Happens on the attacker's side; threat intelligence) |
| 3 | Delivery | Sends it: email attachment, website, USB stick | Email filtering, web filtering, USB policy |
| 4 | Exploitation | The attack code runs on the victim, via a software flaw or by tricking the user | Patching, disabling macros, awareness |
| 5 | Installation | Plants something that lets the attacker stay (a backdoor: a hidden way back in) | Application allowlisting, endpoint protection |
| 6 | Command and control (C2) | A hidden remote link from the victim back to the attacker | Block and alert on unusual outbound traffic |
| 7 | Actions on objectives | Does what they came for: steal, lock or destroy data | Data-loss alerts, backups, segmentation |
A macro is a small program embedded in a document (for example in Word or Excel) that can run when the document is opened.
Demo 3: break one link, early
CHAIN = ["recon", "weaponise", "deliver", "exploit",
"install", "c2", "act on goal"]
def attack(defences):
for i, step in enumerate(CHAIN, 1):
if step in defences:
return f"stopped at step {i}, {step}"
return "reached the goal: data stolen"
print("no defence: ", attack(set()))
print("email filter:", attack({"deliver"}))
print("only at end: ", attack({"act on goal"}))
Output:
no defence: reached the goal: data stolen
email filter: stopped at step 3, deliver
only at end: stopped at step 7, act on goal
enumerate(CHAIN, 1) gives each step a number starting from 1. set() is an empty set: no defences.
Two lessons. The paper says it directly: "just one mitigation breaks the chain and thwarts the adversary." A mitigation is any control that blocks or reduces an attack. And the earlier you break the chain, the less damage and the cheaper the clean-up: stopping at step 7 means the attacker was inside, installed and connected for weeks. So put a control at every step (defence in depth again).
Problem 6: "exploitation" is too vague (MITRE ATT&CK)
The kill chain is great for the big picture, but "exploitation" or "installation" is too vague to write a detection for. Think of a fast bowler in cricket:
| Cricket | Security | Meaning |
|---|---|---|
| Goal: take a wicket (the why) | Tactic | The attacker's goal at that stage |
| A yorker, a bouncer (the how) | Technique | One way to reach the goal; a tactic has many techniques |
| This bowler's exact grip and run-up | Procedure | The specific steps one group uses |
Together: TTPs (tactics, techniques and procedures), a description of how an attacker behaves.
MITRE (an American non-profit organisation) collected real attackers' TTPs into a free public knowledge base, MITRE ATT&CK (Adversarial Tactics, Techniques and Common Knowledge). MITRE started it in 2013 and made it public in 2015. For company networks (the Enterprise matrix) it lists 14 tactics, with about two hundred techniques and over four hundred sub-techniques (more specific versions of a technique), each with real examples, detection ideas and mitigations.
| # | Tactic | The attacker is trying to... |
|---|---|---|
| 1 | Reconnaissance | gather information to plan the attack |
| 2 | Resource Development | set up resources: accounts, servers, tools |
| 3 | Initial Access | get into the network for the first time |
| 4 | Execution | run their code |
| 5 | Persistence | keep their foothold, even after a reboot or password change |
| 6 | Privilege Escalation | get higher permissions (e.g. admin) |
| 7 | Defense Evasion | avoid being detected |
| 8 | Credential Access | steal usernames and passwords |
| 9 | Discovery | learn about the environment from inside |
| 10 | Lateral Movement | move from the first computer to others inside |
| 11 | Collection | gather the data they want |
| 12 | Command and Control | communicate with the computers they control |
| 13 | Exfiltration | copy data out of the network |
| 14 | Impact | disrupt, destroy or lock systems and data |
Demo 4: turn events into the attacker's story
# what the defenders saw, in order
seen = ["phishing email opened", "macro ran powershell",
"new startup entry", "admin password dumped",
"login to file server", "zip sent to unknown site"]
TACTIC = {"phishing": "Initial Access",
"macro": "Execution",
"startup": "Persistence",
"password": "Credential Access",
"login": "Lateral Movement",
"zip": "Exfiltration"}
for event in seen:
t = next(v for k, v in TACTIC.items() if k in event)
print(f"{t:18} <- {event}")
Output:
Initial Access <- phishing email opened
Execution <- macro ran powershell
Persistence <- new startup entry
Credential Access <- admin password dumped
Lateral Movement <- login to file server
Exfiltration <- zip sent to unknown site
next(...) returns the first matching tactic. Phishing (episode 6) is a fake message pretending to be someone you trust. PowerShell is a powerful command tool built into Windows. A startup entry makes a program run every time the computer starts.
Mapping events to ATT&CK gives the whole team a shared language: "we were blind to Credential Access", "write a detection for this Lateral Movement technique next".
Problem 7: the blocked file is back (IoC vs IoA)
Last week the team found the attacker's fake invoice file and blocked its fingerprint. This week the attacker changes one character.
A hash is a short fingerprint computed from a file's exact bytes; change one byte and the hash changes completely. SHA-256 is a common hash function (episode 13 in detail).
Demo 5: blocking by hash
import hashlib
def h(data): # fingerprint of a file
return hashlib.sha256(data).hexdigest()[:12]
v1 = b"fake invoice macro, version 1"
v2 = b"fake invoice macro, version 2" # 1 byte changed
blocklist = {h(v1)} # IoC from last week
for f in (v1, v2):
hit = h(f) in blocklist
print(h(f), "blocked" if hit else "MISSED")
Output:
5de0de08d555 blocked
fdb03da97ed8 MISSED
b"..." is a bytes value (raw data, like a file's contents). .hexdigest()[:12] shows the first 12 characters of the hash.
Demo 5b: watch behaviour instead
# IoA: watch what programs DO, not what they look like
events = [("WINWORD.EXE", "powershell.exe"), # v1 run
("WINWORD.EXE", "powershell.exe"), # v2 run
("explorer.exe", "notepad.exe")] # normal
for p, c in events:
odd = (p, c) == ("WINWORD.EXE", "powershell.exe")
print(f"{p} -> {c}:", "ALERT" if odd else "ok")
Output:
WINWORD.EXE -> powershell.exe: ALERT
WINWORD.EXE -> powershell.exe: ALERT
explorer.exe -> notepad.exe: ok
Each event is a parent program starting a child program. A Word document has no normal reason to start PowerShell.
| Indicator of compromise (IoC) | Indicator of attack (IoA) | |
|---|---|---|
| What it is | Evidence that something bad already happened | Behaviour seen while an attack is happening |
| Examples | A file hash, an attacker's IP address, a bad domain name | Word starting PowerShell, a 3 a.m. login from abroad, 480 files in an evening |
| Strength | Easy to store, search and share with other teams | Catches new variants and unknown tools |
| Weakness | Easy for attackers to change | Needs a baseline; more false alarms to tune |
Good teams use both: IoAs to catch attacks early, IoCs to search for the same attacker elsewhere. An IP address is the number that identifies a computer on a network; a domain is a website name like example.com.
Common mistakes (and what they print)
| Mistake | Real output | Why | Fix |
|---|---|---|---|
| "We're too small to be attacked" | chai-stall.in broken: 'admin' |
Bots are opportunistic: they hit anyone weak | Strong unique passwords, no defaults, updates |
ok = user in allowed as the only check |
dev 480 allowed=True |
Insiders are allowed by definition | Add a behaviour baseline |
| Watching only the final damage | stopped at step 7, act on goal |
Caught after weeks inside | Controls at every step, as early as possible |
blocklist = {h(v1)} (hash only) |
fdb03da97ed8 MISSED |
One changed byte = new hash | Also detect behaviour (IoA) |
| Forgetting offboarding | (Dev's account still works after he leaves) | Access outlives the job | Remove access the day someone leaves |
Mini project: a tiny attack timeline analyser
Combine today's ideas: map each event to an ATT&CK tactic, and raise IoA alerts for suspicious behaviour or night-time activity.
TACTIC = {"phishing": "Initial Access", "powershell": "Execution",
"startup": "Persistence", "login": "Lateral Movement",
"zip": "Exfiltration"}
IOA = ["powershell", "startup", "zip sent"]
EVENTS = [(9, "kiran", "phishing email opened"),
(9, "kiran", "WINWORD.EXE started powershell.exe"),
(10, "kiran", "new startup entry added"),
(2, "kiran", "login to file server"),
(3, "kiran", "zip sent to unknown site")]
for hour, user, ev in EVENTS:
tactic = next((t for k, t in TACTIC.items() if k in ev), "Unknown")
reasons = [k for k in IOA if k in ev] + (["night"] if hour < 6 else [])
flag = "ALERT " + ", ".join(reasons) if reasons else ""
print(f"{hour:02d}:00 {user} {tactic:16} {flag}")
Output:
09:00 kiran Initial Access
09:00 kiran Execution ALERT powershell
10:00 kiran Persistence ALERT startup
02:00 kiran Lateral Movement ALERT night
03:00 kiran Exfiltration ALERT zip sent, night
next(..., "Unknown") returns "Unknown" if no keyword matches. {hour:02d} pads the hour with a zero (2 becomes 02).
Practice
- Add a "night login" check to the baseline idea: given
logins = {"asha": [10, 11, 15], "ravi": [9, 14], "dev": [10, 2, 3]}(hours), flag any login before 6 a.m. - In Demo 3, add a defence at step 6 (
"c2"). Then combine it with the email filter. Where does each attack stop? - Extend Demo 4's table to map three more events: "scanned the network for shared folders", "copied HR files into one folder", "all files encrypted, ransom note shown".
- Which threat actor is most likely? (a) a website's homepage replaced with a political slogan; (b) a ransomware group with a "support chat" for victims; (c) a 10-month quiet intrusion into a defence ministry; (d) an employee emails the customer list to a personal address by mistake.
- IoC or IoA? (a) the domain
update-checker.example; (b) Excel startscmd.exe; (c) the SHA-256 hash of a malicious file; (d) one account logs in from two countries ten minutes apart.
Solutions
1.
logins = {"asha": [10, 11, 15], "ravi": [9, 14], "dev": [10, 2, 3]} # hours
for user, hours in logins.items():
night = [h for h in hours if h < 6]
print(f"{user:5} night logins: {night}", "<- ALERT" if night else "")
Output:
asha night logins: []
ravi night logins: []
dev night logins: [2, 3] <- ALERT
2.
CHAIN = ["recon", "weaponise", "deliver", "exploit",
"install", "c2", "act on goal"]
def attack(defences):
for i, step in enumerate(CHAIN, 1):
if step in defences:
return f"stopped at step {i}, {step}"
return "reached the goal: data stolen"
print("block C2: ", attack({"c2"}))
print("filter + block: ", attack({"deliver", "c2"}))
Output:
block C2: stopped at step 6, c2
filter + block: stopped at step 3, deliver
With both, the attack stops at the first (earliest) defence, and the C2 block is still there as a second layer if the filter misses.
3.
TACTIC = {"phishing": "Initial Access", "macro": "Execution",
"startup": "Persistence", "password": "Credential Access",
"scanned": "Discovery", "login": "Lateral Movement",
"copied": "Collection", "zip": "Exfiltration",
"encrypted": "Impact"}
for event in ["scanned the network for shared folders",
"copied HR files into one folder",
"all files encrypted, ransom note shown"]:
tactic = next(t for k, t in TACTIC.items() if k in event)
print(f"{tactic:12} <- {event}")
Output:
Discovery <- scanned the network for shared folders
Collection <- copied HR files into one folder
Impact <- all files encrypted, ransom note shown
- (a) hacktivist; (b) organised crime (cybercrime run as a business); (c) nation-state / APT; (d) negligent insider.
- (a) IoC; (b) IoA; (c) IoC; (d) IoA (behaviour: "impossible travel").
Quick quiz
An attacker is already on one laptop. Now they use a stolen password to log in to the file server and the HR server. Which ATT&CK tactic is this?
A. Initial Access · B. Exfiltration · C. Lateral Movement · D. Reconnaissance
Answer
C, Lateral Movement: moving from the first computer to others inside the network. Getting onto the first laptop was Initial Access.
Interview questions
- Name the main types of threat actors and their usual motives. Script kiddies (fun, fame), hacktivists (ideology), cybercriminals and organised crime (money), insiders (revenge, money, or mistakes), nation-states and APTs (espionage, disruption).
- What is an insider threat, and how do you detect one? Harm from someone with legitimate access, either malicious or negligent. Detect with behaviour baselines (UEBA), data-loss monitoring and access reviews; reduce with least privilege and prompt offboarding.
- What does APT stand for, and how does an APT differ from an opportunistic attack? Advanced persistent threat: skilled, funded, targeted, and stays hidden for a long time, versus quick attacks on whoever is weak.
- Walk me through the cyber kill chain. Reconnaissance, weaponisation, delivery, exploitation, installation, command and control, actions on objectives. Breaking any one link stops the attack; earlier is cheaper.
- Kill chain vs MITRE ATT&CK? The kill chain is a linear 7-step high-level model; ATT&CK is a detailed knowledge base of 14 tactics and hundreds of techniques and sub-techniques from real attacks, used to map detections and coverage.
- What are TTPs? Tactics (the goal), techniques (how the goal is reached) and procedures (one group's specific implementation): a description of attacker behaviour.
- IoC vs IoA? IoCs are artifacts that show a compromise already happened (hashes, IPs, domains); IoAs are behaviours observed during an attack (Office spawning PowerShell). IoAs survive tool changes; IoCs are easy to share and search.
- Explain lateral movement and exfiltration. Lateral movement is moving from the first compromised machine to others inside the network; exfiltration is copying data out of the network.
Glossary
| Term | Meaning in plain words | Example |
|---|---|---|
| Threat actor | Any person or group that could carry out a threat | A cybercriminal, an insider |
| Bot | A program that runs by itself (short for robot) | The password-trying bot in Demo 1 |
| Opportunistic attack | An attack on anyone who happens to be weak | A thief trying every car door |
| Targeted attack | An attack on one chosen victim, studied in advance | Spear phishing a finance head |
| Script kiddie | A low-skill attacker who runs ready-made tools | Runs a downloaded password-guessing tool |
| Hacktivist | Hacker + activist: attacks to make a political or social point | Defacing a website with a slogan |
| Cybercriminal | Someone who attacks for money | Stealing card details |
| Organised crime | Cybercrime run like a business, with roles and budgets | A ransomware group with "support" |
| Nation-state actor | A hacking team working for a government | Spying on another country |
| Espionage | Spying: secretly collecting information | Stealing defence plans |
| Disruption | Breaking things or causing chaos | Taking a website offline |
| Motive | The reason someone attacks | Money, espionage, disruption |
| Ransomware | Malware that locks files and demands payment | Episode 5 |
| Insider threat | Harm from someone with legitimate access | An employee or contractor |
| Malicious insider | An insider who causes harm on purpose | Dev downloading the customer list |
| Negligent insider | An insider who causes harm by mistake | Emailing a file to the wrong person |
| Firewall | A filter between a network and the outside | Episode 24 |
| Baseline | The usual pattern of behaviour | Dev usually downloads ~10 files a day |
| UEBA | User and entity behaviour analytics: tools that learn baselines and flag oddities | Flags 480 downloads |
| Offboarding | Removing someone's access when they leave | Disable Dev's account on his last day |
| APT | Advanced persistent threat: skilled, funded, patient, usually state-backed | Hidden in a network for months |
| Kill chain | The steps of an attack, borrowed from military language | Lockheed Martin's 7 steps |
| Reconnaissance | Studying the target before attacking | Collecting staff emails |
| Weaponisation | Building the attack file | A document with a malicious macro |
| Delivery | Sending the attack to the victim | An email attachment |
| Exploitation | The attack code actually runs on the victim | Opening the document runs the macro |
| Installation | Planting a way to stay | A backdoor |
| Backdoor | A hidden way back into a system | A program that accepts the attacker's commands |
| Command and control (C2) | A hidden remote link from victim to attacker | A program checking in every minute |
| Actions on objectives | Doing what the attacker came for | Stealing the customer list |
| Mitigation | A control that blocks or reduces an attack | An email filter |
| Macro | A small program inside a document | A Word or Excel macro |
| MITRE | An American non-profit that maintains ATT&CK (and CVE) | mitre.org |
| MITRE ATT&CK | A free knowledge base of real attacker tactics and techniques | 14 Enterprise tactics |
| Tactic | The attacker's goal at a stage (the why) | Lateral Movement |
| Technique | One way to reach a tactic's goal (the how) | Logging in with stolen credentials |
| Sub-technique | A more specific version of a technique | A specific way of dumping passwords |
| Procedure | One group's specific steps | Their exact tools and commands |
| TTPs | Tactics, techniques and procedures together | "How this group behaves" |
| Initial Access | Getting into the network the first time | A phishing email |
| Persistence | Staying in, even after reboots or password changes | A startup entry |
| Lateral Movement | Moving from the first computer to others inside | Logging in to the file server |
| Exfiltration | Copying data out of the network | A zip sent to an unknown site |
| Phishing | A fake message pretending to be someone trusted | Episode 6 |
| PowerShell | A powerful command tool built into Windows | Often abused by attackers |
| Hash | A short fingerprint computed from exact bytes | SHA-256 |
| IoC | Indicator of compromise: evidence it already happened | A file hash, a bad IP |
| IoA | Indicator of attack: behaviour while it happens | Word starting PowerShell |
| IP address | A number that identifies a computer on a network | Episode 18 |
| Domain | A website name | example.com |
Summary
- Nobody is too small: opportunistic bots and script kiddies hit whoever is weak; the basics stop most of them.
- Threat actors: hacktivists, cybercriminals, organised crime, insiders, nation-states. Motives: money, espionage, disruption.
- Insiders are allowed by definition: use least privilege, behaviour baselines and fast offboarding. Most insider incidents are mistakes.
- APTs are advanced, persistent and usually state-backed.
- The cyber kill chain (Lockheed Martin, 2011): seven steps; one mitigation breaks the chain, and earlier is cheaper.
- MITRE ATT&CK: 14 tactics (the why) and hundreds of techniques (the how): a shared language. Know initial access, persistence, lateral movement, exfiltration.
- IoC vs IoA: evidence vs behaviour. Hashes break when one byte changes; behaviour doesn't.
Next episode: malware families explained: viruses, worms, trojans, ransomware, rootkits, botnets, command and control, and how antivirus signatures work.
Sources: E. M. Hutchins, M. J. Cloppert, R. M. Amin (Lockheed Martin), "Intelligence-Driven Computer Network Defense Informed by Analysis of Adversary Campaigns and Intrusion Kill Chains" (2011); TechTarget, "What is the MITRE ATT&CK framework?"; Wikipedia, "Advanced persistent threat"; CyberDefenders glossary, "IOA vs IOC". Fetched 28 Oct 2026.