湖北校园网PC端拨号算法逆向

前言

上一文 PPPoE中间人拦截以及校园网突破漫谈我们谈到使用 PPPoE 拦截来获取真实的账号密码。
在这个的基础上，我对我们湖北的客户端进行了逆向，得到了拨号加密算法。

准备工作

首先查壳，发现这个版本没壳了，我记得之前好像是加过 vmp 的呀，不管了。
然后我们看看目录下的 dll 导出表看看有没有什么好东西

AidcComm.dll 里面有这些东西，看来这个极大可能会是我们的目标。

我们再看看主程序的导入表，发现主程序的导入表里面并没有这个 dll，那我们动态调试的时候应该怎么断到这个 dll 中去呢。
没有导入表说明没有 .lib，那有可能是通过 LoadLibrary 加载的 dll，至于自实现 peloader，我觉得应该这个软件应该不会是这样。
看看就知道了。
直接用 x32dbg 和 IDA 开始看。

逆向过程

x32dbg 打开主程序，然后 bp LoadLibraryW，再重新载入程序，我们可以一步步运行发现 AidcComm.dll 被载入了。
然后运行到用户代码处

我们可以看到此时 eax 寄存器的值为 55870000，这个就是 LoadLibrary 返回的 HANDLE。一般思路来说，接下来就是用 GetProcAddress 获取导出表函数的地址了。
继续往下走几步，即可发现我们的猜测并没有错误。

从这张图我们可以看到主程序获取了 AidcComm.GetPWD 和 AidcComm.GetRegularAccount 的地址。
那我们通过 call 之后的 eax 跳转过去在这两个函数的地址下断，直接跑起来。
然后我们会发现在 AidcComm.GetRegularAccount 断下来了，传入的参数可以在堆栈窗口中看到。

我们去 IDA 分析 GetRegularAccount 这个函数，同时在调试器这边动态跟（这个我已经分析过了，所以有的变量和函数名我已经改过了）

首先最直观的就是账号的变换，账号只需要加上前缀 !^Wnds0 即可（但其实加密出来后，主程序这个给它又加了一个后缀 @hbxy）。（从调试器可以看到）
密码我们直接跟到 GetPWD 里面去看。

通过调试器我们可以观察出，这个分支结构只会执行 a2 == 1 这个分支。
看来是通过下面这个函数加密的了。（我给他改了名 encryptPwdWithKey） 我们进到 encryptPwdWithKey(void *password, char *key, rsize_t SizeInBytes) 这个函数去查看。

通过分析我们可以得出大致上的流程

  1. password 用 key RC4 一下得到 A
  2. 把 A md5 一下得到 B，如果第 11 位为奇数，取 B 的前 16 位，偶数就后 16 位，得到 C
  3. C 再用 key RC4 一下得到 D
  4. D 再 md5 一下，取 [8:24]得到 E

也就是最后得到的 E 是加密之后的。

可能有的小伙伴不明白为什么会是 RC4，这里有几个提示的地方，第一是这个字符串的提示，第二是 RC4 加密流程是很容易分辨的，这个靠经验了。

但是我们发现我们截取出来的密码和这个是有点小不一样的。通过调试，可以看到在 GetRegularAccount 函数加密出来后，又调用了一个函数，这个函数我给它重命名为 fixHBKey 了。

我们跟进去看看

代码并不长，我们可以直接调试器分析，如果你想用 IDA 也是可以的，IDA 可以搜索上图中的 <<< FixHBKey: %s <<< 这个字符串来定位这个函数。 或者我们可以看到这个函数的入口地址为 001115D0，这个 exe 的加载基址我们可以往上滑到顶看到为 000F1000，两个之间的差值为 205D0， 然后再把这个差值加上 IDA 加载的基址，即可找到这个函数。

这个函数的大致作用就是修改上面我们得到的 E

  • E[今天几号日期 % 16] 替换为 ‘b’ 得到最后的密码

这块我们是搞清楚了，那 key 是怎么来的呢。
这个我们就需要大量借助调试器了，我们重启一下主程序，然后在上面的分析基础上找到这个 key 第一次出现的地方，我们可以发现 在 AidcRes 偏移 10110 处即为 key 的生成函数。

这个函数巨长，同样的，我们借助之前的方法在 IDA 中找到这个函数，我这里直接按偏移，可以看到在 sub_420110 即为我们的加密函数， 这里我已经重命名为 generateKey。

这个函数太长了，我无法截全图，我直接丢代码然后分析，这里分析建议大家调试结合代码来看，不然一头雾水。其中大量的必要变量和函数我已经重命名，方便大家阅读。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522

