Domain 1Recon & ReportingCORE

Technical Findings Documentation

Comprehensive guide to documenting technical findings in penetration test reports, including finding structure, vulnerability categories, and detailed documentation templates.

Domain: Domain 1: Reconnaissance & Reporting•Updated: 2026-09-01
#findings#vulnerability-documentation#technical-details#evidence#oscp-exam

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]
*Figure 1: Successful authentication bypass using SQL injection*
📷 [Screenshot Placeholder: SQL Injection Data Extraction]
*Figure 2: Extraction of user credentials from the database*

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):

  1. Implement parameterized queries / prepared statements for all database interactions
  2. Deploy a WAF rule to block SQL injection patterns
  3. Restrict database user permissions to minimum required

Short-term Actions (7-30 days):

  1. Conduct a comprehensive code review of all database interactions
  2. Implement input validation and sanitization across the application
  3. Enable database audit logging

Long-term Actions (30-90 days):

  1. Implement automated security testing in the CI/CD pipeline
  2. Conduct security awareness training for the development team
  3. 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

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:

  1. Service Exploitation: Exploiting a vulnerable service (e.g., Apache Struts, Exchange, SMB)
  2. Web Application Vulnerabilities: SQL injection, command injection, file upload, authentication bypass
  3. Authentication Attacks: Brute force, password spraying, credential reuse
  4. Privilege Escalation (Linux): Kernel exploits, SUID binaries, cron jobs, sudo misconfigurations, capability abuse
  5. Privilege Escalation (Windows): Unquoted service paths, AlwaysInstallElevated, registry misconfigurations, token manipulation
  6. 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:

  1. What is the vulnerability?
  2. Where is it located?
  3. 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

  1. Consistent structure. Use the same template for every finding.
  2. One finding per vulnerability. Keep findings atomic and focused.
  3. Reproducible. Include exact commands, payloads, and output.
  4. Complete. Provide all relevant technical details.
  5. Attributed. Reference CVEs, CWEs, and OWASP categories.
  6. Actionable. Include specific remediation steps with code examples.
  7. Evidence-backed. Support every claim with screenshots or output.
  8. Clear titles. Make finding titles specific and informative.

8. Further Reading