[原创]某某car sd参数分析-Android安全-看雪安全社区

### 某汽车sd参数分析（白盒AES）

#### 总述

- 现在网上有很多关于该参数的分析，但大多都过于简略，而且对于这个版本的sd参数来说，大多数帖子之前的部分分析已不再适用(`checkcode`生成部分)。今天闲来无事，打算写一篇帖子来记录一下自己此前分析的过程。由于该so文件采用了大量的混淆，所以分析难度还是有一点的。本人水平有限，写的可能不好，整个分析过程仅供参考。这也是本人在论坛的第一篇文章，希望效果不会太差。
- 抓包、脱壳、定位so层函数位置都比较简单，过程这里就省略了，仅仅给出so层函数名称以及参数
- so文件名称:`libencrypt.so`
- so层对应函数名称`Java_com_bangcle_comapiprotect_CheckCodeUtil_checkcode`
  - 参数1：`"mobile=1475&password=123456&client_id=2019041810222516127&client_secret=c5ad2a4290faa3df39683865c2e10310&state=CstGrOjmnN&response_type=token&ostype=ios&imei=00&mac=00:00:00:00:00:00&model=Pixel 6&sdk=33&serviceTime=1745556662765&mod=google&checkcode=4cc2dea18c5bbb14e089d181900d3991"`(String 一些登录信息)
  - 参数2：`1745556662765`(时间戳)

#### unidbg补环境

- 具体的补环境的过程这里就省略了，下面给出代码

```java
package com.wulinglogin1;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Emulator;
import com.github.unidbg.Module;
import com.github.unidbg.arm.backend.Unicorn2Factory;
import com.github.unidbg.debugger.BreakPointCallback;
import com.github.unidbg.debugger.Debugger;
import com.github.unidbg.file.FileResult;
import com.github.unidbg.file.IOResolver;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.file.ByteArrayFileIO;
import com.github.unidbg.memory.Memory;
import com.github.unidbg.memory.MemoryBlock;
import com.github.unidbg.pointer.UnidbgPointer;
import org.apache.commons.io.HexDump;
import unicorn.Arm64Const;
import unicorn.ArmConst;

import javax.xml.transform.Source;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class mwzzzh extends AbstractJni implements IOResolver {

private final AndroidEmulator emulator;
    //    private final DvmClass CryptoTool;
    private final VM vm;
    public final Module module;

public mwzzzh() throws IOException{   //进行初始化
        emulator = AndroidEmulatorBuilder
                .for64Bit()
                .addBackendFactory(new Unicorn2Factory(true))
                .setProcessName("com.cloudy.linglingbang")
                .build();
        Memory memory = emulator.getMemory();
        memory.setLibraryResolver(new AndroidResolver(23));
        vm = emulator.createDalvikVM(new File("D:\\xinjianwenjianjia\\anzhuonixiang\\unidbg\\unidbg\\unidbg-android\\src\\test\\java\\com\\wulinglogin\\8.2.4.apk")); //改成自己的apk路径
        vm.setJni(this);
        vm.setVerbose(true);
        emulator.getSyscallHandler().addIOResolver(this);
        DalvikModule dm2 = vm.loadLibrary("encrypt", true);
        module = dm2.getModule();
//        CryptoTool = vm.resolveClass("com.bangcle.CryptoTool");

dm2.callJNI_OnLoad(emulator);
}
public static void main(String[] args) throws Exception {
        mwzzzh test =new mwzzzh();
		test.call_checkcode();
}
public void call_checkcode(){
        List<Object> list = new ArrayList<>(5);
        list.add(vm.getJNIEnv()); // 第一个参数是env
        list.add(0); // 第二个参数，实例方法是jobject，静态方法是jclazz，可以填0，但最好是构造一下

list.add(vm.addLocalObject(new StringObject(vm, "mobile=1475&password=123456&client_id=2019041810222516127&client_secret=c5ad2a4290faa3df39683865c2e10310&state=CstGrOjmnN&response_type=token&ostype=ios&imei=00&mac=00:00:00:00:00:00&model=Pixel 6&sdk=33&serviceTime=1745556662765&mod=google")));
        list.add(2);
        list.add(vm.addLocalObject(new StringObject(vm, "1745556662765")));

Number retNum = module.callFunction(emulator, 0x25250, list.toArray());
        String ret = vm.getObject(retNum.intValue()).getValue().toString();
        System.out.println("结果->" + ret);
}
@Override
public FileResult resolve(Emulator emulator, String pathname, int oflags) {
        System.out.println("open path: "+pathname);
        return null;
}
@Override
public DvmObject<?> callStaticObjectMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        switch (signature){
            case "android/app/ActivityThread->currentActivityThread()Landroid/app/ActivityThread;":{
                // 创建一个假的 ActivityThread 实例返回
                return vm.resolveClass("android/app/ActivityThread").newObject(null);
            }

}
        return super.callStaticObjectMethod(vm, dvmClass, signature, varArg);
 }

@Override
public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        switch (signature) {
            case "android/app/ActivityThread->getSystemContext()Landroid/app/ContextImpl;":{
                return vm.resolveClass("android/app/ContextImpl").newObject(null);
            }
            case "android/app/ContextImpl->getPackageManager()Landroid/content/pm/PackageManager;":{
                return vm.resolveClass("android/content/pm/PackageManager").newObject(null);
            }

}
        return super.callObjectMethod(vm, dvmObject, signature, varArg);
}

@Override
public DvmObject<?> getStaticObjectField(BaseVM vm, DvmClass dvmClass, String signature) {
        switch (signature) {
            case "android/os/Build->MODEL:Ljava/lang/String;":{
                return new StringObject(vm, "Pixel 6");
            }
            case "android/os/Build->MANUFACTURER:Ljava/lang/String;":{
                return new StringObject(vm, "google");
            }
            case "android/os/Build$VERSION->SDK:Ljava/lang/String;":{
                return new StringObject(vm, "29");
            }
        }
        return super.getStaticObjectField(vm, dvmClass, signature);
}
```

