[原创]新版梆企检测绕过-Android安全-看雪安全社区

[原创]新版梆企检测绕过

发表于: 2026-4-19 16:55 13785

[原创]新版梆企检测绕过

Yangser

2026-4-19 16:55

13785

#  新版梆企检测绕过

## 0x00 前言

1. 其实本来应该连dex解密流程一块讲的，但是上周一直在加班，没有时间写完，所以拆成两篇来写吧，这篇先只讲一下如何绕过frida检测，祈祷我下周不要再加班了

## 0x01 linker mini版

### 入手

IDA打开发现导入表空空如也，无需多言，先dump修复一份so，IDA打开之后发现只有寥寥数个函数，并且注册了constructor函数，那只好先去入口处看看了

```c
__int64 sub_4780()
{
  _DWORD *j; // x2
  void *libc_handle; // x0
  int i; // [xsp-60h] [xbp-90h]
  int k; // [xsp-14h] [xbp-44h]

for ( i = 273; i != 70; i = 70 )
    ;
  for ( j = (_DWORD *)((unsigned __int64)sub_4780 & 0xFFFFFFFFFFFFF000LL); *j != 0x464C457F; j -= 1024 )// ELF魔数
    ;
  shell_base = (__int64)j;
  libc_handle = dlopen("libc.so", 2);
  g_scanf = (__int64 (*)(_QWORD, const char *, ...))dlsym(libc_handle, "sscanf");
  for ( k = 273; k != 70; k = 70 )
    ;
  dword_15040 = dword_15008;                    // 0x8000
  dword_15064 = dword_1500C;                    // 0x1608
  dword_15078 = dword_15010;                    // 0x877
  dword_15030 = dword_15014;                    // 0x159000
  dword_15088 = dword_15018;                    // 0x15B000
  dword_15084 = dword_1501C;                    // 0x15C000
  dword_1507C = dword_15020;                    // 0x1181DD
  return sub_33F8();                            // 主加载流程
}
```

这是入口函数，上来就会被调用，其中`0x464C457F`是ELF魔数，这段代码在从自身页面开始往上扫描，直到扫描到ELF魔数，从而查找自身的基地址，然后拿到`sscanf`的地址，存到全局变量中。我也不晓得这一通操作意欲何为。前一个还可以理解，这么做会比较节省时间，至于sscanf，直接拿来用不就行了吗，他这里还查找这个符号然后保存有点没理解，有懂的大牛子可以解释一下

然后就是保存一些全局变量，都是写死的偏移或者秘钥信息，比较重要，后续解密时会用到。最后就是这个壳so最重要的函数了`sub_33F8()`

### 定位

建议如果要分析的话，先看看这个简单的项目吧，因为项目里so加载流程和这个壳不能说100%一样，但是也有90%是一样的 <a href="elink@db0K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6e0L8%4W2n7k6h3q4F1e0h3W2D9K9%4S2Q4x3V1k6K6L8@1I4G2j5h3c8W2M7R3`.`.">Yuuki/soLoader</a>

这个函数有900多行，不算很复杂，而且核心函数一目了然。它调用了  `mmap`，`dlopen`，`mprotect`等函数，结合之前发现的，1.36M的so，反编译之后就几个函数，其他地方都是被加密的，那不难猜到这个函数的作用就是在运行时动态解密释放真正的so，然后真正的so再去对dex做解密等操作。如果是简单的upx壳，那么大概率不会使用到`dlopen`，因为upx只需要申请内存，解密payload即可，但是这里它调用了`dlopen`，还是在一个循环中调用的

```c
do {
    while ( *v76 != 1 )  {
        v76 += 2;
        if ( v76 == v91 )
            goto LABEL_186;
        }
        v92 = v76[1];
        v76 += 2;
        *(&v123 + (int)v90++) = (__int64)dlopen((const char *)(v118 + v92), 2);
    }
while ( v76 != v91 );
```

这很明显就是在处理`DT_NEEDED`条目了，那么这个函数，基本上可以初步判断为一个简易的linker，职责是加载真正的so

那么我们当下的直接目标就是解密出真正的so，所以先来简单分析一下这个函数吧~，我只截取关键的部分，感兴趣的可以自己从头看看

```c
v5 = fopen("/proc/self/maps", "r");
  memset(v143, 0, 0x400u);
  v123 = 0;
  v122 = 0;
  memset(v142, 0, 0x100u);
  while ( fgets((char *)v143, 1024, v5) )       // 解析maps，根据shell_base判断是否为so自身，取出so路径
  {
    g_scanf(v143, "%lx-%lx %s %s %s %s %s", &v122, &v123, v142, v142, v142, v142, so_path);
    if ( v122 <= shell_base && shell_base < v123 )
      break;
  }
  fclose(v5);
  v102 = so_path;
  so_file_handle = open((const char *)so_path, 0x80000);
```

这里反编译之后跟看源码没啥区别。先解析maps，根据上面拿到的 so 基地址来判断当前条目是否命中，命中取出 so 路径，为了拿到libDexHelper.so的路径。这里这么做是因为android加载so时，会从 `/data/app/一串神秘代码/libs` 下加载，而厂商的代码是写死的，他不知道这个神秘代码是啥就拿不到文件的磁盘路径，所以需要这样获取一下。当然我觉得直接在内存里操作也是可以的，不过这个看个人喜好了

拿到路径之后 ，它做了如下三件事情

```c
pread(so_file_handle, &qword_15050, 0x14u, (unsigned int)dword_1507C);// 从0x1181DD读20字节
dword_15080 = dword_15060;
memset(so_path, 0, 64);
qword_15068 = qword_15050;
qword_15070 = qword_15058;
pread(so_file_handle, so_path, 0x40u, (unsigned int)dword_15040);// 从0x8000读64字节
((void (__fastcall *)(_QWORD *, _QWORD))sub_3184)(so_path, (unsigned int)dword_15040);// RC4解密64字节 7F454C4602010... 这是ELF头
```

读了磁盘上的so的特定偏移的一些数据，这些偏移地址是写死的，上述初始化函数里提到过。其中 `sub_3184`是一个变种的RC4算法，秘钥用的是`qword_15068`，`qword_15068`来自 从0x1181DD读的20字节，所以这一块的逻辑就是，读取秘钥，读取要解密的64字节，调用解密函数，解密

解密出的数据如下：

`7F454C460201010000000000000000000300B70001000000B0F8000000000000400000000000000000F71000000000000000000040003800080040001A001900`

这完全验证了我们之前的猜想，这是一个标准的ELF头，所以这个函数的确是一个迷你的linker，并且我们已经拿到了ELF头的解密算法，接下来就是找剩下的数据是如何被加密的了

```c
v36 = v35;
v111 = v35;
v37 = (unsigned __int8 *)mmap((void *)((v32 + v110) & 0xFFFFFFFFFFFFF000LL), v35, 3, 50, 0, 0);// 对每个 `PT_LOAD` 段做映射/拷贝
v38 = v37;
if ( v37 == (unsigned __int8 *)-1LL )
	break;
v39 = HIDWORD(v113);
if ( lseek(SHIDWORD(v113), (unsigned int)v107 & 0xFFFFF000, 0) == -1 )
	break;
v112 = read(v39, v37, v36);         // 读取每个段内容
if ( (_DWORD)v112 == -1 )
	break;
if ( v28 != 1 ) {
	((void (__fastcall *)(unsigned __int8 *, _QWORD, _QWORD))sub_2B1C)(v37, 0, (unsigned int)v112);// 循环调用xor解密函数，解密各个段
    goto LABEL_124;
}
v40 = v133;
v131 = 0;
v132 = 30;
v133[0] = 273;
```

关键解密函数是`sub_2B1C`，这就是一个简单的xor加解密

```c
char *__fastcall sub_2B1C(__int64 a1, int a2, int a3)
{
  char *result; // x0
  char *v4; // x3
  char v5; // t1
  int i; // [xsp-34h] [xbp-44h]

for ( i = 273; i != 70; i = 70 )
    ;
  result = (char *)(a1 + a2);
  v4 = result;
  if ( a3 )
  {
    do
    {
      v5 = *v4++;
      *(v4 - 1) = dword_15080 ^ v5;             // xor 0x41
    }
    while ( a3 > (unsigned __int64)(unsigned int)((_DWORD)v4 - (_DWORD)result) );
  }
  return result;
}
```

秘钥是0x41，之前读20字节的时候读出来的，那么就可以静态解密出真正的so了。当然你也可以运行时动态dump，我看见有的朋友是直接在dlopen onLeave的时候扫描匿名可执行内存，然后直接dump的，这样也可以的，并且不用分析壳so的逻辑，建议大家这么做

分析到这里就可以解密出主so了，但是本着来都来的的心态，还是看看后面它做了哪些操作吧

```c
v21 = (void *)(v12 & 0xFFFFF000);
v22 = ((v17 + 4095) & 0xFFFFF000) - (unsigned int)v21;
real_base = mmap(v21, v22, 3, 34, -1, 0);   // 分配匿名内存，用于映射真正的so
```

```c
if ( mprotect(v38, v111, (*(_DWORD *)v29 >> 2) & 1 | *(_DWORD *)v29 & 2 | (4 * (*(_DWORD *)v29 & 1))) == -1 )// 恢复各个段的权限
goto LABEL_131;
if ( (*(_DWORD *)v29 & 2) != 0 )
	break;
v67 = (*(_DWORD *)v29 >> 2) & 1 | 2;
v68 = (*(_DWORD *)v29 & 1) != 0 ? 4 : 0;
v29 += 56LL;
mprotect(v38, v111, v67 | v68);
v30 = v25 == ++v27;
```

