逆向解析 ColorOS 离线号码库 (二)：多级指针寻址的运营商识别与数据自愈#

0. 前言#

在上一节中，我们成功逆向了号码归属地的 12-Bit 极限压缩算法。本节我们将继续深入，解析系统的运营商查询逻辑，并修复归属地查询中遗留的“异常区号”问题，最终实现一个归属地与运营商全息查询的完整脚本。

1. 架构分析：归属地与运营商的解耦#

如果在归属地数据库（PhoneNumberData_3_1_0.dat）中寻找运营商信息，结果会一无所获。在底层的架构设计中，归属地与运营商采用了两套完全不同的存储与匹配逻辑：

归属地映射的离散性：一个 138 开头的号码，其归属地可能遍布全国各地（取决于号码中间 4 位）。这种离散性无法通过简单的公式计算，因此必须依赖体积达数 MB 的二进制字典树（Trie）进行硬映射。
运营商分配的规律性：在“携号转网”政策全面实施前，中国大陆的手机运营商是严格按前 3 位（或前 4 位）号段分配的（例如 138 归属移动，186 归属联通）。因此，将规律性极强的数据与庞大的归属地数据库分离，可以有效节省存储空间并提升查询效率。

通过对代码的进一步反编译，我们定位到了两个专门处理运营商及特殊情况的文件：

CarrierData_1_0.dat：体积较小，存储了基础的号段与运营商对应关系。
PortabilityNumberData.dat：携号转网（MNP）数据库，用于修正发生转网的特殊号码。

2. 解析 CarrierData 数据结构#

1
public final void q() throws IOException {
2
    File file = new File(f920p.getFilesDir(), "CarrierData_1_0.dat");
3
    if (!file.exists()) {
4
        e.b("OplusCarrierManager", "loadCarrierNameMap dataFile not exist");
5
        return;
59 collapsed lines
6
    }
7
    DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file));
8
    try {
9
        dataInputStream.skipBytes(16);
10
        int unsignedShort = dataInputStream.readUnsignedShort();
11
        for (int i3 = 0; i3 < unsignedShort; i3++) {
12
            int unsignedShort2 = dataInputStream.readUnsignedShort();
13
            String[] strArr = new String[4];
14
            for (int i4 = 0; i4 < 4; i4++) {
15
                strArr[i4] = BuildConfig.FLAVOR;
16
            }
17
            byte[] bArr = new byte[16];
18
            for (int i5 = 0; i5 < 4; i5++) {
19
                int unsignedShort3 = dataInputStream.readUnsignedShort();
20
                if (unsignedShort3 > 0) {
21
                    if (unsignedShort3 > bArr.length) {
22
                        bArr = new byte[unsignedShort3];
23
                    }
24
                    dataInputStream.readFully(bArr, 0, unsignedShort3);
25
                    strArr[i5] = new String(bArr, 0, unsignedShort3, l2.c.f761b);
26
                }
27
            }
28
            f917m.put(Integer.valueOf(unsignedShort2), strArr);
29
        }
30
        int unsignedShort4 = dataInputStream.readUnsignedShort();
31
        for (int i6 = 0; i6 < unsignedShort4; i6++) {
32
            int i7 = dataInputStream.readInt();
33
            int length = String.valueOf(i7).length();
34
            f914j = Math.max(length, f914j);
35
            f915k = Math.min(length, f915k);
36
            f913i.put(Integer.valueOf(i7), Integer.valueOf(dataInputStream.readUnsignedShort()));
37
        }
38
        int unsignedShort5 = dataInputStream.readUnsignedShort();
39
        for (int i8 = 0; i8 < unsignedShort5; i8++) {
40
            int i9 = dataInputStream.readInt();
41
            int length2 = String.valueOf(i9).length();
42
            f909e = Math.max(length2, f909e);
43
            f910f = Math.min(length2, f910f);
44
            f918n.put(Integer.valueOf(i9), Long.valueOf(dataInputStream.readInt()));
45
        }
46
        t1.k kVar = t1.k.f1147a;
47
        c2.a.a(dataInputStream, null);
48
        if (f906b) {
49
            e.a("OplusCarrierManager", "carrierNumberNameMap：");
50
            for (Map.Entry<Integer, String[]> entry : f917m.entrySet()) {
51
                e.a("OplusCarrierManager", entry.getKey().intValue() + " : " + u1.j.l(entry.getValue()));
52
            }
53
            e.a("OplusCarrierManager", "networkNumberFileOffsetMap：" + f918n);
54
        }
55
        f911g = new ThreadLocal<>();
56
    } catch (Throwable th) {
57
        try {
58
            throw th;
59
        } catch (Throwable th2) {
60
            c2.a.a(dataInputStream, th);
61
            throw th2;
62
        }
63
    }
