SyntaxPilot
Courses/Cybersecurity Fundamentals/Lesson 61
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 61 of 90

Security testing, code review and vulnerability management

code review checklistSemgrep and CodeQL (concepts)triaging false positivescoverage-guided fuzzingsecurity unit and regression testsvulnerability scanning (authorised, own assets)vulnerability management lifecycle (discover, prioritise, remediate, verify)remediation SLAsrisk-based prioritisation with CVSSEPSS and KEVpatch managementexceptions and compensating controls

These are the notes for Cybersecurity Fundamentals (defensive), episode 61. In episode 60 we put security checks into every step of building software. Now those checks produce findings, often hundreds of them. This episode covers how to review code well, how tools read code (and why they raise false alarms), how fuzzing finds bugs nobody thought to test, how tests keep fixed bugs fixed, how to scan your own servers, and how to decide which findings to fix first and by when. Every term is defined the first time it appears; the Glossary collects them.

Scope. Defensive and educational only. Every program is a toy on our own strings and functions; nothing real is scanned or fuzzed. The finding ids V1 to V5 are made up. Samples were run on 13 Nov 2026 in the SyntaxPilot compiler (Python 3.13).

Step 1: a security code review checklist

Real-life example: a teacher checking 40 exam papers by feel gets tired and misses mistakes by paper 30. A marking scheme makes every paper get the same checks.

  • Code review: a second developer reads a code change before it is merged (accepted into the main code).
  • Secure code review: a review that looks specifically for security mistakes.
  • Code review checklist: a short list of security questions asked about every change, so reviews are consistent.

A six-question checklist:

# Question Example of a "no"
1 Input: is every value from outside validated (type, length, format)? qty = int(request.args["qty"]) with no range check
2 Output: is it escaped for where it goes (HTML, SQL, shell)? "SELECT ... WHERE name='" + name + "'"
3 Auth: who may call this, and is that checked on the server? an admin URL that only hides its button in the UI
4 Secrets: any key or password in code, config or logs? API_KEY = "..." committed to Git
5 Errors: does it fail safely, without internal details to users? a stack trace shown on the web page
6 Crypto and libraries: vetted, current, used correctly? MD5 for passwords, a library with a known CVE
  • Validation: checking that input has the expected type, length, range and format before using it.
  • Escaping: converting special characters so data can't be read as code (e.g. < becomes &lt; in HTML).
  • Stack trace: the list of function calls printed when a program crashes; useful to developers, useful to attackers too.

Keep it short and specific: six sharp questions get used; a hundred vague ones get skipped.

Step 2: tools that read code, and false positives

  • Static analysis / SAST (from episode 60): tools that read source code without running it.
  • Pattern rule: a rule that flags code that looks like something risky, e.g. every call to os.system (which runs a shell command). Semgrep is an open-source static analysis tool ("semantic grep") whose rules "look like the code you already write"; it supports 30+ languages.
  • Data-flow (taint) analysis: following values through the program.
  • Source: where untrusted data enters (e.g. input(), a web request).
  • Sink: where data becomes dangerous (e.g. os.system, a SQL query).
  • Tainted: data that came from a source.
  • Sanitiser: a check or transformation that makes tainted data safe for a sink (e.g. allowing only letters and digits).
  • A taint rule reports only when tainted data reaches a sink without a sanitiser.
  • CodeQL (GitHub): a "semantic code analysis engine" that treats source code as a queryable dataset ("code as data"), so one query can find every variant of a vulnerability. Semgrep also has a taint mode.

Demo 1: a pattern rule vs a data-flow rule

# Two toy scanners on the same code: a PATTERN rule vs a DATA-FLOW rule.
import ast

source = """import os
name = input()
os.system("ls " + name)
os.system("ls /tmp")
clean = name if name.isalnum() else "x"
os.system("ls " + clean)
"""
tree = ast.parse(source)
calls = [n for n in ast.walk(tree) if isinstance(n, ast.Call)
         and ast.unparse(n.func) == "os.system"]

print("PATTERN rule (simple Semgrep-style): any os.system call")
for c in calls:
    print(f"   line {c.lineno}: {ast.unparse(c)}")

tainted = {"name"}                  # SOURCE: name = input()
print("DATA-FLOW rule (CodeQL-style): does input REACH it?")
for c in calls:
    used = {n.id for n in ast.walk(c) if isinstance(n, ast.Name)}
    if used & tainted:
        print(f"   line {c.lineno}: input reaches the shell  <- REAL")