```c
((void (__fastcall *)(unsigned __int64, __int64, __int64, _QWORD, __int64 *, _QWORD, __int64))sub_2CD0)(// 一种重定位
            v119,
            v118,
            v123,
            (unsigned int)v124,
            &v123,
            v90,
            v117);
          ((void (__fastcall *)(unsigned __int64, __int64, __int64, _QWORD, __int64 *, _QWORD, __int64))sub_2CD0)(// 另一种重定位
            v93,
            v94,
            v129,
            (unsigned int)len,
            &v123,
            v90,
            v95);
```

```c
 v57 = ((__int64 (__fastcall *)(unsigned __int64, const void *, _QWORD, __int64, __int64))sub_303C)(// 查找JNI_OnLoad
                  v107,
                  v106,
                  (unsigned int)v115,
                  v109,
                  v110);
          if ( v80 != (void (__fastcall *)(__int64))-1LL && v80 )
            v80(v57);
          for ( i = 0; (unsigned int)v74 > (unsigned int)i; ++i )// 调内层so的.init_array
          {
            v59 = *(void (**)(void))(v77 + 8 * i);
            if ( v59 != (void (*)(void))-1LL && v59 )
              v59();
          }
```

```c
 memcpy((void *)(shell_base + (unsigned int)dword_15084), (const void *)v116, v63);// 把内层 SysV hash 拷到外层 `0x15C000`
          memcpy(v64, v62, (unsigned int)dword_15064);// 把内层 dynsym 拷到外层 `0x159000`
          memcpy(v65, v61, (unsigned int)dword_15078);// 把内层 dynstr 拷到外层 `0x15B000`
          close(SHIDWORD(v105));
```

总结下来就是：

1. 从 /proc/self/maps 定位当前 so 的真实文件路径
2. 打开自身文件
3. 读取尾部密钥材料
4. 读取并解密内层 ELF 头
5. 映射并解密包含 Program Header 的第一页
6. 计算内层镜像范围并申请最终地址空间
7. 逐段读取、XOR 解密、装载 PT_LOAD，完成 BSS
8. 解析 PT_DYNAMIC
9. dlopen 依赖库
10. 用自定义解析器做重定位
11. 定位内层 JNI_OnLoad
12. 调用 DT_INIT 和 INIT_ARRAY
13. 把内层 hash/dynsym/dynstr 回填到外层壳的预留区
14. 返回，等待外部以后通过外层库视图解析到内层符号

