2026-10-23 18:41:20 网络安全文章来源：ZONE.CI 全球网 0 阅读模式

cover_image

香港人工智能网络安全挑战赛Writeup（初赛）-Reverse全解

原创

Flowers aq
Flowers aq

flower安全

2026年7月6日 19:29
甘肃

在小说阅读器读本章

去阅读

CyberSecurity

前言

香港AI x Cybersecurity Challenge人工智能挑战赛是由数字政策办公室、香港网络安全专业协会、中国网络空间研究院、中国移动香港有限公司主办的新兴网络安全赛事比赛采用动态计分机制，即先完成解题的队伍将获得较高分数。初赛为线上解题赛，决赛为线下地点为维多利亚港。

笔者队伍在本次挑战赛初赛中也取得了不错的成绩成功晋级线下，而笔者负责逆向和二进制分析两部分且都已全解，此篇文章为Reverse篇。

CyberSecurity

CyberSecurity

正文

一，SimpleSocket：

1，题目背景：

“A lightweight client-server program protects its returned message through a custom communication flow. Reverse the logic behind the exchange and recover the final content.一個輕量級用戶端與伺服器程式透過自訂通訊流程保護回傳訊息。請逆向分析交換邏輯，還原最終內容。”

题目给了我们一个轻量级客户端服务端程序，它通过自定义的加密通信流程来保护返回的消息。我们需要做的就是逆向分析这个交换逻辑，还原出最终的机密内容（flag）。

2，题目分析：

解压附件后，我们得到 4 个文件：

SimpleSocket.zip├── py          # Python 源码（1540 字节）├── packet1     # 数据包1（96 字节）├── packet2     # 数据包2（900 字节）└── packet3     # 数据包3（256 字节）

初步判断：

py = 服务端/客户端的参考实现代码
packet1、packet2、packet3 = 网络通信中捕获的原始数据包

这明显是一道给你源码 + 抓包数据，逆向解密的经典 CTF 题型。

首先打开 py 文件，一探究竟：

from Crypto.PublicKey import RSAfrom Crypto.Cipher import PKCS1_OAEP, AESfrom Crypto.Util.Padding import pad, unpadimport osimport socketimport time

导入了 RSA、AES、PKCS1\_OAEP、pad/unpad经典的混合加密体系。

def generate_rsa_keys():    key = RSA.generate(1024)    private_key = key.export_key()    public_key = key.publickey().export_key()    return private_key, public_key

生成了一个 1024 位的 RSA 密钥对。

def client_logic(public_key):    current_time = int(time.time())         aes_key = os.urandom(16)                cipher_rsa = PKCS1_OAEP.new(RSA.import_key(public_key))    encrypted_aes_key = cipher_rsa.encrypt(aes_key)      with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:        s.connect(('localhost', 9999))        s.sendall(encrypted_aes_key)            encrypted_data = s.recv(1024)

这一段属于客户端逻辑代码

def server_logic(private_key):    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:        s.bind(('localhost', 9999))        s.listen()        conn, addr = s.accept()        with conn:            encrypted_aes_key = conn.recv(256)             cipher_rsa = PKCS1_OAEP.new(RSA.import_key(private_key))            aes_key = cipher_rsa.decrypt(encrypted_aes_key)              flag = b\"this is flag\"                       cipher_aes = AES.new(aes_key, AES.MODE_ECB)  # AES-ECB 模式            encrypted_flag = cipher_aes.encrypt(pad(flag, AES.block_size))            conn.sendall(encrypted_flag)

这一段属于服务端逻辑代码。

整个代码的主流程为：

private_key, public_key = generate_rsa_keys()import threadingserver_thread = threading.Thread(target=server_logic, args=(private_key,))server_thread.start()client_logic(public_key)

综上分析可以初步得知整体流程：客户端生成RSA密钥对、168 AES密钥K、用RSA公钥加密K得到了RSA\_C(K)，再发送RSA\_C（K）到服务端，服务端用RSA私钥解密得到AES密钥K、AES-ECB又加密flag得到AES\_C(flag)，最后服务端反回AES\_C(flag)到客户端，客户端再用AES密钥K解密得到flag。

它的核心思路就是：非对称加密（RSA）安全传输对称密钥（AES），再用对称密钥高效加密数据。

3，数据包分析：

首先看 packet2，它长这样（部分）

