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。

with open('Driver.sys', 'rb') as f:
    raw = bytearray(f.read())
repaired = bytearray(raw)
for i in range(0, len(repaired), 4):
    repaired[i] ^= 0x44
with open('Driver_repaired.sys', 'wb') as f:
    f.write(repaired)

按这个规律恢复后,Driver.sys 重新变成正常 PE 驱动,并能看到关键字符串:

\??\DeviceDrive
\Device\MYDEVICE
flag is you input
wrong

真正缺失的符号是 Drive,并且 Drive的md5刚好是f2c6151d6c0d99f3666129b97e2100f5

再把exe修改好

然后回到Driver.sys,看看哪里引用了flag is you input

for ( i = 0; i < v5; ++i )
*((_BYTE *)buf + (int)i) = Format[i];
for ( n32 = 1; n32 < 32; ++n32 )
*((_BYTE *)buf + n32 - 1) ^= (unsigned __int8)(*((_BYTE *)buf + n32 - 1) % 0x12u + *((_BYTE *)buf + n32) + 5) ^ 0x34;
if ( (unsigned int)sub_140001000(buf, 32) )
    {
      strcpy(Format, "flag is you input");
      Irp_1->IoStatus.Information = 18;
      DbgPrint(&Format__2);
    }

跟踪sub_140001000

__int64 __fastcall sub_140001000(__int64 buf, __int64 n32)
{
  char n52; // [rsp+20h] [rbp-28h]
  char n52_1; // [rsp+21h] [rbp-27h]
  char n52_2; // [rsp+22h] [rbp-26h]
  int n32_3; // [rsp+24h] [rbp-24h]
  int n32_2; // [rsp+28h] [rbp-20h]
  _BYTE *PoolWithTag; // [rsp+30h] [rbp-18h]
  int n32_1; // [rsp+58h] [rbp+10h]

  n32_1 = n32;
  PoolWithTag = ExAllocatePoolWithTag(NonPagedPool, 0x100u, 0x504F4F4Cu);
  n52 = 52;
  for ( n32_2 = 0; n32_2 < n32_1; ++n32_2 )
  { //每一个字节都是和上一个原始字节进行异或
    n52_1 = *(_BYTE *)(buf + n32_2);
    PoolWithTag[n32_2] = n52 ^ n52_1;
    n52 = n52_1;
  }
  for ( n32_3 = 0; n32_3 < n32_1; ++n32_3 )
  {
    n52_2 = PoolWithTag[n32_3];
    PoolWithTag[n32_3] = n52 ^ n52_2;
    n52 = n52_2;
    if ( (unsigned __int8)PoolWithTag[n32_3] != byte_140003000[n32_3] )
      return 0;
  }
  return 1;
}

两次链式异或,结果与byte_140003000[n32_3]比较

去找byte_140003000[n32_3]

shift+E

0x66,0xA,0x9,0xE0,0xE2,0xE3,0xCB,0x9,0x14,0x15,0xC,0x38,0x1,0x1F,0x5,0x42,0x71,0x6E,0x56,0x7A,0x0,0x20,0xE4,0xBF,0xE6,0xCD,0x28,0x30,0x2C,0x75,0xA0,0x3A

重新梳理下逻辑

第一轮:从前往后,每个字节跟前一个字节(或初始值 0x34)XOR
tmp[0] = in[0] ^ 0x34        ← 第0个字节用初始值 0x34
tmp[1] = in[1] ^ in[0]       ← 第1个字节用 in[0]
tmp[2] = in[2] ^ in[1]       ← 第2个字节用 in[1]
tmp[3] = in[3] ^ in[2]
...
tmp[31] = in[31] ^ in[30]

第二轮:从前往后,每个字节跟前一个字节(或 in31)XOR
out[0] = tmp[0] ^ in[31]     ← 第0个字节用 in[31]
out[1] = tmp[1] ^ tmp[0]     ← 第1个字节用 tmp[0]
out[2] = tmp[2] ^ tmp[1]     ← 第2个字节用 tmp[1]
out[3] = tmp[3] ^ tmp[2]
...
out[31] = tmp[31] ^ tmp[30]

我们把第一轮的公式代入第二轮去

out[0] = (in[0] ^ 0x34) ^ in[31]
out[1] = (in[1] ^ in[0]) ^ (in[0] ^ 0x34)

看 out1:in[0] 出现了两次,XOR 抵消了!
out[1] = in[1] ^ 0x34

继续:
out[2] = (in[2] ^ in[1]) ^ (in[1] ^ in[0])
       = in[2] ^ in[0]                              ← in[1] 抵消了