感觉和我之前写的差不多，但是我把加密的步骤前置了 [so加固玩具版](https://bbs.kanxue.com/thread-287254.htm)

### 主so解密

```python
from __future__ import annotations

import argparse
from pathlib import Path
import sys

PAYLOAD_OFFSET = 0x8000
TAIL_OFFSET = 0x1181DD
TAIL_SIZE = 0x14
HEADER_SIZE = 0x40
STREAM_KEY_SIZE = 16

def rc4_like_decrypt_header(enc_header: bytes, stream_key: bytes) -> bytes:
    if len(enc_header) != HEADER_SIZE:
        raise ValueError(f"expected {HEADER_SIZE:#x}-byte header, got {len(enc_header):#x}")
    if len(stream_key) != STREAM_KEY_SIZE:
        raise ValueError(f"expected {STREAM_KEY_SIZE} key bytes, got {len(stream_key)}")

sbox = list(range(256))
    j = 0
    key_index = 0

for i in range(256):
        j = (j + sbox[i] + stream_key[key_index]) & 0xFF
        sbox[i], sbox[j] = sbox[j], sbox[i]
        key_index = (key_index + 1) % STREAM_KEY_SIZE

out = bytearray(enc_header)
    i = 0
    j = 0
    for pos in range(len(out)):
        i = (i + 1) & 0xFF
        t = sbox[i]
        j = (j + t) & 0xFF
        sbox[i], sbox[j] = sbox[j], t
        out[pos] ^= sbox[(sbox[i] + t) & 0xFF]

return bytes(out)

def decrypt_libdexhelper_outer(outer_data: bytes) -> tuple[bytes, int]:
    min_size = TAIL_OFFSET + TAIL_SIZE
    if len(outer_data) < min_size:
        raise ValueError(
            f"file too small: need at least {min_size:#x} bytes, got {len(outer_data):#x}"
        )

tail = outer_data[TAIL_OFFSET : TAIL_OFFSET + TAIL_SIZE]
    stream_key = tail[:STREAM_KEY_SIZE]
    body_xor_key = tail[STREAM_KEY_SIZE]

payload = bytearray(outer_data[PAYLOAD_OFFSET:TAIL_OFFSET])
    if len(payload) < HEADER_SIZE:
        raise ValueError("embedded payload is smaller than the encrypted header")

# The inner ELF body is XOR-encrypted with a single-byte key.
    for idx in range(HEADER_SIZE, len(payload)):
        payload[idx] ^= body_xor_key

# The first 0x40 bytes are encrypted separately with the RC4-like routine.
    payload[:HEADER_SIZE] = rc4_like_decrypt_header(payload[:HEADER_SIZE], stream_key)

return bytes(payload), body_xor_key

def build_default_output_path(input_path: Path) -> Path:
    if input_path.suffix:
        return input_path.with_name(f"{input_path.stem}.hidden.decrypted{input_path.suffix}")
    return input_path.with_name(f"{input_path.name}.hidden.decrypted.so")

def parse_args(argv: list[str]) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Decrypt the hidden inner ELF from this protected libDexHelper.so sample."
    )
    parser.add_argument("input", type=Path, help="Path to the encrypted outer libDexHelper.so")
    parser.add_argument(
        "-o",
        "--output",
        type=Path,
        help="Output path for the decrypted inner ELF. Defaults next to the input file.",
    )
    return parser.parse_args(argv)

def main(argv: list[str]) -> int:
    args = parse_args(argv)
    input_path: Path = args.input
    output_path: Path = args.output or build_default_output_path(input_path)

outer_data = input_path.read_bytes()
    inner_data, xor_key = decrypt_libdexhelper_outer(outer_data)

if inner_data[:4] != b"\x7fELF":
        raise RuntimeError(
            "decryption completed, but the result does not start with ELF magic; "
            "double-check the sample matches this script."
        )

output_path.write_bytes(inner_data)

print(f"input : {input_path}")
    print(f"output: {output_path}")
    print(f"tail offset   : {TAIL_OFFSET:#x}")
    print(f"payload offset: {PAYLOAD_OFFSET:#x}")
    print(f"body xor key  : {xor_key:#x}")
    print(f"payload size  : {len(inner_data):#x}")
    print(f"elf magic     : {inner_data[:4].hex()}")

return 0

if __name__ == "__main__":
    try:
        raise SystemExit(main(sys.argv[1:]))
    except Exception as exc:
        print(f"error: {exc}", file=sys.stderr)
        raise SystemExit(1)

```

运行一下，就要开始分析主so了捏

### 铺垫

我们后面在hook主so里的函数时需要使用主so的基地址+函数偏移，但是主so是被映射到它自己mmap的匿名内存上的，这里有很多方案，我们选择相对优雅的一种

之前分析出了

```c
real_base = mmap(v21, v22, 3, 34, -1, 0);   // 分配匿名内存，用于映射真正的so
```

我们直接hook mmap，根据后面四个参数值进行过滤即可，如果噪音过多，可以根据映射大小进一步过滤。过滤完可以看到只这样的

```bash
[+] inner base = 0x7c01620000
[+] mmap args  = addr=0x0 len=0x134000 prot=0x3 flags=0x22 fd=-1 off=0x0 ra=0x7c00c21888
```

```javascript
var target_so = "libDexHelper.so";
var linker_name = Process.pointerSize === 8 ? "linker64" : "linker";
var call_constructors_offset = 0xb4900; // oriole / Pixel 6

var target_seen = false;
var found = false;
var mmap_hooked = false;

var outer_base = null;
var outer_size = 0;

function hook_mmap() {
    if (mmap_hooked) return;

mmap_hooked = true;
    Interceptor.attach(Module.findExportByName("libc.so", "mmap"), {
        onEnter: function (args) {
            this.addr = args[0];
            this.len = args[1];
            this.prot = args[2].toInt32();
            this.flags = args[3].toInt32();
            this.fd = args[4].toInt32();
            this.off = args[5].toUInt32();
            this.ra = this.returnAddress;
        },
        onLeave: function (retval) {
            if (found || retval.isNull() || outer_base == null) return;

let from_outer =
                this.ra.compare(outer_base) >= 0 &&
                this.ra.compare(outer_base.add(outer_size)) < 0;

if (
                from_outer &&
                this.prot === 3 &&
                this.flags === 0x22 &&
                this.fd === -1 &&
                this.off === 0
            ) {
                found = true;
                console.log("[+] inner base =", retval);
                console.log(
                    "[+] mmap args  =",
                    "addr=" + this.addr,
                    "len=" + this.len,
                    "prot=0x" + this.prot.toString(16),
                    "flags=0x" + this.flags.toString(16),
                    "fd=" + this.fd,
                    "off=0x" + this.off.toString(16),
                    "ra=" + this.ra
                );
            }
        }
    });
}

function hook_linker_call_constructors() {
    if (hook_linker_call_constructors.hooked) return;
    hook_linker_call_constructors.hooked = true;

let linker64_base_addr = Module.getBaseAddress(linker_name);
    if (!linker64_base_addr) return;

let call_constructors = linker64_base_addr.add(call_constructors_offset);
    Interceptor.attach(call_constructors, {
        onEnter: function (args) {
            if (!target_seen || mmap_hooked || found) return;

let secmodule = Process.findModuleByName(target_so);
            if (secmodule == null) return;

outer_base = secmodule.base;
            outer_size = secmodule.size;
            hook_mmap();
        }
    });
}

function hook_dlopen() {
    Interceptor.attach(Module.findExportByName(null, "android_dlopen_ext"), {
        onEnter: function (args) {
            if (found) return;

this.fileName = args[0].isNull() ? "" : args[0].readCString();
            if (this.fileName && this.fileName.indexOf(target_so) >= 0) {
                target_seen = true;
                hook_linker_call_constructors();
            }
        }
    });
}

hook_dlopen();

```

如此我们便可以知道映射大小=`len=0x134000`的时候的返回值是我们要的，我们就可以写出更简洁的脚本

```javascript
var found = false;

Interceptor.attach(Module.findExportByName("libc.so", "mmap"), {
    onEnter: function (args) {
        this.len = args[1].toUInt32();
    },
    onLeave: function (retval) {
        if (found || retval.isNull()) return;

if (this.len === 0x134000) {
            found = true;
            console.log("[+] inner base =", retval);
        }
    }
});

```

## 0x02 正文

![](upload/attach/202604/947037_WU645V642D8J8JZ.webp)

蓝蓝一片非常之爽，.init_array里没有注册函数，但是JNI_OnLoad反编译之后居然有3000行，那暂时先不看了

先来明确一下目标吧

1. **过frida检测**
2. **静态解密dex完成脱壳**

到现在为止还没咋使用到frida，但是不用想，附加上去启动app包是会崩溃的。目前已知所有重要逻辑入口都在JNI_OnLoad，那直接来trace一下函数调用链吧

### 0x02.1 frida检测绕过

#### 初步绕过

这里使用到oacia大佬的<a href="elink@78fK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6G2j5h3y4A6j5g2)9J5c8Y4y4@1j5h3I4C8k6i4u0Q4y4h3k6@1M7X3q4U0k6g2)9#2k6Y4y4G2">stalker_trace_so</a>，建议大家优先使用这个工具，他可以记录所有IDA识别出来并且被主线程执行到的函数，帮我们快速定位大致范围

需要注意的是生成的脚本在trace时基地址要稍作修改，因为它的主so是动态释放的

```javascript
var so_name = "libDexHelper.so";
var inner_base = null;
var trace_started = false;
var found = false;
var mmap_listener = null;

/*
    @param print_stack: Whether printing stack info, default is false.
*/
var print_stack = false;

/*
    @param print_stack_mode
    - FUZZY: print as much stack info as possible
    - ACCURATE: print stack info as accurately as possible
    - MANUAL: if printing the stack info in an error and causes exit, use this option to manually print the address
*/
var print_stack_mode = "FUZZY";

// note: you can do any thing before or after stalker trace so.
                    if (inner_base != null) {
                        if (mmap_listener != null) {
                            mmap_listener.detach();
                            mmap_listener = null;
                            console.log("[+] mmap hook detached");
                        }
                        trace_so();
                    }
                }
            }
        }
    );
}

function hook_mmap() {
    mmap_listener = Interceptor.attach(Module.findExportByName("libc.so", "mmap"), {
        onEnter: function (args) {
            this.len = args[1].toUInt32();
        },
        onLeave: function (retval) {
            if (found || retval.isNull()) return;

if (this.len === 0x134000) {
                found = true;
                inner_base = ptr(retval.toString());
                console.log("[+] inner base = " + inner_base);
            }
        }
    });
}

function trace_so(){
    if (inner_base == null || trace_started) return;

trace_started = true;
    var times = 1;
    var module_base = inner_base;
    var pid = Process.getCurrentThreadId();
    console.log("start Stalker!");
    Stalker.exclude({
        "base": Process.getModuleByName("libc.so").base,
        "size": Process.getModuleByName("libc.so").size
    })
    Stalker.follow(pid,{
        events:{
            call:false,
            ret:false,
            exec:false,
            block:false,
            compile:false
        },
        onReceive:function(events){
        },
        transform: function (iterator) {
            var instruction = iterator.next();
            do{
                var offset = instruction.address.sub(module_base).toUInt32();
                var index = func_addr.indexOf(offset);
                if (index !== -1) {
                    console.log("call" + times + ":" + func_name[index])
                    times = times + 1
                    if (print_stack) {
                        if (print_stack_mode === "FUZZY") {
                            iterator.putCallout((context) => {
                                console.log("backtrace:\n"+Thread.backtrace(context, Backtracer.FUZZY).map(DebugSymbol.fromAddress).join('\n'));
                                console.log('---------------------')
                            });
                        }
                        else if (print_stack_mode === "ACCURATE") {
                            iterator.putCallout((context) => {
                                console.log("backtrace:\n"+Thread.backtrace(context, Backtracer.ACCURATE).map(DebugSymbol.fromAddress).join('\n'));
                                console.log('---------------------')
                            })
                        }

else if (print_stack_mode === "MANUAL") {
                            iterator.putCallout((context) => {
                                console.log("backtrace:")
                                Thread.backtrace(context, Backtracer.FUZZY).map(addr_in_so);
                                console.log('---------------------')
                            })
                        }
                    }
                }
                iterator.keep();
            } while ((instruction = iterator.next()) !== null);
        },

onCallSummary:function(summary){

}
    });
    console.log("Stalker end!");
}

hook_mmap();
setImmediate(hook_dlopen,0);
```

只看最后几条日志

```bash
call107:sub_402CC
call108:sub_3ED48
call109:regfree
call110:usleep
call111:dlopen
call112:dlsym
call113:sub_AED04
call114:sub_AE270
call115:sub_AEA58
call116:mmap
call117:sub_AF28C
call118:sub_AF4C8
call119:sub_AEE3C
call120:stat
call121:dlclose
call122:sub_42868
call123:sub_1304C
```

直接hook `sub_1304C`试试看，当然这样不严谨，但是可以快速看看有没有效果

```bash
Spawned `com.moutai.mall`. Resuming main thread!
[Pixel 6::com.moutai.mall ]-> [+] inner base = 0x7c00ce9000
[+] mmap hook detached
[+] patched sub_1304C @ 0x7c00cfc04c
[+] dlopen hook detached
Process terminated
[Pixel 6::com.moutai.mall ]->
```

依旧崩了，但是这次的崩溃相较上一次正常的多，判断为不是被同一处检测点检测到了，把hook `sub_1304C`的 逻辑加上，再trace一次

```javascript
function rep_sub1304C() {
    if (inner_base == null || sub1304c_replaced) return;

var target = inner_base.add(0x1304c);
    console.log("[+] replacing sub_1304C @ " + target);

Interceptor.replace(target, new NativeCallback(function (a0, a1, a2) {
        console.log(
            "[+] skip sub_1304C(flag=" + a0.toString() +
            ", code=0x" + a1.toString(16) +
            ", mask=0x" + a2.toString(16) + ")"
        );
        return 0;
    }, 'int64', ['int64', 'uint32', 'int']));

sub1304c_replaced = true;
}
```

这次的日志的最后几行

```javascript
call188:sub_24F18
call189:.strcasecmp
call190:sub_105B8
call191:sub_FE78
call192:sub_40B04
call193:sub_3DBB4
call194:sub_3DF50
call195:sub_406E8
call196:sub_41838
call197:sub_408C4
Process terminated
[Pixel 6::com.moutai.mall ]->
```

初步看了一下，上面几个没啥可疑的，估计就是检测到了然后正常退出，这里由于最后几条函数并不是检测函数和退出函数，所以这里大概率不是**同步**的检测。或者还有一种可能，假设函数B是检函数，函数A调用B，然后根据B的返回结果决定是否退出App。当前trace脚本只能记录“**执行流进入了哪些函数入口**”，但没有记录“**函数返回到了哪里**”以及“**调用者在拿到返回值后又执行了什么分支逻辑**”，所以只能看到A和B都执行过，却不一定能定位到 A 在函数内部哪一条指令上完成了退出。

#### 进一步绕过

搞这里也是时间有点晚了，我也懒得跟他废话了，直接用内核模块监控一下哪里给我app干崩了(上文已经分析出此处的崩溃是正常的退出)

```bash
[43097.547378] [Yuuki] === kill_monitor: kill (PID:19581 UID:10282 com.moutai.mall) sig=9 ===
[43097.547388] [Yuuki] [UID 10282] #00 pc = 0x7c007720a4 ???!0x190a4
[43097.547390] [Yuuki] [UID 10282] #01 pc = 0x7d41443600 [anon:scudo:primary_reserve]!0xabf7600
[43097.547392] [Yuuki] === end backtrace (2 frames) ===
[43097.547394] [Yuuki]
[43097.548342] [Yuuki] === kill_monitor: kill (PID:19581 UID:10282 com.moutai.mall) sig=9 ===
[43097.548346] [Yuuki] [UID 10282] #00 pc = 0x7c00772424 ???!0x19424
[43097.548348] [Yuuki] [UID 10282] #01 pc = 0x7d41443600 [anon:scudo:primary_reserve]!0xabf7600
[43097.548351] [Yuuki] === end backtrace (2 frames) ===
[43097.548353] [Yuuki]
```

一共两处，IDA跳过去看看

![](upload/attach/202604/947037_85GSRF2X78TWKBK.webp)

![](upload/attach/202604/947037_9TSJ5MP58ERVC77.webp)

两处都是直接svc call `__NR_kill`函数直接退的，果然是像我们上面猜测的那样，我们直接给它们patch掉就行了

```javascript
var target_so = "libDexHelper.so";
var inner_base = null;
var found = false;
var patched = false;
var callbacks = [];
var mmap_listener = null;
var dlopen_listener = null;

function applyPatches() {
    if (patched || inner_base == null) return;

var sub1304c = inner_base.add(0x1304c);
    var cb = new NativeCallback(function () {
        return 0;
    }, "int", []);

callbacks.push(cb);
    Interceptor.replace(sub1304c, cb);
    console.log("[+] patched sub_1304C @ " + sub1304c);

patchArm64MovX0Zero(inner_base.add(0x190a0), "kill syscall #1");
    patchArm64MovX0Zero(inner_base.add(0x19420), "kill syscall #2");

patched = true;
}

mmap_listener = Interceptor.attach(Module.findExportByName("libc.so", "mmap"), {
    onEnter: function (args) {
        this.len = args[1].toUInt32();
    },
    onLeave: function (retval) {
        if (found || retval.isNull()) return;

if (this.len === 0x134000) {
            found = true;
            inner_base = ptr(retval.toString());
            console.log("[+] inner base = " + inner_base);
            if (mmap_listener) {
                mmap_listener.detach();
                mmap_listener = null;
                console.log("[+] mmap hook detached");
            }
        }
    }
});

dlopen_listener = Interceptor.attach(Module.findExportByName(null, "android_dlopen_ext"), {
    onEnter: function (args) {
        this.fileName = args[0].isNull() ? "" : args[0].readCString();
    },
    onLeave: function (retval) {
        if (patched) return;

if (this.fileName && this.fileName.indexOf(target_so) >= 0 && inner_base != null) {
            applyPatches();
            if (dlopen_listener) {
                dlopen_listener.detach();
                dlopen_listener = null;
                console.log("[+] dlopen hook detached");
            }
        }
    }
});

```

直接注入启动，app完美运行，美美得吃了也是

但是这种方式并不是很优雅，毕竟不是每个人都能用内核模块。值得注意的是上面两个退出点都在`JNI_OnLoad`函数中，这就很值得注意了，正常检测逻辑怎么会放在这个函数中呢？我觉得只有**傻***才会这样写代码，所以这里`JNI_OnLoad`只是起到一个最终的决策作用。具体来说就是`JNI_OnLoad`里通过无论是新建线程还是直接同步调用函数的方式，去启动检测函数，然后不在检测函里执行退出机制，而是拿到检测函数的结果，集中在`JNI_OnLoad`里进行处理。当然这些只是我的猜测，至于为什么这么做，可能是因为`JNI_OnLoad`经过了混淆，开发者觉得大多数逆向人员不会去优先看这个函数。事实也的确如此

有的朋友通过hook clone那套 + 处理`sub_1304C`也能绕过检测，但是我感觉这样比较麻烦

####  更一般的方式

我们继续来**优雅**(暴力)的解决刚刚的问题吧

已知退出是正常的退出，只是通过svc直接call内核函数而已。这里可以有一些大众的处理方案

1. 直接trace指令，注册svc的callback，打印内核函数名和参数就行了，直接就能定位到第一现场。这个我是尝试了一下，确实是可行的
2. 直接IDA扫所有svc指令，反向污点确定x8寄存器的值，根据系统调用号(**Android arm64 系统调用号是存在x8寄存器的**)进行过滤，然后全都patch掉

这里我们直接选择**方案二**，因为它足够简单，直接写个IDA脚本，帮我们生成对应的frida patch脚本代码，这里我只处理了 `exit`， `exit_group`，`kill`，`tkill`，`tgkill`，其他的退出方式并没有做处理，抛砖引玉感兴趣的大佬可以自行拓展

```python
import os
import re

import idautils
import ida_bytes
import ida_funcs
import ida_kernwin
import ida_segment
import idc

TARGET_SYSCALLS = {
    93: "exit",
    94: "exit_group",
    129: "kill",
    130: "tkill",
    131: "tgkill",
}
BACKTRACK_LIMIT = 20
PATCH_FILE_NAME = "termination_patch_snippet.txt"

def log(msg=""):
    print(msg)

def is_exec_seg(seg):
    if seg is None:
        return False
    return bool(seg.perm & ida_segment.SEGPERM_EXEC)

def iter_exec_heads():
    for seg_ea in idautils.Segments():
        seg = ida_segment.getseg(seg_ea)
        if not is_exec_seg(seg):
            continue
        ea = seg.start_ea
        while ea < seg.end_ea:
            flags = ida_bytes.get_flags(ea)
            if ida_bytes.is_code(flags):
                yield ea
            ea = idc.next_head(ea, seg.end_ea)

def op_text(ea, n):
    text = idc.print_operand(ea, n)
    return text.strip() if text else ""

def mnem(ea):
    return idc.print_insn_mnem(ea).lower()

def normalize_reg(text):
    return text.lower().strip()

def is_x8_reg(text):
    reg = normalize_reg(text)
    return reg in ("x8", "w8")

def parse_imm_and_shift(text):
    """
    Parse operand text forms like:
      #0x81
      #0xb6a2,LSL#16
      #123
    Returns (imm, shift_bits).
    """
    t = text.lower().replace(" ", "")
    m = re.match(r"#(?P<imm>-?(?:0x[0-9a-f]+|\d+))(?:,lsl#(?P<shift>\d+))?$", t)
    if not m:
        return None
    imm = int(m.group("imm"), 0)
    shift = int(m.group("shift") or 0)
    return imm, shift

def writes_x8(ea):
    return is_x8_reg(op_text(ea, 0))

def decode_syscall_from_backtrack(svc_ea, limit=BACKTRACK_LIMIT):
    """
    Heuristically reconstruct x8 value by scanning backwards.

Supports common forms:
      MOV   X8, #imm
      MOVZ  X8, #imm[, LSL#n]
      MOVK  X8, #imm[, LSL#n]
      ORR   X8, XZR, #imm

Returns:
      {
        "sysno": int or None,
        "writer_eas": [ea...],  # instructions contributing to x8
      }
    """
    func = ida_funcs.get_func(svc_ea)
    if not func:
        return {"sysno": None, "writer_eas": []}

cur = idc.prev_head(svc_ea, func.start_ea)
    seen = 0
    pieces = []
    writer_eas = []

while cur != idc.BADADDR and cur >= func.start_ea and seen < limit:
        seen += 1
        insn_mnem = mnem(cur)

if writes_x8(cur):
            writer_eas.append(cur)

if insn_mnem in ("mov", "movz"):
                parsed = parse_imm_and_shift(op_text(cur, 1))
                if parsed is None:
                    return {"sysno": None, "writer_eas": writer_eas}
                imm, shift = parsed
                value = imm << shift
                for part_shift, part_imm in pieces:
                    mask = 0xFFFF << part_shift
                    value = (value & ~mask) | ((part_imm & 0xFFFF) << part_shift)
                return {"sysno": value, "writer_eas": writer_eas}

if insn_mnem == "movk":
                parsed = parse_imm_and_shift(op_text(cur, 1))
                if parsed is None:
                    return {"sysno": None, "writer_eas": writer_eas}
                imm, shift = parsed
                pieces.append((shift, imm))
                cur = idc.prev_head(cur, func.start_ea)
                continue

if insn_mnem == "orr":
                src1 = normalize_reg(op_text(cur, 1))
                parsed = parse_imm_and_shift(op_text(cur, 2))
                if src1 == "xzr" and parsed is not None:
                    imm, shift = parsed
                    value = imm << shift
                    return {"sysno": value, "writer_eas": writer_eas}
                return {"sysno": None, "writer_eas": writer_eas}

return {"sysno": None, "writer_eas": writer_eas}

cur = idc.prev_head(cur, func.start_ea)

return {"sysno": None, "writer_eas": writer_eas}

def nearby_insns(ea, before=10, after=2):
    items = []
    cur = ea
    for _ in range(before):
        cur = idc.prev_head(cur, idc.get_segm_start(cur))
        if cur == idc.BADADDR:
            break
    count = before + after + 1
    while cur != idc.BADADDR and count > 0:
        items.append((cur, idc.GetDisasm(cur)))
        nxt = idc.next_head(cur, idc.get_segm_end(cur))
        if nxt == idc.BADADDR or nxt == cur:
            break
        cur = nxt
        count -= 1
    return items

def make_patch_lines(matches):
    lines = []
    lines.append("// auto-generated by search_kill.py")
    lines.append("function patchArm64MovX0Zero(addr, tag) {")
    lines.append("    Memory.patchCode(addr, 4, function (code) {")
    lines.append("        var writer = new Arm64Writer(code, { pc: addr });")
    lines.append('        writer.putMovRegReg("x0", "xzr");')
    lines.append("        writer.flush();")
    lines.append("    });")
    lines.append('    console.log("[+] patched " + tag + " @ " + addr + " (mov x0, xzr)");')
    lines.append("}")
    lines.append("")
    for idx, item in enumerate(matches, 1):
        tag = "%s syscall(%d) #%d @ 0x%x" % (
            item["sys_name"],
            item["sysno"],
            idx,
            item["svc_ea"],
        )
        lines.append("// %s (%d)" % (item["sys_name"], item["sysno"]))
        lines.append('patchArm64MovX0Zero(inner_base.add(0x%x), "%s");' % (item["svc_ea"], tag))
    return "\n".join(lines)

def write_snippet_file(text):
    out_dir = os.path.dirname(idc.get_idb_path()) or os.getcwd()
    out_path = os.path.join(out_dir, PATCH_FILE_NAME)
    try:
        with open(out_path, "w", encoding="utf-8") as fp:
            fp.write(text)
        return out_path
    except Exception as exc:
        log("[!] failed to write snippet file: %s" % exc)
        return None

def main():
    matches = []

for ea in iter_exec_heads():
        if mnem(ea) != "svc":
            continue

info = decode_syscall_from_backtrack(ea)
        if info["sysno"] not in TARGET_SYSCALLS:
            continue

func = ida_funcs.get_func(ea)
        func_name = idc.get_func_name(ea) if func else "<no_func>"

matches.append({
            "svc_ea": ea,
            "func_start": func.start_ea if func else idc.BADADDR,
            "func_name": func_name,
            "writer_eas": list(reversed(info["writer_eas"])),
            "sysno": info["sysno"],
            "sys_name": TARGET_SYSCALLS[info["sysno"]],
            "nearby": nearby_insns(ea),
        })

if not matches:
        msg = "[*] no target termination syscall svc sites found"
        log(msg)
        ida_kernwin.info(msg)
        return

matches.sort(key=lambda x: (x["sysno"], x["svc_ea"]))

log("[*] found %d target termination syscall site(s)" % len(matches))
    log("")

for idx, item in enumerate(matches, 1):
        log("=" * 72)
        log("[%d] svc @ 0x%x  func=%s @ 0x%x  %s (sysno=%d / 0x%x)" % (
            idx,
            item["svc_ea"],
            item["func_name"],
            item["func_start"],
            item["sys_name"],
            item["sysno"],
            item["sysno"],
        ))
        if item["writer_eas"]:
            log("    x8 writers:")
            for w in item["writer_eas"]:
                log("      0x%x  %s" % (w, idc.GetDisasm(w)))
        else:
            log("    x8 writers: <unresolved>")
        log("    nearby:")
        for ea, text in item["nearby"]:
            mark = ">>" if ea == item["svc_ea"] else "  "
            log("    %s 0x%x  %s" % (mark, ea, text))
        log("")

snippet = make_patch_lines(matches)
    out_path = write_snippet_file(snippet)

log("=" * 72)
    log("[*] bypass.js snippet:")
    log(snippet)
    log("")
    if out_path:
        log("[*] snippet saved to: %s" % out_path)

ida_kernwin.info("search_kill.py finished, found %d target termination svc site(s)" % len(matches))

if __name__ == "__main__":
    main()

```

加上我们之前对 `sub_1304C`的处理，就可以完美绕过啦~

**完整过检测代码如下：**

```javascript
var target_so = "libDexHelper.so";
var inner_base = null;
var found = false;
var patched = false;
var callbacks = [];
var mmap_listener = null;
var dlopen_listener = null;

function applyPatches() {
    if (patched || inner_base == null) return;

var sub1304c = inner_base.add(0x1304c);
    var cb = new NativeCallback(function () {
        return 0;
    }, "int", []);

callbacks.push(cb);
    Interceptor.replace(sub1304c, cb);
    console.log("[+] patched sub_1304C @ " + sub1304c);

// 精准的patch只需这两处
    // patchArm64MovX0Zero(inner_base.add(0x190a0), "kill syscall #1");
    // patchArm64MovX0Zero(inner_base.add(0x19420), "kill syscall #2");

// kill (129)
    patchArm64MovX0Zero(inner_base.add(0x17558), "kill syscall(129) #1 @ 0x17558");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x17614), "kill syscall(129) #2 @ 0x17614");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x176ec), "kill syscall(129) #3 @ 0x176ec");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x17a7c), "kill syscall(129) #4 @ 0x17a7c");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x17af0), "kill syscall(129) #5 @ 0x17af0");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x190a0), "kill syscall(129) #6 @ 0x190a0");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x1925c), "kill syscall(129) #7 @ 0x1925c");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x19420), "kill syscall(129) #8 @ 0x19420");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x25fb0), "kill syscall(129) #9 @ 0x25fb0");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x4f3a0), "kill syscall(129) #10 @ 0x4f3a0");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x4f5d4), "kill syscall(129) #11 @ 0x4f5d4");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x4febc), "kill syscall(129) #12 @ 0x4febc");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x55368), "kill syscall(129) #13 @ 0x55368");
    // kill (129)
    patchArm64MovX0Zero(inner_base.add(0x56588), "kill syscall(129) #14 @ 0x56588");

patched = true;
}

```

## 0x03 小结

很早以前就读壳感兴趣，但是一直没有时间研究。这次特意选了安卓端最简单的壳进行分析。之前不懂为什么那么多国家相关的APP，以及一些大银行，都喜欢用这个的壳，明明比它强的壳还有很多。最近和朋友聊天时问了这个问题。他跟我说，很多东西不是技术层面的问题，而是法律层面的。恍然大悟了也是

这篇篇幅还是有点太短了，剩下的dex解密流程分析过两天回学校有空了再写吧ovo

很多都是边逆边写的，有些结论可能缺乏准确性，自行甄别

使用到的一些工具以及文章：

1. <a href="elink@b06K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6G2j5h3y4A6j5g2)9J5c8Y4y4@1j5h3I4C8k6i4u0Q4y4h3k6@1M7X3q4U0k6g2)9#2k6Y4y4G2">stalker_trace_so</a>

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

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

#基础理论 #混淆加固

收藏・59

点赞・324

打赏

赞赏记录

参与人

雪币

留言

时间

mb_seddbaqy

期待更多优质内容的分享，论坛有你更精彩！

20小时前

mb_hktfsykj

感谢你的积极参与，期待更多精彩内容！

3天前

Ayuer

非常支持你的观点！

2026-10-3 17:07

git_99440qimingminimax

为你点赞！

2026-9-23 11:30

mb_szqldxer

你的分享对大家帮助很大，非常感谢！

2026-9-17 10:41

mb_hhiypuwp

非常支持你的观点！

2026-9-14 11:34

git_51951meggadf3df

非常支持你的观点！

2026-9-10 20:10

mb_mpffrkcr

非常支持你的观点！

2026-9-2 00:11

mb_bhfoerzx

你的分享对大家帮助很大，非常感谢！

2026-8-28 20:28

EwanSun

感谢你分享这么好的资源！

2026-8-27 20:23

mb_ouivjnmg

为你点赞！

2026-8-26 21:12

leehero

你的分享对大家帮助很大，非常感谢！

2026-8-25 10:23

mb_lhmayubx

期待更多优质内容的分享，论坛有你更精彩！

2026-8-25 09:58

jygzyc

你的帖子非常有用，感谢分享！

2026-8-25 09:20

mb_qecctkwn

感谢你的贡献，论坛因你而更加精彩！

2026-8-25 01:16

mb_haaygihg

这个讨论对我很有帮助，谢谢！

2026-8-21 16:07

看雪高研

期待更多优质内容的分享，论坛有你更精彩！

2026-8-21 14:37

mb_lthgjpwj

期待更多优质内容的分享，论坛有你更精彩！

2026-8-20 16:13

ovo.kx

感谢你分享这么好的资源！

2026-8-18 17:39

4ak5ra

为你点赞！

2026-8-16 15:59

wes1meanon

期待更多优质内容的分享，论坛有你更精彩！

2026-8-16 13:51

mb_obrkxtbn

你的帖子非常有用，感谢分享！

2026-8-15 19:48

mb_cnoouwmr

谢谢你的细致分析，受益匪浅！

2026-8-14 12:40

mb_ooliergk

为你点赞！

2026-8-14 05:24

L4zy0xE4

这个讨论对我很有帮助，谢谢！

2026-8-13 15:29

lookaside

谢谢你的细致分析，受益匪浅！

2026-8-12 15:18

ngiokweng

期待更多优质内容的分享，论坛有你更精彩！

2026-8-11 17:52

mb_ybjiiova

你的分享对大家帮助很大，非常感谢！

2026-8-11 14:12

mb_ljkqvpxg

为你点赞！

2026-8-10 23:41

Wika

感谢你的积极参与，期待更多精彩内容！

2026-8-8 15:42

mb_wsoacceo

为你点赞！

2026-8-8 00:28

coder777

你的分享对大家帮助很大，非常感谢！

2026-8-7 16:16

SX_DomOne

这个讨论对我很有帮助，谢谢！

2026-8-6 10:18

whohh

为你点赞！

2026-8-5 11:57

git_13147Clear2

感谢你的贡献，论坛因你而更加精彩！

2026-8-4 18:12

BlackMaGou

感谢你分享这么好的资源！

2026-7-31 04:33

hexdump

期待更多优质内容的分享，论坛有你更精彩！

2026-7-30 11:24

吃瓜侠

期待更多优质内容的分享，论坛有你更精彩！

2026-7-29 10:05

lihaiyanz

这个讨论对我很有帮助，谢谢！

2026-7-29 02:59

jyotidwi

非常支持你的观点！

2026-7-28 21:18

祝今朝

期待更多优质内容的分享，论坛有你更精彩！

2026-7-28 18:12

云水泱泱

你的分享对大家帮助很大，非常感谢！

2026-7-27 14:12

虎斑猫

期待更多优质内容的分享，论坛有你更精彩！

2026-7-27 10:43

focaccia

你的帖子非常有用，感谢分享！

2026-7-27 10:16

doamzo

非常支持你的观点！

2026-7-23 19:46

学会规则

为你点赞！

2026-7-22 19:37

dawnsky1111

谢谢你的细致分析，受益匪浅！

2026-7-21 11:31

mb_vasnzxkc

你的帖子非常有用，感谢分享！

2026-7-19 23:20

hx九七

感谢你分享这么好的资源！

2026-7-18 21:46

mb_jxftrzms

这个讨论对我很有帮助，谢谢！

2026-7-18 11:12

wx_晨梦

感谢你的贡献，论坛因你而更加精彩！

2026-7-16 06:15

尤瑟努

这个讨论对我很有帮助，谢谢！

2026-7-15 11:30

wx_kx92911

感谢你分享这么好的资源！

2026-7-15 10:28

wx_George_662

感谢你的积极参与，期待更多精彩内容！

2026-7-14 13:01

afishlong

期待更多优质内容的分享，论坛有你更精彩！

2026-7-13 22:42

LuoJunJunJun

你的分享对大家帮助很大，非常感谢！

2026-7-13 15:17

git_89565rockfox0

非常支持你的观点！

2026-7-13 08:48

Fanoteria

你的分享对大家帮助很大，非常感谢！

2026-7-13 02:36

mb_hsscwjpz

你的帖子非常有用，感谢分享！

2026-7-8 19:07

wx_Long_583904

这个讨论对我很有帮助，谢谢！

2026-7-7 12:52

Red

感谢你分享这么好的资源！

2026-7-6 10:16

mb_pawufzho

为你点赞！

2026-7-2 17:13

智童

这个讨论对我很有帮助，谢谢！

2026-6-30 23:26

jiaxinZz

非常支持你的观点！

2026-6-29 13:35

mb_goxfjlsn

谢谢你的细致分析，受益匪浅！

2026-6-29 11:11

dreameriii

期待更多优质内容的分享，论坛有你更精彩！

2026-6-26 14:31

as3ng

谢谢你的细致分析，受益匪浅！

2026-6-25 16:32

StarsunYzL

期待更多优质内容的分享，论坛有你更精彩！

2026-6-25 14:18

mb_cebxltxx

为你点赞！

2026-6-24 16:59

sigmund76

期待更多优质内容的分享，论坛有你更精彩！

2026-6-23 18:48

量凉

感谢你分享这么好的资源！

2026-6-23 14:28

Forgo7ten

为你点赞！

2026-6-23 10:30

mb_jioguoia

谢谢你的细致分析，受益匪浅！

2026-6-21 13:29

mb_tvbqtnbu

谢谢你的细致分析，受益匪浅！

2026-6-21 00:51

wx_GaoH

你的分享对大家帮助很大，非常感谢！

2026-6-20 00:04

mb_qlbmqqmd

谢谢你的细致分析，受益匪浅！

2026-6-18 17:35

mb_cccgiudm

为你点赞！

2026-6-18 12:50

老小白

你的分享对大家帮助很大，非常感谢！

2026-6-17 10:07

Zy143L

你的分享对大家帮助很大，非常感谢！

2026-6-17 06:25

九天666

非常支持你的观点！

2026-6-15 22:21

ddwwtom

感谢你的积极参与，期待更多精彩内容！

2026-6-15 22:09

sice

这个讨论对我很有帮助，谢谢！

2026-6-12 16:25

xiyewuqiu

感谢你的贡献，论坛因你而更加精彩！

2026-6-12 05:28

jikjgygjhg

期待更多优质内容的分享，论坛有你更精彩！

2026-6-11 17:01

sher_wang

为你点赞！

2026-6-10 17:55

git_43837featherL

感谢你的贡献，论坛因你而更加精彩！

2026-6-10 11:02

MochaCo

非常支持你的观点！

2026-6-10 00:12

wx_Kiyose

感谢你的贡献，论坛因你而更加精彩！

2026-6-9 00:50

mb_ekhqutmo

非常支持你的观点！

2026-6-8 15:42

mb_qucmgawb

你的帖子非常有用，感谢分享！

2026-6-7 11:53

zzzzz1

为你点赞！

2026-6-4 19:43

叶晓枫A

感谢你的积极参与，期待更多精彩内容！

2026-6-4 03:03

ycdear

你的分享对大家帮助很大，非常感谢！

2026-6-4 00:13

ReverseMind

谢谢你的细致分析，受益匪浅！

2026-6-3 20:02

miyuecao

感谢你分享这么好的资源！

2026-6-3 11:53

mb_reyfinlv

你的分享对大家帮助很大，非常感谢！

2026-6-3 11:34

berkedel

这个讨论对我很有帮助，谢谢！

2026-6-3 00:12

mb_bzztlmaj

期待更多优质内容的分享，论坛有你更精彩！

2026-6-2 16:13

mb_beoozpcn

你的分享对大家帮助很大，非常感谢！

2026-6-2 11:05

wx_嗨

你的帖子非常有用，感谢分享！

2026-6-2 10:45

darkpond

感谢你的积极参与，期待更多精彩内容！

2026-6-1 10:17

slurse_212010

你的帖子非常有用，感谢分享！

2026-6-1 03:44

mb_gjttoonf

你的分享对大家帮助很大，非常感谢！

2026-5-31 18:42

mb_gatolgsc

为你点赞！

2026-5-31 13:17

trackL

为你点赞！

2026-5-31 02:44

心在o

为你点赞！

2026-5-29 23:56

mb_uzcsurra

你的分享对大家帮助很大，非常感谢！

2026-5-29 21:48

mb_cpsiqdds

期待更多优质内容的分享，论坛有你更精彩！

2026-5-28 15:45

北袅

你的分享对大家帮助很大，非常感谢！

2026-5-28 09:37

s1nec-1o

非常支持你的观点！

2026-5-27 11:52

mb_cikyprom

感谢你的积极参与，期待更多精彩内容！

2026-5-26 02:05

mb_coqbxbgr

谢谢你的细致分析，受益匪浅！

2026-5-24 23:50

lingyi223

你的分享对大家帮助很大，非常感谢！

2026-5-23 16:13

mb_wdhsjycl

这个讨论对我很有帮助，谢谢！

2026-5-22 14:43

wx_霿凇

你的分享对大家帮助很大，非常感谢！

2026-5-20 16:00

伟叔叔

为你点赞！

2026-5-20 13:20

n_1ng

为你点赞！

2026-5-19 19:02

qeruiop

谢谢你的细致分析，受益匪浅！

2026-5-19 15:03

yxnwh

非常支持你的观点！

2026-5-19 12:23

一一映射

感谢你的贡献，论坛因你而更加精彩！

2026-5-18 21:57

dryzh

非常支持你的观点！

2026-5-17 08:19

wx_矛盾体

非常支持你的观点！

2026-5-16 16:41

吃辣超人

你的帖子非常有用，感谢分享！

2026-5-14 10:41

wjdidi

感谢你的贡献，论坛因你而更加精彩！

2026-5-13 16:56

tcc0lin

为你点赞！

2026-5-12 16:31

mb_xrhmetpo

感谢你的积极参与，期待更多精彩内容！

2026-5-12 11:11

Yu4n

感谢你的积极参与，期待更多精彩内容！

2026-5-11 10:44

菜鸟9527

这个讨论对我很有帮助，谢谢！

2026-5-9 13:36

mb_fvjroydy

你的分享对大家帮助很大，非常感谢！

2026-5-8 21:56

xhan8

为你点赞！

2026-5-8 21:00

LyonzzZ

为你点赞！

2026-5-8 14:28

linchuan0

为你点赞！

2026-5-8 13:37

奇奇怪怪

期待更多优质内容的分享，论坛有你更精彩！

2026-5-5 15:00

mb_fxywkzle

这个讨论对我很有帮助，谢谢！

2026-5-5 03:00

Cure.

感谢你分享这么好的资源！

2026-5-4 19:48

HuWemmbu

你的帖子非常有用，感谢分享！

2026-5-4 14:24

mb_uaoofzgb

这个讨论对我很有帮助，谢谢！

2026-5-1 09:52

始識

感谢你的贡献，论坛因你而更加精彩！

2026-4-30 17:42

mb_tbuqykqi

你的分享对大家帮助很大，非常感谢！

2026-4-30 11:26

优质胖虎

这个讨论对我很有帮助，谢谢！

2026-4-30 10:14

mb_jrwjnzux

谢谢你的细致分析，受益匪浅！

2026-4-29 21:25

mb_pnrjfxiv

期待更多优质内容的分享，论坛有你更精彩！

2026-4-29 19:39

erniu222

你的帖子非常有用，感谢分享！

2026-4-29 13:29

深沉

期待更多优质内容的分享，论坛有你更精彩！

2026-4-28 18:41

Nu1lN0ne

感谢你的积极参与，期待更多精彩内容！

2026-4-28 15:00

mb_ghcouuzx

你的帖子非常有用，感谢分享！

2026-4-28 13:59

mb_dfcqyqvn

为你点赞！

2026-4-27 22:29

霸王茶几

非常支持你的观点！

2026-4-27 17:27

mb_mfjsranl

这个讨论对我很有帮助，谢谢！

2026-4-27 17:11

dsfa

为你点赞！

2026-4-27 10:22

wingsevil

谢谢你的细致分析，受益匪浅！

2026-4-27 10:10

哈哥

这个讨论对我很有帮助，谢谢！

2026-4-27 10:09

khacker

这个讨论对我很有帮助，谢谢！

2026-4-27 09:39

Findger

感谢你的积极参与，期待更多精彩内容！

2026-4-27 05:06

mb_tbhosdnk

非常支持你的观点！

2026-4-27 00:33

星辰1190

非常支持你的观点！

2026-4-26 21:37

mb_frjcacmp

为你点赞！

2026-4-26 16:19

mb_bfpbtpsq

感谢你的贡献，论坛因你而更加精彩！

2026-4-26 13:34

mb_frcokwtg

谢谢你的细致分析，受益匪浅！

2026-4-26 12:29

nonovo

感谢你的积极参与，期待更多精彩内容！

2026-4-25 22:58

cr_lgdx

你的帖子非常有用，感谢分享！

2026-4-25 22:11

mb_tvuiswau

为你点赞！

2026-4-25 00:15

mb_ggnpkuap

感谢你分享这么好的资源！

2026-4-24 17:34

LooKoo

非常支持你的观点！

2026-4-24 10:04

mb_pfsyglzv

你的帖子非常有用，感谢分享！

2026-4-24 00:52

mb_ntldvmuf

期待更多优质内容的分享，论坛有你更精彩！

2026-4-23 23:24

gtict

感谢你的积极参与，期待更多精彩内容！

2026-4-23 22:40

wx_不愿入赘老板郎

非常支持你的观点！

2026-4-23 16:45

mb_liueenqt

为你点赞！

2026-4-23 16:25

zhuzhu_biu

感谢你的积极参与，期待更多精彩内容！

2026-4-23 15:45

super_kaka

感谢你的积极参与，期待更多精彩内容！

2026-4-23 15:34

limign

为你点赞！

2026-4-23 15:07

Ally Switch

感谢你的贡献，论坛因你而更加精彩！

2026-4-23 08:48

wx_ㅤ_683

感谢你分享这么好的资源！

2026-4-22 21:54

令狐双

感谢你的积极参与，期待更多精彩内容！

2026-4-22 20:12

the_hs

你的分享对大家帮助很大，非常感谢！

2026-4-22 19:48

苏子寻月zzy

为你点赞！

2026-4-22 16:39

mb_ghacxjfh

感谢你分享这么好的资源！

2026-4-22 16:06

七夜血

期待更多优质内容的分享，论坛有你更精彩！

2026-4-22 15:46

Yuusha

非常支持你的观点！

2026-4-22 14:45

晨曦遇晓

非常支持你的观点！

2026-4-22 14:09

mb_izfxicrp

谢谢你的细致分析，受益匪浅！

2026-4-22 11:55

jiavjiav

谢谢你的细致分析，受益匪浅！

2026-4-22 11:02

x_req

为你点赞！

2026-4-22 10:40

梧桐生

感谢你的贡献，论坛因你而更加精彩！

2026-4-22 10:24

jelasin

你的分享对大家帮助很大，非常感谢！

2026-4-22 10:00

bfloat16

感谢你的积极参与，期待更多精彩内容！

2026-4-22 09:56

mb_zzaaefkp

为你点赞！

2026-4-22 09:53

JasonGama

你的帖子非常有用，感谢分享！

2026-4-22 09:37

iCookiie

你的帖子非常有用，感谢分享！

2026-4-22 09:04

.KK

感谢你分享这么好的资源！

2026-4-22 07:12

mb_ppsrnjlh

谢谢你的细致分析，受益匪浅！

2026-4-22 04:03

mb_smpqvkrj

为你点赞！

2026-4-22 01:45

xianyuuuan

非常支持你的观点！

2026-4-21 20:21

mb_icbgiifu

这个讨论对我很有帮助，谢谢！

2026-4-21 19:40

mb_ejekfyqx

感谢你分享这么好的资源！

2026-4-21 19:34

风兮木晓

你的帖子非常有用，感谢分享！

2026-4-21 19:26

git_69241Zhouhang9527

感谢你的贡献，论坛因你而更加精彩！

2026-4-21 19:08

mb_eiufitqh

为你点赞！

2026-4-21 18:22

熊猫人大A

谢谢你的细致分析，受益匪浅！

2026-4-21 17:31

void *

谢谢你的细致分析，受益匪浅！

2026-4-21 16:35

孤独的街

感谢你的积极参与，期待更多精彩内容！

2026-4-21 16:15

shutterbug

感谢你分享这么好的资源！

2026-4-21 15:24

gal2xy

这个讨论对我很有帮助，谢谢！

2026-4-21 15:19

nianchu

为你点赞！

2026-4-21 15:13

mb_noeuaplg

感谢你分享这么好的资源！

2026-4-21 15:11

小傲骨

期待更多优质内容的分享，论坛有你更精彩！

2026-4-21 14:44

cppasm

你的分享对大家帮助很大，非常感谢！

2026-4-21 14:42

临江仙_

期待更多优质内容的分享，论坛有你更精彩！

2026-4-21 14:08

mb_lizfxfno

谢谢你的细致分析，受益匪浅！

2026-4-21 13:51

Python成长路

谢谢你的细致分析，受益匪浅！

2026-4-21 13:30

岁月。

谢谢你的细致分析，受益匪浅！

2026-4-21 13:11

wogao

谢谢你的细致分析，受益匪浅！

2026-4-21 12:59

git_27068Lych1e1

感谢你的积极参与，期待更多精彩内容！

2026-4-21 11:25

mb_hhtamnlw

这个讨论对我很有帮助，谢谢！

2026-4-21 10:43

ookyo

为你点赞！

2026-4-21 10:22

12321

你的分享对大家帮助很大，非常感谢！

2026-4-21 10:19

P1umH0

谢谢你的细致分析，受益匪浅！

2026-4-21 10:16

mb_axnyspcg

你的分享对大家帮助很大，非常感谢！

2026-4-21 09:17

mb_miogqqxc

感谢你的积极参与，期待更多精彩内容！

2026-4-21 09:02

YuHuanTin

你的帖子非常有用，感谢分享！

2026-4-21 08:16

mb_iekomvyy

感谢你分享这么好的资源！

2026-4-21 08:10

xDragonZ

感谢你分享这么好的资源！

2026-4-21 00:24

New对象处

你的帖子非常有用，感谢分享！

2026-4-20 23:58

bluegatar

你的分享对大家帮助很大，非常感谢！

2026-4-20 23:37

ogli324

这个讨论对我很有帮助，谢谢！

2026-4-20 23:20

MsScotch

非常支持你的观点！

2026-4-20 20:59

王叔叔

这个讨论对我很有帮助，谢谢！

2026-4-20 20:43

寻影星尘

为你点赞！

2026-4-20 20:21

The_Itach1

感谢你的积极参与，期待更多精彩内容！

2026-4-20 19:56

亮亮0107

感谢你分享这么好的资源！

2026-4-20 19:43

逆天而行

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 19:33

GhHei

非常支持你的观点！

2026-4-20 17:48

GoKu123

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 17:45

zz1syyd

为你点赞！

2026-4-20 17:34

吖銮

这个讨论对我很有帮助，谢谢！

2026-4-20 17:23

微笑:)

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 16:45

