跳跳糖
0x00 前言
上一文 PPPoE中间人拦截以及校园网突破漫谈我们谈到使用 PPPoE 拦截来获取真实的账号密码。
在这个的基础上，我对校园网客户端进行了逆向，得到了拨号加密算法。
0x01 准备工作
首先查壳，发现这个版本没壳了，我记得之前好像是加过 vmp 的呀，不管了。
然后我们看看目录下的 dll 导出表看看有没有什么好东西
AidcComm.dll 里面有这些东西，看来这个极大可能会是我们的目标。
我们再看看主程序的导入表，发现主程序的导入表里面并没有这个 dll，那我们动态调试的时候应该怎么断到这个 dll 中去呢。
没有导入表说明没有 .lib，那有可能是通过 LoadLibrary 加载的 dll，至于自实现 peloader，我觉得应该这个软件应该不会是这样。
看看就知道了。
直接用 x32dbg 和 IDA 开始看。
0x02 逆向过程
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
这就是上面所有代码的大致流程，代码中我也有大量注释，大家可以看看。
0x03 总结
这个难点在分析算法上面，分析算法主要还是要靠动态调试，过程中遇到了很多很难的地方，参数和函数的重命名主要还是靠动态调试，
然后去猜测它的作用进行重命名。
这些文件我都保存了分析记录，大家可以跟着看看，总结如下
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' 得到最后的密码
为了防止被人商业利用，就不公布逆向写出来的加密脚本了。喜欢折腾校园网的可以根据本文自行摸索。
