The OWASP Top 10
The OWASP Top 10 is an awareness document from the OWASP Foundation that ranks the ten most critical categories of security risk in web applications. The current edition is OWASP Top 10:2025. Each category has an identifier such as A01:2025, a name, the weaknesses it groups (mapped to CWE entries), prevention advice and example attack scenarios.
For a tester it is a test basis: ten questions to ask about any feature. "Can customer A download customer B's invoice by changing the id?" is the question behind A01:2025 Broken Access Control, and one request sent with the wrong user's token answers it.
Why it matters
Security defects rarely appear in functional tests, because the application behaves as specified for the honest user. They appear when someone sends a request the UI never sends: another user's id, an admin path, a token after logout, a quote inside a field. The Top 10 names the categories of weakness that testing data shows are widespread, weighted by how exploitable and damaging they are, so covering it covers failures that are both common and serious.
It is also a shared language: developers, security specialists and auditors know what an "A01 finding" means, so a report that names the category is understood and prioritised faster. And it marks what a QA tester covers before a specialist penetration test goes deeper into the same categories.
What the Top 10 is, and what it is not
OWASP publishes a new edition every few years; 2025 replaced 2021. Eight of the ten categories come from testing data contributed by organisations that test applications, ranked by a score that combines how often each weakness is found (its incidence rate) with its exploitability and impact; a community survey of practitioners adds the other two, for risks the data under-represents (A09's 2025 page says it was voted in, and A03 was the survey's top-ranked concern). Three changes matter in 2025: A10 Mishandling of Exceptional Conditions is new; A03 grew from 2021's Vulnerable and Outdated Components into the whole build, distribution and update chain; A09 was renamed to stress alerting, not only logging. Each category maps to a list of CWEs: the Common Weakness Enumeration is MITRE's catalogue of weakness types (a CVE, by contrast, names one vulnerability in one product), and many scanners label their findings with CWE ids.
It is neither a standard nor a complete checklist. The Application Security Verification Standard (ASVS) turns security into verifiable requirements, the Web Security Testing Guide (WSTG) gives step-by-step test procedures, and the OWASP API Security Top 10 (2023) covers API-specific risks. Use the Top 10 to decide where to look first, ASVS and WSTG to decide how thoroughly.
- Always quote the year: positions move between editions, and
A03meant Injection in 2021 but Software Supply Chain Failures in 2025. - Test only systems you own or have written permission to test. Every check in this lesson is a non-destructive observation, not an exploit.
The ten categories of 2025 and the tester's first check
For each category: what it groups, then the first check a tester makes. Later lessons in this module go deeper into each area; here the goal is to recognise every category and know where to look.
A01:2025Broken Access Control: acting outside one's permissions, for example reading another user's record by changing an id. Check: repeat the request with a valid token for the wrong user and the wrong role; expect 403 or 404.A02:2025Security Misconfiguration: default accounts, unnecessary features, verbose errors, missing security headers, permissive permissions. Check: read the response headers, trigger an error page, try documented default credentials on the test environment.A03:2025Software Supply Chain Failures: vulnerable, unmaintained, untracked or compromised components, build tools and update channels. Check: ask for the dependency inventory with versions and whether advisories are reviewed before each release.A04:2025Cryptographic Failures: sensitive data sent or stored without encryption, weak algorithms, hard-coded keys. Check: confirm TLS on every endpoint; look for passwords, card numbers or tokens stored or logged in clear text.A05:2025Injection: untrusted input reaching an interpreter (SQL, OS command, template, HTML) unescaped; cross-site scripting (XSS), where input ends up running as script in another user's browser, belongs here. Check: a quote, an angle bracket or a semicolon in each field; watch for errors, changed results or rendered markup.A06:2025Insecure Design: the business logic allows abuse even with correct code, such as a coupon applied twice. Check: walk the flow as a dishonest user and try to break the rule without any technical trick.A07:2025Authentication Failures: weak passwords accepted, no lockout or throttling, user enumeration, sessions that survive logout. Check: wrong-password attempts, messages that differ for existing and unknown accounts, an old token after logout.A08:2025Software or Data Integrity Failures: code or data trusted without verification: scripts from an untrusted CDN, unsigned updates, an unprotected CI/CD pipeline. Check: ask how build artefacts and updates are verified, and whether data the client sends back, such as a serialised object in a cookie, is accepted without an integrity check.A09:2025Security Logging and Alerting Failures: logins, failed logins and high-value transactions not logged, logs not monitored, alerts not raised. Check: after your tests, ask whether your forbidden requests appear in the logs and whether anyone was alerted.A10:2025Mishandling of Exceptional Conditions: errors not handled where they occur, failing open (allowing the action when a check itself errors), exposed stack traces, inconsistent state after a failure. Check: send a missing parameter, a huge value or a wrong type; expect a clean error and a closed door.
| Category (OWASP Top 10:2025) | The tester's first question | Evidence to record |
|---|---|---|
| Broken Access ControlA01:2025 | Can user A reach user B's record or an admin action? | The request as the wrong user and its status (expect 403 or 404) |
| Security MisconfigurationA02:2025 | Are defaults, headers, errors and permissions hardened? | Response headers, one error page, the default-credentials attempt |
| Software Supply Chain FailuresA03:2025 | Are components tracked, supported and from trusted sources? | Dependency inventory with versions and reviewed advisories |
| Cryptographic FailuresA04:2025 | Is sensitive data encrypted in transit and at rest? | TLS on each endpoint; any secret stored or logged in clear text |
| InjectionA05:2025 | Does untrusted input reach SQL, a command or HTML unescaped? | The field, the input and the error or changed behaviour |
| Insecure DesignA06:2025 | Can the business rule be abused with no bug at all? | The flow, the rule and the scenario that bypasses it |
| Authentication FailuresA07:2025 | Can passwords be guessed, accounts enumerated or tokens reused after logout? | Lockout behaviour, differing messages, token lifetime after logout |
| Software or Data Integrity FailuresA08:2025 | Is code or data accepted without a signature or integrity check? | How artefacts and updates are verified; serialised data accepted as is |
| Security Logging and Alerting FailuresA09:2025 | Are logins, failures and high-value actions logged and alerted on? | The log line for each test event and who received the alert |
| Mishandling of Exceptional ConditionsA10:2025 | When something goes wrong, does it fail closed and reveal little? | The error shown, the state left behind, the log entry |
Try it: Security Header Analyzer Try it: API Authentication Tester Try it: Cookie Analyzer
Worked example: one endpoint through the ten categories
A customer portal lets a logged-in customer download an invoice as a PDF. Walking this request through the list takes a few minutes and gives a short, prioritised set of test conditions.
- A01: repeat the request with customer B's token for A's invoice 8812. Expected: 403 or 404, never the PDF. Ask too whether the stored PDF has a predictable direct URL that skips this check. First priority: invoices hold personal and financial data.
- A07 and A04: with no token the request must get 401; the token must stop working after logout and expiry; the response must use TLS and must not be cacheable by a shared cache (
Cache-Control: no-storeorprivate). - A02 and A10: request
/api/invoices/abc/pdfand/api/invoices/99999999/pdf. Expected: a short error with the right status, no stack trace, no framework version in the headers. - A05 and A09: the id is numeric, so also send an id with a quote,
8812'; a database error in the response is a finding even without exploitation. After the run, ask the developer to find your forbidden requests in the log. - A03, A06 and A08 are questions for the team: which PDF library and version renders the invoice (A03), can an invoice be produced for an unpaid order (A06), and is the PDF built from the server's own records or from values the client sends, such as an amount, without verification (A08).
GET /api/invoices/8812/pdf HTTP/1.1
Host: portal.example.com
Authorization: Bearer <access token of customer A>
Accept: application/pdfTry it: API Request Builder Try it: JWT Claims Analyzer Try it: Special Character Dataset Generator
Common mistakes
- Treating the Top 10 as a complete security test plan; it names ten high-risk categories, not every weakness, and ASVS and WSTG go much further.
- Quoting a category without its year, so that
A03means two different things to two readers. - Reporting scanner output unread; a scanner finding is a lead the tester reproduces, classifies and clears of false positives.
- Testing only through the UI, when most checks need a request the UI never sends: another id, a missing token, a changed role.
- Rating a missing security header above a confirmed cross-user data read; classify by impact, as in risk-based testing.
- Sending payloads to a system you do not own or lack written permission to test.
The QA perspective
On a team the list appears at three moments. In refinement, the tester reads a story and asks which categories it touches: an id in a URL touches A01, a new input touches A05 and A10, a login or token touches A07; these become test conditions beside the functional ones. In execution, each check is recorded as a request, a response and a verdict, like any test case, with the identifier in its title.
A finding is reported with the category, the exact request, the expected and actual response, and a severity based on the data or action exposed: a confirmed A01 finding on personal data is usually critical or blocker. Before release, the team states which categories were checked, which were out of scope (A03 often belongs to the build pipeline) and what a specialist penetration test should look at next.
Practice exercise
Map a photo upload feature to the Top 10
A profile page lets a logged-in user upload a profile photo with POST /api/users/{id}/avatar: JPEG or PNG, up to 5 MB, stored in object storage and shown on the user's profile at a URL the server returns.
Go through the ten categories of OWASP Top 10:2025. For each, decide whether it applies to this feature and, if so, write the first check you would make. Then choose the three checks to run first and justify the order.
- List the ten categories with their identifiers.
- Mark each as applies, partly applies, or a question for the team.
- Write one check per applicable category, as a request or an observation.
- Rank the top three by the data or action at risk.
Show the model answer
A01: upload with user A's token to user B's {id}; expect 403 or 404 and B's photo unchanged. Also a file name containing ../ (path traversal, which OWASP maps to A01): the file must not land outside A's own storage location. A07: the same request with no token and with an expired token; expect 401 and nothing stored. A05 and A10: a 6 MB file, an HTML file renamed .png, a file name containing a quote; expect a clean rejection based on the real content, not the extension, no stack trace, nothing stored.
A02: the headers of the returned image URL, and whether the storage bucket lists its contents. A04: HTTPS on the upload and on the image URL. A08: whether the request carries a value the server should decide itself, such as the storage path or the URL to display, and the server accepts it unverified. A09: whether rejected uploads and cross-user attempts are logged. A03 and A06 are questions for the team: which image library and version, and whether a private profile's photo stays reachable by anyone who guesses or keeps its URL.
First three: A01 (another user's photo can be replaced), then the disguised HTML file under A05 (stored content could run in other users' browsers), then A07 (anyone could upload without signing in). Each exposes other users, not only the tester's own account; the oversized file under A10 comes next, because it threatens storage and availability rather than another user's data.
Frequently asked questions
Is the OWASP Top 10 the same as the OWASP API Security Top 10?
No. The Top 10 covers web applications in general; the API Security Top 10 (2023) is a separate list for APIs, whose first item is broken object-level authorisation. Teams that build APIs use both.
Do I need penetration-testing skills to use the Top 10?
No. Most first checks are ordinary requests with a changed id, token or input value, plus reading headers, errors and logs. A specialist penetration test goes deeper into the same categories; your checks make it cheaper and better focused.
Which category should I test first?
Start with A01:2025 Broken Access Control wherever the feature exposes data or actions by id, then authentication and input handling. Order by the impact of what could be exposed, as in risk-based testing, not by the position in the list.
The list changed between 2021 and 2025. Which one do I use?
Use the 2025 edition and quote identifiers with the year. If your organisation's policy or tooling still refers to 2021 categories, map findings to both until it is updated.
References
- OWASP Top 10:2025The ten most critical web application security risks, with how to test for and prevent each.
- OWASP Web Security Testing Guide (WSTG)The reference methodology for testing web applications and APIs for security weaknesses, test by test.
- OWASP Application Security Verification Standard (ASVS)A checklist of verifiable security requirements for web applications, grouped in three assurance levels.
- OWASP API Security Top 10 (2023)The ten most common API weaknesses: broken object-level authorization, broken authentication, unrestricted resource consumption and more.
Practise with Mutqan tools
Grade HTTP security headers (CSP, HSTS, X-Frame-Options, Referrer-Policy, Permissions-Policy, COOP/CORP) from pasted headers or a public URL.
Test Bearer, Basic, API-key and custom-header authentication against an endpoint and compare authorised vs unauthorised responses.
Parse Set-Cookie headers and check Secure, HttpOnly, SameSite, Domain, Path, expiry and size best practices.
Analyze JWT claims for missing, risky or non-standard values and get security recommendations.
Compose and send HTTP requests (method, URL, headers, auth, body) and inspect the response — a lightweight Postman in your browser.
Generate inputs full of special characters: quotes, SQL/HTML/JSON metacharacters, control chars, emoji and path tricks.
Go deeper
Your progress on this topic
Not started
Mark the topic complete when you have studied it and done the exercise.
Sign in to track your progress
Mark topics complete, continue where you left off and unlock specialisation exams.