int __thiscall generateKey(char *this, int a2, char a3, int a4, int a5, int a6, int a7, int a8)
{
  int v8; // eax
  int v9; // edx
  int v11; // [esp+8h] [ebp-37Ch]
  char *v12; // [esp+20h] [ebp-364h]
  int len_username_b_MonthDay; // [esp+24h] [ebp-360h]
  char *v14; // [esp+28h] [ebp-35Ch]
  int len_bUsernameMonthDay; // [esp+2Ch] [ebp-358h]
  char *v16; // [esp+30h] [ebp-354h]
  char *mem_17; // [esp+34h] [ebp-350h]
  int v18; // [esp+38h] [ebp-34Ch]
  int lenMonthDay; // [esp+3Ch] [ebp-348h]
  int lenUsername; // [esp+40h] [ebp-344h]
  int v21; // [esp+44h] [ebp-340h]
  int v22; // [esp+48h] [ebp-33Ch]
  int *v23; // [esp+4Ch] [ebp-338h]
  int v24; // [esp+50h] [ebp-334h]
  const char *v25; // [esp+54h] [ebp-330h]
  int len_HbKeyGa; // [esp+58h] [ebp-32Ch]
  int lenHbKeyGa; // [esp+5Ch] [ebp-328h]
  char *pMem_64_a; // [esp+60h] [ebp-324h]
  int len_HbKeyGb; // [esp+64h] [ebp-320h]
  int lenHbKeyGb; // [esp+68h] [ebp-31Ch]
  char *pMem_64_b; // [esp+6Ch] [ebp-318h]
  int v32; // [esp+70h] [ebp-314h]
  int v33; // [esp+74h] [ebp-310h]
  int v34; // [esp+78h] [ebp-30Ch]
  int v35; // [esp+7Ch] [ebp-308h]
  int len_monthDay_Username_b; // [esp+80h] [ebp-304h]
  char *v37; // [esp+84h] [ebp-300h]
  int len_username_MonthDay_b; // [esp+88h] [ebp-2FCh]
  LPVOID lp_mix_md5_1; // [esp+8Ch] [ebp-2F8h]
  size_t v40; // [esp+90h] [ebp-2F4h]
  int v41; // [esp+94h] [ebp-2F0h]
  LPVOID v42; // [esp+98h] [ebp-2ECh]
  LPVOID v43; // [esp+9Ch] [ebp-2E8h]
  LPVOID v44; // [esp+A0h] [ebp-2E4h]
  int index3; // [esp+A4h] [ebp-2E0h]
  int index2; // [esp+A8h] [ebp-2DCh]
  char *pHbKeyGa; // [esp+ACh] [ebp-2D8h]
  int index6; // [esp+B0h] [ebp-2D4h]
  int index5; // [esp+B4h] [ebp-2D0h]
  _DWORD *md5_monthDay_Username_b; // [esp+B8h] [ebp-2CCh]
  _DWORD *md5_username_b_MonthDay; // [esp+BCh] [ebp-2C8h]
  _DWORD *md5_username_MonthDay_b; // [esp+C0h] [ebp-2C4h]
  void *mix_md5_1; // [esp+C4h] [ebp-2C0h]
  int md5_1_pLus3remainder4; // [esp+C8h] [ebp-2BCh]
  int md5_bUsernameMonthDay; // [esp+CCh] [ebp-2B8h]
  char *pHbKeyGb; // [esp+D0h] [ebp-2B4h]
  void *v57; // [esp+D4h] [ebp-2B0h]
  void *v58; // [esp+D8h] [ebp-2ACh]
  int md5_4_plus5remainer4; // [esp+DCh] [ebp-2A8h]
  void *mix_md5_2; // [esp+E0h] [ebp-2A4h]
  const char *userName; // [esp+E4h] [ebp-2A0h]
  char *monthDay; // [esp+E8h] [ebp-29Ch]
  char *bUsernameMonthDay; // [esp+ECh] [ebp-298h]
  char *username_b_MonthDay; // [esp+F0h] [ebp-294h]
  char *username_MonthDay_b; // [esp+F4h] [ebp-290h]
  char *monthDay_Username_b; // [esp+F8h] [ebp-28Ch]
  char *p_HbKeyGb; // [esp+FCh] [ebp-288h]
  char *p_HbKeyGa; // [esp+100h] [ebp-284h]
  const char *username; // [esp+104h] [ebp-280h]
  _DWORD *md5_2; // [esp+108h] [ebp-27Ch]
  _DWORD *md5_3; // [esp+10Ch] [ebp-278h]
  int index1; // [esp+114h] [ebp-270h]
  int index4; // [esp+118h] [ebp-26Ch]
  int temp1; // [esp+11Ch] [ebp-268h]
  int temp2; // [esp+120h] [ebp-264h]
  _DWORD *md5_4; // [esp+124h] [ebp-260h]
  int md5_1; // [esp+128h] [ebp-25Ch]
  size_t SizeInBytes; // [esp+134h] [ebp-250h]
  char *DstBuf; // [esp+138h] [ebp-24Ch]
  char *pThis; // [esp+13Ch] [ebp-248h]
  int v81; // [esp+140h] [ebp-244h]
  int v82; // [esp+144h] [ebp-240h]
  int v83; // [esp+148h] [ebp-23Ch]
  int v84; // [esp+14Ch] [ebp-238h]
  int v85; // [esp+150h] [ebp-234h]
  int v86; // [esp+154h] [ebp-230h]
  int v87; // [esp+158h] [ebp-22Ch]
  int v88; // [esp+15Ch] [ebp-228h]
  char hbKey; // [esp+160h] [ebp-224h]
  char v90; // [esp+161h] [ebp-223h]
  char hbKeyGa; // [esp+1E4h] [ebp-1A0h]
  char mem_64_a; // [esp+1E5h] [ebp-19Fh]
  char hbKeyGb; // [esp+228h] [ebp-15Ch]
  char mem_64_b; // [esp+229h] [ebp-15Bh]
  char v95; // [esp+22Fh] [ebp-155h]
  char v96[4]; // [esp+26Ch] [ebp-118h]
  char v97[5]; // [esp+270h] [ebp-114h]
  int v98; // [esp+275h] [ebp-10Fh]
  int v99; // [esp+279h] [ebp-10Bh]
  int v100; // [esp+27Dh] [ebp-107h]
  int v101; // [esp+281h] [ebp-103h]
  int v102; // [esp+285h] [ebp-FFh]
  __int16 v103; // [esp+289h] [ebp-FBh]
  char v104; // [esp+28Bh] [ebp-F9h]
  char v105[4]; // [esp+28Ch] [ebp-F8h]
  char v106[5]; // [esp+290h] [ebp-F4h]
  int v107; // [esp+295h] [ebp-EFh]
  int v108; // [esp+299h] [ebp-EBh]
  int v109; // [esp+29Dh] [ebp-E7h]
  int v110; // [esp+2A1h] [ebp-E3h]
  int v111; // [esp+2A5h] [ebp-DFh]
  __int16 v112; // [esp+2A9h] [ebp-DBh]
  char v113; // [esp+2ABh] [ebp-D9h]
  char v114[4]; // [esp+2ACh] [ebp-D8h]
  char v115[5]; // [esp+2B0h] [ebp-D4h]
  int v116; // [esp+2B5h] [ebp-CFh]
  int v117; // [esp+2B9h] [ebp-CBh]
  int v118; // [esp+2BDh] [ebp-C7h]
  int v119; // [esp+2C1h] [ebp-C3h]
  int v120; // [esp+2C5h] [ebp-BFh]
  __int16 v121; // [esp+2C9h] [ebp-BBh]
  char v122; // [esp+2CBh] [ebp-B9h]
  char v123[4]; // [esp+2CCh] [ebp-B8h]
  char v124[5]; // [esp+2D0h] [ebp-B4h]
  int v125; // [esp+2D5h] [ebp-AFh]
  int v126; // [esp+2D9h] [ebp-ABh]
  int v127; // [esp+2DDh] [ebp-A7h]
  int v128; // [esp+2E1h] [ebp-A3h]
  int v129; // [esp+2E5h] [ebp-9Fh]
  __int16 v130; // [esp+2E9h] [ebp-9Bh]
  char v131; // [esp+2EBh] [ebp-99h]
  char char_array_29_2[29]; // [esp+2ECh] [ebp-98h]
  __int16 v133; // [esp+309h] [ebp-7Bh]
  char v134; // [esp+30Bh] [ebp-79h]
  char char_array_29_1[29]; // [esp+30Ch] [ebp-78h]
  __int16 v136; // [esp+329h] [ebp-5Bh]
  char v137; // [esp+32Bh] [ebp-59h]
  char char_array_29_3[29]; // [esp+32Ch] [ebp-58h]
  __int16 v139; // [esp+349h] [ebp-3Bh]
  char v140; // [esp+34Bh] [ebp-39h]
  char char_array_29_4[29]; // [esp+34Ch] [ebp-38h]
  __int16 v142; // [esp+369h] [ebp-1Bh]
  char v143; // [esp+36Bh] [ebp-19h]
  char month_day; // [esp+36Ch] [ebp-18h]
  int v145; // [esp+36Dh] [ebp-17h]
  int v146; // [esp+380h] [ebp-4h]

  pThis = this;
  v41 = 0;
  v146 = 0;
  username = 0;
  v40 = sub_421680("@hbxy", 0);
  if ( v40 != -1 )
  {
    v33 = sub_421630((int)&v11, 0, v40);
    std::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator=(v33);
    std::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string<char,std::char_traits<char>,std::allocator<char>>(&v11);
  }
  username = (const char *)get_username(&a3);
  userName = username;
  v25 = username + 1;
  userName += strlen(userName);
  v24 = ++userName - (username + 1);
  lenUsername = userName - (username + 1);
  month_day = 0;
  v145 = 0;
  strftime(&month_day, 5u, "%m%d", (const struct tm *)(pThis + 8));
  monthDay = &month_day;
  v23 = &v145;
  monthDay += strlen(monthDay);
  v21 = ++monthDay - (char *)&v145;
  lenMonthDay = monthDay - (char *)&v145;
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, ">>> GetHBKey: %s >>>", &month_day);
  v18 = 1;
  SizeInBytes = lenMonthDay + lenUsername + 2;
  mem_17 = (char *)malloc(SizeInBytes);
  DstBuf = mem_17;
  memset(mem_17, 0, SizeInBytes);
  sprintf_s(DstBuf, SizeInBytes, "%c%s%s", pThis[4], username, &month_day);// "b177628979080516"
  bUsernameMonthDay = DstBuf;
  v16 = DstBuf + 1;
  bUsernameMonthDay += strlen(bUsernameMonthDay);
  len_bUsernameMonthDay = ++bUsernameMonthDay - (DstBuf + 1);
  md5_bUsernameMonthDay = md5_StrWithLength(DstBuf, bUsernameMonthDay - (DstBuf + 1));// 5e64fdaa6449e2abb9693f2757c11652
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(
    pThis,
    "[HBKEY] mdata1: %s [%s]",
    DstBuf,
    md5_bUsernameMonthDay);
  memset(DstBuf, 0, SizeInBytes);
  sprintf_s(DstBuf, SizeInBytes, "%s%c%s", username, pThis[4], &month_day);// "17762897908b0516"
  username_b_MonthDay = DstBuf;
  v14 = DstBuf + 1;
  username_b_MonthDay += strlen(username_b_MonthDay);
  len_username_b_MonthDay = ++username_b_MonthDay - (DstBuf + 1);
  md5_username_b_MonthDay = (_DWORD *)md5_StrWithLength(DstBuf, username_b_MonthDay - (DstBuf + 1));// 16dffe496172e2fb1bdb9b2002bfb5a5
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(
    pThis,
    "[HBKEY] mdata2: %s [%s]",
    DstBuf,
    md5_username_b_MonthDay);
  memset(DstBuf, 0, SizeInBytes);
  sprintf_s(DstBuf, SizeInBytes, "%s%s%c", username, &month_day, pThis[4]);// "177628979080516b"
  username_MonthDay_b = DstBuf;
  v12 = DstBuf + 1;
  username_MonthDay_b += strlen(username_MonthDay_b);
  len_username_MonthDay_b = ++username_MonthDay_b - (DstBuf + 1);
  md5_username_MonthDay_b = (_DWORD *)md5_StrWithLength(DstBuf, username_MonthDay_b - (DstBuf + 1));// 6614da7943beed0e7baafc0be7fb624c
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(
    pThis,
    "[HBKEY] mdata3: %s [%s]",
    DstBuf,
    md5_username_MonthDay_b);
  memset(DstBuf, 0, SizeInBytes);
  sprintf_s(DstBuf, SizeInBytes, "%s%s%c", &month_day, username, pThis[4]);// "051617762897908b"
  monthDay_Username_b = DstBuf;
  v37 = DstBuf + 1;
  monthDay_Username_b += strlen(monthDay_Username_b);
  len_monthDay_Username_b = ++monthDay_Username_b - (DstBuf + 1);
  md5_monthDay_Username_b = (_DWORD *)md5_StrWithLength(DstBuf, monthDay_Username_b - (DstBuf + 1));// 2b28feebb48c0cb98b9f3da404fff646
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(
    pThis,
    "[HBKEY] mdata4: %s [%s]",
    DstBuf,
    md5_monthDay_Username_b);
  md5_1 = 0;
  md5_2 = 0;
  md5_3 = 0;
  md5_4 = 0;
  if ( *(char *)(md5_bUsernameMonthDay + 1) % 2 )
  {
    md5_1 = md5_bUsernameMonthDay;
    md5_2 = md5_username_MonthDay_b;
    md5_3 = md5_username_b_MonthDay;
    md5_4 = md5_monthDay_Username_b;
  }
  else
  {
    md5_1 = md5_bUsernameMonthDay;
    md5_2 = md5_monthDay_Username_b;
    md5_3 = md5_username_b_MonthDay;
    md5_4 = md5_username_MonthDay_b;
  }
  hbKeyGa = 0;
  memset(&mem_64_a, 0, 0x40u);
  md5_1_pLus3remainder4 = *(char *)(md5_1 + 3) % 4;
  // 以下一连串的赋值是使 char_array_29_1 = md5_1, char_array_29_2 = md5_2
  char_array_29_1[0] = 0;
  *(_DWORD *)&char_array_29_1[1] = 0;
  *(_DWORD *)&char_array_29_1[5] = 0;
  *(_DWORD *)&char_array_29_1[9] = 0;
  *(_DWORD *)&char_array_29_1[13] = 0;
  *(_DWORD *)&char_array_29_1[17] = 0;
  *(_DWORD *)&char_array_29_1[21] = 0;
  *(_DWORD *)&char_array_29_1[25] = 0;
  v136 = 0;
  v137 = 0;
  char_array_29_2[0] = 0;
  *(_DWORD *)&char_array_29_2[1] = 0;
  *(_DWORD *)&char_array_29_2[5] = 0;
  *(_DWORD *)&char_array_29_2[9] = 0;
  *(_DWORD *)&char_array_29_2[13] = 0;
  *(_DWORD *)&char_array_29_2[17] = 0;
  *(_DWORD *)&char_array_29_2[21] = 0;
  *(_DWORD *)&char_array_29_2[25] = 0;
  v133 = 0;
  v134 = 0;
  *(_DWORD *)char_array_29_1 = *(_DWORD *)md5_1;
  *(_DWORD *)&char_array_29_1[4] = *(_DWORD *)(md5_1 + 4);
  *(_DWORD *)&char_array_29_1[8] = *(_DWORD *)(md5_1 + 8);
  *(_DWORD *)&char_array_29_1[12] = *(_DWORD *)(md5_1 + 12);
  *(_DWORD *)&char_array_29_1[16] = *(_DWORD *)(md5_1 + 16);
  *(_DWORD *)&char_array_29_1[20] = *(_DWORD *)(md5_1 + 20);
  *(_DWORD *)&char_array_29_1[24] = *(_DWORD *)(md5_1 + 24);
  *(_DWORD *)&char_array_29_1[28] = *(_DWORD *)(md5_1 + 28);
  *(_DWORD *)char_array_29_2 = *md5_2;
  *(_DWORD *)&char_array_29_2[4] = md5_2[1];
  *(_DWORD *)&char_array_29_2[8] = md5_2[2];
  *(_DWORD *)&char_array_29_2[12] = md5_2[3];
  *(_DWORD *)&char_array_29_2[16] = md5_2[4];
  *(_DWORD *)&char_array_29_2[20] = md5_2[5];
  *(_DWORD *)&char_array_29_2[24] = md5_2[6];
  *(_DWORD *)&char_array_29_2[28] = md5_2[7];
  v81 = md5_1_pLus3remainder4;                  // 0
  v82 = abs(md5_1_pLus3remainder4 - 5) % 4;     // 1
  v8 = (md5_1_pLus3remainder4 + 2) % 4;         // 2
  v83 = (md5_1_pLus3remainder4 + 2) % 4;        // 2
  v84 = abs(md5_1_pLus3remainder4 - 3);         // 3
  v96[0] = 0;
  *(_DWORD *)&v96[1] = 0;
  *(_DWORD *)&v97[1] = 0;
  v98 = 0;
  v99 = 0;
  v100 = 0;
  v101 = 0;
  v102 = 0;
  v103 = 0;
  v104 = 0;
  v105[0] = 0;
  *(_DWORD *)&v105[1] = 0;
  *(_DWORD *)&v106[1] = 0;
  v107 = 0;
  v108 = 0;
  v109 = 0;
  v110 = 0;
  v111 = 0;
  v112 = 0;
  v113 = 0;
  *(_DWORD *)v96 = *(_DWORD *)&char_array_29_1[8 * md5_1_pLus3remainder4];
  *(_DWORD *)v97 = *(_DWORD *)&char_array_29_1[8 * md5_1_pLus3remainder4 + 4];
  *(_DWORD *)&v97[4] = *(_DWORD *)&char_array_29_2[8 * v82];
  *(int *)((char *)&v98 + 3) = *(_DWORD *)&char_array_29_2[8 * v82 + 4];
  *(int *)((char *)&v99 + 3) = *(_DWORD *)&char_array_29_1[8 * v8];
  *(int *)((char *)&v100 + 3) = *(_DWORD *)&char_array_29_1[8 * v8 + 4];
  *(int *)((char *)&v101 + 3) = *(_DWORD *)&char_array_29_2[8 * v84];
  *(int *)((char *)&v102 + 3) = *(_DWORD *)&char_array_29_2[8 * v84 + 4];
  *(_DWORD *)v105 = *(_DWORD *)&char_array_29_2[8 * md5_1_pLus3remainder4];
  *(_DWORD *)v106 = *(_DWORD *)&char_array_29_2[8 * md5_1_pLus3remainder4 + 4];
  *(_DWORD *)&v106[4] = *(_DWORD *)&char_array_29_1[8 * v82];
  *(int *)((char *)&v107 + 3) = *(_DWORD *)&char_array_29_1[8 * v82 + 4];
  *(int *)((char *)&v108 + 3) = *(_DWORD *)&char_array_29_2[8 * v8];
  *(int *)((char *)&v109 + 3) = *(_DWORD *)&char_array_29_2[8 * v8 + 4];
  *(int *)((char *)&v110 + 3) = *(_DWORD *)&char_array_29_1[8 * v84];
  *(int *)((char *)&v111 + 3) = *(_DWORD *)&char_array_29_1[8 * v84 + 4];
  mix_md5_1 = (void *)md5_StrWithLength(v96, 32);// 第一个参数  5e64fdaa43beed0eb9693f27e7fb624c6614da796449e2ab7baafc0b57c11652  
                                                // 返回值  5008ef506febfc228802dd43b99c1869
                                                // 为 5e64fdaa43beed0eb9693f27e7fb624c 的 md5
  mix_md5_2 = (void *)md5_StrWithLength(v105, 32);// 第一个参数  6614da796449e2ab7baafc0b57c11652
                                                // 返回值  46e4a9da513469a20da82e3136f46951
  sprintf_s(&hbKeyGa, 0x41u, "%s%s", mix_md5_1, mix_md5_2);// hbKeyGa = "5008ef506febfc228802dd43b99c186946e4a9da513469a20da82e3136f46951"
  lp_mix_md5_1 = mix_md5_1;
  j_j___free_base(mix_md5_1);
  if ( lp_mix_md5_1 )
  {
    mix_md5_1 = (void *)33059;
    v35 = 33059;
  }
  else
  {
    v35 = 0;
  }
  v44 = mix_md5_2;
  j_j___free_base(mix_md5_2);
  if ( v44 )
  {
    mix_md5_2 = (void *)33059;
    v34 = 33059;
  }
  else
  {
    v34 = 0;
  }
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, "[HBKEY] ga: %s", &hbKeyGa);
  hbKeyGb = 0;
  memset(&mem_64_b, 0, 0x40u);
  md5_4_plus5remainer4 = *((char *)md5_4 + 5) % 4;
  // 以下一连串的赋值是使 char_array_29_3 = md5_3, char_array_29_4 = md5_4
  char_array_29_3[0] = 0;
  *(_DWORD *)&char_array_29_3[1] = 0;
  *(_DWORD *)&char_array_29_3[5] = 0;
  *(_DWORD *)&char_array_29_3[9] = 0;
  *(_DWORD *)&char_array_29_3[13] = 0;
  *(_DWORD *)&char_array_29_3[17] = 0;
  *(_DWORD *)&char_array_29_3[21] = 0;
  *(_DWORD *)&char_array_29_3[25] = 0;
  v139 = 0;
  v140 = 0;
  char_array_29_4[0] = 0;
  *(_DWORD *)&char_array_29_4[1] = 0;
  *(_DWORD *)&char_array_29_4[5] = 0;
  *(_DWORD *)&char_array_29_4[9] = 0;
  *(_DWORD *)&char_array_29_4[13] = 0;
  *(_DWORD *)&char_array_29_4[17] = 0;
  *(_DWORD *)&char_array_29_4[21] = 0;
  *(_DWORD *)&char_array_29_4[25] = 0;
  v142 = 0;
  v143 = 0;
  *(_DWORD *)char_array_29_3 = *md5_3;
  *(_DWORD *)&char_array_29_3[4] = md5_3[1];
  *(_DWORD *)&char_array_29_3[8] = md5_3[2];
  *(_DWORD *)&char_array_29_3[12] = md5_3[3];
  *(_DWORD *)&char_array_29_3[16] = md5_3[4];
  *(_DWORD *)&char_array_29_3[20] = md5_3[5];
  *(_DWORD *)&char_array_29_3[24] = md5_3[6];
  *(_DWORD *)&char_array_29_3[28] = md5_3[7];
  *(_DWORD *)char_array_29_4 = *md5_4;
  *(_DWORD *)&char_array_29_4[4] = md5_4[1];
  *(_DWORD *)&char_array_29_4[8] = md5_4[2];
  *(_DWORD *)&char_array_29_4[12] = md5_4[3];
  *(_DWORD *)&char_array_29_4[16] = md5_4[4];
  *(_DWORD *)&char_array_29_4[20] = md5_4[5];
  *(_DWORD *)&char_array_29_4[24] = md5_4[6];
  *(_DWORD *)&char_array_29_4[28] = md5_4[7];
  v85 = md5_4_plus5remainer4;                   // 1
  v86 = abs(md5_4_plus5remainer4 - 5) % 4;      // 0
  v9 = (md5_4_plus5remainer4 + 2) % 4;          // 3
  v87 = (md5_4_plus5remainer4 + 2) % 4;         // 3
  v88 = abs(md5_4_plus5remainer4 - 3);          // 2
  v114[0] = 0;
  *(_DWORD *)&v114[1] = 0;
  *(_DWORD *)&v115[1] = 0;
  v116 = 0;
  v117 = 0;
  v118 = 0;
  v119 = 0;
  v120 = 0;
  v121 = 0;
  v122 = 0;
  v123[0] = 0;
  *(_DWORD *)&v123[1] = 0;
  *(_DWORD *)&v124[1] = 0;
  v125 = 0;
  v126 = 0;
  v127 = 0;
  v128 = 0;
  v129 = 0;
  v130 = 0;
  v131 = 0;
  *(_DWORD *)v114 = *(_DWORD *)&char_array_29_3[8 * md5_4_plus5remainer4];
  *(_DWORD *)v115 = *(_DWORD *)&char_array_29_3[8 * md5_4_plus5remainer4 + 4];
  *(_DWORD *)&v115[4] = *(_DWORD *)&char_array_29_4[8 * v86];
  *(int *)((char *)&v116 + 3) = *(_DWORD *)&char_array_29_4[8 * v86 + 4];
  *(int *)((char *)&v117 + 3) = *(_DWORD *)&char_array_29_3[8 * v9];
  *(int *)((char *)&v118 + 3) = *(_DWORD *)&char_array_29_3[8 * v9 + 4];
  *(int *)((char *)&v119 + 3) = *(_DWORD *)&char_array_29_4[8 * v88];
  *(int *)((char *)&v120 + 3) = *(_DWORD *)&char_array_29_4[8 * v88 + 4];
  *(_DWORD *)v123 = *(_DWORD *)&char_array_29_4[8 * md5_4_plus5remainer4];
  *(_DWORD *)v124 = *(_DWORD *)&char_array_29_4[8 * md5_4_plus5remainer4 + 4];
  *(_DWORD *)&v124[4] = *(_DWORD *)&char_array_29_3[8 * v86];
  *(int *)((char *)&v125 + 3) = *(_DWORD *)&char_array_29_3[8 * v86 + 4];
  *(int *)((char *)&v126 + 3) = *(_DWORD *)&char_array_29_4[8 * v9];
  *(int *)((char *)&v127 + 3) = *(_DWORD *)&char_array_29_4[8 * v9 + 4];
  *(int *)((char *)&v128 + 3) = *(_DWORD *)&char_array_29_3[8 * v88];
  *(int *)((char *)&v129 + 3) = *(_DWORD *)&char_array_29_3[8 * v88 + 4];
  v58 = (void *)md5_StrWithLength(v114, 32);    // 返回值 1ed63dc9a269d8705e297c03dcda7cf0
                                                // 为 6172e2fb2b28feeb02bfb5a58b9f3da4 的 md5
  v57 = (void *)md5_StrWithLength(v123, 32);    // 返回值 25928da86463ce9beba8110d2d514464
                                                // 为 b48c0cb916dffe4904fff6461bdb9b20 的 md5

  sprintf_s(&hbKeyGb, 0x41u, "%s%s", v58, v57); // hbKeyGb = "1ed63dc9a269d8705e297c03dcda7cf025928da86463ce9beba8110d2d514464"
  v43 = v58;
  j_j___free_base(v58);
  if ( v43 )
  {
    v58 = (void *)33059;
    v22 = 33059;
  }
  else
  {
    v22 = 0;
  }
  v42 = v57;
  j_j___free_base(v57);
  if ( v42 )
  {
    v57 = (void *)33059;
    v32 = 33059;
  }
  else
  {
    v32 = 0;
  }
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, "[HBKEY] gb: %s", &hbKeyGb);
  if ( v95 % 2 )                                // 从反汇编中可看到 v95 为 hbkey_gb[7]
  {
    temp1 = 0;
    p_HbKeyGa = &hbKeyGa;
    pMem_64_a = &mem_64_a;
    p_HbKeyGa += strlen(p_HbKeyGa);
    lenHbKeyGa = ++p_HbKeyGa - &mem_64_a;
    len_HbKeyGa = p_HbKeyGa - &mem_64_a;
    while ( temp1 < len_HbKeyGa )               // 把 HbKeyGa 里面的小写字母全替换为大写
    {
      if ( *(&hbKeyGa + temp1) >= 97 && *(&hbKeyGa + temp1) <= 122 )
        *(&hbKeyGa + temp1) -= 32;
      ++temp1;
    }
  }
  else
  {
    temp2 = 0;
    p_HbKeyGb = &hbKeyGb;
    pMem_64_b = &mem_64_b;
    p_HbKeyGb += strlen(p_HbKeyGb);
    lenHbKeyGb = ++p_HbKeyGb - &mem_64_b;
    len_HbKeyGb = p_HbKeyGb - &mem_64_b;
    while ( temp2 < len_HbKeyGb )               // 把 HbKeyGb 里面的小写字母全替换为大写
    {
      if ( *(&hbKeyGb + temp2) >= 97 && *(&hbKeyGb + temp2) <= 122 )
        *(&hbKeyGb + temp2) -= 32;
      ++temp2;
    }
  }
  pHbKeyGa = &hbKeyGa;
  pHbKeyGb = &hbKeyGb;
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, "[HBKEY] sga: %s", &hbKeyGa);
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, "[HBKEY] sgb: %s", pHbKeyGb);
  hbKey = 0;
  memset(&v90, 0, 0x80u);
  if ( pHbKeyGb[9] % 2 )
  {
    index1 = 0;
    index2 = 0;
    index3 = 63;
    while ( index1 < 128 )
    {
      *(&hbKey + index1++) = pHbKeyGa[index2++];
      *(&hbKey + index1++) = pHbKeyGb[index3--];
    }
  }
  else
  {
    index4 = 0;
    index5 = 63;
    index6 = 0;
    while ( index4 < 128 )
    {
      *(&hbKey + index4++) = pHbKeyGa[index5--];
      *(&hbKey + index4++) = pHbKeyGb[index6++];
    }
  }
  (*(void (**)(char *, const char *, ...))(*(_DWORD *)pThis + 4))(pThis, "[HBKEY] key: %s", &hbKey);// hbKey = &"115e9d6643Fd6c391a32E6298dA8D70025Ae9269473c1053AdDc9dAa47Ec6f4092658912C89d9aB83644D6D32c0e898b2e2bCaF8B1E1F06d025dF5E184040654"
  sub_40EC40((void *)a2, &hbKey);
  v41 |= 1u;
  v146 = -1;
  std::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string<char,std::char_traits<char>,std::allocator<char>>(&a3);
  return a2;
}

