AI×Cybersecurity Challenge线上初赛re wp
AI×Cybersecurity Challenge人工智能网络安全挑战赛re wp
re
CodeSign
一个移动保险库显示访问已被允许,但秘密仍然没有出现在眼前。请理解应用如何决定展示内容,并还原隐藏结果。
apk安卓逆向
跳到主activity
public class MainActivity extends AppCompatActivity {
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};
@Override // androidx.fragment.app.FragmentActivity, androidx.activity.ComponentActivity, androidx.core.app.ComponentActivity, android.app.Activity
protected void onCreate(Bundle bundle) {
super.onCreate(bundle);
setContentView(R.layout.activity_main);
final TextView textView = (TextView) findViewById(R.id.tv_console);
final TextView textView2 = (TextView) findViewById(R.id.tv_flag);
((Button) findViewById(R.id.btn_unlock)).setOnClickListener(new View.OnClickListener() { // from class: com.icqctf.signcheck.MainActivity$$ExternalSyntheticLambda0
@Override // android.view.View.OnClickListener
public final void onClick(View view) {
this.f$0.m125lambda$onCreate$0$comicqctfsigncheckMainActivity(textView2, textView, view);
}
});
}
/* renamed from: lambda$onCreate$0$com-icqctf-signcheck-MainActivity, reason: not valid java name */
/* synthetic */ void m125lambda$onCreate$0$comicqctfsigncheckMainActivity(TextView textView, TextView textView2, View view) {
String strDecrypt = decrypt(SECRET_DATA, SignUtils.getAppSignature(this));
textView.setText(strDecrypt);
if (strDecrypt.startsWith("flag{")) {
textView2.setText("> ACCESS GRANTED.\n> DATA RENDERED TO BUFFER.\n> UI OUTPUT: DISABLED (Security Mode)");
textView2.setTextColor(-16711936);
} else {
textView2.setText("> SIGNATURE MISMATCH.\n> DECRYPTION FAILED.\n> OUTPUT GARBAGE.");
textView2.setTextColor(SupportMenu.CATEGORY_MASK);
}
}
private String decrypt(byte[] bArr, String str) {
if (str == null || str.length() == 0) {
return "";
}
byte[] bytes = str.getBytes();
byte[] bArr2 = new byte[bArr.length];
for (int i = 0; i < bArr.length; i++) {
bArr2[i] = (byte) (bArr[i] ^ bytes[i % bytes.length]);
}
return new String(bArr2);
}
}直接找关键逻辑
if (strDecrypt.startsWith("flag{")) {
textView2.setText("> ACCESS GRANTED.\n> DATA RENDERED TO BUFFER.\n> UI OUTPUT: DISABLED (Security Mode)");要String strDecrypt以flag{开头
再去看String strDecrypt的逻辑
String strDecrypt = decrypt(SECRET_DATA, SignUtils.getAppSignature(this));
private String decrypt(byte[] bArr, String str) {
if (str == null || str.length() == 0) {
return "";
}
byte[] bytes = str.getBytes();
byte[] bArr2 = new byte[bArr.length];
for (int i = 0; i < bArr.length; i++) {
bArr2[i] = (byte) (bArr[i] ^ bytes[i % bytes.length]);
}
return new String(bArr2);
}逻辑不复杂,把SECRET_DATA和SignUtils.getAppSignature进行异或
继续跳转去看getAppSignature
public static String getAppSignature(Context context) {
try {
return hex(context.getPackageManager().getPackageInfo(context.getPackageName(), 64).signatures[0].toByteArray());
} catch (Exception unused) {
return "";
}
}跳到hex函数
private static String hex(byte[] bArr) throws NoSuchAlgorithmException {
try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA1"); //声明sha1算法
messageDigest.update(bArr); //传入参数bArr
byte[] bArrDigest = messageDigest.digest(); //计算出结果
StringBuilder sb = new StringBuilder();
for (byte b : bArrDigest) {
String hexString = Integer.toHexString(b & UByte.MAX_VALUE);
//UByte.MAX_VALUE即无符号字节的最大值,也就是255,按位与255转换为无符号整数
while (hexString.length() < 2) {
hexString = "0" + hexString;
}
sb.append(hexString);
}
return sb.toString().toLowerCase();
} catch (Exception unused) {
return "";
}
}问题是如何找到hex函数的参数
context.getPackageManager()
.getPackageInfo(context.getPackageName(), 64)
.signatures[0]
.toByteArray()64 是 PackageManager.GET_SIGNATURES 这个常量的值,就是请求签名的指令码
然后signatures[0]取到签名,再.toByteArray()转换成字节
在jadx中拿到签名sha1
0F BF 65 80 2A 94 64 9F 01 92 0C 2A 09 66 C2 93 4E 81 7F 73 写个脚本跑出来
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 = "0fbf65802a94649f01920c2a0966c2934e817f73"
flag = ''.join(
chr(b ^ ord(key[i % len(key)]))
for i, b in enumerate(secret)
)
print(flag)drive
公司的驱动程序好像出bug了,连接的程序也连接不上,重新连接驱动还需要重新输入密钥,请尽快修复程序连接驱动!(缺失的符号md5=f2c6151d6c0d99f3666129b97e2100f5)。
核心文件只有两个:link.exe 和 Driver.sys
一个程序一个驱动
先看exe的string
\\.\Device?????
flag可能是在device这里破坏了
sys文件本质是PE文件,同样具有MZ开头,但是我们查看发现
原本的 4D 5A变成了09 5A
改回去之后发现下面还有异常内容
J...D......L.!Th
-s p6ogr%m c%nno
0 bedrundin .OS This转16进制是
54 68 69 73而这里是
54 68 2D 73经gpt观察后发现,每 4 字节的第 1 个字节都像是被异或了 0x44。按这个规律恢复后,Driver.sys 重新变成正常 PE 驱动,并能看到关键字符串:
\??\DeviceDrive
\Device\MYDEVICE
flag is you input
wrong真正缺失的符号是 Drive,并且 Drive的md5刚好是f2c6151d6c0d99f3666129b97e2100f5
再把exe修改好
下面是gpt独秀
修复驱动后,继续分析驱动逻辑。DriverEntry 中创建了内核设备和符号链接:
DeviceName: \Device\MYDEVICE
SymbolicLink: \??\DeviceDrive同时注册了几个派发函数,其中 IRP_MJ_DEVICE_CONTROL 指向主要处理函数。用户态 link.exe 发送的控制码是:
0x222000进入驱动的 DeviceControl 分支后,可以看到它会读取用户输入的 32 字节缓冲区,然后做第一层原地变换:
for (i = 1; i < 32; i++) {
buf[i - 1] ^= ((buf[i - 1] % 0x12) + buf[i] + 5) ^ 0x34;
}这里有一个关键观察:每一轮修改的是 buf[i - 1],但会用到还没被修改的 buf[i]。这说明如果要逆推原输入,应当从末尾往前推,而不是从开头往后推。
第一层变换后,驱动把结果传入另一个校验函数。这个函数分两轮处理输入。第一轮使用初始值 0x34 做链式异或:
prev = 0x34;
for (i = 0; i < len; i++) {
tmp[i] = input[i] ^ prev;
prev = input[i];
}第二轮继续链式异或,并把结果与 .data 段中的 32 字节常量比较:
for (i = 0; i < len; i++) {
old = tmp[i];
tmp[i] ^= prev;
prev = old;
}目标常量是:
66 0a 09 e0 e2 e3 cb 09 14 15 0c 38 01 1f 05 42
71 6e 56 7a 00 20 e4 bf e6 cd 28 30 2c 75 a0 3a如果比较成功,驱动不会返回真正的新字符串,而是返回:
flag is you input这句话很关键。它说明 flag 不是驱动输出内容,而是用户输入本身。也就是说,攻击目标变成了:构造一个 32 字节输入,使它经过两层变换后等于 .data 段常量。
先逆第二层校验。由于第二层是链式异或,异或本身可逆,所以可以从目标常量倒推出第一层变换后的中间值。逆推得到的 32 字节中间态是:
2f 3e 26 de c4 3d 0f 34 1b 21 17 19 16 06 13 44
62 2a 34 50 34 70 d0 cf 36 02 1e 32 32 47 92 7d接下来逆第一层变换。第一层有这个结构:
buf[i - 1] = original[i - 1] ^ f(original[i - 1], original[i])因为它依赖右侧相邻字节,所以从最后一个字节开始向前回溯最自然。末尾 buf[31] 没被第一层循环修改,因此可以直接确定原始输入最后一字节。然后逐位向前枚举 original[i - 1],要求它变换后等于已知中间态。
回溯后得到多个数学上可行的候选,但大多数包含不可打印字符或不符合 flag 格式。唯一符合常见 CTF flag 形态、且完整可打印的是:
flag{wnNCZJbBOqL3QA1C1cypiKYII4}为了避免只靠格式猜测,还需要做正向验证。把这个候选作为原始输入,先执行驱动第一层变换,得到:
2f3e26dec43d0f341b21171916061344622a34503470d0cf36021e323247927d再执行第二层校验变换,得到:
660a09e0e2e3cb0914150c38011f0542716e567a0020e4bfe6cd28302c75a03a它与 .data 段目标常量完全一致,因此该输入一定会命中成功分支。
最终驱动成功分支提示 flag is you input,说明正确输入就是 flag。经过逆向两层变换并正向验证,最终 flag 为:
flag{wnNCZJbBOqL3QA1C1cypiKYII4}SimpleSocket
一个轻量级客户端与服务端程序通过自定义通信流程保护返回信息。请逆向分析交换逻辑,还原最终内容。
题目目录中有四个文件:py、packet1、packet2、packet3。
先看py
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
from Crypto.Util.Padding import pad, unpad
import os
import socket
import time
def generate_rsa_keys():
key = RSA.generate(1024) #生成一对RSA密钥(1024位)
private_key = key.export_key() #调用.export_key(),把key转换为文本格式
public_key = key.publickey().export_key() #只取出公钥部分
return private_key, public_key
def client_logic(public_key):
current_time = int(time.time())
aes_key = os.urandom(16) #生成16个字节(128位)的完全随机的数据,作为AES加密的密钥
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)
encrypted_flag = cipher_aes.encrypt(pad(flag, AES.block_size))
conn.sendall(encrypted_flag)
private_key, public_key = generate_rsa_keys()
import threading
server_thread = threading.Thread(target=server_logic, args=(private_key,))
server_thread.start()
client_logic(public_key)整体逻辑是用RSA加密AES密钥,再用AES加密数据
packet2: PEM 格式 RSA PRIVATE KEY,但换行被写成了字面量 \n
packet3: 256 个十六进制字符,即 128 字节
packet1: 96 个十六进制字符,即 48 字节packet3 的 128 字节长度正好对应 1024-bit RSA 密文;packet1 的 48 字节长度是 16 的倍数,符合 AES 分组密文特征;packet2 则是泄露的 RSA 私钥。
packet3 --RSA私钥解密--> AES key
AES key + packet1 --AES-ECB解密--> flag注意packet1 和 packet3 都是十六进制文本,不是原始二进制,所以使用前要先 bytes.fromhex()。
packet2 里的私钥不是标准 PEM 换行,而是包含字面量 \n,所以导入 RSA 私钥前要替换成真实换行:
private_key = packet2_text.replace("\\n", "\n").encode()脚本
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
from Crypto.Util.Padding import unpad
private_key = open("packet2").read().replace("\\n", "\n").encode()
rsa_key = RSA.import_key(private_key)
encrypted_aes_key = bytes.fromhex(open("packet3").read().strip())
aes_key = PKCS1_OAEP.new(rsa_key).decrypt(encrypted_aes_key)
encrypted_flag = bytes.fromhex(open("packet1").read().strip())
flag = unpad(AES.new(aes_key, AES.MODE_ECB).decrypt(encrypted_flag), 16)
print(flag)