米游社salt（LK2 & K2）获取

1
{-74, 60, -78, 204, 96, -88, -82, 78, 162, 54, -68, 78, -84, 84, -80, 66, 216, -80, 180, 90, MediaPlayer.MEDIA_PLAYER_OPTION_ABR_AVERAGE_BITRATE, C5432a.f120322i, -74, 66, 114, -98, -116, 54, 84, 204, 204, C5432a.f120320g}

1
{-74, 60, -78, 204, 96, -88, -82, 78, 162, 54, -68, 78, -84, 84, -80, 66, 216, -80, 180, 90, 174, -106, -74, 66, 114, -98, -116, 54, 84, 204, 204, -104}

1
{-98, -66, 192, 120, 60, 198, 168, -68, 216, 66, 168, 126, -108, -76, 126, -82, 114, -88, -88, -122, 162, -112, -66, 180, -122, 72, 108, 180, 78, -108, -106, -116}

1
    public static String m61080b(int[] intArr) {
2
        int i12;
3
        StringBuilder sb2 = new StringBuilder();
4
        ArrayList<Integer> arrayList = new ArrayList<>(intArr.length);
5
        for (int i13 : intArr) {
6
            if (i13 < 0) {
7
                i12 = ((double) (-i13)) >= Math.pow(3.0d, 6.0d) ? (int) (((Math.log(-i13) / Math.log(3.0d)) - 6) + 48) : ~i13;
8
            } else {
9
                i12 = (i13 / 3) + 48;
10
            }
11
            arrayList.add(i12);
12
        }
13
        for (Integer integer : arrayList) {
14
            sb2.append((char) integer.intValue());
15
        }
16
        return sb2.toString();
17
    }

1
    public static final int[] k2 = {-98, -66, 192, 120, 60, 198, 168, -68, 216, 66, 168, 126, -108, -76, 126, -82, 114, -88, -88, -122, 162, -112, -66, 180, -122, 72, 108, 180, 78, -108, -106, -116};
2
    public static final int[] lk2 = {-74, 60, -78, 204, 96, -88, -82, 78, 162, 54, -68, 78, -84, 84, -80, 66, 216, -80, 180, 90, 174, -106, -74, 66, 114, -98, -116, 54, 84, 204, 204, -104};
3
    public static void main(String[] args) {
4
        System.out.println(m61080b(k2));
5
        System.out.println(m61080b(lk2));
6
    }

1
aApXDrhCxFhZkKZQVWWyfoAlyHTlJkis
2
IDMtPWQJfBCJSLOFxOlNjiIFVasBLttg

1
---
2
name: find-miyoushe-ds-salt
3
description: >
4
  从米游社(miyoushe/hyperion) APK 中提取 DS 签名参数(K2/LK2 salt)。
5
  当用户要求分析米游社的 DS 签名机制、查找 K2/LK2 salt、逆向米游社网络请求签名、
6
  或通过 jadx-mcp-server 分析 com.mihoyo.hyperion 包时使用此 skill。
7
  适用于任何版本的米游社 APK，变量名会因混淆而不同，但逻辑结构不变。
8
---
9

10
# 米游社 DS 签名参数提取指南
11

12
## 背景
13

14
米游社 APK 使用 DS (Dynamic Signature) 机制对网络请求进行签名。DS 由 native (JNI) 方法生成，
15
Java 层负责组装参数并注入到 HTTP 请求头中。核心参数 K2 和 LK2 是 `int[]` 数组，
16
通过 `AManager` 类解码为 salt 字符串后传给 native 方法。
17

18
## 前置条件
19

20
- jadx-mcp-server 已启动并连接到 JADX-GUI
21
- JADX-GUI 已打开目标 APK 且反编译完成
22
- 通过 `curl http://127.0.0.1:8650/health` 验证连接正常
23

24
## 定位流程
25

26
以下步骤的类名和字段名会因 APK 版本不同而变化（混淆重命名），但逻辑结构始终一致。
27
每一步都给出了识别特征，不要硬编码类名。
28

29
### 第一步：找到 native JNI 包装类
30

31
DS 签名的核心实现在 native 层。先找到 `com.mihoyo.hyperion.net` 包下的 native 包装类。
32

33
> ⚠️ **搜索 API 注意事项（必读）**：`search-classes-by-keyword` 的 `search_in=class`
34
> 模式会按 `.` 把类名切成 token，再对**单个 token** 做前缀/整词匹配。因此**任何带 `.` 的限定包名**
35
> （如 `com.mihoyo.hyperion.net`、`com.mihoyo`、`hyperion.net`）都会返回 0 条。
36
> 正确做法是：用**单 token**（如 `mihoyo`/`hyperion`/`net`），或改用 `search_in=code` 搜代码级特征。
37

38
**推荐查询（最精准，直接命中 native 库的加载点）：**
39