![图片描述](upload/attach/202504/1034707_59F9WQTMVQJ5A6P.webp)

- 运行结果也是成功出值了，现在我们去trace一份日志，方便后续分析

![图片描述](upload/attach/202504/1034707_YQJ7268RGXEZKJG.webp)

#### so层分析

##### base64

```
JNIEnv->NewStringUTF("Mrh0zeSVubXq3dRfAYRfsCpaeTaMt3WWlTMcCqCJesCJkrzjf63idS/q+MLRC/eIzbfdAP1pjrnI6gAiyORoTUHM1VLCpYGCeXjI6sIMuUQCAIaVpAfVen5tvqy2nIB+UqbivsbOBPYzY/QpsZ6oooAQE5SKp9J/rt2aNzSW6wErEQP8ey4EpRNoYyQjNguKY8FEtcOIaI5hEq5u2gwpl9YlKE8Wey3/JipF4+69Ez7ik1DVmaozl4j3wpjtgLo7fJRN/oZFPfAh8BwL2woSL/1yR5RakfRHtBLg28lUMTSOMwnGk2dPBTC7tZVsKho+CHx5NfZyHjW8L9PcxHQXpRZXOHH3ygB5/Q/2xrpm2J3l6bnqJ1xwGzubiqmvcD38fkBa+t44sNZ1mInNYkX82POjMKRnRXOth93zMQtSu8/7q7ya/dtfWQKFXFLuca5jr+UshG+EqsT9LeitqOxwJSv8UIeYZexsvsjXWBfamD7Noily5wVZF8nTOfwHMZe8H") was called from RX@0x12026a34[libencrypt.so]0x26a34
结果->Mrh0zeSVubXq3dRfAYRfsCpaeTaMt3WWlTMcCqCJesCJkrzjf63idS/q+MLRC/eIzbfdAP1pjrnI6gAiyORoTUHM1VLCpYGCeXjI6sIMuUQCAIaVpAfVen5tvqy2nIB+UqbivsbOBPYzY/QpsZ6oooAQE5SKp9J/rt2aNzSW6wErEQP8ey4EpRNoYyQjNguKY8FEtcOIaI5hEq5u2gwpl9YlKE8Wey3/JipF4+69Ez7ik1DVmaozl4j3wpjtgLo7fJRN/oZFPfAh8BwL2woSL/1yR5RakfRHtBLg28lUMTSOMwnGk2dPBTC7tZVsKho+CHx5NfZyHjW8L9PcxHQXpRZXOHH3ygB5/Q/2xrpm2J3l6bnqJ1xwGzubiqmvcD38fkBa+t44sNZ1mInNYkX82POjMKRnRXOth93zMQtSu8/7q7ya/dtfWQKFXFLuca5jr+UshG+EqsT9LeitqOxwJSv8UIeYZexsvsjXWBfamD7Noily5wVZF8nTOfwHMZe8H

```

这是我们的运行时的最后几句日志，可以看到最后是通过JNIENV->NewStringUTF构造了返回的字符串，地址为0x26a34，我们在IDA中跳转到该地址

![图片描述](upload/attach/202504/1034707_MM2RRDRNBB9BJDP.webp)

这句代码也就是newstringutf函数，那么这里的v5的类型肯定就是JNIEnv*了，我们可以先按y去转一下v5的类型

![图片描述](upload/attach/202504/1034707_PDY9AW9M4SS528M.webp)

现在还原回来了。我们继续分析，可以看到该值是有v138转换而来的，所以我们下一步就是要去分析v138的来源了。继续往上看，我们注意到了5065行的

```c
sprintf(v138, "%c%s", v727, v132); //这里的%c表示char占位符，所以v727是单个字符，而%s表示char*，故v132是一个字符串，所以可想而知v727是前面的M，而v132则是后面的一段连续字符串
//多次改变参数进行验证后可以发现这个M是固定的
```

熟悉c语言的朋友肯定知道，这是在往v138里面写入v727和v132，其中v727是固定的M，后面的v132则是通过前面加密得到的结果。所以v132也就是我们的分析目标

继续往上看

![图片描述](upload/attach/202504/1034707_SJWY4G55BFPCM4Q.webp)

发现

```c
base64_encode(v123, v132, (unsigned int)v771);
```

v132貌似是通过base64编码得到的，我们现在需要去验证`base64_encode`这个函数是否是标准的base64（及其入参与标准bas64解密v132的结果是否一致）

```
.text:00000000000268C0                 MOV             X1, X20
.text:00000000000268C4                 MOV             X0, X24
.text:00000000000268C8                 MOV             X19, #2
.text:00000000000268CC                 BL              base64_encode
```

这是base64_encode处的汇编代码，我们只需要0x268cc处下断点，查看x0寄存器（v123,即该函数的入参）的值

![图片描述](upload/attach/202504/1034707_G4VQK2QQHAB3BZN.webp)

![图片描述](upload/attach/202504/1034707_4HRGJPPKN27NAQC.webp)

这和我们网站上进行在线解base64的结果是一样的，所以毋庸置疑这就是标准的base64，而其中的v123是base64的入参，这样的话base64_encode这个函数里面的逻辑我们就不用去看了。我们的下一步的目标就是要去分析v123所在地址内容的来源

##### AES

###### 识别AES