webfker

非常支持你的观点！

2026-4-20 16:30

neocanable

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 16:19

Shangwendada

你的分享对大家帮助很大，非常感谢！

2026-4-20 16:12

xjohjrdy

这个讨论对我很有帮助，谢谢！

2026-4-20 15:43

带带弟弟吧

为你点赞！

2026-4-20 15:37

autorun886

你的分享对大家帮助很大，非常感谢！

2026-4-20 15:28

陈某人

你的分享对大家帮助很大，非常感谢！

2026-4-20 15:21

曰你

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 15:14

wx_官

这个讨论对我很有帮助，谢谢！

2026-4-20 14:51

Aar0n

谢谢你的细致分析，受益匪浅！

2026-4-20 14:40

mb_bzkmcyjt

你的帖子非常有用，感谢分享！

2026-4-20 14:35

mb_koixqizd

你的分享对大家帮助很大，非常感谢！

2026-4-20 14:24

教教我吧~

这个讨论对我很有帮助，谢谢！

2026-4-20 14:07

taeyeon_ss

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 13:59

fyggxfgv

为你点赞！

2026-4-20 13:39

pianpu

为你点赞！

2026-4-20 13:36

dofla

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 13:27

mb_rbbzqwvn

你的帖子非常有用，感谢分享！