40
```bash
41
# 搜代码里的 System.loadLibrary，再从结果里挑 com.mihoyo.hyperion.net.* 的类
42
curl -s "http://127.0.0.1:8650/search-classes-by-keyword?search_term=loadLibrary&search_in=code&offset=0&count=20"
43
```
44

45
**备选查询（单 token 包名片段，需自己用 `com.mihoyo.hyperion.net` 前缀过滤）：**
46

47
```bash
48
curl -s "http://127.0.0.1:8650/search-classes-by-keyword?search_term=net&search_in=class&offset=0&count=40"
49
```
50

51
识别特征：该包下通常有 2 个类，满足以下条件：
52
- `static { System.loadLibrary("xxx"); }` 加载 native 库
53
- 包含 `native` 方法，参数和返回值都是 `String`
54
- 类名极短（被混淆），如 `aaaaa`、`bbbbb`
55

56
记录这两个类，分别记为 **类A** 和 **类B**。它们各自有一个接受 1-2 个 String 参数、返回 String 的 native 方法（通常是同名的，如 `a2222`）。
57

58
### 第二步：找到 DS 拦截器（OkHttp Interceptor）
59

60
使用交叉引用找到谁调用了这些 native 方法。
61

62
```bash
63
# 对类A和类B的 native 签名方法分别做 xrefs
64
curl -s "http://127.0.0.1:8650/xrefs-to-method?class_name=<类A全名>&method_name=<方法名>&offset=0&count=20"
65
curl -s "http://127.0.0.1:8650/xrefs-to-method?class_name=<类B全名>&method_name=<方法名>&offset=0&count=20"
66
```
67

68
识别特征：xrefs 中会有一个类实现了 `Interceptor`（OkHttp 的 `InterfaceC18926w`），
69
且其 `intercept` 方法中包含 `chain.proceed(...)` 和 `"DS"` 字符串。
70

71
这个类就是 **DS 拦截器**。但实测中**拦截器多为内层类**（如 `hn.C33707m`），而 MCP 的 `class-source`
72
与 `xrefs-to-class` 对带内层类尾部标记（如 `C33707m`）的类都会返回 "Class not found"；只有
73
`xrefs-to-method`（按方法）能解析。另外**不存在 `/method-source` 端点**，不要尝试。
74

75
> ✅ **推荐程序化走法（无需手动开 GUI）**：对 native 方法做 `xrefs-to-method` 找到**调用方**
76
> （通常是 `xxx.app.xxxApplicationHelper` 这类 Application 初始化类），再去读**调用方的**
77
> `class-source`（能正常取到），从中搜索 `new <拦截器类>(K22)` / `int[] K22 = ...` 即可反推出盐值数组。
78
> 这绕开了取不到拦截器源码的问题。
79

80
兜底（调用方也取不到时）：在 JADX-GUI 中手动打开拦截器类，再用 `current-class` API 读取：
81

82
```bash
83
curl -s "http://127.0.0.1:8650/current-class"
84
```
85

86
### 第三步：分析 DS 拦截器逻辑
87

88
从拦截器的 `intercept` 方法中可以看到：
89

90
1. **DS 类型判断**：通过请求 tag 或路径决定使用 DS1 还是 DS2
91
2. **DS1 路径**：调用某个 native 方法，传入一个 salt 字符串
92
3. **DS2 路径**：调用另一个 native 方法，传入请求体和查询串
93
4. **salt 来源**：salt 由 `int[]` 数组通过某个管理器类解码得到
94

95
关键代码模式：
96
```java
97
// DS2 路径（特殊请求）
98
if (isDS2) {
99
    ds = nativeMethod2(requestBody, queryString);
100
} else {
101
    // DS1 路径（普通请求）
102
    ds = nativeMethod1(manager.decode(intArray));
103
}
104
chain.proceed(request.addHeader("DS", ds).build());
105
```
106

107
### 第四步：找到 salt 数组的定义位置
108

109
优先用第二步的"程序化走法"：读拦截器的**调用方** `class-source`，搜索 `new <拦截器>(K22)` 即可定位
110
盐值数组。若坚持用 xrefs，注意 `xrefs-to-class` 对拦截器内层类同样可能返回 not found：
111

112
```bash
113
curl -s "http://127.0.0.1:8650/xrefs-to-class?class_name=<DS拦截器类名>&offset=0&count=20"
114
```
115

116
> ⚠️ **K2/LK2 未必在 BuildConfig 里**：`com.mihoyo.hyperion.utils.BuildConfig`
117
> 只是标准 Gradle 产物（只有 `BUILD_TYPE` 等），两个 `int[]` 实际在另一个类（如 `p232Df.C1989a`）。
118
> 不要硬编码"找 BuildConfig"，应找**含两个相邻 `public static final int[]` 静态字段的类**，
119
> 字段名被混淆（如 `f37869p`/`f37870q`），顺序固定：上 **K2**、下 **LK2**。
120