我们去trace v123当前所在地址的写入(0x1256400,0x1256400+0x01A0)，来看这串字符串到底是在哪里写入的

![图片描述](upload/attach/202504/1034707_Q6E7QXXAUKDA527.webp)

我们可以注意到，0x7a6d6e2579331dae 不就是我们之前base64入参前几个字节的大端序吗，所以写入是在0xa07c这个地址写入的。

但是貌似都是一组一组的进行写入的,0xa128、0xa128(后面都变为了0xa150)，0xa07c、0xa07c；这样 0xa07c处写入的值可能与之前的0xa128处的值是有一定联系的。我们进入到IDA中去看这两个地址

首先是0xa128（位于`WBACRAES128_EncryptCBC`函数中）

![图片描述](upload/attach/202504/1034707_UWQQZ5BM7CP8BA4.webp)

然后是0xa07c（位于`WBACRAES_EncryptOneBlock`函数中）

![图片描述](upload/attach/202504/1034707_TV2NVGERRWFB5V9.webp)

0xa128这个地址处是在进行veorq_s8(*v6,this[1])， 了解veorq_s8这个函数的朋友肯定知道（不了解也没关系哈，可以问一下gpt），这就是在对v6和this[1]进行按位异或。不过目前我们也不懂这是在干嘛，为什么要这样做；

我们暂且先按下不表，继续去看第二处0xa07c，哦，这里我们注意到在这个写入的上方刚刚才进行了AES_EncryptOneBlock(翻译过来是 AES_加密一个块)，这不明摆着告诉我们是一个AES了，似乎还是个白盒AES。

那前面的0xa128又是在干嘛呢，这不也很闲而已见了，大概率是在进行AES前的初始化（在CBC模式中AES分组后每组加密前都要先与前一轮得到的密文进行异或，第一轮的明文与IV进行异或），所以这又极可能是个CBC的加密模式（这个现在只是猜想,我们待会儿会来验证）

okay，现在我们已经明确了这个加密算法是个AES了，并且在`WBACRAES128_EncryptCBC`每完成一块加密明文的初始化后都会进入到`WBACRAES_EncryptOneBlock`中进行一个块的加密

接着我们去验证上面的猜想

##### 确认AES入参

我们可以分别对`WBACRAES128_EncryptCBC`和`WBACRAES_EncryptOneBlock`调用处进行hook，观察其入参（第一处是AES最原始的入参，而第二处则可能是已经经历过填充、第一轮加密前的对第一块明文初始化（与IV进行异或操作）的入参了）

先看第一处，我们先来确认一下最原始的入参是什么

![图片描述](upload/attach/202504/1034707_WXFBMTM2KDNDXPQ.webp)

在`WBACRAES128_EncryptCBC`上按`X`键，找到引用他的地址，发现有两处,我们该如何确认究竟是被哪个函数调用的呢？很简单，我们可以在两个函数跳转处都下上断点，看看究竟是在哪个地方断到了，那么就是哪个函数调用的

好，我们说做就做

![图片描述](upload/attach/202504/1034707_JWYCRYCQU39JPHS.webp)

在加过断点并且重新运行后发现只有在encrypt1这个函数中会断下来，在encrypt2中是断不下来的。

![图片描述](upload/attach/202504/1034707_DRD4SJDQJD6DEVR.webp)

![图片描述](upload/attach/202504/1034707_HHS8KSDVMSWEGA7.webp)

![图片描述](upload/attach/202504/1034707_DUXF4383PU2JKNK.webp)

那我们接着看入参，上面这张图是encrypt1中跳转进入`WBACRAES128_EncryptCBC`附近的代码，其中的x1寄存器存放了我们的入参（这是如何确定的呢？因为之前在`WBACRAES128_EncryptCBC`函数里面是在用v6跟this[1]进行异或且结果赋给了a6，所以a6就是入参，a6又是由这里的a2赋值而来的，而a2在encrypt1对应的是a1这个参数，在a1这个地方按Tab键反汇编可以发现其对应的寄存器是x1）

运行断下之后

![图片描述](upload/attach/202504/1034707_EXV9NAECGHHZES9.webp)

我们可以看到这不就是我们给unidbg的第一个字符串吗？不对，多了一个checkcode，并且每次重新运行时这个checkcode都是会变化的，所以我们又多了一个分析目标checkcode，不过现在还轮不到他，他得先往后稍稍。

所以AES的入参我们其实已经可以确定了，就是我们传给unidbg的第一个字符串+&checkcode=....（距离还原sd又近了一步...）

##### 确认填充模式

接下来我们去看`WBACRAES_EncryptOneBlock`，这个函数是在`WBACRAES128_EncryptCBC`中被引用的，我们直接在跳转处下断点

![图片描述](upload/attach/202504/1034707_DC5SD6PXAVYH3BH.webp)

![图片描述](upload/attach/202504/1034707_5VUBVAAWEUWZA7V.webp)
 ![图片描述](upload/attach/202504/1034707_6B77D2W5VZ7KD6R.webp)

okay，下了断点运行后打印x1寄存器中的内容，发现...好熟悉...这不是上面那种unidbg运行结果图中的内容吗，诶，不对，又多了一个02 02，这似乎是AES进行了填充（当AES明文长度不是16的倍数时，在加密前会进行填充）。填充了02 02，此前长度距离16的整数倍也差了两个字节，这不是PKCS7的填充模式吗（PKCS7填充模式会填充(16-length%16)个(16-length%16) ）。

那这样就说得通了，我们现在可以确认填充模式是PKCS7了。

##### 确认加密模式与IV

