[原创]某海外电商app白盒 AES 识别与密钥恢复-Android安全-看雪安全社区

# 某海外电商app白盒 AES 识别与密钥恢复
ai文，还是将关键数据的加密trace扔给ai，1GB，自动还原出白盒aes的加密方式和密钥
## 1. 摘要

本文记录如何从 ARM64 指令 trace `D:\tome\tome_u2_new4.trace` 出发，定位 `extra` 字段的数据处理路径，识别其中的白盒 AES-128-CTR，并从 `libriver.so` 第一轮白盒 T-box 中恢复标准 AES-128 主密钥。

最终结论：

- 密码原语：AES-128 加密
- 实现形态：Chow 类表驱动白盒 AES，带内部编码和 nibble XOR 表
- 工作模式：CTR 风格流模式，128-bit 大端计数器
- AES 主密钥（hex）：`68656c6c6f776f726c64787878787878`
- AES 主密钥（ASCII）：`helloworldxxxxxx`
- 第一组验证：
  - AES 输入：`4279f8df97bb00006ff75157c5ebcb76`
  - AES 输出：`c35e6ffa54e48548bdd188fae5ddbecf`
  - 使用恢复密钥执行标准 AES-128-ECB 后结果完全一致

本报告强调三个层次必须分开：

1. 白盒 AES-CTR：真正把 JSON 转换成密文；
2. 私有封包：插入 selector 并记录插入位置；
3. 字符编码：标准 Base64，外加字符串版本前缀 `01`。

---

## 2. 样本与证据边界

### 2.1 输入文件

| 文件 | SHA-256 |
|---|---|
| `D:\tome\tome_u2_new4.trace` | `4E4EA96DD17597C2292091C269B563ACA72BCF5FB2F7E8A43B7D7DE765A3114E` |
| `D:\tome\tome\split_config.arm64_v8a\lib\arm64-v8a\libriver.so` | `2774AE72FD2C42A0857942A1FE187E46F807D4EE61DFE38DCDBBBBC81D297E08` |

### 2.2 地址约定

报告内 `0x19C72C`、`0x19E280` 等地址均为 `libriver.so` 的模块相对地址（RVA），不是进程绝对地址。

### 2.3 分析方法

综合使用：

- QBDI ARM64 指令和内存读写 trace；
- IDA/Hex-Rays 静态反汇编与反编译；
- 已知明文、密文和密钥流的动态关联；
- 白盒 AES 表结构识别；
- 基于 BGE 思路的 GF(2) 仿射秩测试；
- Node.js 标准 AES 实现独立验证。

---

## 3. 从 `extra` 回溯到加密输入

trace 最终组装的外层 JSON 包含：

```json
{
  "8": {"realtime": "{\"content\":\"0|Built-in Screen|2138x1080|131|1\"}"},
  "6": {"1": ["394232"]},
  "an": 8,
  "id": "3240a81b31837bae",
  "ts": 1784793365424,
  "seq": 4,
  "pk": "yqFYOTeuVR46dP452Qd+kpQf4sJqiDeqX2ne5+w+Y0E=",
  "ver": "1.0.0",
  "extra": "01D8EAABAIAukAm0J5+N+Xuw..."
}
```

`extra` 的明文数据源是紧凑 JSON，包含 `dynver`、Root/ADB/Boot 状态、系统指纹、ABI、文件权限、Frida 检测、随机字段和 `userenv` 等。trace 中紧凑明文缓冲区为：

```text
地址：0xb4000077a1a24580
长度：0x2fe = 766 字节
首字节：7b 22 64 79 6e 76 65 72 ...
ASCII：{"dynver"...
```

加密后内部缓冲区为：

```text
地址：0xb400007841783b30
长度：0x306 = 774 字节
```

多出的 8 字节位于最前面，后面 766 字节与明文等长，初步提示“元数据前缀 + 流加密密文”，而不是带 PKCS#7 padding 的 CBC。

---

## 4. 首先识别流加密行为

### 4.1 关键 XOR 循环

`libriver.so + 0x19E280` 附近的动态指令是最直接的证据：

```asm
0x19E280  LDRB W10, [plaintext, index]
0x19E284  LDRB W11, [keystream, block_index]
0x19E294  EOR  W8, W11, W10
0x19E2B0  STRB W8, [ciphertext, index]
```