Real output:

PATTERN rule (simple Semgrep-style): any os.system call
   line 3: os.system('ls ' + name)
   line 4: os.system('ls /tmp')
   line 6: os.system('ls ' + clean)
DATA-FLOW rule (CodeQL-style): does input REACH it?
   line 3: input reaches the shell  <- REAL

The pattern rule flags all three os.system calls; only line 3 is real. Line 4 runs a fixed string, and line 6 uses a value that passed isalnum() (our toy knows clean was sanitised, so only name is tainted). The data-flow rule reports one finding: the real one.

Triage

  • Triage: sorting findings by what they really are and how urgent they are (like a hospital sorting patients).
  • True positive: a finding that is a real problem → fix it.
  • False positive: a finding with no real problem behind it → mark it as not a bug, with a written reason, who decided and when, so the same alert doesn't come back.
  • False negative: a real problem the tool did not report (the dangerous kind, because nobody sees it).
  • Alert fatigue: when most alerts are false, people stop reading alerts and miss the real one. Tune rules and triage every finding.
Line Finding Verdict Reason recorded
3 os.system("ls " + name) true positive input reaches the shell → fix with subprocess.run(["ls", name]) and validation
4 os.system("ls /tmp") false positive constant string, no user input
6 os.system("ls " + clean) false positive (still worth fixing) value passed isalnum(); prefer subprocess.run with a list anyway

Step 3: fuzzing and coverage-guided fuzzing

Real-life example: a 4-letter word lock has 26^4 = 456,976 combinations. Random guessing teaches you nothing; but if the lock clicked on each right letter, you could keep what clicked and change one letter at a time.

  • Fuzzing: automatically feeding a program huge numbers of unexpected inputs and watching for crashes, hangs or wrong results.
  • Fuzzer: the tool that does it.
  • Mutation: making a new input by changing an existing one a little.
  • Code coverage: which parts of the program's code an input reached.
  • Coverage-guided fuzzing: keep inputs that reach new code, and mutate them further. The "click" is new coverage.
  • Corpus: the saved set of interesting inputs the fuzzer keeps.
  • Real tools: libFuzzer and AFL++ (C and C++), Atheris, "a coverage-guided fuzzer for Python and Python extensions", "based off of libFuzzer". Fuzz only your own code, on your own machine.

Demo 2: random vs coverage-guided fuzzing on a toy coupon parser

# Random fuzzing vs COVERAGE-GUIDED fuzzing on a toy coupon parser.
import random
random.seed(7)

def parse(code):              # returns how deep it got (coverage)
    if len(code) > 0 and code[0] == "C":
        if len(code) > 1 and code[1] == "H":
            if len(code) > 2 and code[2] == "A":
                if len(code) > 3 and code[3] == "I":
                    return int(code[4:])     # the hidden bug
                return 3
            return 2
        return 1
    return 0

ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def rand4(): return "".join(random.choice(ABC) for _ in range(4))

for i in range(1, 50_001):          # 1) pure random guessing
    try: parse(rand4())
    except ValueError: print("random found it at try", i); break
else: print("random: no crash in 50,000 tries")

best, depth = rand4(), 0            # 2) keep inputs that go DEEPER
for i in range(1, 50_001):
    child = list(best)
    child[random.randrange(4)] = random.choice(ABC)
    child = "".join(child)
    try: d = parse(child)
    except ValueError as e:
        print(f"coverage-guided: crash at try {i}, input {child!r}")
        print("   ValueError:", e); break
    if d > depth: best, depth = child, d   # new coverage: keep it

Real output:

random: no crash in 50,000 tries
coverage-guided: crash at try 484, input 'CHAI'
   ValueError: invalid literal for int() with base 10: ''

Random guessing found nothing in 50,000 tries; the coverage-guided loop found the crash in 484, because every input that got one letter deeper was kept. The real error, ValueError: invalid literal for int() with base 10: '', means the parser never expected a coupon with no number after CHAI.

Step 4: security unit tests and regression tests

  • Unit test: a small automatic test of one function.
  • Security unit test: a unit test that checks one security rule ("no negative discount", "maximum 50 percent").
  • Regression: a bug that was fixed and comes back later.
  • Regression test: a test for a bug you already fixed, so it can't return unnoticed. Every crashing input a fuzzer finds becomes one.