但是我总感觉少了些什么，我记得在进入这个函数之前好像做过异或操作呀，但这里的前16个字节怎么还是原始数据呢，好奇怪呀，那我们再拐回头去看一下那个函数（`WBACRAES128_EncryptCBC`）吧

![图片描述](upload/attach/202504/1034707_BJH5UU33C5896QA.webp)

其实这里的异或逻辑其实有两个分支，其中上面的只进行了一轮的写入，后面的轮次都是在下方地址这个写入的

我们可以猜想，第一轮异或时的this[1]可能为0（任何数异或0的结果都还是它本身），后面轮次异或中的v11为上一轮加密产生的密文。

我们看第一次运行到0xa150这个地方时的v11是否为我们上一轮加密的结果（第一轮异或的地方这里就不再验证了，大家可以自己验证一下），如果是的话，那么加密模式和IV我们也就确认了。

![图片描述](upload/attach/202504/1034707_9U4YVARK8CBAWSP.webp)

这是0xa150处的汇编，我们只需要在这个0xa14c地方下断点然后去看异或前q0,q1寄存器中的内容（这里的Q寄存器是通用向量寄存器）

![图片描述](upload/attach/202504/1034707_K97QZMWW65353Q8.webp)

![图片描述](upload/attach/202504/1034707_BSWGVQHHS2KVUGX.webp)

可以看到q0寄存器中的内容跟我们进行过第一轮加密后的密文内容是一致的，所以我们的猜想正确。

所以现在我们直径知道加密模式是CBC，IV为0x000000000000了，接下来我们就要去获取AES的key了

##### 确认白盒AES

![图片描述](upload/attach/202504/1034707_HFXHJAYJ97RUDCW.webp)

我们回到这个函数中，双击函数中黄色的那个地方，跳转到具体的函数中去

![图片描述](upload/attach/202504/1034707_GGQXG7PF38ADH3U.webp)

里面是这样的，但是我们无论如何都无法继续跳转进去了，我们按TAB把他转换为汇编

![图片描述](upload/attach/202504/1034707_AP7ZHBTZUNH2JQZ.webp)

发现这里其实是混淆过的了，最后是通过

```
BLR X4
```

这条指令跳转到下一个函数中去了，因为IDA无法解析出运行时X4寄存器的内容，所以我们双击也无法进入。现在怎么办？怎么办？okay，那么第一种处理方式就是去混淆（可以把外面的控制流混淆也顺便给去了...）；第二种方式呢，就是在这个地方下个断点，去看在这里断住时的X4寄存器的内容。 本人比较菜，选择第二种方式（不得不说，unidbg对于还原算法来说真是一个好工具）。

![图片描述](upload/attach/202504/1034707_PP7BEUA4Q8U5GFT.webp)

okay,nice!我们现在知道了其在so中的偏移为0x86f8。换不多说，我们直接在IDA中跳转过去。

![图片描述](upload/attach/202504/1034707_MW9RZ6U4QTUN5RB.webp)

废了九牛二虎之力我们终于进来了

![图片描述](upload/attach/202504/1034707_9TX39XXGE55D38Z.webp)

里面似乎都是在查表进行替换，这不就是查表法AES吗，我们点进去后可以发现这个表好像有些大，而且我们似乎也找不到key的逻辑，那..这是个白盒AES了。

###### dfa攻击获取秘钥

对于白盒AES来说，我们的处理方法有两种，第一中就是把代码和表全扣下来；第二种呢就是DFA攻击白盒AES得到秘钥后还原算法。

这里我们选择第二种方式，这里的白盒AES也是一个比较标准的白盒AES。

首先我们要稍微了解一些如何使用DFA攻击白盒AES得到轮秘钥。原理性的东西这里也就不提了（网上也有很多相关文章，大家感兴趣的话可以去看一下）。这里只说怎么去做，白盒AES我们通常是要找到倒数第二轮（在这里aes-128中是第九轮）的入口处去多次修改我们明文的单个字节，通过修改单个字节得到的加密结果与正常的加密结果进行碰撞就可以确定出部分第十轮子密钥，最后只要增加样本数，就能还原出第十轮的紫秘钥了，然后通过秘钥回推就可以得到初始秘钥了。

大家也不用害怕自己不会写这些东西，因为已经有开源的项目了。

现在，我们先去寻找第九轮加密，看下面这段代码

