Skip to main content
Security libraryReviewed

Web application vulnerabilities: find the guide for the problem in front of you

Forty-five guides to vulnerabilities, defences and secure development, sorted into seven areas of an application.

For each one the finder table gives what you notice first, where it lives, who can reach it, the OWASP category the guide itself names, and the lab, checklist or worksheet it hands you.

Pages in this section

45 pages

  • Broken Access Control and IDOR

    Broken access control is an application letting someone read, change or do something its own rules say they may not. This guide explains horizontal and vertical access, the places in real applications where the check goes missing, and a two-account test matrix you can run against your own application, with a local lab that runs the matrix against a flawed and a fixed API.

  • Broken Authentication

    Broken authentication is any flaw that lets someone be accepted as a user they are not, or brings them closer to it. This guide walks through the five flows a sign-in system is made of: registration, login, password recovery, email change and reauthentication before a sensitive action. It shows what each one leaks or lets through when it is built carelessly, with account enumeration as the worked example, and comes with a test pack for your own application and a Node.js lab that measures the timing leak and its fix.

  • Business Logic Vulnerabilities

    A business logic vulnerability is an application doing exactly what its code says, where the code does not say what the business means. This guide explains why these flaws pass the checks a scanner makes, how to find the rules worth protecting, how to write each rule as an invariant a test can check, and where the enforcement belongs. It comes with a worked booking-and-refund state machine, eleven abuse cases played with two accounts, and a local lab with a regression test.

  • CI/CD Security

    A CI/CD pipeline holds the keys to production: a repository token, cloud credentials and the right to deploy without anyone touching a server. This guide explains who and what can make yours run, what each job and each third-party action can reach once it does, and what an approval, a short-lived identity and an attested artefact each prove. GitHub Actions is the worked example, with GitLab CI/CD as a section of its own. It comes with a pipeline trust map, a six-part threat test pack, a sample least-privilege workflow and a local checker you can run against your own workflow files.

  • Clickjacking

    Clickjacking shows one of your pages inside a frame on another site, so that a click the visitor meant for that site lands on your page instead. This guide explains what a frame is, why the visitor's own session is what makes it work, how the Content-Security-Policy frame-ancestors directive and the older X-Frame-Options header differ, which one a browser follows when both are sent, and how to let one partner embed a page while refusing everyone else. It comes with a local harness and a browser evidence table you fill in yourself.

  • Command Injection

    Command injection happens when an application builds an operating system command from input and the input changes what the command does. This guide shows what a shell does with a command string, what an argument array changes, what the environment and working directory still decide, and gives you a local Node.js lab whose marker tests check that shell metacharacters stay data.

  • Cookie Security

    Every cookie your server sets travels in a Set-Cookie header, and its attributes decide who can read the cookie, over what connection, to which hosts and paths, for how long and in which cross-site situations. This guide explains each attribute in plain terms with the standard behind it, and comes with a Set-Cookie decision table for six kinds of cookie and a verification pack you run with Node.js alone.

  • CORS Misconfiguration

    Cross-origin resource sharing (CORS) is how your server tells a visitor's browser which other websites may read its responses. It does not stop simple requests reaching your server, and it does not check who is asking. This guide explains the headers, the preflight and the five misconfigurations that hand the read to sites you never meant to trust, with a request trace and a regression test you can run with Node.js alone.

  • Credential Stuffing

    Credential stuffing replays username and password pairs leaked from somewhere else against your sign-in page, and any customer who reused a password can lose their account to it. This guide shows how to tell it apart from password spraying and brute force in your own login logs, which controls slow it without locking real customers out, and what to do after an attack. It comes with a synthetic detection workbook and a local Node.js lab with a regression test.

  • Cross-Site Request Forgery (CSRF)

    Cross-site request forgery gets a signed-in visitor's browser to send a request they never meant to send. This guide explains in plain English why browsers make that possible, what CSRF tokens, Origin and Sec-Fetch-Site checks and SameSite cookies each do, and where each one stops. It comes with a request matrix and a lab you can run on your own machine with Node.js alone.

  • Cross-Site Scripting (XSS)

    Cross-site scripting happens when text from someone else lands in your page in a way the browser treats as code. This guide explains what that lets an attacker do, how reflected, stored and DOM-based XSS differ, and why the fix depends on where the text lands. Then it gives you a test suite to run with Node.js alone: one marker, five contexts, and the unsafe and safe versions side by side.

  • Dependency Security

    Every package your site installs brings code your team did not write, and each of those packages can bring more. This guide covers the routine side of dependency security: listing direct and transitive dependencies, keeping installs tied to the lockfile, reading an advisory against how your code uses the package, choosing what to update first, and proving the update took. It comes with a triage worksheet, a worked decision for a vulnerable function the code does not call, and a lockfile lab that runs offline.

  • Dynamic Application Security Testing (DAST)

    Dynamic application security testing (DAST) uses a running copy of your application from the outside, the way a visitor would, and judges it by the responses. A scanner can only test what it finds and what its accounts can open. This guide explains how a scanner discovers pages, forms and API operations, why it has to sign in and how it loses its session, and how to read a result that says nothing was found. It comes with a coverage map to fill in from your own scanner and a local lab that shows coverage dropping when a session is lost part way through.

  • File Upload Security

    An upload feature lets a stranger put a file on your server. This guide covers what the server should accept, how it decides what a file is, where it stores it, what it names it and how it serves it back, with a harmless fixture set, a four-check verification table and a local Node.js lab with a regression test.

  • Host Header Injection

    Every request tells the server which site it is asking for, and whoever sends the request writes that name. Host header injection is what follows when an application uses the name to build its own links: on a page, in a redirect or in a password reset email. This guide covers who sets the Host header, how a proxy changes what the application sees, how six frameworks and two web servers decide their own name, the four controls, and a trusted-host test pack with a lab you can run on your own computer.

  • HTTP Request Smuggling

    HTTP request smuggling, also called an HTTP desync attack, happens when a front end such as a reverse proxy, CDN or load balancer and the server behind it read the same bytes and disagree about where one request ends. This guide explains why that matters, what the HTTP standards require of each component, how HTTP/2 downgrading changes the picture and which fixes close the gap. The parser trace lab below runs on your own machine, on 127.0.0.1 only, and shows the disagreement in a few lines of output.

  • Insecure Deserialisation

    A deserialisation vulnerability starts where an application turns bytes it received or stored back into objects, and lets those bytes decide which objects to build. This guide explains what serialisation is, where your application does it without anyone calling it that, which formats carry types as well as data, and the checks that belong before any object is built: a size limit, integrity, a depth limit, an allow-list of types and a schema. It comes with a parser-boundary checklist, a reference to what each language's documentation says, and a Node.js lab that sends tampered objects to a careless, a late-check and a careful version of one feature.

  • JWT Security

    A JSON Web Token is only as trustworthy as the code that checks it. This guide explains in plain English what a JWT is and who can read it, the algorithm, key, claim and revocation decisions a verifier has to make, the attacks that work when one is skipped, and a verification suite you run with Node.js alone to show your own verifier makes each one.

  • Mass Assignment

    A mass assignment vulnerability is a handler that copies every field a client sends onto a stored record, so the client can set fields the form never offered: a role, a price, an owner, a verified flag. This guide explains the mistake in plain terms, which fields matter, why a list of allowed fields holds where a list of banned ones does not, and what each framework's documentation gives you. It comes with a request-diff method and worksheet for your own write endpoints, and a local lab with regression tests that fail until the privileged fields stop changing.

  • MFA Security

    A second factor means a stolen password is not enough on its own, but only on the paths that ask for it. This guide explains how second factors are relayed, fatigued and gone around through enrolment, recovery, remembered devices and older sign-in routes, what the standards ask for at each step, and how to test your own application. It comes with a test matrix organised by state change and a Node.js lab with a time-based one-time password checked against the RFC test values.

  • NoSQL Injection

    NoSQL injection is input changing the question your application asks a document database: as an object where your code expected text, which is operator injection, or as code the database runs on the server. This guide explains it in plain English, then gives you a lab to run on your own machine with Node.js alone: one small API in a flawed version and three fixed ones, the filter each one sent to the database layer, and regression tests that fail until the fix is in.

  • OAuth and OpenID Connect Security

    When a customer clicks "Sign in with" a provider, your application runs the OAuth 2.0 authorisation code flow, and OpenID Connect tells it who signed in. This guide explains each step in plain English, what state, PKCE, the nonce and an exactly registered redirect URI each protect, the attacks that work when one is missing, and a lab with a mock provider and callback tests you run on your own machine with Node.js alone.

  • Open Redirects

    An open redirect sends a visitor wherever a link tells it to, under your domain name. This guide explains what a return address is for, why "it starts with a slash" and "it contains our domain" both fail, how to check the parsed result or, better, an allowlist of routes, and gives you a local Node.js lab with a URL parser test table and a regression test.

  • Path Traversal

    Path traversal happens when code builds a file path from something a visitor controls and the result lands outside the folder the code meant. This guide shows where it hides, why stripping ../ fails, how to check the real path after links are resolved, and gives you a local Node.js lab with a canonical-path test table and a regression test.

  • Race Conditions

    A race condition in a web application is two requests that each pass a check, such as "one per customer" or "while stock lasts", before either has recorded its effect. This guide explains why it surfaces as stock or money that does not add up rather than as an error, what your database's default isolation level does and does not stop, and the controls that make the check and the effect one step or make a repeat harmless. It comes with a verification checklist and a local lab with two server processes, reconciliation tables and a regression test.

  • Rate Limiting

    A rate limit counts what a client does against a key over a window, and decides what happens when the count runs out. This guide covers what to count and against which key (an account, an address, a device or the whole route), how window choices feel to a real user, what a good 429 response says, why counters kept in each server multiply the limit, what to do when the counter store is down, and how a limited customer gets back in. It comes with a design worksheet, a verification table for low-volume checks on staging, and a local Node.js lab with a regression test.

  • Remote Code Execution

    Remote code execution means someone on the internet gets your server to run their code. This guide explains what counts as RCE, the flaws that lead to it, and the part that decides the damage: what the process can reach once code runs. It comes with a review worksheet and a harmless-marker lab that needs only Node.js.

  • SAST

    Static application security testing reads your code without running it and reports lines that look like known weaknesses. This guide explains the difference between matching a pattern and following data, why tools report safe code and miss flawed code, and how to bring a tool into CI without burying the team. It comes with a labelled JavaScript fixture suite, a scorecard and a small local lab for measuring a tool before it gates a merge.

  • SBOM

    A software bill of materials (SBOM) is a machine-readable inventory of the components a piece of software is built from. This guide explains what one holds under the 2021 NTIA minimum elements and the 2026 joint guidance that replaced them, how CycloneDX and SPDX differ, how a small team produces one for a web application at every release, how a component is identified so an advisory can be matched to it, and what a VEX statement adds. It comes with a worked component record and triage table across two releases, and a lab that generates real SBOMs offline.

  • Secrets Exposure

    API keys and other secrets leak into source files, git history, the JavaScript every visitor downloads, log files, and environment files or .git folders a web server hands out. This guide shows how to confirm a leak on your own property, why the old key is revoked or rotated before anything is cleaned, and how to prove it no longer works. It comes with a fixture repository you can run on your own computer, taking four planted canary keys from detection through to proof.

  • Secure SDLC

    A secure software development lifecycle puts a security activity at each stage of delivery and keeps the evidence that it happened. This guide sets out, for a team of a handful of people shipping a web application, what belongs at requirements, design, build, review, test, release and after release, what has to be true before work moves on, and who decides when it is not. It comes with a stage-gate map, a release checklist, a worked example and a small script that checks a release record for missing evidence.

  • Security Logging and Monitoring

    Security logging and monitoring is how an application notices that someone is guessing passwords, changing permissions or asking for records that are not theirs. This guide covers which security events to record, what each record needs to be useful a month later, how to keep secrets and forged lines out of the log, how to protect the log from the person it records, and how to turn a record into an alert that someone acts on. It comes with an event schema you can copy, three detection rules with tests, redaction fixtures, a review checklist and a lab you can run on your own computer.

  • Security Misconfiguration

    A security misconfiguration is a weakness in a setting, not in the code: debug mode left on, a default account that still signs in, a folder that lists its files, an admin page or a storage bucket open to everyone. This guide explains why those settings drift between development, staging and production, what each one exposes, and how to compare what you intended with what is running. It comes with an environment drift worksheet and a lab you can run on your own computer.

  • Sensitive Data Exposure

    Sensitive data exposure does not need a break-in. A signed-in caller makes a request they are allowed to make, and the response, the error, the export, a cached copy or a log line holds more about a person or the business than the task required. This guide covers each of those five places, what OWASP, MITRE, ASVS 5.0 and the HTTP caching standard say about them, and how to keep a field list per endpoint. It comes with a field-by-field table, a response-diff exercise and a lab you can run on your own computer.

  • Server-Side Request Forgery (SSRF)

    Server-side request forgery (SSRF) is what happens when an application fetches a URL that someone else chose and the request lands somewhere it should not: an admin page on the same machine, a service inside your network or a cloud metadata service. This guide explains where SSRF hides in ordinary features, why checking the hostname text is not enough and what network controls add, and gives you a local Node.js lab whose verification table and regression test check an allowlist against ten kinds of input.

  • Server-Side Template Injection (SSTI)

    Server-side template injection happens when text from a visitor, a customer or a staff member becomes part of a template your server renders, so the template engine reads it as instructions instead of printing it. This guide explains what a template engine is for, where the flaw comes from, how to tell it from XSS and what the engines' own sandboxes cover. It comes with a Node.js lab, a harmless arithmetic canary and a regression test you can run on your own machine.

  • Session Management

    After someone signs in, a single random value stands in for their password on every request. This guide explains in plain English how that value should be issued, when it must change, when it must stop working and who should be able to end it, with the standard behind each rule. It comes with a session lifecycle state diagram and six local checks you can run with Node.js alone.

  • SQL Injection

    SQL injection is what happens when text someone typed into your website becomes part of a command to your database. This guide explains it in plain English, then gives you a lab to run on your own machine with Node.js alone: one lookup built two ways, the evidence from each request, and a regression test that fails until the fix is in.

  • Subdomain Takeover

    A DNS record tells every browser that a name on your domain is served by a particular place. When the place is given up and the record stays, whoever claims that place next can serve content under your name. This guide explains how that happens during ordinary work, what the person holding the name can do, and how to find and close dangling records, with a DNS lifecycle evidence worksheet, a verification procedure that creates nothing at any provider, and a local Node.js lab.

  • Supply Chain Attacks

    A supply chain attack reaches a website through code you trust but did not write: a package your build installs, a step in your pipeline, or a script your pages load from someone else's server. This guide explains each route at the level a defender needs to recognise it, the signals that give one away, and what you and your developers, or your incident responder, do in the first days. It comes with a provenance worksheet and a response timeline you can copy.

  • Threat Modelling

    Threat modelling is a design activity. A few people draw what they are building, ask what can go wrong wherever data crosses a line of trust, decide what to do about each answer and write the decisions down. This guide covers the diagram, trust boundaries, STRIDE as a set of prompts, abuse cases, the four decisions, and how a decision becomes a requirement with an owner and a test. It comes with a worked data-flow diagram and threat register for an invented booking application, a blank register and a small checker you can run.

  • Web Application Firewall

    A web application firewall reads each request on its way to your website and blocks or records the ones that match its rules. This guide answers whether one is worth having for your business, what it cannot do, how to change its rules without blocking real customers, and how to test that it behaves the way you think. The worksheet on this page turns that into a record your team can fill in.

  • Web Cache Deception

    A cache in front of your site stores copies of responses so it can answer the next visitor without asking your server. Web cache deception is the case where it stores the wrong one: a signed-in person's private page, kept under an address the cache took for a public file and handed to the next request, session or no session. This guide explains how a shared cache decides what to store, why one URL can mean two things to two layers, and the four controls that stop it. It comes with a response-cache matrix, four path-confusion fixtures and a lab you can run on your own computer.

  • Web Cache Poisoning

    A cache in front of your site keeps one copy of a page and hands it to everyone who asks for the same address. If a request can change that copy through an input the cache does not look at, everyone gets the changed copy. This guide covers cache keys and unkeyed inputs, the three fixes, how to test without touching real visitors, and a lab you can run on your own computer.

  • XML External Entity (XXE)

    XML external entity (XXE) injection happens when an XML parser follows an instruction inside a document to fetch content from somewhere else, such as a file on your server or an address on your network. Entities declared inside the same document can also expand until memory runs out, with nothing fetched at all. This guide explains what an entity is, where XML still turns up in applications built on JSON, and why the fix is a parser setting rather than an input filter. It gives you a parser configuration worksheet and a local DTD canary lab that shows what your parser does with its defaults and with hardened settings.