第一字节：

```text
明文       = 0x7b ('{')
密钥流     = 0xc3
密文       = 0xb8
0x7b XOR 0xc3 = 0xb8
```

第二字节：

```text
明文       = 0x22 ('"')
密钥流     = 0x5e
密文       = 0x7c
0x22 XOR 0x5e = 0x7c
```

因此核心关系被动态确认：

```text
C[i] = P[i] XOR KS[i]
```

这排除了“JSON 直接哈希”“逐字段编码”等不可逆处理，并说明前面的复杂函数是在生成密钥流块。

### 4.2 16 字节分块

密钥流缓冲区按 `index & 0x0f` 访问，每 16 字节重新执行一次块变换，说明底层块大小为 128 bit。这与 AES 的 16 字节块大小一致，但仅凭这一点还不能断言 AES。

---

## 5. 识别 CTR 计数器

白盒块变换完成后，`0x19E1F0–0x19E268` 从状态第 15 字节开始加一，并在溢出时向低地址传播进位：

```asm
MOV   W8, #15
LDRB  W11, [counter, W8]
ADD   W11, W11, #1
STRB  W11, [counter, W8]
...
SUB   index, index, #1
```

去混淆后的语义为：

```c
for (int i = 15; i >= 0; --i) {
    counter[i]++;
    if (counter[i] != 0)
        break;
}
```

因此这是 128-bit 大端计数器。结合：

```text
KS_n = BlockEncrypt(counter_n)
C_n  = P_n XOR KS_n
counter_{n+1} = counter_n + 1
```

可以识别为 CTR 模式，而非 CBC、CFB 或 OFB。

---

## 6. 从指令结构识别白盒 AES

### 6.1 AES ShiftRows 指纹

在完整轮入口处，输入状态按以下索引取字节：

```text
0, 5, 10, 15,
4, 9, 14, 3,
8, 13, 2, 7,
12, 1, 6, 11
```

这正是 AES 状态按列线性存储时的 ShiftRows 置换：

```c
static const uint8_t SR[16] = {
     0,  5, 10, 15,
     4,  9, 14,  3,
     8, 13,  2,  7,
    12,  1,  6, 11
};
```

第一列选择 `state[0]`、`state[5]`、`state[10]`、`state[15]`。动态 trace 对初始状态确实读取：

```text
0x42, 0xbb, 0x51, 0x76
```

精确 ShiftRows 置换是识别 AES 的强证据，通常比搜索 AES S-box 字节更可靠，因为白盒实现会把 S-box 和轮密钥融合进表，使标准 S-box 不再以明文形式出现。

### 6.2 每列四个 256×32-bit T-box

每个输出列对四个输入字节分别查 32-bit 表，四张表之间间隔 `0x400`：

```text
T0[x0]：base + 0x000 + x0*4
T1[x1]：base + 0x400 + x1*4
T2[x2]：base + 0x800 + x2*4
T3[x3]：base + 0xC00 + x3*4
```

第一列动态查表值示例：

```text
T0[0x42] = 0x4051978b
T1[0xbb] = 0xd668e1f7
T2[0x51] = 0x174b2e8c
T3[0x76] = 0x68e9cb63
```

普通 T-table AES 会直接 XOR 四个 word；白盒实现则需要在隐藏内部编码的条件下合并它们。

### 6.3 nibble 编码 XOR 网络

trace 中反复出现如下地址构造：

```text
xor_table + (a_nibble << 4) + b_nibble
```

随后读取一个字节。等价抽象为：

```c
uint8_t wb_xor4(const uint8_t table[256], uint8_t a, uint8_t b) {
    return table[((a & 0xf) << 4) | (b & 0xf)];
}
```

其语义不是简单 `table[a][b] = a ^ b`，而是：

```text
X[Ea(a)][Eb(b)] = Ec(a XOR b)
```

`Ea/Eb/Ec` 是内部编码双射。四个 32-bit T-box 输出经过多层高低 nibble 合并，最终得到四个编码状态字节。这是 Chow 类白盒 AES 的典型结构：

- T-box 融合 S-box、轮密钥、MixColumns 和编码；
- XOR 使用查表而不是裸 `EOR`；
- 中间状态始终处于编码域。

### 6.4 轮数与表跨度