```c
do
{
    v10 = v54;
    v11 = (char *)&unk_31080;
    v12 = 0;
    v13 = 4LL * v9;
    if ( v8 == 1 )
    {
        do
        {
            v36 = v12;
            *v10 = roundTables_auth1[256 * (v12 + 4 * ((*v11 & 3) + 4LL * v9))
                                     + *((unsigned __int8 *)&v49 + 8 * v12 + (*v11 & 3))];
            v10[1] = roundTables_auth1[256 * (v12 + 4 * (((*v11 + 1) & 3) + 4LL * v9))
                                       + *((unsigned __int8 *)&v49 + 8 * v12 + ((*v11 + 1) & 3))];
            v10[2] = roundTables_auth1[256 * (v12 + 4 * (((*v11 + 2) & 3) + 4LL * v9))
                                       + *((unsigned __int8 *)&v49 + 8 * v12 + ((*v11 + 2) & 3))];
            v37 = *v11;
            v11 += 2;
            v10 += 4;
            ++v12;
            *(v10 - 1) = roundTables_auth1[256 * (v36 + 4 * (((v37 + 3) & 3) + 4LL * v9))
                                           + *((unsigned __int8 *)&v49 + 8 * v36 + ((v37 + 3) & 3))];
        }
        while ( v12 != 4 );
    }
    else
    {
        while ( v8 != 2 )
        {
            v33 = *v11;
            v34 = v12;
            v35 = 8LL * v12;
            *v10 = roundTables_auth1[256 * (v12 + 4 * (v13 + (*v11 & 3)))
                                     + *((unsigned __int8 *)&v49 + v35 + (*v11 & 3))];
            v10[1] = roundTables_auth1[256 * (v12 + 4 * (v13 + ((v33 + 1) & 3)))
                                       + *((unsigned __int8 *)&v49 + v35 + ((v33 + 1) & 3))];
            v10[2] = roundTables_auth1[256 * (v12 + 4 * (v13 + ((v33 + 2) & 3)))
                                       + *((unsigned __int8 *)&v49 + v35 + ((v33 + 2) & 3))];
            v10 += 4;
            ++v12;
            v11 += 2;
            *(v10 - 1) = roundTables_auth1[256 * (v34 + 4 * (v13 + ((v33 + 3) & 3)))
                                           + *((unsigned __int8 *)&v49 + v35 + ((v33 + 3) & 3))];
            if ( v12 == 4 )
                goto LABEL_7;
        }
        do
        {
            v14 = v12;
            *v10 = roundTables_auth2[256 * (v12 + 4 * ((*v11 & 3) + 4LL * v9))
                                     + *((unsigned __int8 *)&v49 + 8 * v12 + (*v11 & 3))];
            v10[1] = roundTables_auth2[256 * (v12 + 4 * (((*v11 + 1) & 3) + 4LL * v9))
                                       + *((unsigned __int8 *)&v49 + 8 * v12 + ((*v11 + 1) & 3))];
            v10[2] = roundTables_auth2[256 * (v12 + 4 * (((*v11 + 2) & 3) + 4LL * v9))
                                       + *((unsigned __int8 *)&v49 + 8 * v12 + ((*v11 + 2) & 3))];
            v15 = *v11;
            v11 += 2;
            v10 += 4;
            ++v12;
            *(v10 - 1) = roundTables_auth2[256 * (v14 + 4 * (((v15 + 3) & 3) + 4LL * v9))
                                           + *((unsigned __int8 *)&v49 + 8 * v14 + ((v15 + 3) & 3))];
        }
        while ( v12 != 4 );
    }
    LABEL_7:
    v16 = 1;
    for ( i = 0; i != 4; ++i )
    {
        v18 = &v54[i];
        for ( j = 0; j != 4; ++j )
        {
            v20 = v18[16];
            v21 = v18[32];
            v22 = v18[48];
            v23 = *v18 & 0xF;
            v55[0] = *v18;
            v24 = 24LL * (int)j + 96LL * v9;
            v55[1] = v20;
            v25 = v55[0] & 0xF0;
            v55[2] = v21;
            v26 = v16;
            v27 = 0;
            v55[3] = v22;
            do
            {
                v28 = v26 - 1;
                v29 = (unsigned __int8)v55[v27 + 1];
                v30 = (unsigned __int8)(v23 | (16 * v29));
                if ( v8 == 1 )
                {
                    v23 = xorTables_auth1[256 * (v24 + v28) + (unsigned __int8)(v23 | (16 * v29))] & 0xF;
                    v25 = 16 * (xorTables_auth1[256 * (v24 + v26) + (int)((v25 >> 4) | (16 * (v29 >> 4)))] & 0xF);
                }
                else
                {
                    if ( v8 == 2 )
                    {
                        v31 = (v25 >> 4) | (16 * (v29 >> 4));
                        v23 = xorTables_auth2[256 * (v24 + v28) + v30] & 0xF;
                        v32 = xorTables_auth2;
                    }
                    else
                    {
                        v32 = xorTables_auth1;
                        v31 = (v25 >> 4) | (16 * (v29 >> 4));
                        v23 = xorTables_auth1[256 * (v24 + v28) + v30] & 0xF;
                    }
                    v25 = 16 * (v32[256 * (v24 + v26) + v31] & 0xF);
                }
                ++v27;
                v26 += 2;
            }
            while ( v27 != 3 );
            *((_BYTE *)&v49 + 8 * i + j) = v25 | v23;
            v18 += 4;
        }
        v16 += 6;
    }
    ++v9;
}
while ( v9 <= 8 && v48 > v9 );
```

这里的v48表示表示当前循环次数，每一块的前九轮加密都在这个循环体中，并且每一轮都会经过

```c
v10 = v54;
```

这句代码，所以我们完全可以去在这句代码处下一个断点并重写OnHit，当这句代码经过九次时，我们去改变这轮加密的明文，用新产生的密文与正常密文进行碰撞。这样最终就能得到我们的第十轮子密钥了。由于AES是按块进行加密的，其中每个块加密时的轮秘钥都是相同的，所以我们也只需要去观察一个块的加密即可，这里我们选择第一个块。

那么我们该如何去修改加密的明文呢？我们需要先得到运行时所加密明文的地址

![图片描述](upload/attach/202504/1034707_9EN9YDQ6XWK7RMP.webp)

我们观察到在每一块的AES加密时最初进行的是一个`PrepareAESMatrix`函数，这是在做加密前的矩阵的初始化准备操作

![图片描述](upload/attach/202504/1034707_X8QW7YY2KMFZKZS.webp)

![图片描述](upload/attach/202504/1034707_Z6DSVYXSJNS7PE4.webp)

我们进来后可以看出a3中最后存放存放了我们之后要去加密的数据，所以我们现在的目标就是获取a3的地址

![图片描述](upload/attach/202504/1034707_Q6GQD3RAZR5PC9J.webp)

我们在0x7908处下断点，去观察x2寄存器此时所在地址

![图片描述](upload/attach/202504/1034707_ZHTQC5N772NRVAK.webp)

