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)