动态 trace 显示完整轮循环计数到 9：

```text
round = 1 ... 9
```

每轮表基址增加：

```text
0x4000
```

一轮表大小恰好是：

```text
16 个位置 × 256 项 × 4 字节 = 0x4000
```

九轮总表大小：

```text
9 × 0x4000 = 0x24000
```

之后进入独立末轮。

### 6.5 独立 AES 末轮

末轮使用 16 张 256-byte 表：

```asm
table = final_base + position * 0x100
output = table[state[position]]
```

抽象为：

```c
for (int i = 0; i < 16; ++i)
    state[i] = finalT[i][state[i]];
```

末轮之后没有 MixColumns 合并网络。这与 AES 最后一轮“SubBytes + ShiftRows + AddRoundKey，无 MixColumns”一致。

### 6.6 为什么确定是 AES-128

综合特征：

1. 精确 ShiftRows；
2. 四个 32-bit T-box 合成一列；
3. MixColumns 风格的四路贡献；
4. 9 个完整轮；
5. 第 10 轮无 MixColumns；
6. 16-byte 块。

因此是 AES。轮数为 10，故是 AES-128，而非 AES-192（12 轮）或 AES-256（14 轮）。

---

## 7. 初始 CTR block 的构造

### 7.1 时间戳部分

本次时间戳：

```text
1784793365424 = 0x19f8df97bb0
```

代码先把整数转换为 IEEE-754 `double`：

```asm
SCVTF D0, X8
FMOV  X10, D0
REV   X19, X10
```

得到大端字节：

```hex
42 79 f8 df 97 bb 00 00
```

注意这不是 `uint64_t timestamp` 的大端表示，而是 `(double)timestamp` 的 bit pattern。

加密结果前 8 字节也保存这一值：

```text
encrypted_blob = timestamp_double_be || ciphertext
```

### 7.2 随机 selector

每个 selector 使用三次 `arc4random()`：

```c
bank  = r0 % 9;
lane  = r1 & 0x0f;
index = r2 & 0xff;
```

查找：

```c
word = selectorTable[bank][lane][index];
```

地址结构：

```text
base + bank*0x4000 + lane*0x400 + index*4
```

本次两组结果：

```text
selector1 = 00 05 01 65
word1     = 6f f7 51 57

selector2 = 00 00 09 69
word2     = c5 eb cb 76
```

### 7.3 初始 counter

因此初始 16-byte AES 输入是：

```hex
42 79 f8 df 97 bb 00 00 6f f7 51 57 c5 eb cb 76
```

布局：

```text
[ timestamp double BE: 8 bytes ]
[ selector word 1:      4 bytes ]
[ selector word 2:      4 bytes ]
```

---

## 8. 私有封包与 selector 携带

AES-CTR 输出并未直接 Base64，而是调用 `sub_D912C` 封包。

Base64 解码后的头：

```hex
0f c1 00 00 10 08 02 e9 00 9b
```

其中两个 16-bit 大端位置：

```text
p2 = 0x02e9 = 745
p1 = 0x009b = 155
```

两个插入块并非随机垃圾，而是 selector：

```text
packet[10 + p1 : +4]            = 00 00 09 69 = selector2
packet[10 + p1 + 4 + (p2-p1):] = 00 05 01 65 = selector1
```

解包公式：

```text
encrypted_blob =
    packet[10 : 10+p1]
  || packet[10+p1+4 : 10+p1+4+(p2-p1)]
  || packet[10+p1+4+(p2-p1)+4 : end]
```

恢复后长度：

```text
774 = 8-byte timestamp + 766-byte ciphertext
```

外层最终编码：

```text
extra = "01" + Base64(packet)
```

`01` 是字符串协议版本前缀，不属于 Base64。

---

## 9. 密钥恢复目标与困难

白盒 AES 中不会出现普通的：

```c
uint8_t key[16];
uint8_t roundKey[176];
```

主密钥被融合进第一轮 T-box，后续轮密钥被融合进对应轮表。因此：

- 搜字符串找不到 key；
- 搜标准 AES S-box 可能找不到；
- 从一组 `AES_K(P)=C` 不能实际暴力破解 128-bit key；
- 必须利用 T-box 与 AES S-box 的代数关系消除白盒输出编码。