Vulnerability finder: 45 guides in seven areas

Read down the Area column to the part of your application in trouble, then across: what you notice first, where the problem lives and the platforms the guide names, who can reach it, the OWASP category in the guide's own words, and the guide's asset with what it needs. Rows are numbered 1 to 45, run in the order of the seven areas, and every guide is linked under Pages in this section.

45 rows

Vulnerability finder: 45 guides in seven areas

AreaGuide and addressWhat you notice firstWhere it livesWho can reach itOWASP category the guide namesThe guide's asset, and what it needs
Sign-in, sessions and tokens1. Broken Authentication, at /web-security/authentication-failuresSign-up, sign-in or reset tells a stranger whether an email has an account, a reset link works twice, or an email address changes without the current password.The five account flows (registration, login, recovery, email change and reauthentication) on every channel that shares the accounts, plus password storage.A stranger at the form, and anyone holding a stolen or unattended session.A07 Authentication Failures (Top 10:2025); API2:2023 Broken Authentication.A test pack of 28 tests across the five flows plus a closing log check, and a local Node.js enumeration lab (5 files, 12 regression tests). The pack needs test accounts and a way to read whole responses.
Sign-in, sessions and tokens2. Credential Stuffing, at /web-security/credential-stuffingMany different usernames fail about once each, some of them not accounts on your site, followed by successful sign-ins from the same sources.The sign-in form, mobile login API and password reset or change, with their logs, throttles and breached-password check.Anyone holding username and password lists leaked from another site. Customers who reused a password are exposed without any breach of your site.A07:2025 Authentication Failures; API2:2023 Broken Authentication.A detection workbook of 5 measures, 8 test cases and a local Node.js lab on invented accounts (6 files, 8 regression tests). Needs Node.js only.
Sign-in, sessions and tokens3. Rate Limiting, at /web-security/rate-limitingSign-in, one-time codes, password reset or a costly endpoint accept unlimited requests, or real customers are locked out with no way back.The limiter: what it counts, its key and window, its 429 response, where the counter lives and what happens when that store fails. Edge rules in nginx and Cloudflare are covered too.One source trying many accounts, many sources trying one account, or one heavy user. Anyone who knows a username can spend that customer's allowance.No Top 10 category named; API4:2023 Unrestricted Resource Consumption and API2:2023 Broken Authentication.A design worksheet for 7 kinds of endpoint, 14 low-volume staging checks and a local Node.js lab (8 files, 12 scenarios). The guide says these are not load tests.
Sign-in, sessions and tokens4. MFA Security, at /web-security/mfa-securityAn account with a second factor is entered without it: a relayed code, a push prompt approved to make it stop, or an older route that takes a password alone.Enrolment, the second sign-in step, factor changes, recovery, remembered devices, push approval and reauthentication, with their logs.Someone who already has the password, or holds a stolen session.None named in the guide.A test matrix of 38 rows in 8 groups and a local TOTP lab (7 files, 15 tests). Push and SMS rows need a test device or number.
Sign-in, sessions and tokens5. Session Management, at /web-security/session-managementAn old session cookie still works after sign-out, the identifier is the same before and after sign-in, or sessions survive a password reset.The server-side session after sign-in: issuing, rotation, timeouts, sign-out, revocation and the account page's session list. Django, express-session and PHP are named.Whoever holds the identifier, including an attacker who set it before sign-in.A07 Authentication Failures (Top 10:2025, through CWE-613).A session state diagram with 14 transitions and a local Node.js lab (4 files, 6 checks). Needs Node.js only.
Sign-in, sessions and tokens6. Cookie Security, at /web-security/cookie-securityA session cookie without Secure, HttpOnly or SameSite set deliberately, a Domain attribute that widens it to every subdomain, or a sign-out that leaves it behind.The Set-Cookie header, its attributes and prefixes, the defaults in express-session and Django, and the cookie options the Next.js authentication guide recommends.Network attackers on plain HTTP, script on the page, sibling subdomains and other sites.A02 Security Misconfiguration (Top 10:2025, through CWE-614 and CWE-1004).A decision table for 6 kinds of cookie, a local Node.js lab (5 files, 4 flows, 9 tests) and a cookie register of 13 fields.
Sign-in, sessions and tokens7. OAuth and OpenID Connect Security, at /web-security/oauth-oidc-security"Sign in with" puts a visitor in the wrong account, a leaked code signs someone in as another person, or an unverified provider email takes over a local account.The authorisation code flow: the callback's checks (state, PKCE, nonce, ID Token), account linking, and the redirect URIs and scopes in the provider console.An attacker with their own provider account or a leaked code, or anyone who can open a provider account with a customer's email.None named in the guide.The flow as 9 numbered steps, and a local callback lab with a mock provider (6 files, 13 scenarios, 13 tests). Needs Node.js only.
Sign-in, sessions and tokens8. JWT Security, at /web-security/jwt-securityAn API accepts a token it should refuse: algorithm none, the wrong kind of key, a staging token, a token for another API, an ID token or an expired one.The token verifier on the API (algorithm, key for each issuer, signature and claims) and the settings of the jsonwebtoken and jose libraries.Anyone holding a token or the public key, and anyone who can mint tokens in staging.A04:2025 Cryptographic Failures, the category MITRE files CWE-347 under.A decision table of 11 decisions and a verification suite (5 files, 16 fixtures, 16 tests) that contacts no other machine. Needs Node.js only.
Records, roles and business rules9. Broken Access Control and IDOR, at /web-security/broken-access-control-idorOne customer opens another's invoice by changing an id, a list or export carries extra rows, or an ordinary account reaches an admin function.Server-side authorisation on object routes, lists, exports, background jobs and admin functions. Next.js Server Actions and Supabase row level security are named.Signed-in users in the same role, in a lower role, or in another customer organisation.A01 Broken Access Control (Top 10:2025); API1:2023 and API5:2023.A test matrix of 5 accounts by 7 routes (35 cells) that works on its own, and a local Node.js lab that runs it (5 files, 7 tests).
Records, roles and business rules10. Mass Assignment, at /web-security/mass-assignmentA profile edit, sign-up or order stores a field the form never offered: a role, a verified flag, store credit, a price or an owner.Write endpoints and the binding that copies request fields onto records. Rails, Laravel, Django, ASP.NET Core, Mongoose, Prisma and Zod are named.A signed-in account calling an endpoint it may call, on a record it may edit.No web Top 10 category; API3:2023 Broken Object Property Level Authorization, previously API6:2019 Mass Assignment.A 6-step request-diff method and a worksheet that work without the lab, and a local Node.js lab (8 files, 11 tests).
Records, roles and business rules11. Business Logic Vulnerabilities, at /web-security/business-logic-vulnerabilitiesWell-formed requests from allowed accounts produce a wrong outcome: a booking confirmed with nothing paid, one approval paid twice, a refund larger than the payment.The server's workflow for money and stock: its states, the moves between them and the rules stored records must keep.Signed-in customers and staff with the right role, acting at the wrong step or for the wrong amount.A06 Insecure Design (Top 10:2025); API6, Unrestricted Access to Sensitive Business Flows (API Security Top 10 2023).A booking-and-refund state machine (8 states, 7 invariants, 11 abuse cases) that works without the lab, and a local Node.js lab (7 files, 7 tests).
Records, roles and business rules12. Race Conditions, at /web-security/race-conditionsStock, vouchers or balances that do not add up: a one-per-customer offer redeemed many times, or a double charge, with no errors logged.Check-then-act on shared state across processes: transactions, isolation, constraints, locks and idempotency keys. SQLite, PostgreSQL and Stripe are named.One account sending parallel requests, many accounts competing for the last items, or a client that retries.A06:2025 Insecure Design, through CWE-362.A 10-item checklist and a local Node.js lab (5 files, 5 parallel-request tests) on one SQLite file. The guide says this is not load testing.
Records, roles and business rules13. Sensitive Data Exposure, at /web-security/sensitive-data-exposureA response carries fields the screen never shows, an error quotes a query, an export holds every column, or a log line holds personal details.What the server sends and keeps: responses, Server Action results, errors, exports, caches and logs. Prisma, Mongoose and Next.js are named.A signed-in caller making a request they are allowed to make. Nothing is bypassed.A3:2017 Sensitive Data Exposure, the earlier name of A02:2021 Cryptographic Failures (A04:2025 Cryptographic Failures); the guide's cause is not cryptography. Also A10 Mishandling of Exceptional Conditions (Top 10:2025) for errors, and API3:2023.A field table (12 fields by 6 places) that works without the lab, a 3-test response-diff exercise and a local Node.js lab (6 files, 7 checks).
Input the server hands to other software14. SQL Injection, at /web-security/sql-injectionA name with an apostrophe gives an error page, or a search returns other customers' rows.Database queries built from visitor text: search, filter and sort values, raw ORM queries and database functions. Next.js, WordPress, Supabase, Prisma and Drizzle are named.Signed-in customers through search, and logged-out visitors through public inputs such as WordPress handlers open to them.A05 Injection (Top 10:2025, through CWE-89).One lookup built two ways, as a local lab on in-memory SQLite (3 files, 5 steps, 4 regression tests). Needs Node.js at the minimum version the guide gives.
Input the server hands to other software15. NoSQL Injection, at /web-security/nosql-injectionA sign-in succeeds with the password sent as an object, or a lookup by tracking code returns every customer's records.Code that copies request values into document database filters. MongoDB, Mongoose, Express query parsers and Next.js are named.Any visitor who can send a JSON body or a query string. The sign-in route needs no account.A05 Injection (Top 10:2025 names NoSQL among its more common injections).One value sent as an object, three fixes and their tests, as a local lab with an in-memory stand-in database (4 files, 8 tests). Needs Node.js only.
Input the server hands to other software16. Command Injection, at /web-security/command-injectionA feature passes a file name or other input to a command-line program, and shell syntax or an extra option changes what runs.Server code that starts operating system processes, such as Node.js child_process and Windows batch files, with the environment and working folder it passes.Whoever controls the input that reaches the command, such as a customer naming an upload.A05:2025 Injection (CWE-77, CWE-78 and CWE-88).A local process-execution lab of 6 runners by 7 inputs, each marker harmless (5 files, 9 checks). Needs Node.js and a POSIX shell (macOS, Linux or WSL).
Input the server hands to other software17. Server-Side Template Injection (SSTI), at /web-security/server-side-template-injectionArithmetic such as 7*7 comes back as 49 in a page or email, for example through a "customise your email" setting or a preview, and it can pass for XSS.A server-side template engine that builds templates from text. Jinja, Twig, Handlebars, Mustache and Nunjucks are named.A visitor, customer or staff member whose text becomes part of a template.A05 Injection, through the parent weakness CWE-94 (Top 10:2025).A local rendering lab with an arithmetic canary (6 files, 6 inputs, 8 engine tests and a 12-test regression test) and checks for 5 engines. Needs Node.js only, no template engine.
Input the server hands to other software18. Remote Code Execution, at /web-security/remote-code-executionAn advisory describes remote code execution in a framework or dependency you run, or your code evaluates text: eval, formula fields, rule builders, custom scripts.Every place code runs: the web server, background workers, the build, serverless functions and admin tasks. The guide treats it as an outcome with several routes in.Anyone who can reach the application over the network, where an advisory says no sign-in is needed.A05 Injection for CWE-94, CWE-95 and CWE-78; A08 Software or Data Integrity Failures for CWE-502 (Top 10:2025).An execution-boundary worksheet, a harmless-marker lab (3 runs) whose probe makes no network connection, and a patch-effectiveness check (5 tests). Needs Node.js only.
Input the server hands to other software19. Insecure Deserialisation, at /web-security/insecure-deserializationBytes from outside (a session, token, cache entry, queue message or import) decide which class is built, or a signature is checked only after the objects exist.Every place the application rebuilds objects from bytes. Python pickle, PyYAML, PHP, Java, .NET, Ruby and Node.js are named.Whoever could have written the bytes: the public, signed-in users, partners, staff or another service.A08 Software or Data Integrity Failures (Top 10:2025, through CWE-502).A 9-question checklist, a format reference of 7 entries across 6 languages and a local tampered-object lab (8 files, 8 fixtures, 5 tests). Needs Node.js only.
Input the server hands to other software20. XML External Entity (XXE), at /web-security/xxeAn XML parser, including one inside a library, puts a server file in a response, calls an address or runs out of memory. SVG images, Office files, SAML and SOAP all carry XML.XML parsers and their settings, including those inside libraries. Python, libxml2, PHP, Java and .NET are named.Whoever can send XML. The parser acts with the server's permissions and network position.A02:2025 Security Misconfiguration, through CWE-611.A 4-question worksheet, a reference for 5 parser families and a local DTD canary lab in Python (5 files, 2 tests). Needs Python 3, and xmllint if you have it.
Input the server hands to other software21. Path Traversal, at /web-security/path-traversalA download, template, language or log viewer serves or writes a file outside its folder, or an archive import writes outside its folder.Server code that builds file paths from request input, archive extraction, file inclusion and storage keys. Node.js, Python tarfile, PHP and Amazon S3 are named.A request that controls a parameter, cookie or stored value. The application's own file permissions decide how far it reaches.A01:2025 Broken Access Control (CWE-22, CWE-23, CWE-36 and CWE-59).A local canonical-path lab of 12 inputs by 3 resolvers, with an archive check, in one temporary folder (6 files, 13 regression checks). Needs Node.js only.
Input the server hands to other software22. File Upload Security, at /web-security/file-upload-securityAn upload accepts a renamed file, keeps the uploaded name, serves files from a public folder or as a web page, or stores oversized files and archives.The upload handler, the storage location, stored names and download headers. WordPress uploads and Amazon S3 presigned uploads are named.Someone outside your business choosing the bytes, name and type; on WordPress, roles with upload rights. Downloads reach other users.None named in the guide.15 fixtures in 4 groups, a verification table of 4 checks and a local Node.js lab that writes only to a temporary folder (6 files, 10 tests).
Input the server hands to other software23. Server-Side Request Forgery (SSRF), at /web-security/ssrfA feature that fetches an address someone else chose (link previews, webhooks, imports, PDF renderers) reaches internal pages or the cloud metadata service.Outbound requests from the server, through HTTP clients, SDKs and headless browsers, and the network and metadata service behind it. Node.js and AWS are named.Whoever can supply the address: a customer, partner, stored setting or model. The request leaves with the server's own identity.A01:2025 Broken Access Control, which SSRF was rolled into; CWE-918 also sits in A10:2021; and API7:2023.An egress lab of 4 fetchers by 10 inputs with a 12-test regression test, every server on 127.0.0.1 (5 files). Needs Node.js only.
What the browser does with your pages24. Cross-Site Scripting (XSS), at /web-security/xssText someone else supplied, such as a search term, order note or review, shows up as markup or runs as code, including on staff screens.Page output in five contexts, and front-end JavaScript that carries values from sources to sinks. React, Angular and Next.js are named.Anyone who can send a link or store text. The script runs as whoever views the page.A05 Injection (Top 10:2025).A test suite of one marker in 5 contexts (13 tests for the safe version), a DOM map of 5 sources and 10 sinks, and 7 browser checks. The suite needs Node.js only, and no browser runs in it.
What the browser does with your pages25. Cross-Site Request Forgery (CSRF), at /web-security/csrfA signed-in visitor's account changes through a request they did not mean to send, such as a new email address for invoices.State-changing endpoints that rely on a cookie: forms, API calls, Server Actions, sign-in and settings. Next.js, .NET, Go and Django are named.Another website, or a sibling subdomain, acting with the victim's privileges.A01 Broken Access Control (Top 10:2025 names CWE-352 among its notable weaknesses).A matrix of 8 situations, a local lab (4 files, 7 server settings, 9 tests) and a browser check. Needs Node.js only.
What the browser does with your pages26. Clickjacking, at /web-security/clickjackingYour page loads inside a frame on another site, or the framing headers are missing from error pages and redirects.Response headers (CSP frame-ancestors and X-Frame-Options) on every response, set in nginx, Apache, Next.js or a proxy.Another site framing your page, using the visitor's own signed-in session.A02 Security Misconfiguration, for missing security headers (Top 10:2025).A local framing harness of 14 cases by 4 embeds (6 files, 29 tests), a header check and a browser evidence table. Needs Node.js only.
What the browser does with your pages27. CORS Misconfiguration, at /web-security/cors-misconfigurationAn API echoes any origin with credentials, allows null, matches origins by prefix or suffix, or sends a wildcard from an internal service.API response headers and CORS middleware settings. Express cors, hono and Next.js are named.A page on another site, loaded in a signed-in visitor's browser.A01 Broken Access Control, and A02 Security Misconfiguration through CWE-942 (Top 10:2025).A local request trace of 7 policies (5 files, 9 regression tests), a browser check and a CORS policy record to fill in. Needs Node.js only.
What the browser does with your pages28. Open Redirects, at /web-security/open-redirectsA link on your own domain sends visitors to someone else's page after sign-in or sign-out, through a return_to or next parameter.Redirects the browser follows: return addresses, language switchers, outbound link endpoints and window.location. Next.js and ASP.NET Core are named.Anyone who can write a link. The victims are visitors who trust your domain.A01:2025 Broken Access Control, through CWE-601.A parser table of 24 return addresses by 5 checks, a local sign-in server in 3 variants and a 26-test regression test (6 files). Needs Node.js only.
In front of the application29. Host Header Injection, at /web-security/host-header-injectionA password reset email whose link starts with whatever host name the request carried, or an unknown name answered by the first site on the server.Code that builds absolute links or picks a tenant from the Host header, allowed-host settings, and the proxy and default virtual host. Django, Rails, Laravel, ASP.NET Core, Express, Next.js, nginx and Apache are named.Anyone who can send a request. The forgotten-password form needs no account.None named in the guide.A trusted-host test pack of 4 rows, and a local lab with a proxy and a cache that sends no email (10 files, 7 tests). Needs Node.js only.
In front of the application30. HTTP Request Smuggling, at /web-security/http-request-smugglingA front end and back end disagree about where a request ends, so leftover bytes join the next request or front-end rules miss what the back end saw.The HTTP chain between a proxy, CDN or load balancer and the application: framing headers, connection reuse and HTTP/2 downgrading. Amazon's Application Load Balancer, Apache and Node.js are named.Anyone who can send a request through the shared front end. Other visitors' requests on reused connections are affected.None named in the guide.A local parser trace lab (9 files, 5 probes, a 4-check differential test) and a verification checklist of 22 tick boxes. Needs Node.js only; the guide keeps probes off shared production.
In front of the application31. Web Cache Poisoning, at /web-security/web-cache-poisoningEvery visitor gets a changed page, such as a new script address, redirect or error, after one request through an input the cache does not key on.A shared cache and its key, set against the inputs that reach the origin. nginx, Cloudflare, Amazon CloudFront and Next.js are named.Anyone who can send a request through the cache. The harm lands on every visitor to that address.None named in the guide.A cache-key inventory of 5 columns and a local reverse-proxy lab in 4 modes (2 files) with a regression test. Needs Node.js only.
In front of the application32. Web Cache Deception, at /web-security/web-cache-deceptionA signed-in person's private page is served from a shared cache to a request with no session, under an address the cache took for a static file.The shared cache's rules, the origin's routing and Cache-Control headers, and the path confusion between them. Cloudflare, Amazon CloudFront, nginx and Next.js are named.A signed-in person's browser makes the first request and someone else the second. The guide plays both parts with your own test account.None named in the guide.A response-cache matrix of 6 route types, 4 path-confusion fixtures and a local lab (8 files, 10 checks). Needs Node.js only.
In front of the application33. Subdomain Takeover, at /web-security/subdomain-takeoverA subdomain still points at a provider resource, account or domain that was given up, such as a retired campaign site or a former supplier.DNS records (CNAME, A, MX, NS and TXT), the provider resources they point to, and provider domain verification. Azure App Service and GitHub Pages are named.Whoever claims the abandoned resource at the provider. Visitors see your own name.None named; the guide points to the Top 10:2025 definition of security misconfiguration.A DNS lifecycle worksheet of 10 columns, a 7-step read-only procedure, and a lab on an invented zone (8 files) that makes no DNS query. Needs Node.js only.
In front of the application34. Security Misconfiguration, at /web-security/security-misconfigurationDebug mode on in production, a default account that still signs in, a folder listing, stack traces, or an admin or status page open to the internet.Settings rather than code, across development, staging and production, and across the CDN, web server, application and cloud storage. Django, Express, Next.js, nginx, Apache, WordPress and Amazon S3 are named.Anyone on the internet who can reach the setting's effect.A02 Security Misconfiguration (Top 10:2025).An environment drift worksheet of 10 rows, a local drift lab (14 files, 21 checks) and 14 tick boxes for your own application. Needs Node.js only.
In front of the application35. Web Application Firewall, at /web-security/web-application-firewallReal customers or staff are blocked by false positives, you rely on a dashboard of blocked requests, or the host says the site has a firewall.The edge in front of the application (Cloudflare, AWS WAF, or ModSecurity and Coraza with the OWASP CRS), and any route to the origin that skips it.The firewall sees every request but not who may do what. Anyone who finds the origin address can go around it.None for firewalls; the guide cites the Top 10:2025 for what a firewall cannot do.A rule-change worksheet of 14 lines, 27 staging test cases and an evidence sheet, with no lab. Needs a firewall and a staging site you own or are authorised in writing to test.
Code, dependencies and the pipeline36. Secrets Exposure, at /web-security/secrets-exposureAn API key in source, git history, the JavaScript bundle or a log, a served /.env file or .git folder, or a secret scanning alert.Source and config files, repository history, client bundles, logs and the web root. GitHub, Next.js and Vite are named.Anyone who can read the place: every visitor for the bundle and served files, anyone with a clone for history, whoever reads the logs.None named in the guide.A local canary repository (15 files, 4 canary keys) and a leak response sequence of 18 tick boxes. Needs Node.js, git and git filter-repo, which you install yourself.
Code, dependencies and the pipeline37. Dependency Security, at /web-security/dependency-securityAn npm audit or Dependabot advisory against a package you install, directly or through another package, or a lockfile entry resolved from an unexpected host.Direct and transitive packages, the lockfile, install commands and registry settings. npm, pnpm, Yarn, Composer and pip are named.No attacker is needed for an honest flaw. For dependency confusion, whoever publishes a public package under your private package's name.A03 Software Supply Chain Failures (Top 10:2025).A triage worksheet of 13 columns, a worked decision on an invented advisory and an offline lockfile lab (6 files, 11 tests). Needs Node.js only; npm runs two optional commands.
Code, dependencies and the pipeline38. Supply Chain Attacks, at /web-security/supply-chain-attacksA malware advisory or registry removal, a lockfile change you did not expect, a new install script, lost provenance, or a build reaching unfamiliar hosts.Upstream of your code: packages and their install scripts, the build, the deployed artefact, and browser scripts loaded from other servers.Anyone who controls a maintainer account, publish token, script host or tag manager. No access to your server is needed.A03:2025 Software Supply Chain Failures.A provenance worksheet for packages, browser scripts and the build, a response timeline of 34 tick boxes and an invented worked example, with no lab. Fill it from your lockfile, registry pages and build logs.
Code, dependencies and the pipeline39. SBOM, at /web-security/sbomA customer, procurement team or standard asks for an SBOM, or an advisory arrives and you need to know which releases hold the component.The release inventory built in the pipeline from the lockfile: CycloneDX and SPDX formats, package identifiers, the dependency graph and VEX statements.Not an attack. The guide is for the people who produce the inventory and the buyers who ask for it.A03 Software Supply Chain Failures, which lists an SBOM among its prevention measures (Top 10:2025).A component record of 11 lines, a worked record across 2 releases and an offline lab that generates CycloneDX and SPDX files (5 files, 19 tests). Needs Node.js and npm.
Code, dependencies and the pipeline40. CI/CD Security, at /web-security/cicd-securityA secret in a public workflow log, a deployment nobody started, fork pull requests running with secrets, or a pull request title written into a script.The pipeline: triggers, token permissions, secrets, runners, third-party actions, approvals and deployment identity. GitHub Actions and GitLab CI/CD are named.Fork contributors without write access, anyone who can edit workflows, third-party action maintainers and pull request authors.A03 and A08 (Top 10:2025), and the OWASP Top 10 CI/CD Security Risks.A trust map of 8 actors and stages, 6 threat tests for your own repository, a sample least-privilege workflow and a local checker (4 files, 7 rules). The checker needs Node.js.
Code, dependencies and the pipeline41. SAST, at /web-security/sastYou are choosing or trialling a static analysis tool, it flags safe code or misses flawed code, or switching it on in the pipeline buries the team.Source code and the pipeline, not the running application.Not an attack. Developers and reviewers who run the tool.None named in the guide.A fixture suite of 12 flawed and safe pairs across 6 classes, a results scorecard and a pattern-checker lab (11 files, 25 tests). The fixtures are read as text, not run. Needs Node.js only.
Code, dependencies and the pipeline42. Dynamic Application Security Testing (DAST), at /web-security/dastA scan report with no findings, from a scanner that never signed in, lost its session, or never reached admin pages, script-built links or API operations.The running application seen from outside: the crawl, the scanner's sign-in and session, and its passive and active checks.The scanner's own identities: signed out, and one test account for each role.None named in the guide.A coverage map of 5 tables to fill in from your own scanner and staging site, and a local lab with its target on 127.0.0.1 (5 files). Needs Node.js only.
Design, delivery and evidence43. Threat Modelling, at /web-security/threat-modellingA new route, webhook, upload, outside service, role or kind of personal data changes the design, or a test finds something the register did not predict.The design: a data-flow diagram with trust boundaries, STRIDE prompts, abuse cases and a threat register with owners.Not an attack. The team that decides, builds and tests, thinking about whoever sits across each trust boundary.A06 Insecure Design (Top 10:2025).A worked data-flow diagram, a threat register of 13 rows, a blank register, a list for checking the model against the build, and a Node.js kit (7 files, 5 tests). The first four parts need only a text editor.
Design, delivery and evidence44. Secure SDLC, at /web-security/secure-sdlcSecurity is checked only at the end, a feature has no written statement of what it must refuse, or release approvals carry no evidence.The delivery process: seven stages from requirements to after release, the record each one leaves, its gates, roles and exceptions.Not an attack. The product owner, technical lead, reviewer and release approver.The Top 10:2025 entry on insecure design, which the guide cites without its number.A stage-gate map of 7 stages, a release checklist of 14 questions, a worked example and a release-evidence check (5 files, 14 tests). The check needs Node.js.
Design, delivery and evidence45. Security Logging and Monitoring, at /web-security/security-logging-and-monitoringNo log line for a failed sign-in or a refused record request, lines holding passwords or card numbers, forged lines, or tests that trigger no alert.The application's own security events: the event schema, redaction, who holds the logs, and detection rules with alerts.Not an attack. The log's readers and the people it records, administrators included.A09 Security Logging & Alerting Failures (Top 10:2025).An event schema of 11 fields, 3 detection rules with tests, 5 redaction fixtures, a review checklist of 59 questions and a local lab (8 files, 13 tests).