64
}

通过反编译应用中的 loadCarrierNameMap（即代码中的 q() 方法），我们发现系统对运营商数据的存储采用了一套 “多级索引+内存偏移寻址” 的二进制文件结构。

根据 DataInputStream 的顺序读取逻辑，该 .dat 文件采用 大端序 (Big-Endian) 存储，主要分为四大区域：

文件头 (Header) - 16 字节：包含版本号和 CRC32 校验码，代码中通过 skipBytes(16) 直接跳过。
运营商名称字典 (Carrier Names)：首先读取运营商总数，随后依次读取对应的 ID 以及中文、英文、繁体台湾、繁体香港 4 个语言版本的名称（通过 readUnsignedShort 获取字符串长度，再读取 UTF-8 字符串）。
全局通用号段表 (General Prefixes)：对应代码中的 f913i 变量。存放前 3 位或前 4 位即可直接决定运营商的基础号段。数据结构为一个 32 位 Int（前缀）对应一个 16 位 Short（运营商 ID）。
精细偏移映射表 (Detailed Offsets)：对应代码中的 f918n 变量。针对按万号段细分的复杂号码（如虚拟运营商），该表记录了号段前缀在文件底部的绝对字节偏移量 (Offset)。

2.1 双轨查询逻辑#

在实际查询时，系统设计了两条路径：

1
private final String t(String str, int i3) {
2
    int i4 = f909e;
3
    int i5 = f910f;
4
    if (i5 <= i4) {
5
        while (true) {
32 collapsed lines
6
            String strSubstring = str.substring(0, i4);
7
            i.d(strSubstring, "substring(...)");
8
            Long l3 = f918n.get(Integer.valueOf(Integer.parseInt(strSubstring)));
9
            if (l3 == null) {
10
                if (i4 == i5) {
11
                    break;
12
                }
13
                i4--;
14
            } else {
15
                String strSubstring2 = str.substring(i4, i4 + 4);
16
                i.d(strSubstring2, "substring(...)");
17
                String strK = k(i3, strSubstring, strSubstring2);
18
                c<String, String> cVar = f916l;
19
                String strD = cVar.d(strK);
20
                if (strD != null) {
21
                    if (f906b) {
22
                        e.c("OplusCarrierManager", str + " cache hit ");
23
                    }
24
                    return strD;
25
                }
26
                String[] strArr = f917m.get(Integer.valueOf(r(Long.valueOf(l3.longValue() + ((long) (Integer.parseInt(strSubstring2) * 2))).longValue())));
27
                if (strArr == null) {
28
                    cVar.e(strK, BuildConfig.FLAVOR);
29
                    return null;
30
                }
31
                String str2 = (String) u1.j.h(strArr, i3);
32
                return TextUtils.isEmpty(str2) ? (String) u1.j.h(strArr, 0) : str2;
33
            }
34
        }
35
    }
36
    return null;
37
}

精确路径 (t() 方法)：处理新号段或混合号段（如 1705 虚拟运营商）。光匹配前几位并不足够，系统会查出前缀对应的底层偏移量，再加上号码中段数字计算出内存指针，直接跳转到文件尾部读取真实的运营商 ID。

1
private final String u(String str, int i3) {
2
    int i4 = f914j;
3
    int i5 = f915k;
4
    if (i5 <= i4) {        while (true) {
5
            String strSubstring = str.substring(0, i4);
18 collapsed lines
6
            i.d(strSubstring, "substring(...)");
7
            Integer num = f913i.get(Integer.valueOf(Integer.parseInt(strSubstring)));
8
            if (num == null) {
9
                if (i4 == i5) {
10
                    break;
11
                }
12
                i4--;
13
            } else {
14
                String[] strArr = f917m.get(num);
15
                if (strArr != null) {
16
                    return (String) u1.j.h(strArr, i3);
17
                }
18
                return null;
19
            }
20
        }
21
    }
22
    return null;
23
}

快速路径 (u() 方法)：处理传统号段（如 138）。前三位即可 100% 确定运营商，系统只需在 general_prefixes 哈希表中查询一次即可迅速返回结果。

2.3 Python 算法重构#

基于以上的逆向分析，我们完全脱离了 Android 环境，使用纯 Python 实现了对该二进制数据文件的脱机解析与查询。完整代码如下：

1
import os
2
import struct
3

4
def load_carrier_database(file_path):
5
    print("⏳ 正在加载并解析运营商底层数据库...")
113 collapsed lines
6
    with open(file_path, 'rb') as f:
7
        data = f.read()
8

9
    offset = 16  # dataInputStream.skipBytes(16)
10

11
    # 1. 读取运营商名称字典