上面的就是 AidcRes.generateKey 的整个流程，这个坑多并且复杂，简要说一下，具体看代码（b_Username_MonthDay 代指 ‘b177111122220517’，不再赘述）

  1. 算出 b_Username_MonthDay，username_b_MonthDay，username_MonthDay_b，monthDay_Username_b 四个东西的 md5
  2. 根据 d5_b_Username_MonthDay[1] 的 ascii的奇偶性，重排四个 md5 的顺序并复制给四个变量，分别为 md5_1，md5_2，md5_3，md5_4，
  3. 此时会用到第二步的四个变量，根据他们的特定位来计算得出 hbkey_ga 与 hbkey_gb 的值
    • 根据 md5_1_pLus3remainder4 = *(char *)(md5_1 + 3) % 4; 这步的值取 md5_1 和 md5_2 排列算出 hbkey_ga
    • 根据 md5_4_plus5remainer4 = *((char *)md5_4 + 5) % 4; 这步的值取 md5_3 和 md5_4 排列算出 hbkey_gb
  4. 根据 hbkey_gb[7] 的 ascii，如果奇数就把 hbkey_ga 中的字母都大写，偶数就把 hbkey_gb 中的字母都大写
  5. 根据 hbkey_gb[9] 的 ascii 的奇偶性对 hbkey_ga 与 hbkey_gb 的值用简单算法进行重排，得到真实的 hbkey