Demo 3: tests for the old and the fixed version

# Security unit tests + a REGRESSION test for the bug the fuzzer found.
def discount_v1(code):
    if code.startswith("CHAI"):
        return int(code[4:])                 # crashes on "CHAI"
    return 0

def discount_v2(code):
    if not code.startswith("CHAI"):
        return 0
    digits = code[4:]
    if not digits.isdigit() or not 1 <= int(digits) <= 50:
        return 0                             # reject, don't crash
    return int(digits)

TESTS = [("CHAI", 0, "regression: fuzzer crash"),
         ("CHAI-90", 0, "no negative discount"),
         ("CHAI999", 0, "max 50 percent"),
         ("CHAI20", 20, "normal coupon still works")]

for f in (discount_v1, discount_v2):
    print(f.__name__)
    for code, want, why in TESTS:
        try: got = f(code)
        except ValueError: got = "ValueError"
        mark = "PASS" if got == want else "FAIL"
        print(f"   {mark}  {code!r:<10} {why}  (got {got})")

Real output:

discount_v1
   FAIL  'CHAI'     regression: fuzzer crash  (got ValueError)
   FAIL  'CHAI-90'  no negative discount  (got -90)
   FAIL  'CHAI999'  max 50 percent  (got 999)
   PASS  'CHAI20'   normal coupon still works  (got 20)
discount_v2
   PASS  'CHAI'     regression: fuzzer crash  (got 0)
   PASS  'CHAI-90'  no negative discount  (got 0)
   PASS  'CHAI999'  max 50 percent  (got 0)
   PASS  'CHAI20'   normal coupon still works  (got 20)

Version 1 fails three security tests (crash, a −90 discount, a 999 percent discount). Version 2 passes all four, including the normal coupon: a security fix must not break normal use. These tests run in the pipeline on every change.

Step 5: authorised vulnerability scanning

  • Asset: anything of value you own (episode 1); here, every server, app and device.
  • Asset inventory: the list of all your assets. You can't protect what you don't know you have.
  • Vulnerability scanner: a tool that checks your machines against a database of known vulnerabilities (CVEs, episode 8) and weak settings.
  • Unauthenticated scan: from outside, guessing versions from what services reveal.
  • Authenticated (credentialed) scan: logs in with a read-only account and reads installed versions directly: more accurate, fewer false positives.
  • Scan on a schedule: new servers appear and new CVEs are published daily.
  • Authorisation: scan only assets you own or have written permission to test. Scanning other people's systems without permission can be a crime.

Step 6: the vulnerability management lifecycle

Real-life example: a hospital emergency room: patients arrive, a triage nurse decides who is treated first, doctors treat them, and a check-up confirms they healed.

  • Vulnerability management: the ongoing process of finding, prioritising, fixing and verifying vulnerabilities.
  • Lifecycle: discover (scanners, SAST, fuzzing, reviews, bug reports) → prioritise → remediate (patch, change code or configuration) → verify (re-scan, re-test) → repeat.
  • Remediate: fix the root cause. Mitigate: reduce the risk without fully fixing it.

Scores used to prioritise

Score Who What it measures Range
CVSS (Common Vulnerability Scoring System) FIRST how severe a vulnerability is if exploited 0.0 to 10.0
EPSS (Exploit Prediction Scoring System) FIRST the probability a CVE is exploited in the wild within the next 30 days 0 to 1
KEV (Known Exploited Vulnerabilities catalog) CISA a list of CVEs already being exploited in the list or not
  • FIRST: the Forum of Incident Response and Security Teams.
  • CISA: the US Cybersecurity and Infrastructure Security Agency.
  • Exploited in the wild: used by real attackers against real systems, not just in a lab.
  • CVSS v4.0 became generally available on 1 November 2023. Its metric groups are Base, Threat (renamed from "Temporal" in v3.1), Environmental and Supplemental.
  • Exposure: whether the system is reachable by attackers, e.g. internet-facing vs internal only.
  • Risk-based prioritisation: order by likelihood and impact: already exploited (KEV) → likely to be exploited (EPSS) → exposed → severity (CVSS). CVSS says how bad it could be; EPSS and KEV say how likely it is to actually happen.

Demo 4: CVSS only vs risk-based, with SLA due dates

# Risk-based prioritisation: CVSS alone vs CVSS + EPSS + KEV.
from datetime import date, timedelta

