文章总结： 本文为香港人工智能网络安全挑战赛初赛逆向题目的全解Writeup。作者详细解析了两道题目：第一题SimpleSocket通过分析Python源码与网络数据包，识别出RSA与AES混合加密流程，并发现数据包顺序错位，最终提取RSA私钥解密还原出flag；第二题CodeSign针对AndroidAPK进行逆向，发现其利用APK签名证书SHA1指纹作为XOR密钥，通过解析APK签名块结构提取v2签名证书并计算哈希，成功解密出flag。文章逻辑清晰，对密码学与移动端逆向有较高参考价值。 综合评分： 88 文章分类： 逆向分析,CTF,移动安全
香港人工智能网络安全挑战赛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-----\nMIICXAIBAAKBgQC5hMOyHMbH2no95Br5xHuurgcxzAcK2fULAPQGLkSz5St8Te2L\nG8jUnxjnbOUF1a/72s3rOkZH8IbtUsTvtrcg/WUlyMWSjpiqhbpPNxGXbDQs2KyP\n...-----END RSA PRIVATE KEY-----
这里的 \n 是字面量字符（反斜杠 + 字母 n），而不是真正的换行符。用 Python 查看确认：
>>> with open('packet2', 'r') as f:... data = f.read()>>> data[:100]'-----BEGIN RSA PRIVATE KEY-----\\nMIICXAIBAAKBgQC5hMOyHMbH2no95Br5xHuurgcxzAcK2fULAPQGLkSz5St8Te2L\\nG'
一共 14 处 \n，需要替换为真正的换行符才能得到标准 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()# 替换字面量 \n 为真正的换行符pem_key = raw_key.replace('\\n', '\n')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”但是问题不大。
flag{wnNCZJbBOqL3QA1C1cypiKYII4}
，这是
CyberSecurity
免责声明：
本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。
任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。
本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。
本文转载自：flower安全 Flowers aq Flowers aq《香港人工智能网络安全挑战赛Writeup（初赛）-Reverse全解》
版权声明
本站仅做备份收录，仅供研究与教学参考之用。
读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。
评论