12
    carrier_names = {}
13
    num_carriers = struct.unpack_from(">H", data, offset)[0]
14
    offset += 2
15

16
    for _ in range(num_carriers):
17
        carrier_id = struct.unpack_from(">H", data, offset)[0]
18
        offset += 2
19

20
        names = []
21
        # 依次读取 中文、英文、繁体台湾、繁体香港 4 个语言版本
22
        for _ in range(4):
23
            str_len = struct.unpack_from(">H", data, offset)[0]
24
            offset += 2
25
            if str_len > 0:
26
                # UTF-8 解码字符串
27
                name = data[offset : offset + str_len].decode('utf-8', errors='ignore')
28
                offset += str_len
29
            else:
30
                name = ""
31
            names.append(name)
32

33
        carrier_names[carrier_id] = names
34

35
    # 2. 读取全局通用号段表 (f913i)
36
    general_prefixes = {}
37
    num_gen_prefixes = struct.unpack_from(">H", data, offset)[0]
38
    offset += 2
39

40
    for _ in range(num_gen_prefixes):
41
        prefix_val = struct.unpack_from(">i", data, offset)[0]
42
        offset += 4
43
        cid = struct.unpack_from(">H", data, offset)[0]
44
        offset += 2
45
        general_prefixes[str(prefix_val)] = cid
46

47
    # 3. 读取精细偏移映射表 (f918n)
48
    detailed_prefixes = {}
49
    num_det_prefixes = struct.unpack_from(">H", data, offset)[0]
50
    offset += 2
51

52
    for _ in range(num_det_prefixes):
53
        prefix_val = struct.unpack_from(">i", data, offset)[0]
54
        offset += 4
55
        file_offset = struct.unpack_from(">i", data, offset)[0]
56
        offset += 4
57
        detailed_prefixes[str(prefix_val)] = file_offset
58

59
    print(f"✅ 成功解析: {len(carrier_names)} 个运营商, {len(general_prefixes)} 个全局号段, {len(detailed_prefixes)} 个精细号段偏移")
60

61
    return data, carrier_names, general_prefixes, detailed_prefixes
62

63
def query_carrier(phone, data, carrier_names, general_prefixes, detailed_prefixes):
64
    if len(phone) < 7 or not phone.isdigit():
65
        return "❌ 请输入至少 7 位数字号码"
66

67
    # 还原代码中的 t() 方法：优先匹配精细偏移映射
68
    # 动态尝试长度 4 和 3 (反编译代码里的 f909e 到 f910f)
69
    for length in range(4, 2, -1):
70
        prefix = phone[:length]
71
        if prefix in detailed_prefixes:
72
            suffix = phone[length : length+4]
73
            if len(suffix) == 4:
74
                # 计算文件底部的绝对寻址: Offset + int(suffix) * 2 bytes
75
                target_offset = detailed_prefixes[prefix] + (int(suffix) * 2)
76
                if target_offset + 2 <= len(data):
77
                    cid = struct.unpack_from(">H", data, target_offset)[0]
78
                    if cid in carrier_names:
79
                        # 返回索引 0 的中文名称
80
                        name = carrier_names[cid][0]
81
                        return name if name else carrier_names[cid][1]
82

83
    # 还原代码中的 u() 方法：匹配全局通用号段
84
    for length in range(4, 2, -1):
85
        prefix = phone[:length]
86
        if prefix in general_prefixes:
87
            cid = general_prefixes[prefix]
88
            if cid in carrier_names:
89
                name = carrier_names[cid][0]
90
                return name if name else carrier_names[cid][1]
91

92
    return "未知运营商"
93

94
def main():
95
    file_name = "CarrierData_1_0.dat"
96
    if not os.path.exists(file_name):
97
        print(f"❌ 找不到文件：{file_name}，请确保与脚本同目录。")
98
        return
99

100
    data, carrier_names, general_prefixes, detailed_prefixes = load_carrier_database(file_name)
101

102
    print("\n" + "="*40)
103
    print("📡 OPPO 底层运营商查询系统")
104
    print("="*40)
105

106
    while True:
107
        try:
108
            user_input = input("\n👉 请输入 7位及以上手机号 (输入 q 退出): ").strip()
109
            if user_input.lower() == 'q':
110
                break
111

112
            carrier = query_carrier(user_input, data, carrier_names, general_prefixes, detailed_prefixes)
113
            print(f"🏢 运营商: 【{carrier}】")
114

115
        except KeyboardInterrupt:
116
            break
117
        except Exception as e:
118
            print(f"发生错误: {e}")

3. 修复长途区号 “9999” 的墓碑机制#

在初步运行上一节的归属地查询脚本时，部分地区的归属地虽然正确，但长途区号会异常显示为 9999。