# toy findings: id, where, CVSS, EPSS, in KEV?, internet-facing?
F = [("V1", "admin panel lib",  9.8, 0.02, False, False),
     ("V2", "VPN gateway",      7.5, 0.94, True,  True),
     ("V3", "image library",    8.8, 0.01, False, True),
     ("V4", "web framework",    6.1, 0.47, False, True),
     ("V5", "build tool",       9.1, 0.00, False, False)]

print("CVSS only: ", [f[0] for f in sorted(F, key=lambda f: -f[2])])

def risk(f):
    _, _, cvss, epss, kev, exposed = f
    return (kev, epss >= 0.1, exposed, cvss)   # compared in order

order = sorted(F, key=risk, reverse=True)
print("Risk-based:", [f[0] for f in order])

SLA = {"P1": 2, "P2": 14, "P3": 30, "P4": 90}   # days to fix
today = date(2026, 11, 13)
for f in order:
    p = "P1" if f[4] else "P2" if f[3] >= 0.1 else "P3" if f[5] else "P4"
    due = today + timedelta(days=SLA[p])
    print(f"   {f[0]} {f[1]:<17} {p}  fix by {due}")

Real output:

CVSS only:  ['V1', 'V5', 'V3', 'V2', 'V4']
Risk-based: ['V2', 'V4', 'V3', 'V1', 'V5']
   V2 VPN gateway       P1  fix by 2026-11-15
   V4 web framework     P2  fix by 2026-11-27
   V3 image library     P3  fix by 2026-12-13
   V1 admin panel lib   P4  fix by 2027-02-11
   V5 build tool        P4  fix by 2027-02-11

By CVSS alone, V2 (the internet-facing VPN gateway, already exploited, 94% likely) would be fixed fourth. Risk-based ordering puts it first.

  • Remediation SLA (service level agreement): the agreed deadline for fixing a finding of a given priority, e.g. P1 = 2 days, P2 = 14 days.
  • Real example: CISA's Binding Operational Directive 22-01 requires US federal civilian agencies to remediate KEV vulnerabilities "within two weeks" (for CVE IDs from 2021 onward) and "within 6 months" for CVE IDs assigned before 2021.

Step 7: patch management, exceptions and compensating controls

  • Patch: an update from a vendor that fixes a flaw.
  • Patch management: applying patches safely at scale: inventory → test on a small group → roll out in waves → verify (re-scan).
  • Maintenance window: an agreed time when a short outage is acceptable, used for critical servers.
  • Rollback plan: a tested way to undo a patch if it breaks something.
  • Laptops and phones: automatic updates.

Real-life example: a shop's lock breaks on Sunday; the new one arrives Tuesday. The owner writes down the decision (an exception) and puts a guard and a camera there tonight (a compensating control).

  • Exception (risk acceptance): a written, approved decision to leave a vulnerability unfixed for now, with an owner, a reason and an end date.
  • Compensating control: another safeguard that reduces the same risk while the real fix waits: a firewall rule blocking the vulnerable port, a web application firewall rule, turning the feature off, isolating the machine, extra monitoring.

The whole chain

  1. Tired reviewers miss bugs → a security code review checklist.
  2. Pattern rules cry wolf → data-flow (taint) rules, triage of false positives.
  3. Bugs nobody imagined → coverage-guided fuzzing.
  4. Fixed bugs return → security unit and regression tests.
  5. Old software on servers → authorised vulnerability scanning.
  6. Hundreds of findings → the lifecycle, CVSS + EPSS + KEV, remediation SLAs.
  7. Can't patch yet → a dated exception + a compensating control.

Common mistakes (and the fix)

Mistake What you see Why Fix
fix findings in CVSS order only an exploited bug waits while theoretical ones get fixed ignores likelihood KEV first, then EPSS and exposure, then CVSS
mark "false positive" with no reason a real bug is silenced, nobody can check later no audit trail record why, who and when
fix a crash, add no test ValueError: invalid literal for int() with base 10: '' returns two releases later no regression test add the crashing input to the tests
"temporary" exception with no end date the risk is accepted forever no owner, no deadline owner + end date + compensating control
scan an IP range you don't own unauthorised testing no permission scan only your inventory, or with written scope
patch production directly an outage, no way back no testing or rollback test group → waves → verify, with a rollback plan
never re-scan after fixing "fixed" tickets that aren't no verification verify is a lifecycle step