121
识别特征：实例化通常在 Application 初始化方法中（如 `initAppEnv` 或类似名称）。找到类似代码：
122

123
```java
124
int[] K22 = SomeClass.K2_FIELD;     // 上方字段 = K2
125
new DSInterceptor(K22);
126
// 同类下方还有 LK2_FIELD = LK2
127
```
128

129
记录该类的两个 `int[]` 字段（名字被混淆）。通常两个数组字段紧挨着定义，
130
上面一个是 **K2**，下面一个是 **LK2**（顺序固定）。可用第五步的 JS Bridge 类交叉确认。
131

132
如果该类可通过 API 访问，直接获取：
133
```bash
134
curl -s "http://127.0.0.1:8650/class-source?class_name=<盐值数组所在类名>"
135
```
136

137
### 第五步：确认 K2 和 LK2 的对应关系
138

139
通过 xrefs 或搜索找到另一个使用这些数组的地方。`GetDSMethodImpl`（JS Bridge 实现）
140
会使用 LK2，可以通过搜索其中的数组引用来确认：
141

142
```bash
143
# 搜索包含两个 native 方法名的类（通常是 JS Bridge）
144
curl -s "http://127.0.0.1:8650/search-classes-by-keyword?search_term=getDS&search_in=code&offset=0&count=10"
145
```
146

147
该类中会有类似代码来明确标识 LK2：
148
```java
149
int[] LK2 = SomeClass.LK2_FIELD;    // 与第四步同一个类
150
data.put("DS", nativeMethod(manager.decode(LK2)));
151
```
152

153
### 第六步：解码 salt
154

155
找到 `AManager` 类（负责将 `int[]` 解码为 String 的工具类）。
156

157
识别特征：
158
- 包名通常在 `bn` 包下
159
- 包含两个参数和返回值相同的方法（一个给 K2 用，一个给 LK2 用）
160
- 方法逻辑：遍历 int 数组，对每个元素做数学运算转为 char
161

162
解码算法（版本间不变）：
163
```javascript
164
// Node.js 解码脚本
165
function decodeSalt(intArr) {
166
    return intArr.map(x => {
167
        if (x < 0) {
168
            return Math.abs(x) >= 729
169
                ? String.fromCharCode(Math.floor(Math.log(-x) / Math.log(3) - 6 + 48))
170
                : String.fromCharCode(~x);
171
        }
172
        return String.fromCharCode(Math.floor(x / 3) + 48);
173
    }).join('');
174
}
175
```
176

177
直接执行：
178
```bash
179
node -e "
180
const k2 = [<K2数组值>];
181
const lk2 = [<LK2数组值>];
182
function d(a){return a.map(x=>x<0?Math.abs(x)>=729?String.fromCharCode(Math.floor(Math.log(-x)/Math.log(3)-6+48)):String.fromCharCode(~x):String.fromCharCode(Math.floor(x/3)+48)).join('');}
183
console.log('K2 salt:', d(k2));
184
console.log('LK2 salt:', d(lk2));
185
"
186
```
187

188
## 版本差异说明
189

190
| 元素            | 是否变化   | 说明                                                                         |
191
|---------------|--------|----------------------------------------------------------------------------|
192
| 包结构           | 不变     | `com.mihoyo.hyperion.net` 始终存在                                             |
193
| native 包装类名   | 变化     | 混淆为短名，如 `aaaaa`/`bbbbb`                                                    |
194
| native 方法名    | 变化     | 混淆为短名，如 `a2222`/`b5555`                                                    |
195
| native 库名     | 变化     | 混淆为短名，如 `libdddd.so`                                                       |
196
| DS 拦截器类名      | 变化     | 混淆，但一定实现 Interceptor 接口                                                    |
197
| 盐值数组所在类名      | 变化     | 包名/类名会被混淆，且**不一定是 BuildConfig**（本版本实测在 `p232Df.C1989a`）；一定含两个相邻 `int[]` 字段 |
198
| K2/LK2 数组值    | **变化** | 每个版本的 salt 不同                                                              |
199
| AManager 解码算法 | 不变     | 数学逻辑固定                                                                     |
200
| DS header 名称  | 不变     | 始终为 `"DS"`                                                                 |
201
| DS1/DS2 判断逻辑  | 不变     | 通过 tag 或路径判断                                                               |
202

203
## 快速参考
204

205
DS 生成的完整调用链：
206
```
207
OkHttp 请求 → DS 拦截器.intercept()
208
  ├─ DS2: nativeMethod(body, query) → 加密签名
209
  └─ DS1: nativeMethod(AManager.decode(K2/LK2)) → 加密签名
210
       └─ int[] → 解码算法 → salt 字符串
211
最终: request.addHeader("DS", 签名值)
212
```
213

214
K2 用于主 API 拦截器，LK2 用于 WebView JS Bridge 的 `getDS` 方法。
215
两者解码方式完全相同，只是应用场景不同。