2026-4-20 13:26

aut0run

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 12:54

miredo

非常支持你的观点！

2026-4-20 12:50

Hades一KXXY

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 12:44

wx_浓情淡如你

为你点赞！

2026-4-20 12:41

CCC_

为你点赞！

2026-4-20 11:47

流霜瞳

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 11:26

mb_ovfonqtb

为你点赞！

2026-4-20 11:06

Max_hhg

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 11:04

mb_eeiaotyg

你的帖子非常有用，感谢分享！

2026-4-20 11:03

mb_npylpnpl

感谢你的积极参与，期待更多精彩内容！

2026-4-20 10:59

LovelyWei

为你点赞！

2026-4-20 10:56

mb_bppcorlj

非常支持你的观点！

2026-4-20 10:50

oMasko

为你点赞！

2026-4-20 10:44

git_56009war9

你的帖子非常有用，感谢分享！

2026-4-20 10:36

rettozero

感谢你的积极参与，期待更多精彩内容！

2026-4-20 10:25

wx_funcrever

感谢你分享这么好的资源！

2026-4-20 10:18

Catmeow

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 10:12

ChuXinﻬ.

感谢你分享这么好的资源！

2026-4-20 09:57

柳哈辣子

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 09:45

beimingyouyu

谢谢你的细致分析，受益匪浅！