这就是上面所有代码的大致流程，代码中我也有大量注释，大家可以看看。

总结

这个难点在分析算法上面，分析算法主要还是要靠动态调试，过程中遇到了很多很难的地方，参数和函数的重命名主要还是靠动态调试， 然后去猜测它的作用进行重命名。

这些文件我都保存了分析记录，大家可以跟着看看，总结如下

AidcComm.idb 看导出表可以看出是干嘛的，直接点进GetPWD即可看到我的分析 AidcRes.idb 里面也有我的分析，具体查看我改过的函数名 generateKey，然后 x 一下看调用地方 x32dbg_AidcRes.dd32 为我在用 x32dbg 分析AidcRes.exe的时候的记录，有一些我改过的函数名以及简要分析 简单的分析流程为 bp LoadLibrary，断到 AidcComm.dll，然后具体看eax和栈的变化，找到加密函数，再一层一层分析。

建议 ida 与 x32dbg 结合分析，最好起个 pppoe 服务器拦截账号密码协助分析，见我上一篇文章 PPPoE中间人拦截以及校园网突破漫谈中的代码。

调用流程为 AidcRes.generateKey(分析大头) –> AidcComm.GetRegularAccount –> AidcComm.GetPWD –> AidcComm.encryptPwdWithKey(分析大头，注意里面有个地方 f5 显示不出来，就是把一个key中的字母全大写的那部分，请结合汇编分析)