Area

Guide and address

  1. Sign-in, sessions and tokens1. Broken Authentication, at /web-security/authentication-failures
    What you notice first
    Sign-up, sign-in or reset tells a stranger whether an email has an account, a reset link works twice, or an email address changes without the current password.
    Where it lives
    The five account flows (registration, login, recovery, email change and reauthentication) on every channel that shares the accounts, plus password storage.
    Who can reach it
    A stranger at the form, and anyone holding a stolen or unattended session.
    OWASP category the guide names
    A07 Authentication Failures (Top 10:2025); API2:2023 Broken Authentication.
    The guide's asset, and what it needs
    A test pack of 28 tests across the five flows plus a closing log check, and a local Node.js enumeration lab (5 files, 12 regression tests). The pack needs test accounts and a way to read whole responses.

    Open Broken Authentication

  2. Sign-in, sessions and tokens2. Credential Stuffing, at /web-security/credential-stuffing
    What you notice first
    Many different usernames fail about once each, some of them not accounts on your site, followed by successful sign-ins from the same sources.
    Where it lives
    The sign-in form, mobile login API and password reset or change, with their logs, throttles and breached-password check.
    Who can reach it
    Anyone holding username and password lists leaked from another site. Customers who reused a password are exposed without any breach of your site.
    OWASP category the guide names
    A07:2025 Authentication Failures; API2:2023 Broken Authentication.
    The guide's asset, and what it needs
    A detection workbook of 5 measures, 8 test cases and a local Node.js lab on invented accounts (6 files, 8 regression tests). Needs Node.js only.

    Open Credential Stuffing

  3. Sign-in, sessions and tokens3. Rate Limiting, at /web-security/rate-limiting
    What you notice first
    Sign-in, one-time codes, password reset or a costly endpoint accept unlimited requests, or real customers are locked out with no way back.
    Where it lives
    The limiter: what it counts, its key and window, its 429 response, where the counter lives and what happens when that store fails. Edge rules in nginx and Cloudflare are covered too.
    Who can reach it
    One source trying many accounts, many sources trying one account, or one heavy user. Anyone who knows a username can spend that customer's allowance.
    OWASP category the guide names
    No Top 10 category named; API4:2023 Unrestricted Resource Consumption and API2:2023 Broken Authentication.
    The guide's asset, and what it needs
    A design worksheet for 7 kinds of endpoint, 14 low-volume staging checks and a local Node.js lab (8 files, 12 scenarios). The guide says these are not load tests.

    Open Rate Limiting

  4. Sign-in, sessions and tokens4. MFA Security, at /web-security/mfa-security
    What you notice first
    An account with a second factor is entered without it: a relayed code, a push prompt approved to make it stop, or an older route that takes a password alone.
    Where it lives
    Enrolment, the second sign-in step, factor changes, recovery, remembered devices, push approval and reauthentication, with their logs.
    Who can reach it
    Someone who already has the password, or holds a stolen session.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A test matrix of 38 rows in 8 groups and a local TOTP lab (7 files, 15 tests). Push and SMS rows need a test device or number.

    Open MFA Security

  5. Sign-in, sessions and tokens5. Session Management, at /web-security/session-management
    What you notice first
    An old session cookie still works after sign-out, the identifier is the same before and after sign-in, or sessions survive a password reset.
    Where it lives
    The server-side session after sign-in: issuing, rotation, timeouts, sign-out, revocation and the account page's session list. Django, express-session and PHP are named.
    Who can reach it
    Whoever holds the identifier, including an attacker who set it before sign-in.
    OWASP category the guide names
    A07 Authentication Failures (Top 10:2025, through CWE-613).
    The guide's asset, and what it needs
    A session state diagram with 14 transitions and a local Node.js lab (4 files, 6 checks). Needs Node.js only.

    Open Session Management

  6. Sign-in, sessions and tokens6. Cookie Security, at /web-security/cookie-security
    What you notice first
    A session cookie without Secure, HttpOnly or SameSite set deliberately, a Domain attribute that widens it to every subdomain, or a sign-out that leaves it behind.
    Where it lives
    The Set-Cookie header, its attributes and prefixes, the defaults in express-session and Django, and the cookie options the Next.js authentication guide recommends.
    Who can reach it
    Network attackers on plain HTTP, script on the page, sibling subdomains and other sites.
    OWASP category the guide names
    A02 Security Misconfiguration (Top 10:2025, through CWE-614 and CWE-1004).
    The guide's asset, and what it needs
    A decision table for 6 kinds of cookie, a local Node.js lab (5 files, 4 flows, 9 tests) and a cookie register of 13 fields.

    Open Cookie Security

  7. Sign-in, sessions and tokens7. OAuth and OpenID Connect Security, at /web-security/oauth-oidc-security
    What you notice first
    "Sign in with" puts a visitor in the wrong account, a leaked code signs someone in as another person, or an unverified provider email takes over a local account.
    Where it lives
    The authorisation code flow: the callback's checks (state, PKCE, nonce, ID Token), account linking, and the redirect URIs and scopes in the provider console.
    Who can reach it
    An attacker with their own provider account or a leaked code, or anyone who can open a provider account with a customer's email.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    The flow as 9 numbered steps, and a local callback lab with a mock provider (6 files, 13 scenarios, 13 tests). Needs Node.js only.

    Open OAuth and OpenID Connect Security

  8. Sign-in, sessions and tokens8. JWT Security, at /web-security/jwt-security
    What you notice first
    An API accepts a token it should refuse: algorithm none, the wrong kind of key, a staging token, a token for another API, an ID token or an expired one.
    Where it lives
    The token verifier on the API (algorithm, key for each issuer, signature and claims) and the settings of the jsonwebtoken and jose libraries.
    Who can reach it
    Anyone holding a token or the public key, and anyone who can mint tokens in staging.
    OWASP category the guide names
    A04:2025 Cryptographic Failures, the category MITRE files CWE-347 under.
    The guide's asset, and what it needs
    A decision table of 11 decisions and a verification suite (5 files, 16 fixtures, 16 tests) that contacts no other machine. Needs Node.js only.

    Open JWT Security

  9. Records, roles and business rules9. Broken Access Control and IDOR, at /web-security/broken-access-control-idor
    What you notice first
    One customer opens another's invoice by changing an id, a list or export carries extra rows, or an ordinary account reaches an admin function.
    Where it lives
    Server-side authorisation on object routes, lists, exports, background jobs and admin functions. Next.js Server Actions and Supabase row level security are named.
    Who can reach it
    Signed-in users in the same role, in a lower role, or in another customer organisation.
    OWASP category the guide names
    A01 Broken Access Control (Top 10:2025); API1:2023 and API5:2023.
    The guide's asset, and what it needs
    A test matrix of 5 accounts by 7 routes (35 cells) that works on its own, and a local Node.js lab that runs it (5 files, 7 tests).

    Open Broken Access Control and IDOR

  10. Records, roles and business rules10. Mass Assignment, at /web-security/mass-assignment
    What you notice first
    A profile edit, sign-up or order stores a field the form never offered: a role, a verified flag, store credit, a price or an owner.
    Where it lives
    Write endpoints and the binding that copies request fields onto records. Rails, Laravel, Django, ASP.NET Core, Mongoose, Prisma and Zod are named.
    Who can reach it
    A signed-in account calling an endpoint it may call, on a record it may edit.
    OWASP category the guide names
    No web Top 10 category; API3:2023 Broken Object Property Level Authorization, previously API6:2019 Mass Assignment.
    The guide's asset, and what it needs
    A 6-step request-diff method and a worksheet that work without the lab, and a local Node.js lab (8 files, 11 tests).

    Open Mass Assignment

  11. Records, roles and business rules11. Business Logic Vulnerabilities, at /web-security/business-logic-vulnerabilities
    What you notice first
    Well-formed requests from allowed accounts produce a wrong outcome: a booking confirmed with nothing paid, one approval paid twice, a refund larger than the payment.
    Where it lives
    The server's workflow for money and stock: its states, the moves between them and the rules stored records must keep.
    Who can reach it
    Signed-in customers and staff with the right role, acting at the wrong step or for the wrong amount.
    OWASP category the guide names
    A06 Insecure Design (Top 10:2025); API6, Unrestricted Access to Sensitive Business Flows (API Security Top 10 2023).
    The guide's asset, and what it needs
    A booking-and-refund state machine (8 states, 7 invariants, 11 abuse cases) that works without the lab, and a local Node.js lab (7 files, 7 tests).

    Open Business Logic Vulnerabilities

  12. Records, roles and business rules12. Race Conditions, at /web-security/race-conditions
    What you notice first
    Stock, vouchers or balances that do not add up: a one-per-customer offer redeemed many times, or a double charge, with no errors logged.
    Where it lives
    Check-then-act on shared state across processes: transactions, isolation, constraints, locks and idempotency keys. SQLite, PostgreSQL and Stripe are named.
    Who can reach it
    One account sending parallel requests, many accounts competing for the last items, or a client that retries.
    OWASP category the guide names
    A06:2025 Insecure Design, through CWE-362.
    The guide's asset, and what it needs
    A 10-item checklist and a local Node.js lab (5 files, 5 parallel-request tests) on one SQLite file. The guide says this is not load testing.

    Open Race Conditions

  13. Records, roles and business rules13. Sensitive Data Exposure, at /web-security/sensitive-data-exposure
    What you notice first
    A response carries fields the screen never shows, an error quotes a query, an export holds every column, or a log line holds personal details.
    Where it lives
    What the server sends and keeps: responses, Server Action results, errors, exports, caches and logs. Prisma, Mongoose and Next.js are named.
    Who can reach it
    A signed-in caller making a request they are allowed to make. Nothing is bypassed.
    OWASP category the guide names
    A3:2017 Sensitive Data Exposure, the earlier name of A02:2021 Cryptographic Failures (A04:2025 Cryptographic Failures); the guide's cause is not cryptography. Also A10 Mishandling of Exceptional Conditions (Top 10:2025) for errors, and API3:2023.
    The guide's asset, and what it needs
    A field table (12 fields by 6 places) that works without the lab, a 3-test response-diff exercise and a local Node.js lab (6 files, 7 checks).

    Open Sensitive Data Exposure

  14. Input the server hands to other software14. SQL Injection, at /web-security/sql-injection
    What you notice first
    A name with an apostrophe gives an error page, or a search returns other customers' rows.
    Where it lives
    Database queries built from visitor text: search, filter and sort values, raw ORM queries and database functions. Next.js, WordPress, Supabase, Prisma and Drizzle are named.
    Who can reach it
    Signed-in customers through search, and logged-out visitors through public inputs such as WordPress handlers open to them.
    OWASP category the guide names
    A05 Injection (Top 10:2025, through CWE-89).
    The guide's asset, and what it needs
    One lookup built two ways, as a local lab on in-memory SQLite (3 files, 5 steps, 4 regression tests). Needs Node.js at the minimum version the guide gives.

    Open SQL Injection

  15. Input the server hands to other software15. NoSQL Injection, at /web-security/nosql-injection
    What you notice first
    A sign-in succeeds with the password sent as an object, or a lookup by tracking code returns every customer's records.
    Where it lives
    Code that copies request values into document database filters. MongoDB, Mongoose, Express query parsers and Next.js are named.
    Who can reach it
    Any visitor who can send a JSON body or a query string. The sign-in route needs no account.
    OWASP category the guide names
    A05 Injection (Top 10:2025 names NoSQL among its more common injections).
    The guide's asset, and what it needs
    One value sent as an object, three fixes and their tests, as a local lab with an in-memory stand-in database (4 files, 8 tests). Needs Node.js only.

    Open NoSQL Injection

  16. Input the server hands to other software16. Command Injection, at /web-security/command-injection
    What you notice first
    A feature passes a file name or other input to a command-line program, and shell syntax or an extra option changes what runs.
    Where it lives
    Server code that starts operating system processes, such as Node.js child_process and Windows batch files, with the environment and working folder it passes.
    Who can reach it
    Whoever controls the input that reaches the command, such as a customer naming an upload.
    OWASP category the guide names
    A05:2025 Injection (CWE-77, CWE-78 and CWE-88).
    The guide's asset, and what it needs
    A local process-execution lab of 6 runners by 7 inputs, each marker harmless (5 files, 9 checks). Needs Node.js and a POSIX shell (macOS, Linux or WSL).

    Open Command Injection

  17. Input the server hands to other software17. Server-Side Template Injection (SSTI), at /web-security/server-side-template-injection
    What you notice first
    Arithmetic such as 7*7 comes back as 49 in a page or email, for example through a "customise your email" setting or a preview, and it can pass for XSS.
    Where it lives
    A server-side template engine that builds templates from text. Jinja, Twig, Handlebars, Mustache and Nunjucks are named.
    Who can reach it
    A visitor, customer or staff member whose text becomes part of a template.
    OWASP category the guide names
    A05 Injection, through the parent weakness CWE-94 (Top 10:2025).
    The guide's asset, and what it needs
    A local rendering lab with an arithmetic canary (6 files, 6 inputs, 8 engine tests and a 12-test regression test) and checks for 5 engines. Needs Node.js only, no template engine.

    Open Server-Side Template Injection (SSTI)

  18. Input the server hands to other software18. Remote Code Execution, at /web-security/remote-code-execution
    What you notice first
    An advisory describes remote code execution in a framework or dependency you run, or your code evaluates text: eval, formula fields, rule builders, custom scripts.
    Where it lives
    Every place code runs: the web server, background workers, the build, serverless functions and admin tasks. The guide treats it as an outcome with several routes in.
    Who can reach it
    Anyone who can reach the application over the network, where an advisory says no sign-in is needed.
    OWASP category the guide names
    A05 Injection for CWE-94, CWE-95 and CWE-78; A08 Software or Data Integrity Failures for CWE-502 (Top 10:2025).
    The guide's asset, and what it needs
    An execution-boundary worksheet, a harmless-marker lab (3 runs) whose probe makes no network connection, and a patch-effectiveness check (5 tests). Needs Node.js only.

    Open Remote Code Execution

  19. Input the server hands to other software19. Insecure Deserialisation, at /web-security/insecure-deserialization
    What you notice first
    Bytes from outside (a session, token, cache entry, queue message or import) decide which class is built, or a signature is checked only after the objects exist.
    Where it lives
    Every place the application rebuilds objects from bytes. Python pickle, PyYAML, PHP, Java, .NET, Ruby and Node.js are named.
    Who can reach it
    Whoever could have written the bytes: the public, signed-in users, partners, staff or another service.
    OWASP category the guide names
    A08 Software or Data Integrity Failures (Top 10:2025, through CWE-502).
    The guide's asset, and what it needs
    A 9-question checklist, a format reference of 7 entries across 6 languages and a local tampered-object lab (8 files, 8 fixtures, 5 tests). Needs Node.js only.

    Open Insecure Deserialisation

  20. Input the server hands to other software20. XML External Entity (XXE), at /web-security/xxe
    What you notice first
    An XML parser, including one inside a library, puts a server file in a response, calls an address or runs out of memory. SVG images, Office files, SAML and SOAP all carry XML.
    Where it lives
    XML parsers and their settings, including those inside libraries. Python, libxml2, PHP, Java and .NET are named.
    Who can reach it
    Whoever can send XML. The parser acts with the server's permissions and network position.
    OWASP category the guide names
    A02:2025 Security Misconfiguration, through CWE-611.
    The guide's asset, and what it needs
    A 4-question worksheet, a reference for 5 parser families and a local DTD canary lab in Python (5 files, 2 tests). Needs Python 3, and xmllint if you have it.

    Open XML External Entity (XXE)

  21. Input the server hands to other software21. Path Traversal, at /web-security/path-traversal
    What you notice first
    A download, template, language or log viewer serves or writes a file outside its folder, or an archive import writes outside its folder.
    Where it lives
    Server code that builds file paths from request input, archive extraction, file inclusion and storage keys. Node.js, Python tarfile, PHP and Amazon S3 are named.
    Who can reach it
    A request that controls a parameter, cookie or stored value. The application's own file permissions decide how far it reaches.
    OWASP category the guide names
    A01:2025 Broken Access Control (CWE-22, CWE-23, CWE-36 and CWE-59).
    The guide's asset, and what it needs
    A local canonical-path lab of 12 inputs by 3 resolvers, with an archive check, in one temporary folder (6 files, 13 regression checks). Needs Node.js only.

    Open Path Traversal

  22. Input the server hands to other software22. File Upload Security, at /web-security/file-upload-security
    What you notice first
    An upload accepts a renamed file, keeps the uploaded name, serves files from a public folder or as a web page, or stores oversized files and archives.
    Where it lives
    The upload handler, the storage location, stored names and download headers. WordPress uploads and Amazon S3 presigned uploads are named.
    Who can reach it
    Someone outside your business choosing the bytes, name and type; on WordPress, roles with upload rights. Downloads reach other users.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    15 fixtures in 4 groups, a verification table of 4 checks and a local Node.js lab that writes only to a temporary folder (6 files, 10 tests).

    Open File Upload Security

  23. Input the server hands to other software23. Server-Side Request Forgery (SSRF), at /web-security/ssrf
    What you notice first
    A feature that fetches an address someone else chose (link previews, webhooks, imports, PDF renderers) reaches internal pages or the cloud metadata service.
    Where it lives
    Outbound requests from the server, through HTTP clients, SDKs and headless browsers, and the network and metadata service behind it. Node.js and AWS are named.
    Who can reach it
    Whoever can supply the address: a customer, partner, stored setting or model. The request leaves with the server's own identity.
    OWASP category the guide names
    A01:2025 Broken Access Control, which SSRF was rolled into; CWE-918 also sits in A10:2021; and API7:2023.
    The guide's asset, and what it needs
    An egress lab of 4 fetchers by 10 inputs with a 12-test regression test, every server on 127.0.0.1 (5 files). Needs Node.js only.

    Open Server-Side Request Forgery (SSRF)

  24. What the browser does with your pages24. Cross-Site Scripting (XSS), at /web-security/xss
    What you notice first
    Text someone else supplied, such as a search term, order note or review, shows up as markup or runs as code, including on staff screens.
    Where it lives
    Page output in five contexts, and front-end JavaScript that carries values from sources to sinks. React, Angular and Next.js are named.
    Who can reach it
    Anyone who can send a link or store text. The script runs as whoever views the page.
    OWASP category the guide names
    A05 Injection (Top 10:2025).
    The guide's asset, and what it needs
    A test suite of one marker in 5 contexts (13 tests for the safe version), a DOM map of 5 sources and 10 sinks, and 7 browser checks. The suite needs Node.js only, and no browser runs in it.

    Open Cross-Site Scripting (XSS)

  25. What the browser does with your pages25. Cross-Site Request Forgery (CSRF), at /web-security/csrf
    What you notice first
    A signed-in visitor's account changes through a request they did not mean to send, such as a new email address for invoices.
    Where it lives
    State-changing endpoints that rely on a cookie: forms, API calls, Server Actions, sign-in and settings. Next.js, .NET, Go and Django are named.
    Who can reach it
    Another website, or a sibling subdomain, acting with the victim's privileges.
    OWASP category the guide names
    A01 Broken Access Control (Top 10:2025 names CWE-352 among its notable weaknesses).
    The guide's asset, and what it needs
    A matrix of 8 situations, a local lab (4 files, 7 server settings, 9 tests) and a browser check. Needs Node.js only.

    Open Cross-Site Request Forgery (CSRF)

  26. What the browser does with your pages26. Clickjacking, at /web-security/clickjacking
    What you notice first
    Your page loads inside a frame on another site, or the framing headers are missing from error pages and redirects.
    Where it lives
    Response headers (CSP frame-ancestors and X-Frame-Options) on every response, set in nginx, Apache, Next.js or a proxy.
    Who can reach it
    Another site framing your page, using the visitor's own signed-in session.
    OWASP category the guide names
    A02 Security Misconfiguration, for missing security headers (Top 10:2025).
    The guide's asset, and what it needs
    A local framing harness of 14 cases by 4 embeds (6 files, 29 tests), a header check and a browser evidence table. Needs Node.js only.

    Open Clickjacking

  27. What the browser does with your pages27. CORS Misconfiguration, at /web-security/cors-misconfiguration
    What you notice first
    An API echoes any origin with credentials, allows null, matches origins by prefix or suffix, or sends a wildcard from an internal service.
    Where it lives
    API response headers and CORS middleware settings. Express cors, hono and Next.js are named.
    Who can reach it
    A page on another site, loaded in a signed-in visitor's browser.
    OWASP category the guide names
    A01 Broken Access Control, and A02 Security Misconfiguration through CWE-942 (Top 10:2025).
    The guide's asset, and what it needs
    A local request trace of 7 policies (5 files, 9 regression tests), a browser check and a CORS policy record to fill in. Needs Node.js only.

    Open CORS Misconfiguration

  28. What the browser does with your pages28. Open Redirects, at /web-security/open-redirects
    What you notice first
    A link on your own domain sends visitors to someone else's page after sign-in or sign-out, through a return_to or next parameter.
    Where it lives
    Redirects the browser follows: return addresses, language switchers, outbound link endpoints and window.location. Next.js and ASP.NET Core are named.
    Who can reach it
    Anyone who can write a link. The victims are visitors who trust your domain.
    OWASP category the guide names
    A01:2025 Broken Access Control, through CWE-601.
    The guide's asset, and what it needs
    A parser table of 24 return addresses by 5 checks, a local sign-in server in 3 variants and a 26-test regression test (6 files). Needs Node.js only.

    Open Open Redirects

  29. In front of the application29. Host Header Injection, at /web-security/host-header-injection
    What you notice first
    A password reset email whose link starts with whatever host name the request carried, or an unknown name answered by the first site on the server.
    Where it lives
    Code that builds absolute links or picks a tenant from the Host header, allowed-host settings, and the proxy and default virtual host. Django, Rails, Laravel, ASP.NET Core, Express, Next.js, nginx and Apache are named.
    Who can reach it
    Anyone who can send a request. The forgotten-password form needs no account.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A trusted-host test pack of 4 rows, and a local lab with a proxy and a cache that sends no email (10 files, 7 tests). Needs Node.js only.

    Open Host Header Injection

  30. In front of the application30. HTTP Request Smuggling, at /web-security/http-request-smuggling
    What you notice first
    A front end and back end disagree about where a request ends, so leftover bytes join the next request or front-end rules miss what the back end saw.
    Where it lives
    The HTTP chain between a proxy, CDN or load balancer and the application: framing headers, connection reuse and HTTP/2 downgrading. Amazon's Application Load Balancer, Apache and Node.js are named.
    Who can reach it
    Anyone who can send a request through the shared front end. Other visitors' requests on reused connections are affected.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A local parser trace lab (9 files, 5 probes, a 4-check differential test) and a verification checklist of 22 tick boxes. Needs Node.js only; the guide keeps probes off shared production.

    Open HTTP Request Smuggling

  31. In front of the application31. Web Cache Poisoning, at /web-security/web-cache-poisoning
    What you notice first
    Every visitor gets a changed page, such as a new script address, redirect or error, after one request through an input the cache does not key on.
    Where it lives
    A shared cache and its key, set against the inputs that reach the origin. nginx, Cloudflare, Amazon CloudFront and Next.js are named.
    Who can reach it
    Anyone who can send a request through the cache. The harm lands on every visitor to that address.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A cache-key inventory of 5 columns and a local reverse-proxy lab in 4 modes (2 files) with a regression test. Needs Node.js only.

    Open Web Cache Poisoning

  32. In front of the application32. Web Cache Deception, at /web-security/web-cache-deception
    What you notice first
    A signed-in person's private page is served from a shared cache to a request with no session, under an address the cache took for a static file.
    Where it lives
    The shared cache's rules, the origin's routing and Cache-Control headers, and the path confusion between them. Cloudflare, Amazon CloudFront, nginx and Next.js are named.
    Who can reach it
    A signed-in person's browser makes the first request and someone else the second. The guide plays both parts with your own test account.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A response-cache matrix of 6 route types, 4 path-confusion fixtures and a local lab (8 files, 10 checks). Needs Node.js only.

    Open Web Cache Deception

  33. In front of the application33. Subdomain Takeover, at /web-security/subdomain-takeover
    What you notice first
    A subdomain still points at a provider resource, account or domain that was given up, such as a retired campaign site or a former supplier.
    Where it lives
    DNS records (CNAME, A, MX, NS and TXT), the provider resources they point to, and provider domain verification. Azure App Service and GitHub Pages are named.
    Who can reach it
    Whoever claims the abandoned resource at the provider. Visitors see your own name.
    OWASP category the guide names
    None named; the guide points to the Top 10:2025 definition of security misconfiguration.
    The guide's asset, and what it needs
    A DNS lifecycle worksheet of 10 columns, a 7-step read-only procedure, and a lab on an invented zone (8 files) that makes no DNS query. Needs Node.js only.

    Open Subdomain Takeover

  34. In front of the application34. Security Misconfiguration, at /web-security/security-misconfiguration
    What you notice first
    Debug mode on in production, a default account that still signs in, a folder listing, stack traces, or an admin or status page open to the internet.
    Where it lives
    Settings rather than code, across development, staging and production, and across the CDN, web server, application and cloud storage. Django, Express, Next.js, nginx, Apache, WordPress and Amazon S3 are named.
    Who can reach it
    Anyone on the internet who can reach the setting's effect.
    OWASP category the guide names
    A02 Security Misconfiguration (Top 10:2025).
    The guide's asset, and what it needs
    An environment drift worksheet of 10 rows, a local drift lab (14 files, 21 checks) and 14 tick boxes for your own application. Needs Node.js only.

    Open Security Misconfiguration

  35. In front of the application35. Web Application Firewall, at /web-security/web-application-firewall
    What you notice first
    Real customers or staff are blocked by false positives, you rely on a dashboard of blocked requests, or the host says the site has a firewall.
    Where it lives
    The edge in front of the application (Cloudflare, AWS WAF, or ModSecurity and Coraza with the OWASP CRS), and any route to the origin that skips it.
    Who can reach it
    The firewall sees every request but not who may do what. Anyone who finds the origin address can go around it.
    OWASP category the guide names
    None for firewalls; the guide cites the Top 10:2025 for what a firewall cannot do.
    The guide's asset, and what it needs
    A rule-change worksheet of 14 lines, 27 staging test cases and an evidence sheet, with no lab. Needs a firewall and a staging site you own or are authorised in writing to test.

    Open Web Application Firewall

  36. Code, dependencies and the pipeline36. Secrets Exposure, at /web-security/secrets-exposure
    What you notice first
    An API key in source, git history, the JavaScript bundle or a log, a served /.env file or .git folder, or a secret scanning alert.
    Where it lives
    Source and config files, repository history, client bundles, logs and the web root. GitHub, Next.js and Vite are named.
    Who can reach it
    Anyone who can read the place: every visitor for the bundle and served files, anyone with a clone for history, whoever reads the logs.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A local canary repository (15 files, 4 canary keys) and a leak response sequence of 18 tick boxes. Needs Node.js, git and git filter-repo, which you install yourself.

    Open Secrets Exposure

  37. Code, dependencies and the pipeline37. Dependency Security, at /web-security/dependency-security
    What you notice first
    An npm audit or Dependabot advisory against a package you install, directly or through another package, or a lockfile entry resolved from an unexpected host.
    Where it lives
    Direct and transitive packages, the lockfile, install commands and registry settings. npm, pnpm, Yarn, Composer and pip are named.
    Who can reach it
    No attacker is needed for an honest flaw. For dependency confusion, whoever publishes a public package under your private package's name.
    OWASP category the guide names
    A03 Software Supply Chain Failures (Top 10:2025).
    The guide's asset, and what it needs
    A triage worksheet of 13 columns, a worked decision on an invented advisory and an offline lockfile lab (6 files, 11 tests). Needs Node.js only; npm runs two optional commands.

    Open Dependency Security

  38. Code, dependencies and the pipeline38. Supply Chain Attacks, at /web-security/supply-chain-attacks
    What you notice first
    A malware advisory or registry removal, a lockfile change you did not expect, a new install script, lost provenance, or a build reaching unfamiliar hosts.
    Where it lives
    Upstream of your code: packages and their install scripts, the build, the deployed artefact, and browser scripts loaded from other servers.
    Who can reach it
    Anyone who controls a maintainer account, publish token, script host or tag manager. No access to your server is needed.
    OWASP category the guide names
    A03:2025 Software Supply Chain Failures.
    The guide's asset, and what it needs
    A provenance worksheet for packages, browser scripts and the build, a response timeline of 34 tick boxes and an invented worked example, with no lab. Fill it from your lockfile, registry pages and build logs.

    Open Supply Chain Attacks

  39. Code, dependencies and the pipeline39. SBOM, at /web-security/sbom
    What you notice first
    A customer, procurement team or standard asks for an SBOM, or an advisory arrives and you need to know which releases hold the component.
    Where it lives
    The release inventory built in the pipeline from the lockfile: CycloneDX and SPDX formats, package identifiers, the dependency graph and VEX statements.
    Who can reach it
    Not an attack. The guide is for the people who produce the inventory and the buyers who ask for it.
    OWASP category the guide names
    A03 Software Supply Chain Failures, which lists an SBOM among its prevention measures (Top 10:2025).
    The guide's asset, and what it needs
    A component record of 11 lines, a worked record across 2 releases and an offline lab that generates CycloneDX and SPDX files (5 files, 19 tests). Needs Node.js and npm.

    Open SBOM

  40. Code, dependencies and the pipeline40. CI/CD Security, at /web-security/cicd-security
    What you notice first
    A secret in a public workflow log, a deployment nobody started, fork pull requests running with secrets, or a pull request title written into a script.
    Where it lives
    The pipeline: triggers, token permissions, secrets, runners, third-party actions, approvals and deployment identity. GitHub Actions and GitLab CI/CD are named.
    Who can reach it
    Fork contributors without write access, anyone who can edit workflows, third-party action maintainers and pull request authors.
    OWASP category the guide names
    A03 and A08 (Top 10:2025), and the OWASP Top 10 CI/CD Security Risks.
    The guide's asset, and what it needs
    A trust map of 8 actors and stages, 6 threat tests for your own repository, a sample least-privilege workflow and a local checker (4 files, 7 rules). The checker needs Node.js.

    Open CI/CD Security

  41. Code, dependencies and the pipeline41. SAST, at /web-security/sast
    What you notice first
    You are choosing or trialling a static analysis tool, it flags safe code or misses flawed code, or switching it on in the pipeline buries the team.
    Where it lives
    Source code and the pipeline, not the running application.
    Who can reach it
    Not an attack. Developers and reviewers who run the tool.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A fixture suite of 12 flawed and safe pairs across 6 classes, a results scorecard and a pattern-checker lab (11 files, 25 tests). The fixtures are read as text, not run. Needs Node.js only.

    Open SAST

  42. Code, dependencies and the pipeline42. Dynamic Application Security Testing (DAST), at /web-security/dast
    What you notice first
    A scan report with no findings, from a scanner that never signed in, lost its session, or never reached admin pages, script-built links or API operations.
    Where it lives
    The running application seen from outside: the crawl, the scanner's sign-in and session, and its passive and active checks.
    Who can reach it
    The scanner's own identities: signed out, and one test account for each role.
    OWASP category the guide names
    None named in the guide.
    The guide's asset, and what it needs
    A coverage map of 5 tables to fill in from your own scanner and staging site, and a local lab with its target on 127.0.0.1 (5 files). Needs Node.js only.

    Open Dynamic Application Security Testing (DAST)

  43. Design, delivery and evidence43. Threat Modelling, at /web-security/threat-modelling
    What you notice first
    A new route, webhook, upload, outside service, role or kind of personal data changes the design, or a test finds something the register did not predict.
    Where it lives
    The design: a data-flow diagram with trust boundaries, STRIDE prompts, abuse cases and a threat register with owners.
    Who can reach it
    Not an attack. The team that decides, builds and tests, thinking about whoever sits across each trust boundary.
    OWASP category the guide names
    A06 Insecure Design (Top 10:2025).
    The guide's asset, and what it needs
    A worked data-flow diagram, a threat register of 13 rows, a blank register, a list for checking the model against the build, and a Node.js kit (7 files, 5 tests). The first four parts need only a text editor.

    Open Threat Modelling

  44. Design, delivery and evidence44. Secure SDLC, at /web-security/secure-sdlc
    What you notice first
    Security is checked only at the end, a feature has no written statement of what it must refuse, or release approvals carry no evidence.
    Where it lives
    The delivery process: seven stages from requirements to after release, the record each one leaves, its gates, roles and exceptions.
    Who can reach it
    Not an attack. The product owner, technical lead, reviewer and release approver.
    OWASP category the guide names
    The Top 10:2025 entry on insecure design, which the guide cites without its number.
    The guide's asset, and what it needs
    A stage-gate map of 7 stages, a release checklist of 14 questions, a worked example and a release-evidence check (5 files, 14 tests). The check needs Node.js.

    Open Secure SDLC

  45. Design, delivery and evidence45. Security Logging and Monitoring, at /web-security/security-logging-and-monitoring
    What you notice first
    No log line for a failed sign-in or a refused record request, lines holding passwords or card numbers, forged lines, or tests that trigger no alert.
    Where it lives
    The application's own security events: the event schema, redaction, who holds the logs, and detection rules with alerts.
    Who can reach it
    Not an attack. The log's readers and the people it records, administrators included.
    OWASP category the guide names
    A09 Security Logging & Alerting Failures (Top 10:2025).
    The guide's asset, and what it needs
    An event schema of 11 fields, 3 detection rules with tests, 5 redaction fixtures, a review checklist of 59 questions and a local lab (8 files, 13 tests).

    Open Security Logging and Monitoring