Mini project: a tiny vulnerability-management board

Write vm.py that reads a CSV of findings (id, asset, cvss, epss, kev, internet_facing, found_on), computes a priority (P1–P4) with the risk-based rule from Demo 4, adds a due date from an SLA table, marks anything past its due date as OVERDUE, and supports an exceptions.csv (id, owner, reason, until, compensating_control) that hides a finding only until its end date. Print a sorted table. Add tests: a KEV finding is always P1; an expired exception no longer hides its finding.

Practice

1. Add a question to the checklist for file uploads.

Solution

"Uploads: is the file type checked by content (not just the extension), the size limited, the name replaced with a generated one, and the file stored outside the web root?"

2. Extend the toy data-flow rule: clean = name.upper() should still be tainted.

Solution

Propagate taint through assignments: for each ast.Assign, if any name used on the right side is tainted and the expression is not a known sanitiser, add the target to tainted.

SANITISERS = {"isalnum"}
for node in ast.walk(tree):
    if isinstance(node, ast.Assign):
        used = {n.id for n in ast.walk(node.value) if isinstance(n, ast.Name)}
        calls = {getattr(n.func, "attr", "") for n in ast.walk(node.value) if isinstance(n, ast.Call)}
        if used & tainted and not calls & SANITISERS:
            tainted.add(node.targets[0].id)

3. Make the fuzzer work on 5-letter coupons where the bug needs CHAIX.

Solution

Add a fifth nested if in parse that returns a deeper value, change rand4() to build 5 letters, and mutate random.randrange(5). Random guessing now needs about 26^5 ≈ 11.9 million tries on average; the coverage-guided loop still needs only a few hundred to a few thousand.

4. Add a regression test: discount CHAI0 must be rejected.

Solution

("CHAI0", 0, "zero discount rejected"). Version 2 already returns 0 because 1 <= 0 is false; version 1 returns 0 too, so this test passes on both: a reminder that a test only proves what it checks.

5. A finding has CVSS 5.3, EPSS 0.88, is not in KEV, and is internet-facing. Which priority does Demo 4 give it, and is that sensible?

Solution

P2 (EPSS ≥ 0.1), due in 14 days. Sensible: a medium-severity bug that is very likely to be exploited on an exposed system deserves quick attention.

6. Write an exception record for a server that can't be patched until a vendor release.

Solution

id: V7 · asset: billing-db-02 · owner: platform team lead · reason: vendor patch not released · until: 2026-12-15 · compensating control: firewall allows port 5432 only from app servers; extra login alerts.

Quick quiz

A: CVSS 9.8, EPSS 0.02, not in KEV, internal only
B: CVSS 7.5, EPSS 0.94, in KEV, internet-facing
C: CVSS 8.8, EPSS 0.01, not in KEV, internet-facing
D: CVSS 9.1, EPSS 0.00, not in KEV, build tool

Which finding should you fix first?

Answer

B. It is already exploited (KEV), very likely to be exploited soon (EPSS 0.94) and exposed to the internet. CVSS measures how bad a vulnerability could be, not how likely it is to be used.

Interview questions

  1. What belongs on a secure code review checklist? Input validation, output encoding, server-side authorisation, secrets, error handling, crypto and dependency use: short and specific.
  2. What is the difference between a pattern rule and a taint rule? A pattern rule flags code that looks risky; a taint rule tracks untrusted data from sources to sinks and reports only unsanitised flows, so it has fewer false positives.
  3. How do you handle false positives? Triage each, record the reason, tune or suppress the rule, and track the false-positive rate so alerts stay trusted.
  4. What is coverage-guided fuzzing? A fuzzer that measures which code each input reaches and keeps inputs that reach new code as seeds for further mutation.
  5. What is a regression test? A test for a previously fixed bug that keeps it from returning.
  6. What is the vulnerability management lifecycle? Discover, prioritise, remediate, verify, repeat.
  7. CVSS vs EPSS vs KEV? CVSS: severity (0–10). EPSS: probability of exploitation in the next 30 days (0–1). KEV: confirmed exploitation in the wild.
  8. What is a remediation SLA? The agreed time to fix a finding of a given priority.
  9. What is a compensating control? An alternative safeguard that reduces the risk while the primary fix is not possible.
  10. Why must scanning be authorised? Testing systems without permission can be illegal and can disrupt them; scope must be written and agreed.