-----BEGIN RSA PRIVATE KEY-----\
MIICXAIBAAKBgQC5hMOyHMbH2no95Br5xHuurgcxzAcK2fULAPQGLkSz5St8Te2L\
G8jUnxjnbOUF1a/72s3rOkZH8IbtUsTvtrcg/WUlyMWSjpiqhbpPNxGXbDQs2KyP\
...-----END RSA PRIVATE KEY-----

这里的 \
是字面量字符（反斜杠 + 字母 n），而不是真正的换行符。用 Python 查看确认：

>>> with open('packet2', 'r') as f:...     data = f.read()>>> data[:100]'-----BEGIN RSA PRIVATE KEY-----\\\
MIICXAIBAAKBgQC5hMOyHMbH2no95Br5xHuurgcxzAcK2fULAPQGLkSz5St8Te2L\\\
G'

一共 14 处 \\
，需要替换为真正的换行符才能得到标准 PEM 格式。修复后的 PEM 私钥：

-----BEGIN RSA PRIVATE KEY----- MIICXAIBAAKBgQC5hMOyHMbH2no95Br5xHuurgcxzAcK2fULAPQGLkSz5St8Te2L G8jUnxjnbOUF1a/72s3rOkZH8IbtUsTvtrcg/WUlyMWSjpiqhbpPNxGXbDQs2KyP ... -----END RSA PRIVATE KEY-----

可知RSA密钥信息：

密钥长度：1024 bits模数 N：13027559903439716274...（309 位十进制数）公钥指数 E：65537（0x10001）私钥指数 D：30169603970959981967...（309 位十进制数）

再来看看packet1这是加密数据包：

e41663ce2af0328f88f97fcc992a3e6d9f1f8a0de3b5b0c47fcc2e439db4a71a48b46de06059a701d5ff4cac88ace640

纯 ASCII 文本，内容是 96 个十六进制字符
解码后 = 48 字节原始数据

同样是加密数据包的packet3：

4560c76721e670ecde8b553a112ae052060a478c83ca3806c2eb39eb8da2b80f7dccb14fa985b23fe78c6dfc891897bd...

同样是纯 ASCII 文本，256 个十六进制字符
解码后 = 128 字节原始数据

参考代码告诉我们：

1.客户端发送 → RSA 加密的 AES 密钥（encrypted\_aes\_key）

2.服务端返回 → AES-ECB 加密的 Flag（encrypted\_flag）

按理说： RSA-1024 加密输出 = 128 字节（1024 bits ÷ 8）
AESECB 加密输出 = 16 的整数倍。Flag 约 40+ 字节，pad 后约 48 字节（3 个 AES 块）

然而实际数据包中：packet1为48字节太小了(本来需 128B)，但它的AES密文又恰好为48B，packet3为128 字节正好128B但它的AES密文又太大了，所有猜测packet1 和 packet3 在抓包文件中的角色被交换了。

4.解题过程：

第一步：提取 RSA 私钥