可以看到这确实是在做矩阵变换的操作。做完矩阵变换后的明文地址为0xe4ffeb10，这是我们dfa时要去修改的地方。下面是dfaattach这段代码的写法

![图片描述](upload/attach/202504/1034707_E2GBWUXT3GVPH2Q.webp)

我们之前提到过dfa攻击时要使用用正常加密结果生成的密文和改变一字节明文后加密得到的密文进行碰撞，所以我们需要去trace 密文的写入。还记不记得我们每轮密文写入的地址了，我们在识别AES中这一步中已经获得过了，是(0x1256400,0x1256400+0x01A0)这块地址，我们加上这句代码重新运行，但是发现很奇怪，并没有trace相关的日志。我们已经trace不到了，这是为什么？我们尝试重新去hook base64_encode这个函数，重新查看数据所在的地址

![图片描述](upload/attach/202504/1034707_2DAQSJT7WKAWJFT.webp)

我们可以发现到地址竟然发生了变化，这又是为什么？可能是因为我文章写的时间间隔太久了？我也不是很清楚。但是没关系，我们重新去trace(0x1255a380,0x1255a380+0x01A0);

![图片描述](upload/attach/202504/1034707_MBTZXER6B7K4W7E.webp)

![图片描述](upload/attach/202504/1034707_TH8NZRX4EY6XMRT.webp)

上图为dfa注入前第一块的加密结果，下图为dfa注入后第一块的加密结果。

可以看到，有四个字节发生了变化，这就证明我们的注入是对的。

我们尝试使用`phoenixAES`这个库来完成轮秘钥的分析（使用时需要注入多组故障密文已完成秘钥分析）

![图片描述](upload/attach/202504/1034707_9JS2QBGZ2V392E3.webp)

这样我们就成功的获取到了第十轮的轮秘钥，由于AES加密算法轮秘钥生成的特型，有第i轮的轮秘钥是可以推出i-1轮的轮秘钥，以此类推，可以得到初始秘钥（由于篇幅问题，具体原理这里不再解释，有兴趣的朋友可以自行了解）。下面给出相关代码

```python
#ki2k0.py

# 定义常量
Nb = 4  # AES 状态的列数，固定为 4

# S-Box 和 Rcon 表
sbox = [
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
]

Rcon = [0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]

# 全局变量
RoundKey = [0] * 240  # 存储轮密钥
Key = [0] * 32        # 输入密钥

def KeyExpansion(start: int, AesSize: int):
    """执行 AES 密钥扩展，从给定的起始轮密钥生成所有轮密钥"""
    Nk = AesSize // 32  # 密钥长度（以 32 位字为单位）
    Nr = Nk + 6         # 轮数：10 (AES-128), 12 (AES-192), 14 (AES-256)
    start *= 4          # 转换为字节偏移

# 初始化第一组轮密钥
    for i in range(start, Nk + start):
        RoundKey[i * 4 + 0] = Key[(i - start) * 4 + 0]
        RoundKey[i * 4 + 1] = Key[(i - start) * 4 + 1]
        RoundKey[i * 4 + 2] = Key[(i - start) * 4 + 2]
        RoundKey[i * 4 + 3] = Key[(i - start) * 4 + 3]

# 生成后续轮密钥
    for i in range(Nk + start, Nb * (Nr + 1)):
        tempa = [RoundKey[(i - 1) * 4 + j] for j in range(4)]

if i % Nk == 0:
            # RotWord: 循环左移
            k = tempa[0]
            tempa[0] = tempa[1]
            tempa[1] = tempa[2]
            tempa[2] = tempa[3]
            tempa[3] = k

# SubWord: 应用 S-Box
            tempa = [sbox[x] for x in tempa]

# XOR with Rcon
            tempa[0] ^= Rcon[i // Nk]

elif Nk > 6 and i % Nk == 4:
            # SubWord: 仅对 AES-256 在特定条件下应用
            tempa = [sbox[x] for x in tempa]

# 生成新轮密钥
        for j in range(4):
            RoundKey[i * 4 + j] = RoundKey[(i - Nk) * 4 + j] ^ tempa[j]

# 反向扩展到前面的轮密钥
    for i in range(Nk + start - 1, Nk - 1, -1):
        tempa = [RoundKey[(i - 1) * 4 + j] for j in range(4)]

if i % Nk == 0:
            # RotWord
            k = tempa[0]
            tempa[0] = tempa[1]
            tempa[1] = tempa[2]
            tempa[2] = tempa[3]
            tempa[3] = k

# SubWord
            tempa = [sbox[x] for x in tempa]

# XOR with Rcon
            tempa[0] ^= Rcon[i // Nk]

elif Nk > 6 and i % Nk == 4:
            tempa = [sbox[x] for x in tempa]

# 生成前一轮密钥
        for j in range(4):
            RoundKey[(i - Nk) * 4 + j] = RoundKey[i * 4 + j] ^ tempa[j]

# 打印所有轮密钥
    for j in range(16 * (Nr + 1)):
        if j % 16 == 0:
            print(f"K{j // 16:02d}: ", end="")
        print(f"{RoundKey[j]:02X}", end="")
        if j % 16 == 15:
            print()

def main():
    # 硬编码示例输入（AES-128 密钥）
    example_key = "8A6E30D74045AE83634D6ECDE1516CA1"  # 16 字节密钥
    AesSize = 128  # AES-128 ,如果是196或者256,只需修改该参数
    round_start = 10  # 从第 10 轮开始反推，如果是0，则表示进行一轮新的秘钥拓展 #一般我们能拿到的都是第十轮的秘钥

# 将十六进制字符串转换为字节数组
    for i in range(0, len(example_key), 2):
        Key[i // 2] = int(example_key[i:i + 2], 16)
        
    KeyExpansion(round_start, AesSize)

if __name__ == "__main__":
    main()
```