Glossary

Term Meaning
code review a second developer reading a change before it is merged
secure code review a review focused on security mistakes
code review checklist a short list of security questions asked about every change
validation checking input's type, length, range and format before use
escaping converting special characters so data can't act as code
stack trace the list of function calls printed when a program crashes
static analysis / SAST analysing source code without running it
pattern rule a rule that flags code that looks like a risky pattern
Semgrep an open-source static analysis tool whose rules look like code
CodeQL GitHub's semantic code analysis engine; code as a queryable dataset
data-flow / taint analysis following untrusted data through the program
source where untrusted data enters a program
sink where data becomes dangerous (shell, SQL, HTML)
tainted data that came from a source
sanitiser a check or transformation that makes data safe for a sink
triage sorting findings by what they are and how urgent they are
true positive a finding that is a real problem
false positive a finding with no real problem behind it
false negative a real problem the tool did not report
alert fatigue ignoring alerts because most are false
fuzzing feeding a program many unexpected inputs to find crashes
fuzzer the tool that does fuzzing
mutation changing an existing input a little to make a new one
code coverage which parts of the code an input reached
coverage-guided fuzzing keeping and mutating inputs that reach new code
corpus the saved set of interesting fuzzing inputs
libFuzzer / AFL++ / Atheris coverage-guided fuzzers (C/C++; Python, based on libFuzzer)
ValueError Python's error for a value of the right type but wrong content
unit test a small automatic test of one function
security unit test a unit test that checks one security rule
regression / regression test a fixed bug returning / a test that prevents it
asset inventory the list of everything you own and must protect
vulnerability scanner a tool that checks systems for known vulnerabilities and weak settings
authenticated scan a scan that logs in read-only to see installed versions
authorised scanning scanning only assets you own or have written permission for
vulnerability management finding, prioritising, fixing and verifying vulnerabilities, continuously
discover / prioritise / remediate / verify the four lifecycle steps
mitigate reduce risk without fully fixing
CVSS Common Vulnerability Scoring System: severity 0.0–10.0 (v4.0: Base, Threat, Environmental, Supplemental)
EPSS Exploit Prediction Scoring System: probability of exploitation in the next 30 days (0–1), by FIRST
KEV CISA's Known Exploited Vulnerabilities catalog
FIRST Forum of Incident Response and Security Teams
CISA US Cybersecurity and Infrastructure Security Agency
exploited in the wild used by real attackers against real systems
exposure / internet-facing reachable by attackers / reachable from the internet
risk-based prioritisation ordering fixes by likelihood and impact, not severity alone
remediation SLA the deadline to fix a finding of a given priority
BOD 22-01 CISA directive: fix KEV vulnerabilities within set deadlines (federal agencies)
patch a vendor update that fixes a flaw
patch management testing and rolling out patches safely at scale
maintenance window an agreed time when a short outage is acceptable
rollback plan a tested way to undo a change
exception / risk acceptance a written, approved, time-limited decision to leave a risk for now
compensating control an alternative safeguard that reduces the same risk

Summary

  • Review every change with a short, specific security checklist.
  • Pattern rules flag lots of code; data-flow (taint) rules follow untrusted data from source to sink. Triage every finding and record why.
  • Coverage-guided fuzzing keeps inputs that reach new code and finds bugs random guessing never reaches; every crash becomes a regression test.
  • Scan only what you own, on a schedule, ideally authenticated.
  • Manage vulnerabilities as a lifecycle: discover, prioritise, remediate, verify.
  • Prioritise by risk: KEV, then EPSS and exposure, then CVSS, with remediation SLAs.
  • Patch in tested waves with a rollback plan; when you can't, use a dated exception plus a compensating control.
  • Next episode: software supply chain security.

Sources (fetched 13 Nov 2026)

  • Semgrep on GitHub: https://www.github.com/semgrep/semgrep
  • CodeQL: https://codeql.github.com/
  • Atheris on PyPI: https://pypi.org/project/atheris/
  • Bitsight glossary, EPSS: https://www.bitsight.com/glossary/epss-exploit-prediction-scoring-system
  • CISA, BOD 22-01: https://cisa.gov/binding-operational-directive-22-01
  • Qualys, CVSS v4 is now live: https://blog.qualys.com/product-tech/2023/11/02/cvss-v4-is-now-live-and-what-do-you-need-to-know