About this library

Web application vulnerabilities, sorted by where they live

This index covers forty-five guides in the web security library.

Thirty-seven describe one kind of vulnerability each, from broken authentication to subdomain takeover. The other eight cover what catches or contains those vulnerabilities: three defences, two testing methods and three development practices. Every guide explains its subject, shows how to check for it on a system you own, and hands you a working asset to keep, such as a test lab, a checklist, a worksheet or a matrix.

The finder table on this page gives each guide one row. Use it when you know something is wrong but not what it is called, when a scanner or a report has named a problem in words that do not match a guide title, or when you want every guide that applies to one part of your application.

Each row is written from the guide it points to. A cell says only what that guide says, and where the guide does not say something, the cell says so rather than filling the gap.

Seven areas, from the application's own logic outward

The rows are grouped by where in the application the problem lives.

The groups start with sign-in and then move outward: to the records and rules behind it, to the input the server hands to other software, to what the browser does with your pages, to the machinery in front of the application, and to the code and pipeline behind it.

The last group holds the practices that shape all six. Within a group, related guides sit next to each other. Rows are numbered 1 to 45, and this page refers to them by number.

  • Sign-in, sessions and tokens, rows 1 to 8: how people prove who they are, and what stays true about them once they have.
  • Records, roles and business rules, rows 9 to 13: who may read or change which record, and whether a workflow keeps its own rules.
  • Input the server hands to other software, rows 14 to 23: text that becomes a database query, a shell command, a template, an object, a file path or an outbound request.
  • What the browser does with your pages, rows 24 to 28: injected scripts, forged form posts, framing, cross-origin reads and redirects.
  • In front of the application, rows 29 to 35: host names, proxies, caches and DNS records, the settings of every layer, and the firewall at the edge.
  • Code, dependencies and the pipeline, rows 36 to 42: keys in the code, the packages it installs, the record of what shipped, the pipeline that builds it and the tools that scan it.
  • Design, delivery and evidence, rows 43 to 45: threat modelling, a secure development lifecycle, and the security logs that show what happened.