2026-4-20 09:43

hy6ran

这个讨论对我很有帮助，谢谢！

2026-4-20 09:40

qqizai

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 09:35

mb_izpwdqte

为你点赞！

2026-4-20 09:28

vox

谢谢你的细致分析，受益匪浅！

2026-4-20 09:27

签个到

谢谢你的细致分析，受益匪浅！

2026-4-20 09:23

丁海洋

非常支持你的观点！

2026-4-20 09:21

mystica

谢谢你的细致分析，受益匪浅！

2026-4-20 09:14

Hawcett

感谢你分享这么好的资源！

2026-4-20 09:06

ONewTach

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 08:58

mb_kgfqphsx

这个讨论对我很有帮助，谢谢！

2026-4-20 08:25

npc0vo

期待更多优质内容的分享，论坛有你更精彩！

2026-4-20 07:16

saykao

你的分享对大家帮助很大，非常感谢！

2026-4-20 02:44

mb_mmodulik

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 00:03

Je2em1ah

谢谢你的细致分析，受益匪浅！

2026-4-19 23:47

千屈

非常支持你的观点！

2026-4-19 23:38

便胜晴天

这个讨论对我很有帮助，谢谢！

2026-4-19 23:26

冲冲冲

为你点赞！

2026-4-19 23:26

