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.
On this page
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 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.
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 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 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.
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.
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 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 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.
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.
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.
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, 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.
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.
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.
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.
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 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.
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 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.
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.
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 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.
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.
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.
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.
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.
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 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.
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 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.
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.
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 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.
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.
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.
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) 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
Area
Guide and address
Sign-in, sessions and tokens1. Broken Authentication, at /web-security/authentication-failures
- Guide and address
- 1. 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.
Sign-in, sessions and tokens2. Credential Stuffing, at /web-security/credential-stuffing
- Guide and address
- 2. 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.
Sign-in, sessions and tokens3. Rate Limiting, at /web-security/rate-limiting
- Guide and address
- 3. 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.
Sign-in, sessions and tokens4. MFA Security, at /web-security/mfa-security
- Guide and address
- 4. 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.
Sign-in, sessions and tokens5. Session Management, at /web-security/session-management
- Guide and address
- 5. 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.
Sign-in, sessions and tokens6. Cookie Security, at /web-security/cookie-security
- Guide and address
- 6. 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.
Sign-in, sessions and tokens7. OAuth and OpenID Connect Security, at /web-security/oauth-oidc-security
- Guide and address
- 7. 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.
Sign-in, sessions and tokens8. JWT Security, at /web-security/jwt-security
- Guide and address
- 8. 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.
Records, roles and business rules9. Broken Access Control and IDOR, at /web-security/broken-access-control-idor
- Guide and address
- 9. 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).
Records, roles and business rules10. Mass Assignment, at /web-security/mass-assignment
- Guide and address
- 10. 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).
Records, roles and business rules11. Business Logic Vulnerabilities, at /web-security/business-logic-vulnerabilities
- Guide and address
- 11. 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).
Records, roles and business rules12. Race Conditions, at /web-security/race-conditions
- Guide and address
- 12. 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.
Records, roles and business rules13. Sensitive Data Exposure, at /web-security/sensitive-data-exposure
- Guide and address
- 13. 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).
Input the server hands to other software14. SQL Injection, at /web-security/sql-injection
- Guide and address
- 14. 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.
Input the server hands to other software15. NoSQL Injection, at /web-security/nosql-injection
- Guide and address
- 15. 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.
Input the server hands to other software16. Command Injection, at /web-security/command-injection
- Guide and address
- 16. 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).
Input the server hands to other software17. Server-Side Template Injection (SSTI), at /web-security/server-side-template-injection
- Guide and address
- 17. 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.
Input the server hands to other software18. Remote Code Execution, at /web-security/remote-code-execution
- Guide and address
- 18. 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.
Input the server hands to other software19. Insecure Deserialisation, at /web-security/insecure-deserialization
- Guide and address
- 19. 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.
Input the server hands to other software20. XML External Entity (XXE), at /web-security/xxe
- Guide and address
- 20. 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.
Input the server hands to other software21. Path Traversal, at /web-security/path-traversal
- Guide and address
- 21. 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.
Input the server hands to other software22. File Upload Security, at /web-security/file-upload-security
- Guide and address
- 22. 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).
Input the server hands to other software23. Server-Side Request Forgery (SSRF), at /web-security/ssrf
- Guide and address
- 23. 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.
What the browser does with your pages24. Cross-Site Scripting (XSS), at /web-security/xss
- Guide and address
- 24. 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.
What the browser does with your pages25. Cross-Site Request Forgery (CSRF), at /web-security/csrf
- Guide and address
- 25. 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.
What the browser does with your pages26. Clickjacking, at /web-security/clickjacking
- Guide and address
- 26. 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.
What the browser does with your pages27. CORS Misconfiguration, at /web-security/cors-misconfiguration
- Guide and address
- 27. 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.
What the browser does with your pages28. Open Redirects, at /web-security/open-redirects
- Guide and address
- 28. 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.
In front of the application29. Host Header Injection, at /web-security/host-header-injection
- Guide and address
- 29. 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.
In front of the application30. HTTP Request Smuggling, at /web-security/http-request-smuggling
- Guide and address
- 30. 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.
In front of the application31. Web Cache Poisoning, at /web-security/web-cache-poisoning
- Guide and address
- 31. 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.
In front of the application32. Web Cache Deception, at /web-security/web-cache-deception
- Guide and address
- 32. 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.
In front of the application33. Subdomain Takeover, at /web-security/subdomain-takeover
- Guide and address
- 33. 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.
In front of the application34. Security Misconfiguration, at /web-security/security-misconfiguration
- Guide and address
- 34. 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.
In front of the application35. Web Application Firewall, at /web-security/web-application-firewall
- Guide and address
- 35. 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.
Code, dependencies and the pipeline36. Secrets Exposure, at /web-security/secrets-exposure
- Guide and address
- 36. 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.
Code, dependencies and the pipeline37. Dependency Security, at /web-security/dependency-security
- Guide and address
- 37. 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.
Code, dependencies and the pipeline38. Supply Chain Attacks, at /web-security/supply-chain-attacks
- Guide and address
- 38. 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.
Code, dependencies and the pipeline39. SBOM, at /web-security/sbom
- Guide and address
- 39. 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.
Code, dependencies and the pipeline40. CI/CD Security, at /web-security/cicd-security
- Guide and address
- 40. 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.
Code, dependencies and the pipeline41. SAST, at /web-security/sast
- Guide and address
- 41. 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.
Code, dependencies and the pipeline42. Dynamic Application Security Testing (DAST), at /web-security/dast
- Guide and address
- 42. 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.
Design, delivery and evidence43. Threat Modelling, at /web-security/threat-modelling
- Guide and address
- 43. 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.
Design, delivery and evidence44. Secure SDLC, at /web-security/secure-sdlc
- Guide and address
- 44. 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.
Design, delivery and evidence45. Security Logging and Monitoring, at /web-security/security-logging-and-monitoring
- Guide and address
- 45. 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).
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.
Read down the column headed What you notice first, inside the area where the trouble showed up. The cells use each guide's own examples, so a customer who opened someone else's invoice by changing a number points to row 9, a password reset email whose link starts with a strange host name points to row 29, and a voucher redeemed more often than it should be points to row 12.
Some symptoms belong to two rows, and the difference is who served the page. A private account page that a stranger can load is an access control problem, row 9, when the application hands it over, and a cache problem, row 32, when a shared cache does.
A response that shows a customer their own record plus fields the screen never displays is row 13 rather than row 9, because the request was one they were allowed to make.
A scanner finding may name the mechanism rather than the cause. A dependency advisory from npm audit or Dependabot belongs to row 37, unless the package was published to do harm, which is row 38. A missing header can lead to clickjacking, row 26, to cookie attributes, row 6, or to security misconfiguration, row 34, depending on which header it names.
A static analysis warning on a query, a command or a file path leads to rows 14, 16 or 21, and row 41 covers how far to trust the tool that raised it.
Treat a clean result from a dynamic scanner as a question for row 42 before you treat it as good news. That guide starts from scans that never signed in, lost their session or never reached part of the application, and its coverage map shows what a scan actually visited.
A report finding carries a title, and may carry a weakness id or an OWASP category. Match the title to a guide first. Clever Ops reports map each finding to its OWASP Top 10:2025 category. A category narrows the field without settling it. A01 Broken Access Control appears in rows 9, 21, 23, 25, 27 and 28, and A05 Injection in rows 14 to 18 and 24.
Fourteen guides file their own subject under no Top 10 category, so a finding filed under a category will not lead you to them. For a finding about request smuggling, a cache, a host header, an upload, a second factor or a leaked key, use the area and the symptom instead.
The column headed Where it lives names the platforms and libraries each guide works through. Next.js appears in fifteen rows, from cookies and access control to caches, settings and leaked keys. WordPress appears in rows 14, 22 and 34, Django in rows 5, 6, 10, 25, 29 and 34, Express in rows 15, 27, 29 and 34 with express-session in rows 5 and 6, Supabase in rows 9 and 14, and Prisma in rows 10, 13 and 14. Where a cell names no platform, open the guide for the examples it uses.
The library also has platform guides for Next.js and for WordPress, which collect the framework-specific material in one place.
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.