from Crypto.PublicKey import RSAwith open('packet2', 'r') as f:    raw_key = f.read().strip()# 替换字面量 \
 为真正的换行符pem_key = raw_key.replace('\\\
', '\
')private_key = RSA.import_key(pem_key)print(f\"RSA Key Size: {private_key.size_in_bits()} bits\")# 输出: RSA Key Size: 1024 bits

第二步：解密 packet3 得到 AES 密钥

from Crypto.Cipher import PKCS1_OAEP# 读取 packet3with open('packet3', 'r') as f:    hex_data = f.read().strip()encrypted_aes_key = bytes.fromhex(hex_data)# RSA-OAEP 解密cipher_rsa = PKCS1_OAEP.new(private_key)aes_key = cipher_rsa.decrypt(encrypted_aes_key)print(f\"AES Key (hex): {aes_key.hex()}\")print(f\"AES Key length: {len(aes_key)} bytes\")

输出：

AES Key (hex): f9134243d20e0a1f4ab78466015d5efeAES Key length: 16 bytes

解密成功得到了的AES密钥f9134243d20e0a1f4ab78466015d5efe。

第三步：解密 packet1 得到 Flag

from Crypto.Cipher import AESfrom Crypto.Util.Padding import unpad# 读取 packet1with open('packet1', 'r') as f:    hex_data = f.read().strip()encrypted_flag = bytes.fromhex(hex_data)# AES-ECB 解密cipher_aes = AES.new(aes_key, AES.MODE_ECB)decrypted = cipher_aes.decrypt(encrypted_flag)# 去除 PKCS7 填充flag = unpad(decrypted, AES.block_size)print(f\"Flag: {flag.decode()}\")

输出：

Flag: flag{28b0e93d-1b8c-40ff-9075-2049102f1e26}

二，CodeSign：

1.题目描述：

“A protected message is mixed with a long stream of seemingly random data. Determine what is truly random, recover the missing context, and decrypt the hidden flag. 一段受保護的訊息被混入大量看似隨機的資料之中。請判斷其中的規律，還原缺失的上下文並解開隱藏的 flag。”

附件：SecureGate.apk

2.解题过程：

2.1.第一步：反编译APK 定位解密逻辑

$ unzip SecureGate.apk -d apk_contents$ jadx -d decompiled SecureGate.apk

目标代码：com.icqctf.signcheck 包下两个核心文件。

2.2.第二步：分析 MainActivity — 发现XOR解密

// 29字节密文private static final byte[] SECRET_DATA = {    86, 10, 3, 1, 77, 124, 123, 97, 109, 37, 64, 90, 2, 89, 8, 5,    111, 115, 64, 66, 4, 16, 65, 62, 123, 8, 88, 81, 30};// 循环XOR解密private String decrypt(byte[] cipher, String keyStr) {    byte[] key = keyStr.getBytes();    byte[] plain = new byte[cipher.length];    for (int i = 0; i < cipher.length; i++) {        plain[i] = (byte)(cipher[i] ^ key[i % key.length]);    }    return new String(plain);}// 调用String result = decrypt(SECRET_DATA, SignUtils.getAppSignature(this));if (result.startsWith(\"flag{\")) { /* 解密成功 */ }

关键发现：

算法：循环XOR
密文：SECRET\_DATA（29字节）
密钥：SignUtils.getAppSignature(this) 的返回值

2.3.第三步：分析 SignUtils — 密钥生成机制

public static String getAppSignature(Context context) {    // 获取APK签名证书的原始DER字节    byte[] certBytes = context.getPackageManager()        .getPackageInfo(context.getPackageName(), 64)        .signatures[0].toByteArray();    return hex(certBytes);  // SHA1(DER) → 小写hex字符串}

解密公式为：

flag = SECRET_DATA ⊕ SHA1(X.509_CERT_DER_BYTES).hex()

也就是密钥 = APK签名证书的SHA1指纹（40字符小写hex字符串）。

第四步：提取APK签名证书

APK使用 APK Signature Scheme v2/v3，签名信息不在 META-INF/CERT.RSA，嵌入在了 APK Signing Block 中。所以像下面这样传统的提取办法会失效。

$ keytool -printcert -jarfile SecureGate.apkNot a signed jar file

它的Signing Block数据结构为：

[8 bytes]  block_size[16 bytes] magic: \"APK Sig Block 42\"[可变]     ID-value 对序列             [4B ID]  [4B 长度]  [值]             0x7109871a = v2 Block              0xf05368c0 = v3 Block             0x42726577 = v3.1 Block[8 bytes]  block_size (重复)[16 bytes] magic: \"APK Sig Block 42\" (重复)

知道这些过后直接编写py脚本提取证书就行：

import struct, hashlibwith open(\"SecureGate.apk\", \"rb\") as f:    data = f.read()# 定位Signing Blockmagic = b'APK Sig Block 42'pos = data.find(magic)block_size = struct.unpack('<Q', data[pos-8:pos])[0]block_start = pos - 8 - block_size# 遍历ID-value对offset = block_start + 24while offset < block_start + 24 + block_size:    pair_id = struct.unpack('<I', data[offset:offset+4])[0]    pair_len = struct.unpack('<I', data[offset+4:offset+8])[0]    if pair_id == 0x7109871a:  # v2签名块        v2 = data[offset+8:offset+8+pair_len]        # 提取X.509证书（ASN.1 SEQUENCE标记 0x30 0x82）        idx = 0        while idx < len(v2) - 4:            if v2[idx:idx+2] == b'0\\x82':                cert_len = struct.unpack('>H', v2[idx+2:idx+4])[0]                if 200 < cert_len < 3000:                    cert_der = v2[idx:idx+4+cert_len]                    sha1 = hashlib.sha1(cert_der).hexdigest()                    print(f\"证书 @{idx}, DER长度:{4+cert_len}, SHA1:{sha1}\")                    idx += 4 + cert_len                    continue            idx += 1    offset += 8 + pair_len

输出结果：

ICQCTF CA根证书

0fbf65802a94649f01920c2a0966c2934e817f73

签名子证书

10da7c0bcabc2ac73130adea122a7bba7f2f2740

2.4.最后一步获取flag：XOR解密

SECRET_DATA = [86,10,3,1,77,124,123,97,109,37,64,90,2,89,8,5,               111,115,64,66,4,16,65,62,123,8,88,81,30]sha1_root = \"0fbf65802a94649f01920c2a0966c2934e817f73\"key = sha1_root.encode()flag = bytes([SECRET_DATA[i] ^ key[i % 40] for i in range(29)])print(flag.decode())

完整解密脚本：

import structimport hashlibwith open(\"SecureGate.apk\", \"rb\") as f:    data = f.read()magic = b'APK Sig Block 42'pos = data.find(magic)block_size = struct.unpack('<Q', data[pos-8:pos])[0]block_start = pos - 8 - block_sizeoffset = block_start + 24while offset < block_start + 24 + block_size:    pair_id = struct.unpack('<I', data[offset:offset+4])[0]    pair_len = struct.unpack('<I', data[offset+4:offset+8])[0]    if pair_id == 0x7109871a:        v2 = data[offset+8:offset+8+pair_len]        idx = 0        while idx < len(v2) - 4:            if v2[idx:idx+2] == b'0\\x82':                cert_len = struct.unpack('>H', v2[idx+2:idx+4])[0]                if 200 < cert_len < 3000:                    cert_der = v2[idx:idx+4+cert_len]                    sha1 = hashlib.sha1(cert_der).hexdigest()                    SECRET = [86,10,3,1,77,124,123,97,109,37,64,90,2,89,8,5,                              111,115,64,66,4,16,65,62,123,8,88,81,30]                    key = sha1.encode()                    flag = bytes([SECRET[i] ^ key[i%40] for i in range(29)])                    if flag.startswith(b'flag{'):                        print(f\"FLAG: {flag.decode()}\")                    idx += 4 + cert_len                    continue            idx += 1    offset += 8 + pair_len

成功获取flag：

flag{ICQ_Dyn4m1c_Byp4ss_K1ng}

三，Drive：

1.题目描述：

“The company's driver program seems to have a bug, and the connected program cannot connect. To reconnect to the driver, you need to re-enter the key. Please fix the program and connect to the driver as soon as possible! (Missing symbol md5=f2c6151d6c0d99f36666129b97e2100f5) 公司的驅動程序好像出bug了，連接的程序也連接不上，重新連接驅動還需要重新輸入密鑰，請儘快修復程序連接驅動！（缺失的符號md5=f2c6151d6c0d99f3666129b97e2100f5）。”

题目附件是一个zip包，里面有两个文件：

Driver.sys —— 驱动程序
link.exe —— 连接程序

根据题目描述其实这道题目就已经比较明确了：修复驱动程序，找到正确的密钥，获取flag。

2.解题过程：

2.1.第一步：文件初步分析

解压与识别

$ unzip driver_xxx.zip -d driver_analysis/$ cd driver_analysis/$ file *Driver.sys: datalink.exe:   PE32+ executable for MS Windows 6.00 (console), x86-64, 11 sections

link.exe是标准的PE32+ x86-64控制台程序，但 Driver.sys被识别为普通data正常的 .sys驱动应该是PE格式才对，这说明驱动文件被混淆了。

查看link.exe的导入表

先看看link.exe导入了哪些关键函数：

KERNEL32.dll:  CreateFileA       - 打开设备  CloseHandle       - 关闭句柄  DeviceIoControl   - 与驱动通信  CreateFileW       - 打开设备(Unicode)

关键字符串：

\\\\.\\Device?????     - 设备路径（名称被隐藏）flag:               - 输出flaginput               - 提示输入

可以确定的是link.exe打开一个设备，向其发送IOCTL请求，验证密钥后输出flag。

2.2.第二步：破解Driver.sys的混淆

用十六进制查看Driver.sys的头部

00000000: 09 5a 90 00 47 00 00 00 40 00 00 00 bb ff 00 00

正常的MZ头部应该是 4D 5A 90 00（\"MZ\"标记）。这里第一个字节是 0x09 而不是 0x4D。尝试XOR分析： 0x09 ^ 0x4D = 0x44 再检查DOS stub区域（标准DOS消息区域）：

原始: \"!This program cannot be run in DOS mode.\"文件:  \"!Th-s p6ogr%m c%nno0 bedrundin \"

逐字节对比XOR值，发现了一个有趣的规律：

 偏移  原始值   文件值  XOR值  0x00  0x4D (M)  0x09   0x44 0x04  0x03      0x47   0x44  0x08  0x04      0x40  0x44 0x0C  0xFF      0xBB  0x44

每4字节中的第1个字节（offset % 4 == 0）被 XOR 0x44

编写解码脚本：

with open('Driver.sys', 'rb') as f:    data = bytearray(f.read())# 修复混淆：每4字节的第1个字节 XOR 0x44for i in range(0, len(data), 4):    data[i] ^= 0x44with open('Driver_decoded.sys', 'wb') as f:    f.write(data)

验证解码结果

解码后文件头部：

00000000: 4d 5a 90 00 03 00 00 00 04 00 00 00 ff ff 00 00

MZ 标记出现！这是有效的PE文件头。再用PE解析工具查看：

Machine:     0x8664 (x86-64)Sections:    6Subsystem:   Native (Windows驱动)EntryPoint:  0x5000 (INIT节区)

 节区    VA      原始偏移  大小  .text   0x1000  0x400    0xA00  .rdata  0x2000  0xE00    0x600  .data   0x3000  0x1400   0x200  INIT    0x5000  0x1800   0x200

驱动修复成功

2.3.第三步：反汇编分析驱动逻辑

使用 objdump 反汇编解码后的驱动，找到了以下关键函数：

0x400  密钥校验函数（核心） 0x510  设备创建分发例程 (IRP_MJ_CREATE) 0x560  设备关闭分发例程 (IRP_MJ_CLOSE) 0x5B0  设备控制分发例程 (IRP_MJ_DEVICE_CONTROL) 0x1800  DriverEntry（驱动入口）

在 0x5B0 的设备控制函数中，识别出两个IOCTL代码：

cmp [rsp+0x28], 0x222000   ; 密钥验证je  0x649cmp [rsp+0x28], 0x222400   ; 写操作je  0x791

IOCTL 0x222000（密钥验证）的完整流程：

拷贝输入：从用户缓冲区拷贝最多32字节到栈上
Scramble混淆：从i=1到31，对缓冲区进行变换
调用校验函数：调用地址0x400的函数验证结果
返回结果：成功返回\"flag is you input\"，失败返回\"wrong\"

关键引用字符串：

0xB70: \"flag is you input\\0\"（成功时的输出）
0xBA0: \"wrong\\0\"（失败时的输出）

在从从驱动中提取的Unicode字符串：

\\??\\DeviceDrive      （符号链接名）\\Device\\MYDEVICE     （设备名）

2.4.第四步：核心算法逆向

密钥验证由三层变换组成：第1层：Scramble混淆、第2层: 反馈XOR Pass 1、第3层: 反馈XOR Pass 2

第1层：Scramble混淆

这是IOCTL处理函数中的混淆循环（地址0x6A7-0x716）：

; 循环 i = 1 到 316B1: mov eax, [rsp+0x20]      ; i6B5: inc eax                   ; i++6C2: mov eax, [rsp+0x20]      ; i6C6: dec eax                   ; i-16D8: movzx ecx, byte [rsp+rcx+0x60]  ; ecx = buffer[i-1]6DD: xor edx, edx6DF: mov eax, ecx              ; eax = buffer[i-1]6E1: mov ecx, 0x12             ; ecx = 186E6: div ecx                   ; edx = buffer[i-1] % 186E8: mov eax, edx              ; eax = buffer[i-1] % 186EF: movzx ecx, byte [rsp+rcx+0x60]  ; ecx = buffer[i]6F4: lea eax, [rax+rcx+0x5]   ; eax = (buffer[i-1]%18) + buffer[i] + 56F8: xor eax, 0x34             ; eax ^= 0x34700: movzx ecx, byte [rsp+rcx+0x60]  ; ecx = buffer[i-1]705: xor ecx, eax              ; ecx = buffer[i-1] ^ key712: mov [rsp+rcx+0x60], al    ; buffer[i-1] = result

用Python表示：

def scramble(buffer):    n = 32    buf = list(buffer)    for i in range(1, n):        prev = buf[i-1]        key = ((prev % 18) + buf[i] + 5) ^ 0x34        buf[i-1] = prev ^ key    return buf

关键观察每个位置 i-1 只被修改一次，修改时使用的 buf[i-1] 是原始值（因为该位置之前未被修改过），而 buf[i] 也是原始值。最后一个字节 buf[31] 不变。

第2层：反馈XOR Pass 1（函数0x400）

425: mov byte [rsp+0x20], 0x34   ; key = 0x3442A: mov dword [rsp+0x28], 0     ; i = 0; 循环体448: movsxd rax, [rsp+0x28]      ; rax = i452: movzx eax, byte [rcx+rax]   ; eax = buffer[i]45F: movzx ecx, byte [rsp+0x20]  ; ecx = key464: xor eax, ecx                 ; eax = buffer[i] ^ key470: mov [rdx+rcx], al            ; temp[i] = buffer[i] ^ key478: mov [rsp+0x20], al           ; key = buffer[i] (反馈!)

Python表示：

def pass1(buffer):    n = 32    key = 0x34    temp = [0] * n    for i in range(n):        temp[i] = buffer[i] ^ key        key = buffer[i]          return temp

第3层：反馈XOR Pass 2（函数0x400后半段）

def pass2(temp, buffer):    n = 32    key = buffer[n-1]      result = [0] * n    for j in range(n):        cur = temp[j]        result[j] = cur ^ key        key = cur            return result

2.5.第五步：逆向计算正确密钥

找到硬编码比较数据指令 lea rdx, [rip+0x1F16] 中的目标地址是 VA 0x3000，对应 .data 节区的原始偏移 0x1400：

比较数据(32字节):66 0a 09 e0 e2 e3 cb 09 14 15 0c 38 01 1f 05 4271 6e 56 7a 00 20 e4 bf e6 cd 28 30 2c 75 a0 3a

逆向Pass 2和Pass 1 从比较数据 B[k] 逆向推导 S[k]：

S[1]  = B[1] ^ 0x34                    (奇数链起点)S[3]  = B[3] ^ S[1]S[5]  = B[5] ^ S[3]...                                     (递推奇数位置)S[31] = B[31] ^ S[29]S[0]  = B[0] ^ 0x34 ^ S[31]           (偶数链起点)S[2]  = B[2] ^ S[0]S[4]  = B[4] ^ S[2]...                                     (递推偶数位置)

Python代码：

def reverse_pass2_pass1(B):    n = len(B)    S = [0] * n    # 奇数链    S[1] = B[1] ^ 0x34    for k in range(3, n, 2):        S[k] = B[k] ^ S[k-2]    # 偶数链（需要先知道S[31]）    S[31] = B[31] ^ S[29]    S[0] = B[0] ^ 0x34 ^ S[31]    for k in range(2, n, 2):        S[k] = B[k] ^ S[k-2]    return S

逆向Scramble层（含DFS回溯）这是最棘手的部分。Scramble层的方程是：

S[k] = U[k] ^ (((U[k] % 18) + U[k+1] + 5) ^ 0x34)

我们需要从 S[k] 和已知的 U[k+1] 求出 U[k]。因为 U[k] % 18 只有18种可能，我们可以逐个尝试：

def find_candidates(S_k, next_val):    \"\"\"找到所有满足条件的U[k]\"\"\"    candidates = []    for c in range(256):        key = ((c % 18) + next_val + 5) ^ 0x34        if c ^ key == S_k:            candidates.append(c)    return candidates

但问题是，每个位置可能有多个候选值有些候选会导致后续位置无解。因此需要使用深度优先搜索和回溯来找到正确的路径：

def dfs(k, U):    \"\"\"从k位置向前回溯\"\"\"    if k < 0:        return True  # 找到完整解    next_val = U[k+1] if k < 31 else 0    candidates = find_candidates(S[k], next_val)    for c in candidates:        U[k] = c        if dfs(k-1, U):            return True    U[k] = 0  # 回溯    return FalseU = [0] * 32U[31] = S[31]  # 最后一位已知dfs(30, U)     # 从倒数第二位开始回溯

验证结果

用户输入U[]: 62 6c 61 67 7b 77 6e 4e 43 5a 4a 62 42 4f 71 4c             33 51 41 31 43 31 63 79 70 69 4b 59 49 49 34 7dASCII:       b l a g  {  w  n  N  C  Z  J  b  B  O  q  L              3  Q  A  1  C  1  c  y  p  i  K  Y  I  I  4  }

完整正向验证通过，但过程中可能有问题，最后flag为“flag”不是“blag”但是问题不大。