东方玻璃

非常支持你的观点！

2026-4-19 23:22

tDasm

这个讨论对我很有帮助，谢谢！

2026-4-19 22:38

pexillove

感谢你分享这么好的资源！

2026-4-19 22:31

mb_iesvmzqc

为你点赞！

2026-4-19 22:30

mihacker

你的帖子非常有用，感谢分享！

2026-4-19 22:22

D-t

为你点赞！

2026-4-19 22:16

逆向小玖

感谢你的贡献，论坛因你而更加精彩！

2026-4-19 22:07

悲殇落幕

你的帖子非常有用，感谢分享！

2026-4-19 21:56

X66iaM

感谢你分享这么好的资源！

2026-4-19 21:52

git_91357jnabnsn

为你点赞！

2026-4-19 21:49

菱志漪

期待更多优质内容的分享，论坛有你更精彩！

2026-4-19 21:43

青衫不负雪

非常支持你的观点！

2026-4-19 21:42

mb_zfqvurgb

谢谢你的细致分析，受益匪浅！

2026-4-19 21:37

git_47499test-look

你的分享对大家帮助很大，非常感谢！

2026-4-19 21:29

mb_aoooaosd

谢谢你的细致分析，受益匪浅！

2026-4-19 21:11

lanoche

非常支持你的观点！