本次使用的是 BGE 思路中的仿射等价秩测试，直接从第一轮 16 张 T-box 逐字节恢复首轮 key byte。

---

## 10. 第一轮 T-box 的代数模型

对于第 `i` 个第一轮 T-box，可抽象为：

```text
T_i(x) = A_i(MC_i(S(x XOR k_i))) XOR b_i
```

其中：

- `x`：输入字节；
- `k_i`：需要恢复的 AES key byte；
- `S`：标准 AES S-box；
- `MC_i`：该字节对 MixColumns 的 32-bit 贡献；
- `A_i`、`b_i`：白盒输出的未知仿射编码。

虽然 `A_i` 和 `b_i` 未知，但正确 `k_i` 下，`T_i(x)` 与 `S(x XOR k_i)` 之间仍是仿射关系。

错误 key guess 会让两个映射之间通常不存在低维仿射关系。

---

## 11. GF(2) 仿射秩测试

### 11.1 构造向量

对每张 T-box、每个候选 `k ∈ [0,255]` 和所有 `x ∈ [0,255]`，构造 41-bit 向量：

```text
v_x = 1 || SBOX(x XOR k) || T_i(x)
```

位数：

```text
1 个仿射常数位
+ 8 个 AES S-box 输出位
+ 32 个 T-box 输出位
= 41 bit
```

代码表达：

```python
row = 1 | (SBOX[x ^ key_guess] << 1) | (outputs[x] << 9)
```

### 11.2 为什么正确 key 的秩是 9

若存在仿射映射：

```text
T_i(x) = A(SBOX(x XOR k)) XOR b
```

那么 32-bit `T_i(x)` 完全由：

```text
常数 1 + 8-bit SBOX 输出
```

线性决定，所以所有 41-bit 图向量最多张成 9 维空间。

正确 key byte 因而满足：

```text
rank_GF(2) <= 9
```

错误 key guess 通常使 rank 明显高于 9。

### 11.3 GF(2) 高斯消元

实现以 Python 大整数保存 41-bit 行，逐列选 pivot 并 XOR 消元：

```python
def gf2_rank(rows):
    rows = list(rows)
    rank = 0
    for column in range(41):
        pivot = next(
            (i for i in range(rank, len(rows))
             if (rows[i] >> column) & 1),
            None
        )
        if pivot is None:
            continue

rows[rank], rows[pivot] = rows[pivot], rows[rank]

for i in range(len(rows)):
            if i != rank and ((rows[i] >> column) & 1):
                rows[i] ^= rows[rank]

rank += 1

return rank
```

对每张表测试全部 256 个候选。实际每张表均只有一个 rank-9 候选。

---

## 12. 读取第一轮表

第一轮白盒表位于二进制文件偏移：

```text
0x7020
```

大小：

```text
0x4000
```

读取方式：

```python
round0 = image[0x7020 : 0x7020 + 0x4000]
```

第 `i` 张表：

```python
raw = round0[i*0x400 : (i+1)*0x400]
```

每项是 little-endian `uint32_t`：

```python
T_i[x] = int.from_bytes(raw[x*4:x*4+4], "little")
```

然后执行秩测试：

```python
for i in range(16):
    for k in range(256):
        rank = gf2_rank(
            1 |
            (AES_SBOX[x ^ k] << 1) |
            (T_i[x] << 9)
            for x in range(256)
        )
        if rank <= 9:
            candidate[i].append(k)
```

---

## 13. 恢复结果与逆 ShiftRows

16 张 T-box 得到的唯一候选，按 T-box/ShiftRows 顺序为：

```text
T00=68 T01=77 T02=78 T03=78
T04=6f T05=64 T06=78 T07=6c
T08=6c T09=78 T10=6c T11=72
T12=78 T13=65 T14=6f T15=78
```

拼接：

```text
687778786f64786c6c786c7278656f78
```

这是 T-box 输入使用 ShiftRows 排列后的 key byte 顺序，不是标准 AES key 顺序。

已知表索引对应标准状态索引：

```c
SR = {
     0,  5, 10, 15,
     4,  9, 14,  3,
     8, 13,  2,  7,
    12,  1,  6, 11
};
```

逆排列：

```python
key = bytearray(16)
for table_index, value in enumerate(table_order_key):
    key[SR[table_index]] = value
```

得到标准 AES-128 主密钥：