Four guides that could sit in two areas

Cookie security sits with sessions because the session cookie is its main subject, though the same attributes matter to the forgery guide in row 25. Sensitive data exposure sits with records because its cause is what the server chooses to send, though caches and logs carry the same fields.

Rate limiting sits with sign-in, though its worksheet also covers search, exports and public APIs. Security misconfiguration sits in front of the application, though its worksheet reaches the application's own settings as well.

Four ways into the table: a symptom, a scanner, a report or a framework

You may arrive with one of four things in hand.

Each needs a slightly different way of reading the table.

Starting from a symptom

Read down the column headed What you notice first, inside the area where the trouble showed up. 1 min read

Starting from a scanner finding

A scanner finding may name the mechanism rather than the cause. 1 min read

Starting from a penetration test report line

A report finding carries a title, and may carry a weakness id or an OWASP category. 1 min read

Starting from a framework or platform

The column headed Where it lives names the platforms and libraries each guide works through. 1 min read

Reading orders for four common problems

Some problems span several guides.

Each order starts with the guide to open first, and each step says why the next guide follows.

A sign-in or account problem: rows 1 to 6, then 7 or 8

Start with Broken Authentication, row 1, which walks the five account flows from registration to reauthentication and is where enumeration and weak resets show up. Credential stuffing, row 2, and rate limiting, row 3, deal with volume against those flows: many accounts tried once each, or one account tried many times.

