Repository navigation
OWASP Top 10 Deep Dive
Caution
Authorized use only. The exploitation techniques below are for authorized testing, education, and defensive research. Testing without authorization may violate applicable laws, contracts, or policies; the legal analysis depends on jurisdiction and facts. Obtain written authorization and follow the approved scope. See LEGAL.md and consult qualified counsel for legal questions.
A working reference for the OWASP Top 10 web application risks - each category covering what it is, how it is exploited, how to test for it, and how to defend against it.
Walks all ten categories of the OWASP Top 10:2025 final edition, with a mapping back to the stable 2021 list. Each entry pairs offensive testing notes with defensive controls and links to the relevant OWASP Cheat Sheet.
Let a reader look up any Top 10 category and immediately know how it manifests, how to test for it in an authorized engagement, and what remediation to recommend.
- Testing a web application against a specific risk class
- Writing a finding and needing the OWASP/CWE mapping plus remediation guidance
- Reviewing an application or design defensively against the current risk list
- Version Note: 2025 Final vs 2021
- A01: Broken Access Control
- A02: Security Misconfiguration
- A03: Software Supply Chain Failures
- A04: Cryptographic Failures
- A05: Injection
- A06: Insecure Design
- A07: Authentication Failures
- A08: Software or Data Integrity Failures
- A09: Security Logging and Alerting Failures
- A10: Mishandling of Exceptional Conditions
- 2021 to 2025 Mapping
- Resources
The OWASP Top 10:2025 is the current final edition; OWASP marks the 2021 edition as superseded. This guide follows the 2025 ordering and category names and preserves a 2021โ2025 mapping for older reports and crosswalks. Check the official OWASP Top 10 repository and 2025 introduction for the current publication.
Key changes include:
- A03: Software Supply Chain Failures expands 2021's "Vulnerable and Outdated Components" to cover risks across software dependencies, build systems and distribution infrastructure.
- SSRF, formerly 2021 A10, is incorporated into 2025 A01: Broken Access Control.
- A10: Mishandling of Exceptional Conditions is new and includes error handling, logic errors, and fail-open behavior.
This summarizes selected structural changes; use the crosswalk below for category-by-category mapping.
The most prevalent risk in both 2021 and 2025. The application fails to enforce what an authenticated user is allowed to do.
- How it is exploited: changing an identifier to access another user's data (IDOR / horizontal), reaching admin functionality as a normal user (vertical), forced browsing to unlinked endpoints, or tampering with a JWT/cookie role claim.
- How to test: with two accounts of different privilege, replay each request as the other (Burp's Autorize/Auth Analyzer extensions help); enumerate object IDs; request admin routes directly; verify server-side enforcement rather than hidden-in-the-UI controls.
- How to defend: deny access by default and enforce authorization server-side on every request. Verify that the authenticated principal is permitted to perform the requested action on the specific object, including applicable ownership, role, and tenant-boundary checks. Use opaque or unpredictable identifiers only as defense in depth, never as a substitute for authorization. Centralize access-control logic and log authorization failures without recording credentials or unnecessary sensitive data.
- Validation: in an authorized test environment, create two ordinary users with separate private objects. Confirm that each user can perform permitted actions on their own objects but cannot read, modify, delete, or export the other user's private objects, even when the identifier is known. Also test administrative functions with an ordinary account and cross-tenant access where applicable. Verify both the response and resulting data state; an error response alone does not prove that an unauthorized change was prevented.
- CWE: CWE-284, CWE-639, CWE-862. Cheat sheet: Authorization.
Insecure defaults, incomplete hardening, verbose errors, and unnecessary features.
-
How it is exploited: default/administrative credentials, exposed admin
consoles or
.git/backup files, missing security headers, directory listing, overly permissive CORS, verbose stack traces revealing internals. -
How to test: enumerate exposed paths and files; review response headers
(CSP, HSTS,
X-Content-Type-Options); check CORS with a rogueOrigin; probe default credentials on any admin surface; diff against a hardening baseline. - How to defend: a repeatable hardening process; remove unused features and sample apps; set security headers; suppress verbose errors in production; keep environments consistent; automate configuration checks.
- CWE: CWE-16, CWE-548. Cheat sheet: OWASP Secure Headers.
Expanded in 2025 from "Vulnerable and Outdated Components" to the whole chain: dependencies, build pipelines, and distribution.
-
How it is exploited: known-vulnerable libraries (n-day), typosquatted or
compromised packages, poisoned build/CI steps, unsigned artifacts, or a
compromised update channel (cf. the SolarWinds and
xz/CVE-2024-3094 cases). - How to test: inventory dependencies (SBOM); run SCA against known-CVE databases; check for pinned, integrity-verified dependencies; review CI/CD trust boundaries and who can publish artifacts.
- How to defend: maintain an SBOM; pin and verify dependencies (hashes/lock files); use signed artifacts and provenance (e.g. SLSA, Sigstore); restrict and monitor the build pipeline; patch promptly.
- CWE: CWE-1104, CWE-1357. Cheat sheet: Vulnerable Dependency Management.
Weak, misused, or missing cryptography that exposes data in transit or at rest.
- How it is exploited: cleartext transport, weak/deprecated ciphers or hashes (MD5, SHA-1, ECB), hard-coded or reused keys, missing encryption of sensitive data, predictable IVs/nonces, unsalted password hashes.
- How to test: check TLS configuration and certificate validity; look for sensitive data sent or stored in cleartext; review password storage (algorithm/salt); inspect for hard-coded secrets; verify token/randomness quality.
- How to defend: enforce TLS (HSTS); use vetted algorithms (AES-GCM, ChaCha20-Poly1305; Argon2/bcrypt/scrypt for passwords); manage keys in a KMS/HSM; classify data and encrypt sensitive fields; never roll your own crypto.
- CWE: CWE-259, CWE-327, CWE-331. Cheat sheet: Cryptographic Storage.
Untrusted input is interpreted as code or a command. Includes SQL, NoSQL, OS command, LDAP, and (server-side) template injection, plus cross-site scripting.
-
How it is exploited: breaking out of a query/command context -
' OR 1=1--(SQLi),{{7*7}}(SSTI), backtick/;chaining (command injection), or reflected /stored/DOM XSS injecting script into a page. -
How to test: fuzz every input (params, headers, JSON, path) with
context-specific payloads; use Burp Intruder/Scanner; confirm SQLi with
sqlmapin scope; test XSS across reflected, stored, and DOM sinks. - How to defend: parameterized queries / prepared statements; safe ORMs; context-aware output encoding and a strong Content-Security-Policy for XSS; allow-list input validation; avoid passing input to shells/interpreters.
- CWE: CWE-89, CWE-79, CWE-78, CWE-94. Cheat sheets: Injection Prevention, XSS Prevention.
Flaws in the design itself - missing or ineffective controls that no amount of clean implementation can fix.
- How it is exploited: abusing a workflow that was never threat-modeled - e.g. no rate limiting on a password-reset or OTP flow, trusting client-side controls, or a recovery process that leaks information.
- How to test: threat-model the feature; look for missing anti-automation, trust-boundary violations, and assumptions the client can break; test negative and abuse cases, not just the happy path.
- How to defend: threat modeling in design; secure design patterns and reference architectures; establish trust boundaries; write abuse/misuse cases and test them; apply defense in depth.
- CWE: CWE-73, CWE-602, CWE-657. Cheat sheet: Threat Modeling.
Weaknesses in confirming identity and managing sessions.
-
How it is exploited: credential stuffing and brute force (no lockout/rate
limit), weak password policies, session fixation, exposed or non-expiring session
tokens, flawed MFA, and weak JWT handling (
alg:none, weak secret, no expiry). - How to test: probe login for lockout/rate limiting; test session lifecycle (fixation, invalidation on logout, rotation); inspect JWTs (algorithm, signature, expiry, claims); test password reset and MFA bypasses.
-
How to defend: rate limiting and lockout; MFA; strong password storage
(Argon2/bcrypt) and breached-password checks; secure,
HttpOnly,SameSitesession cookies with rotation and expiry; validate JWTalgand signature server-side. - CWE: CWE-287, CWE-384, CWE-613. Cheat sheet: Authentication.
Code or data trusted without verifying integrity - including insecure deserialization and unverified updates.
- How it is exploited: insecure deserialization leading to RCE, unsigned or unverified auto-updates, CI/CD that trusts untrusted input, or client-side integrity assumptions (no Subresource Integrity on third-party scripts).
- How to test: identify serialized objects crossing trust boundaries; test deserialization with known gadget chains (in scope); check update mechanisms for signature verification; look for missing SRI on external resources.
- How to defend: avoid native deserialization of untrusted data (use data-only formats with schema validation); sign and verify updates and artifacts; enforce integrity in CI/CD; use Subresource Integrity for third-party scripts.
- CWE: CWE-502, CWE-345, CWE-829. Cheat sheet: Deserialization.
Insufficient logging, monitoring, and alerting - which lets attacks proceed undetected. (2021: "Logging and Monitoring Failures".)
- How it is exploited: not a direct exploit but an amplifier - failed logins, access-control denials, and input-validation failures go unlogged, so intrusions are neither detected nor investigable.
- How to test: verify security-relevant events are logged (authn/authz failures, high-value actions); confirm logs are tamper-resistant and shipped off host; check that alerts actually fire on suspicious patterns.
- How to defend: log security events with enough context; centralize logs to a SIEM; protect log integrity; define and test alerting; align retention with response needs.
- CWE: CWE-778, CWE-223. Cheat sheet: Logging.
New in 2025: error-handling and edge-case logic that fails insecurely.
- How it is exploited: fail-open logic (an error path that grants access), inconsistent state after a partial failure, information disclosure through error messages, or race conditions in exceptional paths.
- How to test: force error and edge conditions (malformed input, timeouts, concurrent requests); observe whether failures fail open or closed; check error responses for leaked internals; test race conditions on state-changing ops.
- How to defend: fail closed by default; handle errors explicitly and uniformly; avoid leaking internals in messages; make state changes atomic; test exceptional paths as first-class scenarios.
- CWE: CWE-755, CWE-209, CWE-362. Cheat sheet: Error Handling.
| 2021 | 2025 |
|---|---|
| A01 Broken Access Control | A01 Broken Access Control |
| A02 Cryptographic Failures | A04 Cryptographic Failures |
| A03 Injection | A05 Injection |
| A04 Insecure Design | A06 Insecure Design |
| A05 Security Misconfiguration | A02 Security Misconfiguration |
| A06 Vulnerable and Outdated Components | A03 Software Supply Chain Failures (expanded) |
| A07 Identification and Authentication Failures | A07 Authentication Failures |
| A08 Software and Data Integrity Failures | A08 Software or Data Integrity Failures |
| A09 Security Logging and Monitoring Failures | A09 Security Logging and Alerting Failures |
| A10 Server-Side Request Forgery (SSRF) | folded into A01 / server-side request areas |
| (new in 2025) | A10 Mishandling of Exceptional Conditions |
- OWASP Top 10 - authoritative source (check current edition)
- OWASP Web Security Testing Guide - how to test each category
- OWASP Cheat Sheet Series - defensive guidance per topic
- MITRE CWE - weakness identifiers used above
- PortSwigger Web Security Academy - hands-on labs per vulnerability class
- README.md - Web Application Security section index
- methodology.md - the assessment workflow that applies these categories
- ../GLOSSARY.md - Acronyms (OWASP, CWE, SSRF, XSS, SSTIโฆ)
๐ Source: WebAppSecurity/owasp-top-10.md | โ๏ธ Suggest an edit | โฌ
๏ธ Back to Web App Security
- ๐บ๏ธ Browse by Topic
- ๐ All Repository Files
- ๐งญ Learning Paths
- ๐ Master Guide
- ๐ค Glossary
- โ๏ธ Legal & Disclaimer
๐ Foundations & Learning
๐ก๏ธ Defense & Investigations
- Incident Response
- Open Source Intelligence (OSINT)
- Reverse Engineering
- Operations Security (OPSEC)
- Compliance
โ๏ธ Platforms & Infrastructure
๐ก Hardware, Wireless & Field Projects
- PNWC Cyberdeck
- Hardware Testing
- Hardware Hacking
- Software-Defined Radio
- Wardriving
- uConsole
- Space Security
๐งฐ Assessment & Field Reference
๐ฆ Downloads & Project Resources
๐๏ธ Additional Topics