```hex
68 65 6c 6c 6f 77 6f 72 6c 64 78 78 78 78 78 78
```

ASCII：

```text
helloworldxxxxxx
```

---

## 14. 密钥验证闭环

### 14.1 已知 AES 输入

初始 counter：

```text
4279f8df97bb00006ff75157c5ebcb76
```

### 14.2 标准 AES 验证

使用恢复密钥执行普通 AES-128-ECB 单块加密：

```text
key   = 68656c6c6f776f726c64787878787878
input = 4279f8df97bb00006ff75157c5ebcb76
```

结果：

```text
c35e6ffa54e48548bdd188fae5ddbecf
```

与 trace 第一块白盒输出完全一致。

### 14.3 明文/密钥流/密文验证

```text
明文：
7b2264796e766572223a22322e302e30

密钥流：
c35e6ffa54e48548bdd188fae5ddbecf

XOR 密文：
b87c0b833a92e03a9febaac8cbed90ff
```

这与解包后的密文首块完全一致，实现三重闭环：

1. 白盒结构识别为 AES；
2. 代数恢复出的 key 能生成 trace 密钥流；
3. 密钥流 XOR 明文能生成 trace 密文。

因此密钥不是猜测，也不是仅凭可打印字符串判断。

---

## 15. 完整解密流程

```text
extra
  ↓ 删除前缀 "01"
Base64 文本
  ↓ Base64 decode
私有 packet
  ↓ 解析 10-byte header 和两个插入位置
  ↓ 取出 selector1 / selector2
  ↓ 删除 selector 插入块并重组
774-byte encrypted_blob
  ↓ 前 8 字节读取 timestamp double bits
  ↓ 后 766 字节为 ciphertext
  ↓ selector 查表得到两个 counter word
  ↓ 构造 16-byte initial counter
AES-128-CTR transform
  ↓ key = helloworldxxxxxx
紧凑 JSON
```

CTR 加解密相同：

```c
P[i] = C[i] XOR AES_K(counter_block)[i & 15];
```

---

## 16. 普通 AES 替代白盒实现

恢复 key 后，不再需要模拟白盒表。可直接用标准 AES-128-ECB 生成 CTR 密钥流：

```javascript
const crypto = require("crypto");

const KEY = Buffer.from(
  "68656c6c6f776f726c64787878787878",
  "hex"
);

function aesBlock(block) {
  const cipher = crypto.createCipheriv("aes-128-ecb", KEY, null);
  cipher.setAutoPadding(false);
  return Buffer.concat([cipher.update(block), cipher.final()]);
}

function incrementBE128(counter) {
  for (let i = 15; i >= 0; --i) {
    counter[i] = (counter[i] + 1) & 0xff;
    if (counter[i] !== 0) break;
  }
}

function ctrTransform(input, initialCounter) {
  const counter = Buffer.from(initialCounter);
  const output = Buffer.alloc(input.length);

for (let off = 0; off < input.length; off += 16) {
    const stream = aesBlock(counter);
    const n = Math.min(16, input.length - off);

for (let i = 0; i < n; ++i)
      output[off + i] = input[off + i] ^ stream[i];

incrementBE128(counter);
  }

return output;
}
```

---

## 17. 可复现密钥提取脚本

脚本位置：

```text
C:\Users\zgy\AppData\Local\Temp\opencode\recover_libriver_wbaes_key.py
```

运行：

```powershell
py C:\Users\zgy\AppData\Local\Temp\opencode\recover_libriver_wbaes_key.py `
  D:\tome\tome\split_config.arm64_v8a\lib\arm64-v8a\libriver.so
```

实际输出：

```text
rank-9 guesses in T-box/ShiftRows order:
T00=68 T01=77 T02=78 T03=78 T04=6f T05=64 T06=78 T07=6c
T08=6c T09=78 T10=6c T11=72 T12=78 T13=65 T14=6f T15=78