MFA security, row 4, comes next if accounts carry a second factor, because it starts from an attacker who already has the password. Then read session management, row 5, and cookie security, row 6, for what happens after a successful sign-in.

Move to row 7 if people sign in through another provider, and to row 8 if your API accepts tokens.

Data that reached the wrong person: rows 13, 9, 10, 32 and 36, then 45

Begin with sensitive data exposure, row 13, when the person who saw the data was allowed to make the request and the response simply carried too much. If they should have been refused, row 9 covers the missing check, and row 10 covers its mirror on the write side, where a request sets fields it should never reach.

If a shared cache served the data instead of the application, read row 32. If what leaked was a key rather than a record, row 36 sets out the order for containing it.

Row 45 comes last, because any account of who saw what depends on the events your application already records. Rows 13 and 36 say when to bring in an incident response specialist, and rows 9 and 13 say to bring in whoever handles privacy for your business.

An upload, import or file problem: rows 22, 21, 20 and 19, then 18 and 16

File upload security, row 22, comes first, because it covers what the application accepts, where it stores the file and how it serves it back. Path traversal, row 21, follows wherever a file name or an archive entry decides where something is read or written.

If the files are XML, which includes SVG images and Office documents, row 20 applies to the parser that opens them. If an import or a settings file is turned back into objects, row 19 applies.

