These are the notes for Cybersecurity Fundamentals (defensive), episode 8. Last time we found threats in our own design. But most software you run was written by someone else: libraries, apps, operating systems. When a weakness is found in one of them, the whole world has to name it, score it, decide what to patch first, and report it safely. Today you invent that system with small Python programs: CVE IDs, CWE and CAPEC, CVSS base/temporal (threat)/environmental scores with a real CVSS v3.1 calculator, the NVD, EPSS and the CISA KEV catalog, zero-day vs n-day, patches and security advisories, and coordinated (responsible) disclosure with vulnerability disclosure policies (VDPs), safe harbour, bug bounty programmes and security.txt. Every term is explained the first time it appears, and the Glossary at the end defines them all again.
ChaiGo, chaigo.example and bugs A-E are made up. Log4Shell (CVE-2021-44228) is a real example. Every code sample runs as-is; outputs are real (Python 3).
The problems you'll solve
| Problem | Idea it teaches |
|---|---|
| One bug, three names, "is it fixed?" | CVE IDs, CNAs |
| The same kind of mistake, again and again | CWE (weakness types), CAPEC (attack patterns) |
| "Critical", "Important", "High" sort A to Z | CVSS scores; base, temporal/threat, environmental; NVD |
| Patched the 9.8, hacked through the 7.5 | EPSS, CISA KEV |
| A bug with no patch yet | Zero-day, n-day, patch, security advisory |
| Priya finds a bug: post it or stay silent? | Coordinated disclosure, VDP, safe harbour, bug bounty |
| "Who do I even tell?" | security.txt (RFC 9116) |
First, three words from episode 1: a vulnerability is a weakness that can be used to cause harm; an exploit is a way of using it; to exploit a vulnerability is to actually use it in an attack.
Problem 1: one bug, one name (CVE)
In December 2021, a bug was found in Log4j, a logging library (code that writes log messages) used inside huge numbers of Java programs. A specially crafted piece of text, if it got logged, could make the server run an attacker's code. This is remote code execution (RCE): an attacker running their own code on your machine from far away. It got the maximum CVSS score of 10 and the nickname Log4Shell. It was reported privately to Apache on 24 November 2021 by Chen Zhaojun of Alibaba Cloud, became public around 9 December 2021, and was fixed in Log4j 2.15.0 (with follow-up fixes in 2.16.0 and 2.17.1).
Reports used different names: "remote code execution in logging", "JNDI lookup flaw" (JNDI is a Java feature for looking up resources by name, which the attack abused), "critical log4j RCE".
Demo 1: matching bugs by name
advisories = [("Vendor A", "Remote code execution in logging"),
("Vendor B", "Log4j JNDI lookup flaw"),
("Scanner", "Critical: log4j RCE")]
patched = {"Log4j JNDI lookup flaw"} # what we fixed
for who, name in advisories:
print(f"{who:9} {name:34} fixed: {name in patched}")
Output:
Vendor A Remote code execution in logging fixed: False
Vendor B Log4j JNDI lookup flaw fixed: True
Scanner Critical: log4j RCE fixed: False
One bug, but two reports look unfixed.
Demo 1b: one ID for one bug
advisories = [("Vendor A", "CVE-2021-44228"),
("Vendor B", "CVE-2021-44228"),
("Scanner", "CVE-2021-44228")]
patched = {"CVE-2021-44228"} # one name for one bug
for who, cve in advisories:
print(f"{who:9} {cve:16} fixed: {cve in patched}")
Output:
Vendor A CVE-2021-44228 fixed: True
Vendor B CVE-2021-44228 fixed: True
Scanner CVE-2021-44228 fixed: True
CVE (Common Vulnerabilities and Exposures) is a public list that gives each publicly known vulnerability one ID: CVE-<year>-<number>.
| Fact | Value |
|---|---|
| Started | 1999, run by MITRE (a US non-profit) |
| Who assigns IDs | CVE Numbering Authorities (CNAs): vendors, security teams, national CERTs; more than 400 in 40 countries (Oct 2024) |
| Records | Over 240,000 by October 2024 |
| New CVEs in 2025 | 48,185, up 20.6% from 39,962 in 2024 (about 130 a day) |
A CVE is a name, not a score or a fix.
Problem 2: kinds of mistake (CWE and CAPEC)
| Hospital | Security | Meaning |
|---|---|---|
| Ravi's case file No. 4521 | CVE | One specific bug in one product |
| The disease: dengue | CWE (Common Weakness Enumeration) | A type of mistake that many bugs share |
| How it spreads: mosquito bites | CAPEC (Common Attack Pattern Enumeration and Classification) | A type of attack, described so defenders can plan against it |
Enumeration just means a numbered list. Examples: CWE-79 is cross-site scripting (number 1 on the 2024 CWE Top 25 most dangerous weaknesses) and CWE-89 is SQL injection (number 3). Thousands of CVEs share the same CWE. Developers use CWE to learn which mistakes to stop making; we'll meet both of these in the web-security episodes.
Problem 3: how bad is it? (CVSS)
Demo 2: sorting severity words
reports = {"bug A": "Important", "bug B": "Critical",
"bug C": "Moderate", "bug D": "High", "bug E": "Low"}
# fix the worst first?
for bug in sorted(reports, key=reports.get):
print(bug, reports[bug])
Output:
bug B Critical
bug D High
bug A Important
bug E Low
bug C Moderate
Alphabetical order: Low comes before Moderate, and nobody knows if one vendor's "Important" equals another's "High".
CVSS (Common Vulnerability Scoring System), maintained by FIRST (the Forum of Incident Response and Security Teams), turns a few standard questions into a number from 0.0 to 10.0. The answers are written as a vector string such as AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H.
| Metric | Question | Values (v3.1 weight) |
|---|---|---|
| AV attack vector | From where can it be attacked? | Network 0.85, Adjacent network 0.62, Local 0.55, Physical 0.2 |
| AC attack complexity | Are special conditions needed? | Low 0.77, High 0.44 |
| PR privileges required | Does the attacker need an account? | None 0.85, Low 0.62, High 0.27 (scope unchanged) |
| UI user interaction | Must a victim do something (click)? | None 0.85, Required 0.62 |
| S scope | Can it affect things beyond the vulnerable component? | Unchanged / Changed (our demo handles Unchanged only) |
| C, I, A impact | How much confidentiality, integrity, availability is lost? | High 0.56, Low 0.22, None 0 |
Demo 2b: a real CVSS v3.1 base score calculator
import math
W = {"AV": {"N": .85, "A": .62, "L": .55, "P": .2},
"AC": {"L": .77, "H": .44}, "PR": {"N": .85, "L": .62, "H": .27},
"UI": {"N": .85, "R": .62}, "CIA": {"H": .56, "L": .22, "N": 0}}
def score(vector): # CVSS v3.1 base, scope unchanged
m = dict(part.split(":") for part in vector.split("/"))
w = lambda k: W[k][m[k]]
iss = 1 - math.prod(1 - W["CIA"][m[k]] for k in "CIA")
impact = 6.42 * iss
exploit = 8.22 * w("AV") * w("AC") * w("PR") * w("UI")
if impact <= 0:
return 0.0
return math.ceil(min(impact + exploit, 10) * 10) / 10
print(score("AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H")) # internet, no login
print(score("AV:N/AC:L/PR:N/UI:R/C:H/I:H/A:H")) # victim must click
print(score("AV:L/AC:L/PR:L/UI:N/C:H/I:H/A:H")) # already on the PC
print(score("AV:N/AC:L/PR:N/UI:R/C:L/I:L/A:N")) # small leak
Output:
9.8
8.8
7.8
5.4
These match the official calculator for the same vectors with S:U. How the formula works: ISS (impact sub-score) = 1 - (1-C)(1-I)(1-A); impact = 6.42 x ISS; exploitability = 8.22 x AV x AC x PR x UI; base = round up to one decimal of min(impact + exploitability, 10), or 0 if there's no impact. (The official spec defines a "Roundup" function that avoids floating-point surprises; math.ceil(x * 10) / 10 gives the same results here.)
| Score | Rating |
|---|---|
| 0.0 | None |
| 0.1-3.9 | Low |
| 4.0-6.9 | Medium |
| 7.0-8.9 | High |
| 9.0-10.0 | Critical |
The metric groups:
| Group | What it describes | Who sets it |
|---|---|---|
| Base | The bug itself; the same for everyone | Vendor or CNA |
| Temporal (v3.1) → Threat (v4.0) | Things that change over time: is there working exploit code? (v3.1 also: is there a fix, how confirmed is the report) In v4.0 it mainly asks: is it being exploited? | Updated over time |
| Environmental | How much it matters in your setup (e.g. a server that's offline matters less) | You |
| Supplemental (v4.0 only, optional) | Extra context that doesn't change the score | Vendor |
CVSS v4.0 was released by FIRST on 1 November 2023; it renamed Temporal to Threat, kept Exploit Maturity, and dropped Remediation Level and Report Confidence.
The NVD (National Vulnerability Database), run by the US agency NIST, adds details to each CVE, such as affected products. In 2026, NIST said it would largely stop calculating its own CVSS scores in order to cut a large analysis backlog (about 27,000 by September 2025), so you'll often see the vendor's or CNA's score instead.
Problem 4: what to patch first (EPSS and KEV)
ChaiGo sorted by CVSS and patched the 9.8 printer bug first; on day two, attackers walked in through bug B, the VPN login page (a VPN is the secure tunnel staff use to reach the office network from outside), rated 7.5. Bug B was being attacked across the internet; the printer bug had never been attacked by anyone. CVSS says how bad a bug could be, not how likely it is to be used.
Demo 3: CVSS order only
# bug, CVSS, EPSS (chance of attack in 30 days), in KEV?
vulns = [("A printer firmware", 9.8, 0.002, False),
("B VPN login page", 7.5, 0.94, True),
("C image library", 8.8, 0.01, False),
("D web framework", 6.1, 0.35, True)]
order = sorted(vulns, key=lambda v: v[1], reverse=True)
print("by CVSS only:", [v[0][0] for v in order])
Output:
by CVSS only: ['A', 'C', 'B', 'D']
Demo 3b: KEV first, then EPSS, then CVSS
# bug, CVSS, EPSS (chance of attack in 30 days), in KEV?
vulns = [("A printer firmware", 9.8, 0.002, False),
("B VPN login page", 7.5, 0.94, True),
("C image library", 8.8, 0.01, False),
("D web framework", 6.1, 0.35, True)]
def priority(v): # attacked now? then likely? then severe?
name, cvss, epss, kev = v
return (kev, epss, cvss)
for v in sorted(vulns, key=priority, reverse=True):
print(f"{v[0]:20} KEV={str(v[3]):5} EPSS={v[2]:<6} CVSS={v[1]}")
Output:
B VPN login page KEV=True EPSS=0.94 CVSS=7.5
D web framework KEV=True EPSS=0.35 CVSS=6.1
C image library KEV=False EPSS=0.01 CVSS=8.8
A printer firmware KEV=False EPSS=0.002 CVSS=9.8
Python compares tuples left to right, and True > False, so KEV entries come first, then higher EPSS, then higher CVSS.
| Question | Source | Details |
|---|---|---|
| How bad could it be? | CVSS | 0-10, from FIRST |
| How likely is an attack soon? | EPSS (Exploit Prediction Scoring System) | From FIRST: a probability from 0 to 1 that a CVE will be exploited in the next 30 days, recalculated daily for all published CVEs |
| Is it being attacked now? | CISA KEV (Known Exploited Vulnerabilities) catalog | From the US Cybersecurity and Infrastructure Security Agency, created November 2021 (Binding Operational Directive 22-01). An entry needs a CVE ID, reliable evidence of active exploitation, and clear remediation guidance. Log4Shell was added on 10 December 2021 |
| Do we run it? | Your inventory | A list of every system and software version you run |
Problem 5: zero-day and n-day
bug exists -> someone finds it -> vendor releases a patch -> you install it
(no one knows) ("day 0" for defenders) ("day N")
| Term | Meaning |
|---|---|
| Patch | The vendor's fixed version of the code (an update) |
| Zero-day | A vulnerability attacked before any patch exists: defenders had zero days to fix it |
| N-day | A vulnerability with a patch available that hasn't been installed yet; attackers can study the patch to learn what to attack |
| Security advisory | The vendor's public notice: which products and versions are affected, how bad it is, how to fix or work around it |
Zero-days get headlines, but many attacks use n-days, so patching fast is one of the best defences there is.
Problem 6: you found a bug (coordinated disclosure)
Priya, a student, is using her college's results app normally and notices that changing a number in the address shows another student's marks. Posting it online exposes every student before a fix exists; staying silent leaves it for someone worse to find.
Coordinated disclosure (also called responsible disclosure): report privately to the owner, let them fix it, then publish together, with credit.
| The researcher | The organisation |
|---|---|
| Stop; don't look at other people's data or dig further | Publish a vulnerability disclosure policy (VDP): how and where to report |
| Report privately, with clear steps and no extra data | Offer safe harbour: a promise not to take legal action against good-faith reporters who follow the policy |
| Agree a timeline (Google Project Zero, for example, gives vendors 90 days by default) | Fix, credit the reporter, then publish an advisory |
| Only ever test systems you are authorised to test | Optionally run a bug bounty programme: pay rewards for valid reports |
In India, CERT-In (the Indian Computer Emergency Response Team) has a Responsible Vulnerability Disclosure and Coordination Policy: it validates reports, coordinates with the vendor and aims to resolve issues within 120 days of first contacting the vendor. The policy is clear that the person reporting remains responsible for any action they took to find the bug, and must follow laws such as the IT Act 2000. Ethics and the law (episode 1) come first: authorised work only.
Problem 7: who do I even tell? (security.txt)
security.txt (standard RFC 9116, April 2022) is a small text file at https://<site>/.well-known/security.txt that says where to report security issues. Two fields are required: Contact (where to send reports) and Expires (a date after which the file should not be trusted; it is recommended to be less than a year ahead). Optional fields include Policy (link to the VDP), Preferred-Languages, Encryption and Acknowledgments.
Demo 4: a file missing a required field
txt = """Contact: mailto:security@chaigo.example
Policy: https://chaigo.example/security-policy
Preferred-Languages: en, hi"""
fields = {}
for line in txt.splitlines():
key, value = line.split(": ", 1)
fields[key] = value
for need in ("Contact", "Expires"): # both are required
print(f"{need:8}", "OK" if need in fields else "MISSING")
Output:
Contact OK
Expires MISSING
Demo 4b: add Expires and check the date
from datetime import date
TODAY = date(2026, 10, 28)
txt = """Contact: mailto:security@chaigo.example
Expires: 2027-06-30T00:00:00Z
Policy: https://chaigo.example/security-policy
Preferred-Languages: en, hi"""
fields = dict(line.split(": ", 1) for line in txt.splitlines())
for need in ("Contact", "Expires"): # both are required
print(f"{need:8}", "OK" if need in fields else "MISSING")
days = (date.fromisoformat(fields["Expires"][:10]) - TODAY).days
print("expires in", days, "days:", "OK" if 0 < days < 365 else "FIX")
Output:
Contact OK
Expires OK
expires in 245 days: OK
TODAY is fixed so the demo always gives the same answer; in real use, use date.today().
The whole chain
| Step | Problem | You invented |
|---|---|---|
| 1 | One bug, three names | CVE IDs |
| 2 | The same mistake again | CWE, CAPEC |
| 3 | Words sort A to Z | CVSS |
| 4 | Hacked through the 7.5 | EPSS, KEV |
| 5 | No patch yet | Zero-day, n-day, advisories |
| 6 | Post it or stay silent? | Coordinated disclosure, VDP, safe harbour, bug bounty |
| 7 | Who to tell | security.txt |
Common mistakes (and what they print)
| Mistake | What you see | Why it's wrong | Fix |
|---|---|---|---|
| Match bugs by their names | Scanner Critical: log4j RCE fixed: False |
Everyone names it differently | Match by CVE ID |
sorted(reports, key=reports.get) |
Critical, High, Important, Low, Moderate |
Words sort A to Z | Compare CVSS numbers |
| Patch in CVSS order only | by CVSS only: ['A', 'C', 'B', 'D'] |
Severe isn't the same as attacked | KEV first, then EPSS, then CVSS |
| security.txt without Expires | Expires MISSING |
RFC 9116 requires it | Add Expires, under a year ahead |
| Treating CVSS as "risk" | 9.8 printer patched, VPN hacked | CVSS ignores likelihood and your environment | Add EPSS/KEV and environmental context |
Mini project: a patch-priority report
Compute CVSS from vectors, add ratings, and sort by KEV, EPSS, CVSS (the findings are made up).
import math
W = {"AV": {"N": .85, "A": .62, "L": .55, "P": .2},
"AC": {"L": .77, "H": .44}, "PR": {"N": .85, "L": .62, "H": .27},
"UI": {"N": .85, "R": .62}, "CIA": {"H": .56, "L": .22, "N": 0}}
def score(vector): # CVSS v3.1 base, scope unchanged
m = dict(part.split(":") for part in vector.split("/"))
w = lambda k: W[k][m[k]]
iss = 1 - math.prod(1 - W["CIA"][m[k]] for k in "CIA")
impact = 6.42 * iss
exploit = 8.22 * w("AV") * w("AC") * w("PR") * w("UI")
if impact <= 0:
return 0.0
return math.ceil(min(impact + exploit, 10) * 10) / 10
def rating(s):
if s == 0: return "None"
if s < 4: return "Low"
if s < 7: return "Medium"
if s < 9: return "High"
return "Critical"
# our inventory: what we run, and the (made-up) findings for it
findings = [
{"id": "BUG-1", "asset": "printer", "vec": "AV:A/AC:L/PR:N/UI:N/C:H/I:H/A:H", "epss": 0.003, "kev": False},
{"id": "BUG-2", "asset": "vpn", "vec": "AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:N", "epss": 0.91, "kev": True},
{"id": "BUG-3", "asset": "web app", "vec": "AV:N/AC:L/PR:L/UI:N/C:L/I:L/A:N", "epss": 0.02, "kev": False},
{"id": "BUG-4", "asset": "laptops", "vec": "AV:L/AC:L/PR:L/UI:N/C:H/I:H/A:H", "epss": 0.40, "kev": True},
]
for f in findings:
f["cvss"] = score(f["vec"])
for f in sorted(findings, key=lambda f: (f["kev"], f["epss"], f["cvss"]), reverse=True):
due = "patch within 48h" if f["kev"] else "next patch cycle"
print(f'{f["id"]} {f["asset"]:8} CVSS {f["cvss"]:4} {rating(f["cvss"]):8} '
f'EPSS {f["epss"]:<5} KEV {str(f["kev"]):5} -> {due}')
Output:
BUG-2 vpn CVSS 7.5 High EPSS 0.91 KEV True -> patch within 48h
BUG-4 laptops CVSS 7.8 High EPSS 0.4 KEV True -> patch within 48h
BUG-3 web app CVSS 5.4 Medium EPSS 0.02 KEV False -> next patch cycle
BUG-1 printer CVSS 8.8 High EPSS 0.003 KEV False -> next patch cycle
The "48h" and "next patch cycle" deadlines are an example policy; each organisation sets its own.
Practice
1. Score three vectors with the calculator: AV:A/AC:H/PR:N/UI:N/C:H/I:N/A:N, AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H, AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:N.
Solution
Output:
5.3
7.5
0.0
5.3 Medium (attacker on the same local network, hard to pull off, only confidentiality lost). 7.5 High (anyone on the internet can crash it: availability). 0.0: no impact at all means no vulnerability score.
2. An expired security.txt. Change Expires in demo 4b to 2026-01-31T00:00:00Z. What does it print?
Solution
from datetime import date
TODAY = date(2026, 10, 28)
txt = """Contact: mailto:security@chaigo.example
Expires: 2026-01-31T00:00:00Z"""
fields = dict(line.split(": ", 1) for line in txt.splitlines())
days = (date.fromisoformat(fields["Expires"][:10]) - TODAY).days
print("expires in", days, "days:", "OK" if 0 < days < 365 else "FIX")
Output:
expires in -270 days: FIX
A negative number of days means the file expired 270 days ago: reporters can't trust the contact any more.
3. CVE, CWE or CAPEC? (a) "SQL injection, as a kind of mistake"; (b) "CVE-2021-44228"; (c) "a catalogue entry describing how attackers inject commands into input fields".
Solution
(a) CWE (CWE-89). (b) CVE: one specific bug (Log4Shell). (c) CAPEC: an attack pattern.
4. Zero-day or n-day? A vendor released a patch last month; your servers aren't updated and attackers are now using the bug against you.
Solution
An n-day: a patch exists, but it isn't installed. Check KEV and EPSS, then patch now.
Quick quiz
Bug X: CVSS 9.1, EPSS 0.01, not in KEV. Bug Y: CVSS 7.2, EPSS 0.89, in CISA KEV. Which first? A. X B. Y C. Neither D. Whichever is easier
Answer
B, Y. It's in KEV (reliable evidence of active exploitation) and EPSS agrees. CVSS says how bad a bug could be, not how likely it is to be used. Patch Y first, then X soon after.
Interview questions
- What's the difference between a CVE and a CWE? A CVE identifies one specific vulnerability in a specific product; a CWE identifies a type of weakness (e.g. CWE-89, SQL injection) that many CVEs share.
- Who assigns CVE IDs? CVE Numbering Authorities (CNAs): vendors, security organisations and national CERTs authorised by the CVE Program.
- What do the CVSS base metrics measure? Exploitability (attack vector, attack complexity, privileges required, user interaction), scope, and impact on confidentiality, integrity and availability.
- Why is CVSS alone a poor way to prioritise patching? It measures potential severity, not likelihood of exploitation or your environment. Combine it with EPSS, KEV, asset importance and exposure.
- What is EPSS? FIRST's Exploit Prediction Scoring System: the probability (0-1) that a CVE will be exploited in the next 30 days, updated daily.
- What is the CISA KEV catalog? A list of vulnerabilities with reliable evidence of active exploitation, each with a CVE ID and remediation guidance; a strong signal to patch first.
- What changed between CVSS v3.1 and v4.0? v4.0 (Nov 2023) renamed temporal metrics to threat metrics (mainly exploit maturity), refined base metrics, and added an optional supplemental group.
- Zero-day vs n-day? A zero-day is exploited before a patch exists; an n-day has a patch available that hasn't been applied.
- What is coordinated disclosure? Privately reporting a vulnerability to the owner, giving time to fix, then publishing together, with credit.
- What is safe harbour in a VDP, and what is security.txt? Safe harbour is a promise not to take legal action against good-faith researchers who follow the policy. security.txt (RFC 9116) is a file at
/.well-known/security.txtwith at least Contact and Expires, telling researchers where to report.
Glossary
| Term | Meaning in plain words | Example |
|---|---|---|
| Vulnerability | A weakness that can be used to cause harm | Log4Shell |
| Exploit (concept) | A way of using a vulnerability | Crafted text that triggers Log4Shell |
| Library | Reusable code that many programs include | Log4j |
| Remote code execution (RCE) | An attacker running their own code on your machine from far away | Log4Shell's impact |
| JNDI | A Java feature for looking up resources by name, abused by Log4Shell | "JNDI lookup flaw" |
| CVE | Common Vulnerabilities and Exposures: one public ID per known vulnerability | CVE-2021-44228 |
| CNA | CVE Numbering Authority: an organisation allowed to assign CVE IDs | A software vendor, a national CERT |
| MITRE | The US non-profit that runs the CVE Program | Started CVE in 1999 |
| CWE | Common Weakness Enumeration: a numbered list of types of mistake | CWE-79 XSS, CWE-89 SQL injection |
| CAPEC | Common Attack Pattern Enumeration and Classification: a list of how attacks work | An injection attack pattern |
| Enumeration | A numbered list | CWE, CAPEC |
| CVSS | Common Vulnerability Scoring System: a 0-10 severity score from standard questions | 9.8 Critical |
| FIRST | Forum of Incident Response and Security Teams; maintains CVSS and EPSS | Released CVSS v4.0 |
| Vector string | CVSS answers in short form | AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H |
| Attack vector (AV) | From where the bug can be attacked | Network, adjacent, local, physical |
| Attack complexity (AC) | Whether special conditions are needed | Low or high |
| Privileges required (PR) | Whether the attacker needs an account | None, low, high |
| User interaction (UI) | Whether a victim must do something | A click |
| Scope (S) | Whether impact reaches beyond the vulnerable component | Unchanged / changed |
| Base score | Severity of the bug itself, the same for everyone | 9.8 |
| Temporal score (v3.1) | Adjusts for things that change over time (exploit code, fix availability) | Lower once a fix exists |
| Threat metrics (v4.0) | v4.0's replacement for temporal: mainly, is it being exploited? | Exploit Maturity: Attacked |
| Environmental score | Adjusts severity for your own setup | An offline server matters less |
| Supplemental metrics (v4.0) | Optional extra context that doesn't change the score | Extra notes for defenders |
| NVD | National Vulnerability Database, run by NIST, adding details to CVEs | Affected product lists |
| NIST | The US National Institute of Standards and Technology | Runs the NVD |
| EPSS | Exploit Prediction Scoring System: probability (0-1) of exploitation in the next 30 days | 0.94 |
| CISA | The US Cybersecurity and Infrastructure Security Agency | Runs KEV |
| KEV catalog | Known Exploited Vulnerabilities: bugs with evidence of active attacks | Log4Shell, added 10 Dec 2021 |
| Inventory | A list of every system and software version you run | "We run Log4j 2.14 on 3 servers" |
| VPN | A secure tunnel to reach a private network from outside | Staff working from home |
| Patch | The vendor's fixed version of code | Log4j 2.15.0 |
| Zero-day | A vulnerability exploited before any patch exists | Defenders had zero days |
| N-day | A vulnerability with a patch available but not installed | Unpatched for a year |
| Security advisory | A vendor's public notice about a vulnerability and its fix | Affected versions + upgrade steps |
| Coordinated (responsible) disclosure | Report privately, fix, then publish together | Priya reports to her college |
| Full disclosure | Publishing a bug before a fix exists | Posting it online on day one |
| Vulnerability disclosure policy (VDP) | A public page saying how to report bugs | chaigo.example/security-policy |
| Safe harbour | A promise not to take legal action against good-faith reporters who follow the rules | Part of a good VDP |
| Bug bounty programme | Paying rewards for valid vulnerability reports | ₹ rewards per accepted bug |
| CERT-In | The Indian Computer Emergency Response Team | Has a disclosure policy |
| security.txt | A file at /.well-known/security.txt saying where to report (RFC 9116) |
Contact: mailto:security@... |
| RFC | "Request for Comments": an internet standards document | RFC 9116 |
Summary
- A CVE names one bug; a CWE names the kind of mistake; CAPEC names the kind of attack.
- CVSS says how bad a bug could be (base), adjusted over time (temporal/threat) and for your setup (environmental). Ratings: Low < 4 ≤ Medium < 7 ≤ High < 9 ≤ Critical.
- Prioritise with KEV (attacked now), then EPSS (likely soon), then CVSS, for software that's actually in your inventory.
- Zero-days have no patch; n-days have a patch nobody installed. Patch fast.
- Found a bug? Coordinated disclosure: stop, report privately, wait for the fix. Only test what you're authorised to.
- Organisations: publish a VDP with safe harbour, consider a bug bounty, and serve a valid security.txt (Contact + Expires).
Next episode: operating system security on Linux and Windows: kernel vs user mode, users and groups, file permissions, sudo, UAC and hardening.
Sources: MITRE, "CVE Program Celebrates 25 Years of Impact in Cybersecurity" (22 Oct 2024); Jerry Gamblin, "2025 CVE Data Review" (1 Jan 2026); Wikipedia, "Log4Shell"; BleepingComputer, "New CVSS 4.0 vulnerability severity rating standard released" (1 Nov 2023); Qualys, "CVSS v4 is now live" (2 Nov 2023); heise online on NIST and NVD CVSS scoring (2026); Tarlogic, "EPSS"; CISA, "CISA Adds 13 Known Exploited Vulnerabilities to Catalog" (10 Dec 2021); a dev.to KEV guide on KEV criteria; ThreatDown, "Top 5 most dangerous software weaknesses in 2024"; RFC 9116; 9to5Google on Project Zero's 90-day policy (7 Jan 2020); MediaNama on CERT-In's disclosure policy (Sept 2021). Fetched 28 Oct 2026.