湖北校园网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。

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

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' 得到最后的密码

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

分析文件打包

湖北校园网PC端拨号算法逆向的更多相关文章

  1. PC端车牌识别朱凯茵从事图像识别算法、OCR算法

    大家好,我是从事图像识别的pc端车牌识别朱凯茵,多多交流OCR算法,不限于车牌识别等,技术需要突破,你我成就梦想.

  2. 关于pc端直播

    写这篇文章首先是想给自己一个总结.整理,还有就是给那些 没有特别明白直播是怎么回事的人一点 思路 最近公司想要做pc端直播,作为一个自认为很菜的前端实在是不知从何下手,所以只能用国人最爱的百度,搜索了 ...

  3. 第 31 章 项目实战-PC端固定布局[2]

    学习要点: 1.大纲算法 2.section和div 3.结构分析 主讲教师:李炎恢 本章主要开始使用学习用HTML5和CSS3来构建Web页面,第一个项目采用PC端 固定布局来实现. 一．大纲算法  ...

  4. 网易云音乐PC端刷曲快捷键

    文章首发于szhshp的第三边境研究所(szhshp.org), 转载请注明 网易云音乐PC端刷曲快捷键   好吧我承认我特别懒 云音乐其实做的还不错,FM推荐的算法明显比虾米好. 虾米可以听的曲子都 ...

  5. 钉钉如何进行PC端开发

    前段时间,用钉钉进行了服务器端的开发,对照着官方文档,感觉还是比较顺利的.后续想有时间研究一下PC端客户端的开发,看着官方文档,说的确实是比较简练,但也确实没看太明白,废了半天劲也没成功.后来经过无数 ...

  6. 职业定位(Web前端、后台、PC端)

    Web前端 Web前端开发工程师:http://baike.sogou.com/v18499271.htm WEB前端开发面试题集锦:http://wenku.baidu.com/view/47bbc ...

  7. 前端里移动端到底比pc端多哪些知识?

    端里移动端到底比pc端多哪些知识,为啥面试时好多公司都问h5水平如何? 我做过几年的web前端开发,就简单谈谈自己的感受吧.首先来看看PC端和移动端在前端开发上的一些区别:(1)PC考虑的是浏览器兼容 ...

  8. PC端和移动端在前端开发上的一些区别，前端里移动端到底比pc端多哪些知识

    (1)———————— 前端里移动端到底比pc端多哪些知识,为啥面试时好多公司都问h5水平如何?我做过几年的web前端开发,就简单谈谈自己的感受吧.首先来看看PC端和移动端在前端开发上的一些区别: ( ...

  9. Java SpringMVC实现PC端网页微信扫码支付完整版

    一:前期微信支付扫盲知识 前提条件是已经有申请了微信支付功能的公众号,然后我们需要得到公众号APPID和微信商户号,这个分别在微信公众号和微信支付商家平台上面可以发现.其实在你申请成功支付功能之后,微 ...

随机推荐

  1. Centos7 中查找文件、目录、内容

    1.查找文件 find / -name ‘filename’ 2.查找目录 find / -name ‘path’ -type d 3.查找内容 find . | xargs grep -ri ‘co ...

  2. flask 设置访问地址 和 访问端口

    app.run() 四个参数 host:主机,可设置为本地或其他IP port:端口,是run()启动服务的时候指定的运行端口, debug:调试,如果需要进入调试模式,可以将这个选项设置成True ...

  3. strace命令 二

    让我们看一台高负载服务器的 top 结果: top 技巧:运行 top 时,按「1」打开 CPU 列表,按「shift+p」以 CPU 排序. 在本例中大家很容易发现 CPU 主要是被若干个 PHP ...

  4. 面邻域Polygon Neighbors

    面邻域Polygon Neighbors 商务合作,科技咨询,版权转让:向日葵,135-4855__4328,xiexiaokui#qq.com 功能: Polygon Neighbors Creat ...

  5. Microservices in action: java(spring) and .net

    Manning | Homehttps://www.manning.com/ What is a Microservice? | Manninghttps://freecontent.manning. ...

  6. mongodb的开机自启动

    一.背景 Linux轻松的在rc.local中写上启动脚本,reboot~发现没有启动成功.这不科学啊,查看日志发现“permission denied” 二.解决 Linux系统下,使用自定配置文件 ...

  7. Python的collections之defaultdict的使用及其优势

    user_dict = {} users = ["baoshan1", "baoshan2", "baoshan3","baosh ...

  8. 八、postman的cookie支持

    postman中可以直接添加cookie,查看响应中的cookie https://postman-echo.com/cookies/set?foo1=bar1&foo2=bar2 var r ...

  9. 【插件式框架探索系列】使用多UI线程提升性能

    了解WPF线程模型的都知道,UI线程负责呈现和管理UI,而UI元素(派生自 DispatcherObject)只能由创建该元素的线程来访问,这就导致了一些耗时的UI操作将影 响到整个应用程序性能,未响 ...

  10. VPB测试 使用Osgdem运行例子

    1.Osgdem运行例子所需数据下载地址: http://www.cc.gatech.edu/projects/large_models/ps.html Download Elevation Map: ...