Skip to content

OWASP Top 10 Deep Dive

github-actions[bot] edited this page Nov 19, 2026 · 4 revisions

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.

๐ŸŽฏ Purpose

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.

โš™๏ธ Function

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.

๐Ÿ† Goal

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.

๐Ÿ“‹ When to Use

  • 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

๐Ÿ“‹ Table of Contents


๐Ÿ—“๏ธ Version Note: 2025 Final vs 2021

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.

Key category changes and edition status from OWASP Top 10 2021 to final 2025

This summarizes selected structural changes; use the crosswalk below for category-by-category mapping.


A01: Broken Access Control

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.

A02: Security Misconfiguration

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 rogue Origin; 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.

A03: Software Supply Chain Failures

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.

A04: Cryptographic Failures

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.

A05: Injection

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 sqlmap in 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.

A06: Insecure Design

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.

A07: Authentication Failures

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, SameSite session cookies with rotation and expiry; validate JWT alg and signature server-side.
  • CWE: CWE-287, CWE-384, CWE-613. Cheat sheet: Authentication.

A08: Software or Data Integrity Failures

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.

A09: Security Logging and Alerting Failures

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.

A10: Mishandling of Exceptional Conditions

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 to 2025 Mapping

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

๐Ÿ“š Resources


Related Files

  • 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

Clone this wiki locally