![图片描述](upload/attach/202504/1034707_2DU95Y8WZSK2FZ4.webp)

成功运行，这样我们也获取到AES的key了。

我们已经还原出AES的所有内容了，但是似乎又少了什么，对了，我们的checkcode还没有分析呢，这是个动态的32字节的值。

#### checkcode还原(md5)

从哪里开始呢，我依稀记得checkcode最先出现在了白盒AES的入参中的，可以尝试通过hook白盒AES入口函数得到checkcode字符相对应的地址，再去trace这个地址的写入。我们去试一下

首先，先去hook白盒AES入口处

![图片描述](upload/attach/202504/1034707_PGGDERCT6S7RM2R.webp)

![图片描述](upload/attach/202504/1034707_J7EHXUVGUD5AJ6H.webp)

![图片描述](upload/attach/202504/1034707_GEBQRB5MHZ9UGC6.webp)

可以看到，checkcode字段的内容对应的地址大概是在0x1255a380+0x15e~0x1255a380+0x17d,我们去trace这段地址的写入

![图片描述](upload/attach/202504/1034707_VF3EVG55ZWSGTPE.webp)

大概是在这一块，对应的so偏移地址是0x29bac。

在IDA跳转到这块地址之后

![图片描述](upload/attach/202504/1034707_JDQWDKDPTNRY5BS.webp)

发现是将v472中的内容写入到了这里，向上看v472,又是通过v469来的，继续向上看v469似乎又是通过v116来的。

![图片描述](upload/attach/202504/1034707_SR868SV4ZBCQHWA.webp)

继续向上看，发现v116是通过v108来的，而v108似乎是通过4697行的sprintf写入的，但是继续向上看

![图片描述](upload/attach/202504/1034707_NJSVFM2WQ656JR7.webp)

发现有好几个通过sprintf向v108中写入的函数（上面还有两个），回忆一下之前AES的入参`od=gogle&checkcode=`

通过该入参格式我们就已经可以判断出是在4665这一行中写入的（如果当时没看出来怎么办，没关系的，可以在这几个sprintf出都下上断点，看看是在哪个地方断住了）

![图片描述](upload/attach/202504/1034707_G5HKQEH23XW57HE.webp)

![图片描述](upload/attach/202504/1034707_4KEP8GNGQSXH7C3.webp)

![图片描述](upload/attach/202504/1034707_D6RK3QEMVJM62T8.webp)

确实在这个地方断住了,并且x3也就是p跟后面的AES入参checkcode内容是一致的。

okay，这样就确定了这个p就是checkcode的来源，现在我们需要去找这个p的赋值逻辑

![图片描述](upload/attach/202504/1034707_S2W94Z9MYVT4Q8R.webp)

按下X键我们可以看到哪个地方引用了这个p，似乎是在4567行对p进行了赋值

![图片描述](upload/attach/202504/1034707_ZPVT6D3ZZMYDCPQ.webp)

但是这四句代码好像是在对p进行换位的逻辑，并不是给p赋值的地方（这也说明了p经过上一步的加密后是有一部内部的换位操作的）

我们继续向上看，有个endText函数，我们先跳转过去，在这个函数处下个断点

![图片描述](upload/attach/202504/1034707_CF5GNAUFJS7ABXP.webp)

![图片描述](upload/attach/202504/1034707_YT8VA6GYNEQJU64.webp)

可以看到确实在这里端住了，并且在进入到这个函数之前，x0寄存器（也就是p）是空的，证实了p确实是有这个函数生成的；

![图片描述](upload/attach/202504/1034707_KHS6N97FC6GY4HU.webp)

其中的第二个参数v68的内容是这样的（经过多次运行验证发现是个定值（是对包名做了md5，有兴趣的话大家可以自己去跟一下））

现在我们进入到endText里面去看看具体的逻辑

进来之后发现，好家伙，全是混淆，这我怎么下手。别急，我们先在入参处按X键，去找a1(也就是p)的生成逻辑

![图片描述](upload/attach/202504/1034707_FRZUH2BG3QUJ9HW.webp)

可以看到，最后是将a1赋值给了v320（由于a1是个char*也就是指针类型，所以这句代码也相当于是将v320指向了a1所指向的内存，这样后续修改v320，也就相当于修改a1了），可以的，我们去看v320好了。

![图片描述](upload/attach/202504/1034707_NGPXR2FHDQH6N4G.webp)

跳转过去发现，这似乎已经是在做最后的写入操作了，而且写的来源是v556，而v556来源于v546，所以下一步我们要去看v546。

在v546处按下X键，随便进入跳转一个，发现似乎是在进行md5了，而且还有很多虚假控制流，这很难看啊，md5的参数又是什么呢。别急，不要忘了入参中还有另外一个，这个入参不可能毫无用处，我们去看看对他进行了什么操作。

![图片描述](upload/attach/202504/1034707_965N4SGCQRBX5H6.webp)

在a2处按下X键，只有一处，我们直接跳转过去

![图片描述](upload/attach/202504/1034707_AVPYRJUWA6Y9TCG.webp)

这里是在往s里面写东西，往下面稍微看一下就知道是在对s进行md5（是否魔改目前还未知）加密操作了。其中的a2（一个定值）是一个字符串，v9是time(0)（这是个时间戳）。

我们在完成对s的写入操作后下一个断点去看看其内容

![图片描述](upload/attach/202504/1034707_HV24XMSCJNDM2TK.webp)

![图片描述](upload/attach/202504/1034707_UMZK6XKMWT8F3HZ.webp)