AidcRes.generateKey大致流程，这个坑多并且复杂，简要说一下，具体看代码 （b_Username_MonthDay 代指 ‘b177111122220517’，不再赘述）

  1. 算出 b_Username_MonthDay，username_b_MonthDay，username_MonthDay_b，monthDay_Username_b 四个东西的 md5
  2. 根据 d5_b_Username_MonthDay[1] 的 ascii的奇偶性，重排四个 md5 的顺序并复制给四个变量
  3. 此时会用到第二步的四个变量，根据他们的特定位来计算得出 hbkey_ga 与 hbkey_gb 的值
  4. 根据 hbkey_gb[7] 的 ascii，如果奇数就把 hbkey_ga 中的字母都大写，偶数就把 hbkey_gb 中的字母都大写
  5. 根据 hbkey_gb[9] 的 ascii 的奇偶性对 hbkey_ga 与 hbkey_gb 的值用简单算法进行重排，得到真实的 hbkey

AidcComm.encryptPwdWithKey大致流程

  1. password 用 key RC4 一下得到 A
  2. 把 A md5 一下得到 B，如果第 11 位为奇数，取 B 的前 16 位，偶数就后 16 位，得到 C
  3. C 再用 key RC4 一下得到 D
  4. D 再 md5 一下，取 [8:24]得到 E
  5. E[今天几号日期 % 16] 替换为 ‘b’ 得到最后的密码

为了防止被商业利用，就不公开逆向得出的加密脚本了，喜欢折腾校园网的可以自行根据本文摸索。

分析文件打包