这一现象源于近年来中国部分省份的行政区划调整和长途区号合并。例如：

广西南宁与崇左合并了区号 0771。
四川成都、眉山、资阳合并了区号 028。
辽宁沈阳、抚顺、铁岭合并了区号 024。

为了避免重新生成并下发数 MB 的底层二进制结构，工程师采用了一种巧妙的 “墓碑机制 (Tombstone)” ：

将原有的老条目（如独立的“广西南宁”）区号修改为 9999，作为废弃标记。
在城市字典列表的末尾，追加新的合并城市名（如 0771 广西南宁/崇左）。

同时，系统引入了一个外挂补丁文件 Multi_Areano_Table.txt。该文件记录了新旧数据的映射关系：

1
origin_id  cityname  equal_id  equal_cityname
2
10  辽宁沈阳  379  辽宁沈阳/抚顺/铁岭
3
13  四川成都  378  四川成都/眉山/资阳

遗憾的是，当试图查看最核心的重定向方法 h() 时，Jadx 再次放弃了转换。无奈之下，只能继续硬着头皮去阅读底层的 Smali 汇编指令。

1
.method public h(Landroid/database/sqlite/SQLiteDatabase;)V
2
    .registers 11
3

4
    .line 1
5
    const-string v0, "PhoneNoDbHelper"
438 collapsed lines
6

7
    .line 2
8
    .line 3
9
    const/4 v1, 0x0
10

11
    .line 4
12
    :try_start_3
13
    iget-object p0, p0, Ll0/d;->d:Landroid/content/Context;
14

15
    .line 5
16
    .line 6
17
    invoke-virtual {p0}, Landroid/content/Context;->getAssets()Landroid/content/res/AssetManager;
18

19
    .line 7
20
    .line 8
21
    .line 9
22
    move-result-object p0
23

24
    .line 10
25
    const-string v2, "Multi_Areano_Table.txt"
26

27
    .line 11
28
    .line 12
29
    invoke-virtual {p0, v2}, Landroid/content/res/AssetManager;->open(Ljava/lang/String;)Ljava/io/InputStream;
30

31
    .line 13
32
    .line 14
33
    .line 15
34
    move-result-object p0
35
    :try_end_f
36
    .catch Ljava/lang/Exception; {:try_start_3 .. :try_end_f} :catch_a3
37
    .catchall {:try_start_3 .. :try_end_f} :catchall_a0
38

39
    .line 16
40
    if-eqz p0, :cond_8e
41

42
    .line 17
43
    .line 18
44
    if-nez p1, :cond_15
45

46
    .line 19
47
    .line 20
48
    goto/16 :goto_8e
49

50
    .line 21
51
    .line 22
52
    :cond_15
53
    :try_start_15
54
    invoke-static {}, Landroid/os/SystemClock;->elapsedRealtime()J
55

56
    .line 23
57
    .line 24
58
    .line 25
59
    move-result-wide v2
60

61
    .line 26
62
    new-instance v4, Ljava/io/BufferedReader;
63

64
    .line 27
65
    .line 28
66
    new-instance v5, Ljava/io/InputStreamReader;
67

68
    .line 29
69
    .line 30
70
    invoke-direct {v5, p0}, Ljava/io/InputStreamReader;-><init>(Ljava/io/InputStream;)V
71

72
    .line 31
73
    .line 32
74
    .line 33
75
    invoke-direct {v4, v5}, Ljava/io/BufferedReader;-><init>(Ljava/io/Reader;)V
76
    :try_end_23
77
    .catch Ljava/lang/Exception; {:try_start_15 .. :try_end_23} :catch_9d
78
    .catchall {:try_start_15 .. :try_end_23} :catchall_99
79

80
    .line 34
81
    .line 35
82
    .line 36
83
    const/4 v1, 0x1
84

85
    .line 37
86
    :cond_24
87
    :goto_24
88
    :try_start_24
89
    invoke-virtual {v4}, Ljava/io/BufferedReader;->readLine()Ljava/lang/String;
90

91
    .line 38
92
    .line 39
93
    .line 40
94
    move-result-object v5
95

96
    .line 41
97
    invoke-static {v5}, Landroid/text/TextUtils;->isEmpty(Ljava/lang/CharSequence;)Z
98

99
    .line 42
100
    .line 43
101
    .line 44
102
    move-result v6
103

104
    .line 45
105
    if-eqz v6, :cond_2f
106

107
    .line 46
108
    .line 47
109
    goto :goto_39
110

111
    .line 48
112
    :cond_2f
113
    invoke-virtual {v5}, Ljava/lang/String;->trim()Ljava/lang/String;
114

115
    .line 49