table-order key : 687778786f64786c6c786c7278656f78
AES-128 key     : 68656c6c6f776f726c64787878787878
AES-ECB result  : c35e6ffa54e48548bdd188fae5ddbecf
expected result : c35e6ffa54e48548bdd188fae5ddbecf
validation      : PASS
```

---

## 18. 分析中容易出现的误判

### 18.1 看到 XOR 就称为自定义流密码

错误。CTR 模式本来就是明文 XOR 块密码输出。必须继续分析密钥流生成器。

### 18.2 搜不到 AES S-box 就排除 AES

错误。白盒 AES 会融合 S-box、轮密钥、MixColumns 和编码，标准 S-box 字节序列往往不存在。

应优先寻找：

- ShiftRows 索引；
- 16-byte state；
- 4×32-bit 列查表；
- 9+1 轮结构；
- 末轮无 MixColumns；
- 每轮 `0x4000` 的表几何。

### 18.3 把 selector 插入块当随机垃圾

错误。两个 4-byte 插入块携带 `bank/lane/index`，接收方需要它们重建 counter 后 8 字节。

### 18.4 把 `01` 当成 Base64 内容

错误。`01` 是 ASCII 协议前缀，真正 Base64 从后面的 `D8EA...` 开始。

### 18.5 仅凭 ASCII 可读性认定 key

`helloworldxxxxxx` 很可读，但仍必须验证。最终可信度来自标准 AES 对已知输入输出的精确匹配。

---

## 19. 最终结论

从 trace 指令识别白盒 AES 的关键路径是：

```text
逐字节 XOR
→ 16-byte 密钥流块
→ 128-bit 大端 counter
→ 精确 AES ShiftRows
→ 4 个 32-bit T-box/列
→ 编码 nibble XOR 网络
→ 9 个完整轮，每轮 0x4000
→ 16×256-byte 无 MixColumns 末轮
→ 确认白盒 AES-128-CTR
```

密钥恢复路径是：

```text
定位第一轮 16×256×32-bit T-box
→ 对每张表枚举 256 个 key-byte guess
→ 构造 (1, AES_SBOX(x⊕k), T[x]) 图向量
→ GF(2) 仿射秩测试
→ 每张表取得唯一 rank-9 候选
→ 得到 ShiftRows 顺序 key
→ 逆 ShiftRows
→ 获得标准 AES-128 主密钥
→ 用标准 AES-ECB 对 trace counter/keystream 验证
```

最终恢复结果：

```text
AES-128 key (hex):
68656c6c6f776f726c64787878787878

AES-128 key (ASCII):
helloworldxxxxxx
```

验证状态：

```text
PASS
```

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

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最新回复 (11)
wx_龙龙_794 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 18 粉丝 0 关注私信	wx_龙龙_794 2 楼 tql 13小时前 0
Zepp7289 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 154 粉丝 0 关注私信	Zepp7289 3 楼有了trace和ai后，这些加密手段和纸糊的一样 12小时前 0
乐子人雪币： 4492 活跃值： (7452) 能力值： ( LV9，RANK：220 ) 在线值：发帖 14 回帖 134 粉丝 657 关注私信	乐子人 4 4 楼 Zepp7289 有了trace和ai后，这些加密手段和纸糊的一样是这样的，简单的ai直接分析。特别复杂的混淆，trace完ai也直接分析trace。 12小时前 0
koflfy 雪币： 102 活跃值： (4161) 能力值： ( LV4，RANK：50 ) 在线值：发帖 8 回帖 486 粉丝 5 关注私信	koflfy 1 5 楼乐哥出品，必属精品。 12小时前 0
xingbing 雪币： 158 活跃值： (5841) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 1407 粉丝 2 关注私信	xingbing 6 楼感谢分享。 11小时前 0
iBa0 雪币： 1901 活跃值： (5983) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 497 粉丝 37 关注私信	iBa0 7 楼 111 8小时前 0
kingking888 雪币： 3245 活跃值： (6359) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 305 粉丝 6 关注私信	kingking888 8 楼 666 8小时前 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 714 粉丝 7 关注私信	mb_ldbucrik 9 楼感谢分享 8小时前 0
mb_ykavguun 雪币： 1328 活跃值： (1860) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 168 粉丝 0 关注私信	mb_ykavguun 10 楼 666 8小时前 0
蜡笔晓辉雪币： 1200 活跃值： (755) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 51 粉丝 2 关注私信	蜡笔晓辉 11 楼 666 6小时前 0
温泉划水鱼雪币： 95 能力值： ( LV1，RANK：0 ) 在线值：发帖 6 回帖 229 粉丝 28 关注私信	温泉划水鱼 12 楼 777 2小时前 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复