Row 18 covers the case where any of these lets the server run code, and row 16 the case where a file name is handed to a command-line tool.

A build or pipeline problem: rows 36, 40, 37, 38 and 39, then 41 and 42

Secrets come first, row 36, because a key in a workflow log or a repository has to be rotated before anything else is cleaned up. CI/CD security, row 40, then maps who and what can change the pipeline.

Dependency security, row 37, deals with flawed packages and row 38 with packages and scripts published to do harm; they share a lockfile, so read them together. An SBOM, row 39, records what each release contained, which is what you need when the next advisory arrives.

SAST and DAST, rows 41 and 42, are the checks a pipeline runs, and both guides are about measuring what those checks catch and reach.

How the cells were filled, and what they leave to the guides

What you notice first shortens each guide's own examples of how the problem shows itself.

Where it lives names the part of the application the guide works on, with the platforms and libraries it names. Who can reach it gives the person or access the guide describes. For the guides about practices rather than attacks, that cell says so and names who does the work.

The OWASP column gives only the category each guide names, in the edition and wording that guide uses. Nothing in it was mapped for this page, which is why the column is uneven. Some guides name a category directly, some reach it through a weakness id that the Top 10:2025 maps to the category, one credits the mapping to MITRE, and fourteen name no Top 10 category.