116
    .line 50
117
    .line 51
118
    move-result-object v5
119

120
    .line 52
121
    invoke-static {v5}, Landroid/text/TextUtils;->isEmpty(Ljava/lang/CharSequence;)Z
122

123
    .line 53
124
    .line 54
125
    .line 55
126
    move-result v6
127

128
    .line 56
129
    if-eqz v6, :cond_56
130

131
    .line 57
132
    .line 58
133
    :goto_39
134
    new-instance p1, Ljava/lang/StringBuilder;
135

136
    .line 59
137
    .line 60
138
    invoke-direct {p1}, Ljava/lang/StringBuilder;-><init>()V
139

140
    .line 61
141
    .line 62
142
    .line 63
143
    const-string v1, "updateCityCode use "
144

145
    .line 64
146
    .line 65
147
    invoke-virtual {p1, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
148

149
    .line 66
150
    .line 67
151
    .line 68
152
    invoke-static {}, Landroid/os/SystemClock;->elapsedRealtime()J
153

154
    .line 69
155
    .line 70
156
    .line 71
157
    move-result-wide v5
158

159
    .line 72
160
    sub-long/2addr v5, v2
161

162
    .line 73
163
    invoke-virtual {p1, v5, v6}, Ljava/lang/StringBuilder;->append(J)Ljava/lang/StringBuilder;
164

165
    .line 74
166
    .line 75
167
    .line 76
168
    invoke-virtual {p1}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
169

170
    .line 77
171
    .line 78
172
    .line 79
173
    move-result-object p1
174

175
    .line 80
176
    invoke-static {v0, p1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
177
    :try_end_52
178
    .catch Ljava/lang/Exception; {:try_start_24 .. :try_end_52} :catch_9e
179
    .catchall {:try_start_24 .. :try_end_52} :catchall_8c
180

181
    .line 81
182
    .line 82
183
    .line 83
184
    invoke-virtual {p0}, Ljava/io/InputStream;->close()V
185

186
    .line 84
187
    .line 85
188
    .line 86
189
    goto :goto_b0
190

191
    .line 87
192
    :cond_56
193
    const/4 v6, 0x0
194

195
    .line 88
196
    if-eqz v1, :cond_5b
197

198
    .line 89
199
    .line 90
200
    move v1, v6
201

202
    .line 91
203
    goto :goto_24
204

205
    .line 92
206
    :cond_5b
207
    :try_start_5b
208
    const-string v7, "\t"
209

210
    .line 93
211
    .line 94
212
    invoke-virtual {v5, v7}, Ljava/lang/String;->split(Ljava/lang/String;)[Ljava/lang/String;
213

214
    .line 95
215
    .line 96
216
    .line 97
217
    move-result-object v5
218

219
    .line 98
220
    array-length v7, v5
221

222
    .line 99
223
    const/4 v8, 0x4
224

225
    .line 100
226
    if-ne v7, v8, :cond_24
227

228
    .line 101
229
    .line 102
230
    new-instance v7, Ljava/lang/StringBuilder;
231

232
    .line 103
233
    .line 104
234
    invoke-direct {v7}, Ljava/lang/StringBuilder;-><init>()V
235

236
    .line 105
237
    .line 106
238
    .line 107
239
    const-string v8, "UPDATE areano_and_citynames SET equal_id = \'"
240

241
    .line 108
242
    .line 109
243
    invoke-virtual {v7, v8}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
244

245
    .line 110
246
    .line 111
247
    .line 112
248
    const/4 v8, 0x2
249

250
    .line 113
251
    aget-object v8, v5, v8
252

253
    .line 114
254
    .line 115
255
    invoke-virtual {v7, v8}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
256

257
    .line 116
258
    .line 117
259
    .line 118
260
    const-string v8, "\' WHERE _id = \'"
261

262
    .line 119
263
    .line 120
264
    invoke-virtual {v7, v8}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
265

266
    .line 121
267
    .line 122
268
    .line 123
269
    aget-object v5, v5, v6
270

271
    .line 124
272
    .line 125
273
    invoke-virtual {v7, v5}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
274

275
    .line 126
276
    .line 127
277
    .line 128
278
    const-string v5, "\';"
279

280
    .line 129
281
    .line 130
282
    invoke-virtual {v7, v5}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
283

284
    .line 131
285
    .line 132
286
    .line 133
287
    invoke-virtual {v7}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
288

289
    .line 134
290
    .line 135
291
    .line 136
292
    move-result-object v5
293

294
    .line 137
295
    invoke-virtual {p1, v5}, Landroid/database/sqlite/SQLiteDatabase;->execSQL(Ljava/lang/String;)V
296
    :try_end_8b
297
    .catch Ljava/lang/Exception; {:try_start_5b .. :try_end_8b} :catch_9e
298
    .catchall {:try_start_5b .. :try_end_8b} :catchall_8c
299

300
    .line 138
301
    .line 139
302
    .line 140
303
    goto :goto_24
304

305
    .line 141
306
    :catchall_8c
307
    move-exception p1
308

309
    .line 142
310
    goto :goto_9b
311

312
    .line 143
313
    :cond_8e
314
    :goto_8e
315
    :try_start_8e
316
    const-string p1, "updateCityCode inputStream or db is null"
317

318
    .line 144
319
    .line 145
320
    invoke-static {v0, p1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
321
    :try_end_93
322
    .catch Ljava/lang/Exception; {:try_start_8e .. :try_end_93} :catch_9d
323
    .catchall {:try_start_8e .. :try_end_93} :catchall_99
324

325
    .line 146
326
    .line 147
327
    .line 148
328
    if-eqz p0, :cond_98
329

330
    .line 149
331
    .line 150
332
    invoke-virtual {p0}, Ljava/io/InputStream;->close()V
333

334
    .line 151
335
    .line 152
336
    .line 153
337
    :cond_98
338
    return-void
339

340
    .line 154
341
    :catchall_99
342
    move-exception p1
343

344
    .line 155
345
    move-object v4, v1
346

347
    .line 156
348
    :goto_9b
349
    move-object v1, p0
350

351
    .line 157
352
    goto :goto_b5
353

354
    .line 158
355
    :catch_9d
356
    move-object v4, v1
357

358
    .line 159
359
    :catch_9e
360
    move-object v1, p0
361

362
    .line 160
363
    goto :goto_a4
364

365
    .line 161
366
    :catchall_a0
367
    move-exception p1
368

369
    .line 162
370
    move-object v4, v1
371

372
    .line 163
373
    goto :goto_b5
374

375
    .line 164
376
    :catch_a3
377
    move-object v4, v1
378

379
    .line 165
380
    :goto_a4
381
    :try_start_a4
382
    const-string p0, "update city code error"
383

384
    .line 166
385
    .line 167
386
    invoke-static {v0, p0}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;)I
387
    :try_end_a9
388
    .catchall {:try_start_a4 .. :try_end_a9} :catchall_b4
389

390
    .line 168
391
    .line 169
392
    .line 170
393
    if-eqz v1, :cond_ae
394

395
    .line 171
396
    .line 172
397
    invoke-virtual {v1}, Ljava/io/InputStream;->close()V
398

399
    .line 173
400
    .line 174
401
    .line 175
402
    :cond_ae
403
    if-eqz v4, :cond_b3
404

405
    .line 176
406
    .line 177
407
    :goto_b0
408
    invoke-virtual {v4}, Ljava/io/BufferedReader;->close()V
409

410
    .line 178
411
    .line 179
412
    .line 180
413
    :cond_b3
414
    return-void
415

416
    .line 181
417
    :catchall_b4
418
    move-exception p1
419

420
    .line 182
421
    :goto_b5
422
    if-eqz v1, :cond_ba
423

424
    .line 183
425
    .line 184
426
    invoke-virtual {v1}, Ljava/io/InputStream;->close()V
427

428
    .line 185
429
    .line 186
430
    .line 187
431
    :cond_ba
432
    if-eqz v4, :cond_bf
433

434
    .line 188
435
    .line 189
436
    invoke-virtual {v4}, Ljava/io/BufferedReader;->close()V
437

438
    .line 190
439
    .line 191
440
    .line 192
441
    :cond_bf
442
    throw p1
443
.end method

在对应的 Smali 代码中，系统在初始化 SQLite 数据库时执行了类似如下的重定向操作：

1
-- 省略部分逻辑
2
UPDATE areano_and_citynames SET equal_id = '379' WHERE _id = '10';

这意味着，当底层解密算出号码属于旧的 id = 10 时，系统会通过重定向直接获取 id = 379 的合并后数据。

4. 全息解析 Python 脚本整合#

结合以上两节的分析，我们将官方的 Multi_Areano_Table.txt 补丁动态加载至内存，并融合了多级指针寻址的运营商识别机制，实现了归属地与运营商的“二合一”查询。

以下是完整的 Python 实现代码：

1
import os
2
import struct
3

4
# ==========================================
5
# 模块 1：归属地数据库解析 (PhoneNumberData)
217 collapsed lines
6
# ==========================================
7
def load_location_db(file_path):
8
    print("⏳ [1/2] 正在加载 归属地 数据库...")
9
    with open(file_path, 'rb') as f:
10
        data = f.read()
11

12
    tail_data = data[-12002:]
13
    area_codes_raw = tail_data[2:2002]
14
    city_names_raw = tail_data[2002:10002]
15
    extend_prefix_raw = tail_data[10002:12002]
16

17
    cities = []
18
    for i in range(400):
19
        area = area_codes_raw[i*5 : i*5+5].decode('ascii', errors='ignore').strip()
20
        name_bytes = city_names_raw[i*20 : i*20+20].split(b'\x00')[0]
21
        name = name_bytes.decode('gbk', errors='ignore').strip()
22
        cities.append([area, name])
23

24
    # 🌟 官方补丁外挂：动态加载 Multi_Areano_Table.txt 处理重定向
25
    patch_file = "Multi_Areano_Table.txt"
26
    if os.path.exists(patch_file):
27
        print("   -> 发现官方区号修正补丁，正在进行数据合并重定向...")
28
        with open(patch_file, "r", encoding="utf-8") as f:
29
            lines = f.readlines()
30
            for line in lines[1:]:  # 跳过表头
31
                parts = line.strip().split('\t')
32
                if len(parts) == 4:
33
                    origin_id = int(parts[0])
34
                    equal_id = int(parts[2])
35

36
                    # 数据库 _id 从 1 开始，数组索引需减 1
37
                    target_area, target_name = cities[equal_id - 1]
38
                    # 覆盖旧的 9999 废弃数据
39
                    cities[origin_id - 1][0] = target_area
40
    else:
41
        print(f"   -> ⚠️ 未找到 {patch_file}，部分合并城市的区号可能显示为 9999。")
42

43
    # 构建号段偏移映射表
44
    prefix_map = {}
45
    base_idx = 0
46
    for p in range(130, 140): prefix_map[str(p)] = base_idx; base_idx += 10000
47
    for p in range(150, 160): prefix_map[str(p)] = base_idx; base_idx += 10000
48
    prefix_map["188"] = base_idx; base_idx += 10000
49
    prefix_map["189"] = base_idx; base_idx += 10000
50

51
    for i in range(1000):
52
        b1 = extend_prefix_raw[i*2]
53
        b2 = extend_prefix_raw[i*2 + 1]
54
        prefix_val = (b1 << 8) | b2
55
        if prefix_val == 0: break
56
        prefix_map[str(prefix_val)] = base_idx
57
        base_idx += 10000
58

59
    binary_array = data[16 : -12002]
60
    print(f"✅ [1/2] 归属地加载成功！(解析号段数: {len(prefix_map)})")
61

62
    return prefix_map, cities, binary_array
63

64
# ==========================================
65
# 模块 2：运营商数据库解析 (CarrierData)
66
# ==========================================
67
def load_carrier_db(file_path):
68
    print("⏳ [2/2] 正在加载 运营商 数据库...")
69
    with open(file_path, 'rb') as f:
70
        data = f.read()
71

72
    offset = 16
73

74
    # 1. 解析运营商名称字典
75
    carrier_names = {}
76
    num_carriers = struct.unpack_from(">H", data, offset)[0]
77
    offset += 2
78
    for _ in range(num_carriers):
79
        carrier_id = struct.unpack_from(">H", data, offset)[0]
80
        offset += 2
81
        names = []
82
        for _ in range(4):
83
            str_len = struct.unpack_from(">H", data, offset)[0]
84
            offset += 2
85
            if str_len > 0:
86
                name = data[offset : offset + str_len].decode('utf-8', errors='ignore')
87
                offset += str_len
88
            else:
89
                name = ""
90
            names.append(name)
91
        carrier_names[carrier_id] = names
92

93
    # 2. 解析全局通用号段表
94
    general_prefixes = {}
95
    num_gen_prefixes = struct.unpack_from(">H", data, offset)[0]
96
    offset += 2
97
    for _ in range(num_gen_prefixes):
98
        prefix_val = struct.unpack_from(">i", data, offset)[0]
99
        offset += 4
100
        cid = struct.unpack_from(">H", data, offset)[0]
101
        offset += 2
102
        general_prefixes[str(prefix_val)] = cid
103

104
    # 3. 解析精细偏移映射表
105
    detailed_prefixes = {}
106
    num_det_prefixes = struct.unpack_from(">H", data, offset)[0]
107
    offset += 2
108
    for _ in range(num_det_prefixes):
109
        prefix_val = struct.unpack_from(">i", data, offset)[0]
110
        offset += 4
111
        file_offset = struct.unpack_from(">i", data, offset)[0]
112
        offset += 4
113
        detailed_prefixes[str(prefix_val)] = file_offset
114

115
    print(f"✅ [2/2] 运营商加载成功！(精细号段规则: {len(detailed_prefixes)}条)")
116
    return data, carrier_names, general_prefixes, detailed_prefixes
117

118
# ==========================================
119
# 模块 3：全息信息统一查询接口
120
# ==========================================
121
def query_phone_info(phone, loc_data, car_data):
122
    if len(phone) < 7 or not phone.isdigit():
123
        return "❌ 格式错误：请输入至少 7 位纯数字号码！"
124

125
    eval_phone = phone[:8]
126
    phone_7 = eval_phone[:7]
127

128
    # --- A. 归属地查询逻辑 (12-Bit 压缩解密) ---
129
    prefix_map, cities, binary_array = loc_data
130
    prefix = phone_7[:3]
131
    suffix = phone_7[3:]
132

133
    loc_name = "未知"
134
    area_code = "未知"
135

136
    if prefix in prefix_map:
137
        absolute_index = prefix_map[prefix] + int(suffix)
138
        byte_offset = (absolute_index // 2) * 3
139

140
        if byte_offset + 2 < len(binary_array):
141
            b1 = binary_array[byte_offset]
142
            b2 = binary_array[byte_offset + 1]
143
            b3 = binary_array[byte_offset + 2]
144

145
            if absolute_index % 2 == 0:
146
                city_id = (b1 << 4) | (b2 >> 4)
147
            else:
148
                city_id = ((b2 & 0x0F) << 8) | b3
149

150
            if city_id != 0 and city_id < len(cities):
151
                area_code, loc_name = cities[city_id]
152
                if not loc_name: loc_name = "未知"
153

154
    # --- B. 运营商查询逻辑 (多级指针寻址) ---
155
    car_raw_data, carrier_names, general_prefixes, detailed_prefixes = car_data
156
    carrier_name = "未知运营商"
157
    found_carrier = False
158

159
    # B.1 优先进行精细规则匹配
160
    for length in range(4, 2, -1):
161
        p_prefix = eval_phone[:length]
162
        if p_prefix in detailed_prefixes:
163
            p_suffix = eval_phone[length : length+4]
164
            if len(p_suffix) == 4:
165
                target_offset = detailed_prefixes[p_prefix] + (int(p_suffix) * 2)
166
                if target_offset + 2 <= len(car_raw_data):
167
                    cid = struct.unpack_from(">H", car_raw_data, target_offset)[0]
168
                    if cid in carrier_names:
169
                        carrier_name = carrier_names[cid][0] or carrier_names[cid][1]
170
                        found_carrier = True
171
                        break
172

173
    # B.2 若未命中，则进行全局大号段匹配
174
    if not found_carrier:
175
        for length in range(4, 2, -1):
176
            p_prefix = eval_phone[:length]
177
            if p_prefix in general_prefixes:
178
                cid = general_prefixes[p_prefix]
179
                if cid in carrier_names:
180
                    carrier_name = carrier_names[cid][0] or carrier_names[cid][1]
181
                    break
182

183
    result = (
184
        f"📱 查询号码: {phone}\n"
185
        f"📍 归属地点: 【{loc_name}】 (长途区号: {area_code})\n"
186
        f"🏢 运营网络: 【{carrier_name}】"
187
    )
188
    return result
189

190
def main():
191
    print("=" * 45)
192
    print("🚀 ColorOS 离线号码全息识别系统")
193
    print("=" * 45)
194

195
    loc_file = "PhoneNumberData_3_1_0.dat"
196
    car_file = "CarrierData_1_0.dat"
197

198
    if not os.path.exists(loc_file) or not os.path.exists(car_file):
199
        print(f"❌ 启动失败：缺少数据库文件。\n请确保 {loc_file} 和 {car_file} 都在同一目录！")
200
        return
201

202
    loc_data = load_location_db(loc_file)
203
    car_data = load_carrier_db(car_file)
204
    print("-" * 45)
205

206
    while True:
207
        try:
208
            user_input = input("\n👉 请输入完整的手机号 (输入 q 退出): ").strip()
209
            if user_input.lower() == 'q':
210
                print("👋 系统已退出。")
211
                break
212

213
            result = query_phone_info(user_input, loc_data, car_data)
214
            print("-" * 35)
215
            print(result)
216
            print("-" * 35)
217

218
        except KeyboardInterrupt:
219
            print("\n👋 系统已退出。")
220
            break
221
        except Exception as e:
222
            print(f"⚠️ 查询中发生异常: {e}")

5. 小结#

至此，我们已经成功提取并重构了基于号码前 7 位的归属地与运营商查询逻辑。但对于发生过“携号转网”的特例号码，传统的号段查询便会失效。在下一节中，我们将解析 PortabilityNumberData.dat 特权库，探究系统是如何利用二分查找算法解决携号转网难题的，并最终实现支持高并发的数据全量导出脚本。