![图片描述](upload/attach/202504/1034707_YDGFG6VNWRESP2R.webp)

发现就是一个定值加一个时间戳。我们下一步验证endText的结果是否与对其进行标准md5一致。

![图片描述](upload/attach/202504/1034707_F8WU5WKXMVZHQEU.webp)
 ![图片描述](upload/attach/202504/1034707_K24ETP5AHDZZQRG.webp)

可以发现我们在网站上进行的md5似乎跟写入checkcode中的不...，一样的。只不过调整了顺序，大家是否还记得之前有个对p进行内部换位的操作，那这不就对应上了吗。

所以checkcode就是对 `6cf70fabc636f5e6569cd03e194e5769+现在的时间戳`进行标准的md5后调整顺序 （即checkcode=p[12:16]+p[4:12]+p[0:4]）。这样checkcode也就分析完成了。

####  最后的最后
okay，好了，这篇文章写的陆陆续续的，花费了大概3天时间终于也是写完了，个人感觉该案例难度中等，希望对大家能够有所帮助，有什么不好的地方也请大家多多指出。

最后，另提一嘴，小弟目前大二，想找个逆向实习（web逆向/安卓逆向），有没有大佬的公司招实习生的，可以看看小弟。

联系邮箱：2871856995@qq.com

QQ交流群：631483465

回复或点赞可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-4-29 07:27 被git_21210wzzzh2025编辑，原因：修复部分图片

#逆向分析

最新回复 (48) 1 2 ▶
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 707 粉丝 7 关注私信	mb_ldbucrik 2 楼感谢分享 2025-4-28 23:32 0
啊你好哇123 雪币： 798 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 376 粉丝 0 关注私信	啊你好哇123 3 楼前两个图片挂了？ 2025-4-29 00:22 0
bluegatar 雪币： 6 活跃值： (5949) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 241 粉丝 6 关注私信	bluegatar 4 楼部分图片，不仅是头两个图片挂了 2025-4-29 02:27 0
git_21210wzzzh2025 雪币： 2506 活跃值： (3852) 能力值： ( LV3，RANK：20 ) 在线值：发帖 2 回帖 19 粉丝 23 关注私信	git_21210wzzzh2025 5 楼 bluegatar 部分图片，不仅是头两个图片挂了现在应该看得到了，我又重新上传了一次 2025-4-29 07:32 0
git_21210wzzzh2025 雪币： 2506 活跃值： (3852) 能力值： ( LV3，RANK：20 ) 在线值：发帖 2 回帖 19 粉丝 23 关注私信	git_21210wzzzh2025 6 楼 yazigegeda 前两个图片挂了？是的，我又重新上传了一次 2025-4-29 07:32 0
肥一闪雪币： 828 活跃值： (1993) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 20 粉丝 0 关注私信	肥一闪 7 楼 2025-4-30 09:30 0
Imxz 雪币： 110 活跃值： (9571) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 8 楼 666 2025-4-30 20:17 0
kingking888 雪币： 3235 活跃值： (6337) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 302 粉丝 6 关注私信	kingking888 9 楼 666 2025-5-3 19:11 0
逍遥无极天雪币： 226 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 27 粉丝 0 关注私信	逍遥无极天 10 楼 666 2025-5-3 21:32 0
Reze 雪币： 6544 活跃值： (130) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	Reze 11 楼厉害了 2025-5-3 21:46 0
FMNS 雪币： 9 活跃值： (2036) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 124 粉丝 1 关注私信	FMNS 12 楼厉害 2025-5-3 22:01 0
mb_cbgtaveo 雪币： 292 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 259 粉丝 0 关注私信	mb_cbgtaveo 13 楼 6666666666 2025-5-7 00:39 0
ONewTach 雪币： 242 活跃值： (5670) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 0 关注私信	ONewTach 14 楼 666 2025-5-7 09:20 0
lotus* 雪币： 42 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 59 粉丝 4 关注私信	lotus* 15 楼 666666 2025-5-7 14:19 0
spdfdfer 雪币： 166 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 40 粉丝 0 关注私信	spdfdfer 16 楼 666666 2025-5-8 18:49 0
ATrueMan 雪币： 1048 活跃值： (1680) 能力值： ( LV2，RANK：10 ) 在线值：发帖 11 回帖 89 粉丝 14 关注私信	ATrueMan 17 楼 study 2025-5-9 14:09 0
mb_ifjlatem 雪币： 10 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 75 粉丝 0 关注私信	mb_ifjlatem 18 楼 study 2025-5-15 11:43 0
mb_basgiwmq 雪币： 212 能力值： ( LV1，RANK：0 ) 在线值：发帖 3 回帖 38 粉丝 1 关注私信	mb_basgiwmq 19 楼 nb 2025-5-15 14:21 0
hacker521 雪币： 2676 活跃值： (5841) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 226 粉丝 30 关注私信	hacker521 20 楼 666666 2025-5-15 15:17 0
ldehua 雪币： 158 活跃值： (2731) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 111 粉丝 0 关注私信	ldehua 21 楼 66666666666 2025-5-22 13:20 0
edisonhu 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 42 粉丝 0 关注私信	edisonhu 22 楼 12312 2025-5-23 11:06 0
iBa0 雪币： 1901 活跃值： (5928) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 490 粉丝 37 关注私信	iBa0 23 楼；l 2025-5-25 23:07 0
街道办事处雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 48 粉丝 0 关注私信	街道办事处 24 楼 1 2025-6-3 14:55 0
mb_yfmtnfii 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 17 粉丝 0 关注私信	mb_yfmtnfii 25 楼 1 2025-6-3 15:19 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复