Where a guide names an entry from the OWASP API Security Top 10 instead of or as well as a web category, the cell gives that too. An empty category says nothing about how serious a problem is.

The last column describes the asset each guide hands you, counted from the guide: parts, rows, tests and files. Most assets include a lab that runs on your own computer against invented data, usually with Node.js alone. The XML guide's lab runs on Python, and the firewall and supply chain assets have no lab: you fill them in from your own systems.

Read each guide's own notes on what its lab touches before you run it. Use the labs to learn, and point what they teach only at systems you own or are authorised in writing to test.

Where the guides stop and a test takes over

The guides are written so a developer can check and fix code they own.

A test answers a different question: what someone outside the build finds when they examine it. Each Clever Ops service covers part of this table.

  • A website security check is an external review of what anyone can see without logging in, including security headers, cookie settings, exposed files and admin paths. Among its twelve checks are framing (row 26), cookie attributes (row 6), cross-origin rules (row 27), dangling DNS (row 33), hidden administrator interfaces and error pages (row 34), and keys in page source and JavaScript (row 36). It does not look behind a login.
  • A web application and API penetration test is signed in. It covers authentication and sessions, what each role can see and change, whether one customer can reach another customer's records, the API called directly, payment and billing flows, file uploads and the business rules your application is meant to enforce. Of those subjects, authentication is the subject of row 1, sessions of row 5, roles and other customers' records of row 9, business rules of row 11 and file uploads of row 22.
  • Read-only code access can be added to a penetration test for a closer look at the riskiest areas, and a code review reads the source to find flaws a running test may not reach.
  • A WordPress security audit follows each role that can log in, and checks the login and password-reset flows, installed plugin and theme versions, and how the admin area is exposed.

After the report, and what sits outside these services

Findings can go to your own developers, your agency or a Clever Ops security fix sprint under a separate statement of work, and every test includes one consolidated retest that records what your fixes changed. If Clever Ops built or hosts the application, the work is a security review rather than an independent penetration test, and the report says who built and who hosts the system.

Some rows lead to work Clever Ops does not do. It does not provide managed IT, round-the-clock monitoring or emergency incident response, which matters for row 45 and for any guide you open because something has already happened. Load and denial-of-service testing is not part of any Clever Ops service; the rate limiting and race condition guides say their own checks are not load tests either. Laravel applications sit outside the service, though rows 10 and 29 name Laravel among their platforms.

Frequently asked questions

Thirty-seven of the forty-five guides each describe one kind of vulnerability, from broken authentication to subdomain takeover. The other eight cover what catches or contains them: three defences (a web application firewall, rate limiting, and security logging and monitoring), two testing methods (SAST and DAST) and three practices (an SBOM, threat modelling and a secure development lifecycle). They share the table because a finding can lead to one of them, such as a missing alert to the logging guide or a clean scan to the DAST guide.

Because the guides behind them name none, and this page does not add one. Two of them cite an OWASP API Security Top 10 entry instead, the subdomain takeover guide points to the Top 10:2025 definition of security misconfiguration without naming a category for itself, and the firewall guide cites the Top 10:2025 on what a firewall cannot do and on testing it, without filing firewalls under a category. A missing category is not a judgement about severity. If a questionnaire asks for a category, take it from your report or from the sources a guide cites, not from a gap in this table.

Not on its own. The table is a finder: it tells you which guide to open. The checklists, test packs and worksheets live in the guides, and the last column says which one each guide gives you and what it needs. Several work without their lab, such as the access control matrix in row 9, the state machine and abuse cases in row 11 and the field table in row 13.

The labs are built to run on your own computer against invented data; read each guide's notes on what its lab touches before you run it. To check a real application, use the guide's checklist or test pack on a system you own or are authorised in writing to test, preferably a staging copy with test accounts. Some guides add limits of their own: the request smuggling guide keeps its probes off shared production infrastructure, and the web cache poisoning guide asks for the owner's authority, a cache key no visitor uses and the host's or CDN's testing terms.

Match the finding's title to a guide first, since a report title may use the same name. If the title is unfamiliar, use the affected route and the evidence: what the tester sent and what came back may match a cell in What you notice first. If the finding gives only an OWASP category, the OWASP column narrows it to a handful of rows. A finding about a missing control, such as no rate limit, a firewall that can be skipped or no alert, leads to the defence guides in rows 3, 35 and 45.

In the guide for the finding. Each vulnerability guide sets out what to change, in the terms of the platforms it names, and most of the labs end in a regression test you can point at your own code, so the fix is checked again on the next build. If your team does not have the time, a Clever Ops security fix sprint covers remediation of known findings, from a Clever Ops report or another tester's, under its own statement of work.

No. Clever Ops does not provide managed IT, round-the-clock monitoring or emergency incident response. Several guides here, including those on supply chain attacks, subdomain takeover and secrets exposure, say to bring in an incident response specialist when an attack has already happened. Once the site is clean, an audit can check the web application before you rely on it again.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.