out[3] = (in[3] ^ in[2]) ^ (in[2] ^ in[1])
       = in[3] ^ in[1]                              ← in[2] 抵消了
out[4] = (in[4] ^ in[3]) ^ (in[3] ^ in[2])
       = in[4] ^ in[2]                              ← in[3] 抵消了
最后:
out[31] = (in[31] ^ in[30]) ^ (in[30] ^ in[29])
        = in[31] ^ in[29]                           ← in[30] 抵消了
        
合并后的完整公式:
out[0] = in[0] ^ 0x34 ^ in[31]
out[1] = in[1] ^ 0x34
out[2] = in[2] ^ in[0]
out[3] = in[3] ^ in[1]
out[4] = in[4] ^ in[2]
out[5] = in[5] ^ in[3]
...
out[31] = in[31] ^ in[29]

out已知,可以推出in

尝试借助刚学的z3

from z3 import *
s = Solver()
out=[0x66, 0xA, 0x9, 0xE0, 0xE2, 0xE3, 0xCB, 0x9, 0x14, 0x15, 0xC, 0x38, 0x1, 0x1F, 0x5, 0x42, 0x71, 0x6E, 0x56, 0x7A, 0x0, 0x20, 0xE4, 0xBF, 0xE6, 0xCD, 0x28, 0x30, 0x2C, 0x75, 0xA0, 0x3A] 
inn=[BitVec(f'x_{i}', 8) for i in range(32)]
s.add(
    out[0] == inn[0] ^ 0x34 ^ inn[31],
    out[1] == inn[1] ^ 0x34,
)
for i in range(2, 32):
    s.add(out[i] == inn[i] ^ inn[i-2])
assert s.check() == sat
m = s.model()
flag = bytes([m.eval(inn[i]).as_long() for i in range(32)])
print(list(flag))

输出

[47, 62, 38, 222, 196, 61, 15, 52, 27, 33, 23, 25, 22, 6, 19, 68, 98, 42, 52, 80, 52, 112, 208, 207, 54, 2, 30, 50, 50, 71, 146, 125]

别忘了在sub_140001000的两次异或前还有一次处理

简化一下代码

buf[n32-1] ^= (buf[n32-1] % 18 + buf[n32] + 5) ^ 0x34;

自己除以18,加5,加下一位,与0x34异或,再与自己异或,赋值给自己

from z3 import *
s = Solver()
buf_new=[47, 62, 38, 222, 196, 61, 15, 52, 27, 33, 23, 25, 22, 6, 19, 68, 98, 42, 52, 80, 52, 112, 208, 207, 54, 2, 30, 50, 50, 71, 146, 125]
buf_old=[BitVec(f'x_{i}', 8) for i in range(32)]
for n32 in range(1,32):
    s.add(
    buf_new[n32-1] == (buf_old[n32-1] % 18 + buf_old[n32] + 5) ^ 0x34 ^ buf_old[n32-1]
)
assert s.check() == sat
m = s.model()
flag = bytes([m.eval(buf_old[i]).as_long() for i in range(32)])
print(flag.hex())

但是发现这个输出很奇怪,转换成字符是乱码

我们加一段代码看是不是有多解

s.add(Or([buf_old[i] != m[buf_old[i]] for i in range(32)]))
if s.check() == sat:
    print("many")
    m2 = s.model()
else:
    print("only one")

输出many说明有多解,我们再加一些关于输出格式为flag的限制

限制第一个字符为f(0x66)

最终脚本

from z3 import *
s = Solver()
buf_new=[47, 62, 38, 222, 196, 61, 15, 52, 27, 33, 23, 25, 22, 6, 19, 68, 98, 42, 52, 80, 52, 112, 208, 207, 54, 2, 30, 50, 50, 71, 146, 125]
buf_old=[BitVec(f'x_{i}', 8) for i in range(32)]
for n32 in range(1,32):
    s.add(
    buf_new[n32-1] == (buf_old[n32-1] % 18 + buf_old[n32] + 5) ^ 0x34 ^ buf_old[n32-1],
    buf_old[0]==0x66
)
assert s.check() == sat
m = s.model()
flag = bytes([m.eval(buf_old[i]).as_long() for i in range(32)])
print(flag)
s.add(Or([buf_old[i] != m[buf_old[i]] for i in range(32)]))
if s.check() == sat:
    print("many")
    m2 = s.model()
else:
    print("only one")
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) #发送加密后的aes密钥
        encrypted_data = s.recv(1024) #接收最多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) #接收最多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)) #用aes加密
            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)