2026-4-19 20:43

darbra

为你点赞！

2026-4-19 20:43

huangyalei

感谢你分享这么好的资源！

2026-4-19 19:31

棕熊

感谢你分享这么好的资源！

2026-4-19 19:26

permanent011

你的分享对大家帮助很大，非常感谢！

2026-4-19 19:21

Ms135

这个讨论对我很有帮助，谢谢！

2026-4-19 18:57

mb_kflrccfl

感谢你的贡献，论坛因你而更加精彩！

2026-4-19 18:51

顽劣

为你点赞！

2026-4-19 18:33

Yves Luo

感谢你分享这么好的资源！

2026-4-19 18:25

doduhuang

感谢你的积极参与，期待更多精彩内容！

2026-4-19 18:14

mb_rjdrqvpa

感谢你的积极参与，期待更多精彩内容！

2026-4-19 18:09

下雨天sana

为你点赞！

2026-4-19 17:51

robinhust

你的帖子非常有用，感谢分享！

2026-4-19 17:47

mb_yvuzbfvo

非常支持你的观点！

2026-4-19 17:44

mb_cfjwplfo

感谢你分享这么好的资源！

2026-4-19 17:43

像风一样呢

感谢你分享这么好的资源！

2026-4-19 17:05

iBa0

期待更多优质内容的分享，论坛有你更精彩！

2026-4-19 17:01

最新回复 (248) 1 2 3 4 5 6 7 8 9 10 ▶
iBa0 雪币： 1901 活跃值： (5928) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 490 粉丝 37 关注私信	iBa0 2 楼 2026-4-19 17:01 0
Gryffindoss 雪币： 635 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 126 粉丝 0 关注私信	Gryffindoss 3 楼 6666 2026-4-19 17:47 0
xingbing 雪币： 158 活跃值： (5791) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 1400 粉丝 2 关注私信	xingbing 4 楼学习。 2026-4-19 19:51 0
一栋奥特曼雪币： 59 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 66 粉丝 1 关注私信	一栋奥特曼 5 楼 666 2026-4-19 19:52 0
mb_asiwnxyv 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 100 粉丝 0 关注私信	mb_asiwnxyv 6 楼学习。 2026-4-19 20:08 0
Zepp7289 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 147 粉丝 0 关注私信	Zepp7289 7 楼 tql 2026-4-19 20:14 0
guijingwen 雪币： 7377 活跃值： (7605) 能力值： ( LV2，RANK：10 ) 在线值：发帖 13 回帖 312 粉丝 0 关注私信	guijingwen 8 楼 66 2026-4-19 20:14 0
我今年6岁雪币： 47 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 10 粉丝 0 关注私信	我今年6岁 9 楼 tql 2026-4-19 20:27 0
Migc 雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 39 粉丝 0 关注私信	Migc 10 楼 666 2026-4-19 21:43 0
我不是卷王雪币： 547 能力值： ( LV1，RANK：0 ) 在线值：发帖 5 回帖 123 粉丝 36 关注私信	我不是卷王 11 楼 11 2026-4-19 21:45 0
mb_jacxgcwv 雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	mb_jacxgcwv 12 楼 666 2026-4-19 21:52 0
季东雪币： 21 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 5 粉丝 4 关注私信	季东 13 楼 11 2026-4-19 21:53 0
X66iaM 雪币： 1049 活跃值： (3521) 能力值： ( LV3，RANK：30 ) 在线值：发帖 8 回帖 33 粉丝 19 关注私信	X66iaM 14 楼 22 2026-4-19 22:02 0
cx52038 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 17 粉丝 0 关注私信	cx52038 15 楼 666 2026-4-19 22:17 0
mb_iesvmzqc 雪币： 5208 活跃值： (6077) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 31 粉丝 1 关注私信	mb_iesvmzqc 16 楼 11 2026-4-19 22:34 0
Yangser 雪币： 1954 活跃值： (4268) 能力值： ( LV4，RANK：50 ) 在线值：发帖 11 回帖 130 粉丝 220 关注私信	Yangser 17 楼季东 11 22 2026-4-19 22:38 0
mb_agxdcibq 雪币： 14 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 46 粉丝 0 关注私信	mb_agxdcibq 18 楼 111 2026-4-19 22:40 0
乐子人雪币： 4511 活跃值： (7372) 能力值： ( LV9，RANK：220 ) 在线值：发帖 11 回帖 131 粉丝 657 关注私信	乐子人 4 19 楼 6 2026-4-19 23:07 0
mb_rpyecnrv 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	mb_rpyecnrv 20 楼 6 2026-4-19 23:42 0
mb_qnrjnwyl 雪币： 40 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	mb_qnrjnwyl 21 楼 6 2026-4-20 00:13 0
xianhuimin 雪币： 9341 活跃值： (6228) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 231 粉丝 2 关注私信	xianhuimin 22 楼 666 2026-4-20 00:18 0
wx_窒息雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 17 粉丝 0 关注私信	wx_窒息 23 楼 666 2026-4-20 00:29 0
SomeMx 雪币： 4211 活跃值： (5614) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 158 粉丝 1 关注私信	SomeMx 24 楼学习一下 2026-4-20 01:18 0
a7dd 雪币： 634 活跃值： (1561) 能力值： ( LV2，RANK：15 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	a7dd 25 楼学习 2026-4-20 08:58 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

Yangser

发帖

130

回帖

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (248) 1 2 3 4 5 6 7 8 9 10 ▶
iBa0 雪币： 1901 活跃值： (5928) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 490 粉丝 37 关注私信	iBa0 2 楼 2026-4-19 17:01 0
Gryffindoss 雪币： 635 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 126 粉丝 0 关注私信	Gryffindoss 3 楼 6666 2026-4-19 17:47 0
xingbing 雪币： 158 活跃值： (5791) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 1400 粉丝 2 关注私信	xingbing 4 楼学习。 2026-4-19 19:51 0
一栋奥特曼雪币： 59 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 66 粉丝 1 关注私信	一栋奥特曼 5 楼 666 2026-4-19 19:52 0
mb_asiwnxyv 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 100 粉丝 0 关注私信	mb_asiwnxyv 6 楼学习。 2026-4-19 20:08 0
Zepp7289 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 147 粉丝 0 关注私信	Zepp7289 7 楼 tql 2026-4-19 20:14 0
guijingwen 雪币： 7377 活跃值： (7605) 能力值： ( LV2，RANK：10 ) 在线值：发帖 13 回帖 312 粉丝 0 关注私信	guijingwen 8 楼 66 2026-4-19 20:14 0
我今年6岁雪币： 47 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 10 粉丝 0 关注私信	我今年6岁 9 楼 tql 2026-4-19 20:27 0
Migc 雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 39 粉丝 0 关注私信	Migc 10 楼 666 2026-4-19 21:43 0
我不是卷王雪币： 547 能力值： ( LV1，RANK：0 ) 在线值：发帖 5 回帖 123 粉丝 36 关注私信	我不是卷王 11 楼 11 2026-4-19 21:45 0
mb_jacxgcwv 雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 6 粉丝 0 关注私信	mb_jacxgcwv 12 楼 666 2026-4-19 21:52 0
季东雪币： 21 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 5 粉丝 4 关注私信	季东 13 楼 11 2026-4-19 21:53 0
X66iaM 雪币： 1049 活跃值： (3521) 能力值： ( LV3，RANK：30 ) 在线值：发帖 8 回帖 33 粉丝 19 关注私信	X66iaM 14 楼 22 2026-4-19 22:02 0
cx52038 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 17 粉丝 0 关注私信	cx52038 15 楼 666 2026-4-19 22:17 0
mb_iesvmzqc 雪币： 5208 活跃值： (6077) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 31 粉丝 1 关注私信	mb_iesvmzqc 16 楼 11 2026-4-19 22:34 0
Yangser 雪币： 1954 活跃值： (4268) 能力值： ( LV4，RANK：50 ) 在线值：发帖 11 回帖 130 粉丝 220 关注私信	Yangser 17 楼季东 11 22 2026-4-19 22:38 0
mb_agxdcibq 雪币： 14 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 46 粉丝 0 关注私信	mb_agxdcibq 18 楼 111 2026-4-19 22:40 0
乐子人雪币： 4511 活跃值： (7372) 能力值： ( LV9，RANK：220 ) 在线值：发帖 11 回帖 131 粉丝 657 关注私信	乐子人 4 19 楼 6 2026-4-19 23:07 0
mb_rpyecnrv 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	mb_rpyecnrv 20 楼 6 2026-4-19 23:42 0
mb_qnrjnwyl 雪币： 40 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	mb_qnrjnwyl 21 楼 6 2026-4-20 00:13 0
xianhuimin 雪币： 9341 活跃值： (6228) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 231 粉丝 2 关注私信	xianhuimin 22 楼 666 2026-4-20 00:18 0
wx_窒息雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 17 粉丝 0 关注私信	wx_窒息 23 楼 666 2026-4-20 00:29 0
SomeMx 雪币： 4211 活跃值： (5614) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 158 粉丝 1 关注私信	SomeMx 24 楼学习一下 2026-4-20 01:18 0
a7dd 雪币： 634 活跃值： (1561) 能力值： ( LV2，RANK：15 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	a7dd 25 楼学习 2026-4-20 08:58 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复