BlogJava-Phrancol's blog-文章分类-反汇编http://www.blogjava.net/Phrancol/category/31828.htmlTo be surprised,to wonder,is to begin to understand.zh-cnMon, 09 Jun 2008 07:22:49 GMTMon, 09 Jun 2008 07:22:49 GMT60[原]MIR3G反汇编分析（一）——命令体二次解密http://www.blogjava.net/Phrancol/articles/206529.htmlPhrancol YangPhrancol YangSat, 07 Jun 2008 08:06:00 GMThttp://www.blogjava.net/Phrancol/articles/206529.htmlhttp://www.blogjava.net/Phrancol/comments/206529.htmlhttp://www.blogjava.net/Phrancol/articles/206529.html#Feedback0http://www.blogjava.net/Phrancol/comments/commentRss/206529.htmlhttp://www.blogjava.net/Phrancol/services/trackbacks/206529.html #eLrBHMNx<F=hgmlYA]X]ENtpGM`X@?PuN`LwT_m>RmleJ_l{PAMHQ?pUCpdbENa<F`pjBllQC=HSC\\pT?LduQ_y=PQM>JptK!
命令体部分经过普通解密后，还需要根据一个掩码来进行二次解密

这里是二次解密命令体的部分
  push    ebp
  mov     ebp, esp
  and     esp, FFFFFFF8
  push    -1
  push    004C833C
  mov     eax, dword ptr fs:[0]
  push    eax
  mov     dword ptr fs:[0], esp
  push    ecx
  mov     eax, 549C
  call    004BC0B0
  push    ebx
  push    esi
  push    edi
  mov     edi, dword ptr [ebp+8]
  cmp     byte ptr [edi], 2B                    <------判断第一个字节是否为 +
  mov     ebx, ecx
  jnz L029
  inc     edi
  push    edi
  call    0042B0D0
  mov     ecx, dword ptr [esp+54AC]
  mov     dword ptr fs:[0], ecx
  pop     edi
  pop     esi
  pop     ebx
  mov     esp, ebp
  pop     ebp
  retn    4
L029:
  push    edi     <-----   密文
  lea     eax, dword ptr [esp+3C]
  push    eax   <------  密文解密后被保存在这里
  call    004A0CE0
  mov     cx, word ptr [ebx+49B162]
  xor     word ptr [esp+3C], cx
  xor     edx, edx
  mov     dh, byte ptr [esp+43]
  mov     cl, byte ptr [ebx+49B161]
  xor     eax, eax
  mov     ah, byte ptr [esp+3F]
  mov     dl, byte ptr [esp+41]
  mov     al, byte ptr [esp+3D]
  shl     edx, 10
  or      edx, eax
  mov     al, byte ptr [ebx+49B160]
  mov     esi, edx
  xor     cl, byte ptr [esp+3C]
  xor     edx, edx
  mov     dh, cl
  xor     al, byte ptr [esp+38]
  mov     dword ptr [esp+1C], esi
  mov     dl, al
  mov     eax, dword ptr [esp+38]
  shr     eax, 10
  mov     cx, dx
  movzx   dx, byte ptr [esp+39]
  mov     dh, byte ptr [esp+3E]
  mov     word ptr [esp+20], cx
  mov     word ptr [esp+22], dx
  xor     edx, edx
  mov     dh, byte ptr [esp+40]
  mov     dl, al
  movzx   ax, ah
  mov     ah, byte ptr [esp+42]
  mov     word ptr [esp+24], dx
  mov     word ptr [esp+26], ax
  movzx   eax, cx
  add     eax, -138A
  cmp     eax, 123
  ja      0043BF9D
  movzx   ecx, byte ptr [eax+43C220]
  jmp     dword ptr [ecx*4+43BFB4]

在 MIR3G二次加解密反汇编分析（三）——跟踪  中有4个赋值
  mov     byte ptr [ebx+49B160], al
  mov     byte ptr [ebx+49B161], ah
  mov     word ptr [ebx+49B162], ax
  mov     word ptr [ebx+49B164], ax
这就是命令体二次解密时的掩码

从一次解密的消息体中提取掩码的部分
  sub     eax, edx
  cmp     eax, 3C                     ;判断消息体长度是否为60
  jnz     0043BF9D
  mov     ecx, dword ptr [esp+CA8]      esp+CA8保存的就是经过一次解密的消息体（不包含命令体）
  mov     edx, dword ptr [esp+CAC]
  mov     eax, dword ptr [esp+CB0]
  mov     dword ptr [esp+38], ecx
  mov     ecx, dword ptr [esp+CB4]
  mov     dword ptr [esp+44], ecx
  mov     ecx, dword ptr [esp+CC0]
  mov     dword ptr [esp+3C], edx
  mov     edx, dword ptr [esp+CB8]
  mov     dword ptr [esp+40], eax
  mov     eax, dword ptr [esp+CBC]
  mov     dword ptr [esp+54], ecx
  mov     ecx, dword ptr [esp+CCC]
  mov     dword ptr [esp+48], edx
  mov     edx, dword ptr [esp+CC4]
  mov     dword ptr [esp+50], eax
  mov     eax, dword ptr [esp+CC8]
  mov     dword ptr [esp+60], ecx
  mov     ecx, dword ptr [esp+CD8]
  mov     dword ptr [esp+58], edx
  mov     edx, dword ptr [esp+CD0]
  mov     dword ptr [esp+5C], eax
  mov     eax, dword ptr [esp+CD4]
  mov     dword ptr [esp+24], ecx
  lea     ecx, dword ptr [esp+1C]
  mov     dword ptr [esp+1C], edx          ;最后20个字节
  mov     edx, dword ptr [esp+CDC]
  mov     dword ptr [esp+20], eax
  mov     eax, dword ptr [esp+CE0]
  push    ecx
  mov     ecx, ebx
  mov     byte ptr [esp+50], 0
  mov     byte ptr [esp+68], 0
  mov     dword ptr [esp+2C], edx
  mov     dword ptr [esp+30], eax
  mov     byte ptr [esp+34], 0
  call    0042BD60
  lea     edx, dword ptr [esp+38]           前20个字节
  push    edx
  mov     ecx, ebx
  mov     byte ptr [ebx+49B160], al
  mov     byte ptr [ebx+49B161], ah
  call    0042BD60
  mov     word ptr [ebx+49B162], ax
  lea     eax, dword ptr [esp+50]
  push    eax
  mov     ecx, ebx
  call    0042BD60
  mov     word ptr [ebx+49B164], ax


提取掩码的函数 0042BD60
  push    ebx
  push    esi
  mov     esi, dword ptr [esp+C]  esi = arg1    ;消息体
  mov     eax, esi                eax = arg1
  xor     ebx, ebx                ebx = 0
  lea     edx, dword ptr [eax+1]  edx = arg+1 ，从第二个字节开始
  lea     ecx, dword ptr [ecx]
L007:
  mov     cl, byte ptr [eax]
  inc     eax
  test    cl, cl
  jnz L007                    
  sub     eax, edx
  cmp     eax, 14               检查参数长度是否是20
  jnb L018
  pop     esi
  xor     ax, ax
  pop     ebx
  retn    4
L018:
  mov     eax, 2                ;eax =2
  lea     edx, dword ptr [esi+1] ;edx指向第二个字节  edx = 1
  push    edi                  
L022:
  mov     cl, byte ptr [edx-1]   ;cl = arg[edx-1]
  movzx   esi, byte ptr [edx+8]  ;esi = ((long)(arg[edx+8]))
  movzx   ecx, cl                ;ecx = ((long)cl)
  add     esi, ecx               ;esi = esi+ecx
  movzx   ecx, byte ptr [edx]    ;ecx = (long)arg[edx]
  cmp     ecx, esi               ;if(ecx < esi) 跳转到 L033
  jl L033
  lea     ecx, dword ptr [eax-2] ; ecx = eax-2
  mov     edi, 8000              ; edi = 0x8000
  sar     edi, cl                ; edi = edi >> cl
  or      ebx, edi               ; ebx = ebx | edi
L033:
  movzx   ecx, byte ptr [edx+1]  ;ecx = (long)arg[edx+1]
  cmp     ecx, esi                ;if(ecx<esi) 跳转到 L040
  jl L040
  lea     ecx, dword ptr [eax-1] ;ecx = eax-2
  mov     edi, 8000              ;edi = 0x8000
  sar     edi, cl                ;edi = edi >> arg[eax-1]
  or      ebx, edi               ;ebx = ebx | edi
L040:
  movzx   ecx, byte ptr [edx+2]  ;ecx = (long)arg[edx+2]
  cmp     ecx, esi               ;if(ecx < esi) 跳转到 L047
  jl L047
  mov     edi, 8000              ;edi = 0x8000
  mov     ecx, eax               ;ecx = eax
  sar     edi, cl                ;edi = edi >> cl
  or      ebx, edi               ;ebx = ebx | edi
L047:
  movzx   ecx, byte ptr [edx+3]  ;ecx = (long)arg[edx+3]
  cmp     ecx, esi               ; if(ecx < esi) 跳转到 L054
  jl L054
  lea     ecx, dword ptr [eax+1] ;ecx = eax+1
  mov     edi, 8000              ;edi = 0x8000
  sar     edi, cl                ;edi = edi >> cl
  or      ebx, edi               ;ebx = ebx | edi
L054:
  movzx   ecx, byte ptr [edx+4]  ;ecx = (long)arg[edx+4]
  cmp     ecx, esi               ; if(ecx < esi) 跳转到 L061
  jl L061
  lea     ecx, dword ptr [eax+2] ;ecx = eax+2
  mov     edi, 8000              ;edi = 0x8000
  sar     edi, cl                ;edi = edi >> cl
  or      ebx, edi               ;ebx = ebx | edi
L061:
  movzx   ecx, byte ptr [edx+5]   ;ecx = (long)arg[edx+5]
  cmp     ecx, esi                 ; if(ecx < esi) 跳转到 L068
  jl L068
  lea     ecx, dword ptr [eax+3] ;ecx = eax+3
  mov     edi, 8000              ;edi = 0x8000
  sar     edi, cl                ;edi = edi >> cl
  or      ebx, edi               ;ebx = ebx | edi
L068:
  movzx   ecx, byte ptr [edx+6]  ;ecx = (long)arg[edx+6]
  cmp     ecx, esi               ; if(ecx < esi) 跳转到 L075
  jl L075
  lea     ecx, dword ptr [eax+4] ;ecx = eax+4
  mov     edi, 8000              ;edi = 0x8000
  sar     edi, cl                ;edi = edi >> cl
  or      ebx, edi               ;ebx = ebx | edi
L075:                          
  movzx   ecx, byte ptr [edx+7]   ;ecx = (long)arg[edx+7]
  cmp     ecx, esi               ; if(ecx < esi) 跳转到 L082
  jl L082
  lea     ecx, dword ptr [eax+5] ;ecx = eax+5
  mov     esi, 8000              ;edi = 0x8000
  sar     esi, cl                ;edi = edi >> cl
  or      ebx, esi               ;ebx = ebx | edi
L082:
  add     eax, 8              ;eax = eax+8
  add     edx, 0A             ;edx = edx+0x0A
  cmp     eax, 0A             ;if(eax <= 0X0A) 跳转到 L022
  jle L022
  movzx   edx, bl             ;edx = (long)bl   低8位0扩展
  movzx   eax, bh             ;eax = (long)bh   高8位0扩展
  pop     edi                 ;
  xor     edx, 87             ;edx = edx ^ 0x87
  xor     eax, 87             ;eax = eax ^ 0x87
  shl     edx, 8              ;edx << 8
  pop     esi       
  or      eax, edx            ;eax = eax | edx  
  pop     ebx
  retn    4

至此，消息的加解密部分已经全部还原

Phrancol Yang 2008-06-07 16:06 发表评论
]]>[原]MIR3G二次加解密反汇编分析（四）——还原http://www.blogjava.net/Phrancol/articles/205936.htmlPhrancol YangPhrancol YangSat, 07 Jun 2008 02:20:00 GMThttp://www.blogjava.net/Phrancol/articles/205936.htmlhttp://www.blogjava.net/Phrancol/comments/205936.htmlhttp://www.blogjava.net/Phrancol/articles/205936.html#Feedback0http://www.blogjava.net/Phrancol/comments/commentRss/205936.htmlhttp://www.blogjava.net/Phrancol/services/trackbacks/205936.html阅读全文

Phrancol Yang 2008-06-07 10:20 发表评论
]]>[原]MIR3G二次加解密反汇编分析（三）——跟踪 http://www.blogjava.net/Phrancol/articles/205195.htmlPhrancol YangPhrancol YangSun, 01 Jun 2008 12:12:00 GMThttp://www.blogjava.net/Phrancol/articles/205195.htmlhttp://www.blogjava.net/Phrancol/comments/205195.htmlhttp://www.blogjava.net/Phrancol/articles/205195.html#Feedback0http://www.blogjava.net/Phrancol/comments/commentRss/205195.htmlhttp://www.blogjava.net/Phrancol/services/trackbacks/205195.html根据3EF找到生成命令体的函数，该函数只有一个参数——消息体，转到上一个函数得到以下代码

  push    1FFF           ;1FFF入栈
  lea     eax, dword ptr [esp+CAC] ;(3244)  距离栈顶811个存储单元
  push    eax            ;eax入栈 解密后要存入的地址入栈
  add     edi, 10        ;edi=从字符串第17个字节开始往后的串
  push    edi            ;密文入栈
  call    004A0BD0       ;跟进发现这是普通的一次解密，解密后数据存在esp+CAC里
  mov     byte ptr [esp+eax+CA8], 0
  xor     eax, eax
  mov     ecx, 100       ;ecx=100 (256) 循环次数
  lea     edi, dword ptr [esp+3F8]   ;edi
  rep     stos dword ptr es:[edi]    ;
  lea     ecx, dword ptr [esp+3F8]  
  push    ecx
  lea     edx, dword ptr [ebx+3CD864]
  push    edx
  mov     ecx, ebx
  call    0042C440                   ;二次解密，生成回复密文
  lea     eax, dword ptr [esp+3F8]
  push    eax
  mov     ecx, 004D5C70 
  call    0049F770        ;调用messageSend(char* msg)
  lea     eax, dword ptr [esp+CA8]
  lea     edx, dword ptr [eax+1]
L023:
  mov     cl, byte ptr [eax]
  inc     eax
  test    cl, cl
  jnz L023
  sub     eax, edx
  cmp     eax, 3C
  jnz     0043BF9D
  mov     ecx, dword ptr [esp+CA8]
  mov     edx, dword ptr [esp+CAC]
  mov     eax, dword ptr [esp+CB0]
  mov     dword ptr [esp+38], ecx
  mov     ecx, dword ptr [esp+CB4]
  mov     dword ptr [esp+44], ecx
  mov     ecx, dword ptr [esp+CC0]
  mov     dword ptr [esp+3C], edx
  mov     edx, dword ptr [esp+CB8]
  mov     dword ptr [esp+40], eax
  mov     eax, dword ptr [esp+CBC]
  mov     dword ptr [esp+54], ecx
  mov     ecx, dword ptr [esp+CCC]
  mov     dword ptr [esp+48], edx
  mov     edx, dword ptr [esp+CC4]
  mov     dword ptr [esp+50], eax
  mov     eax, dword ptr [esp+CC8]
  mov     dword ptr [esp+60], ecx
  mov     ecx, dword ptr [esp+CD8]
  mov     dword ptr [esp+58], edx
  mov     edx, dword ptr [esp+CD0]
  mov     dword ptr [esp+5C], eax
  mov     eax, dword ptr [esp+CD4]
  mov     dword ptr [esp+24], ecx
  lea     ecx, dword ptr [esp+1C]
  mov     dword ptr [esp+1C], edx
  mov     edx, dword ptr [esp+CDC]
  mov     dword ptr [esp+20], eax
  mov     eax, dword ptr [esp+CE0]
  push    ecx
  mov     ecx, ebx
  mov     byte ptr [esp+50], 0
  mov     byte ptr [esp+68], 0
  mov     dword ptr [esp+2C], edx
  mov     dword ptr [esp+30], eax
  mov     byte ptr [esp+34], 0
  call    0042BD60
  lea     edx, dword ptr [esp+38]
  push    edx
  mov     ecx, ebx
  mov     byte ptr [ebx+49B160], al
  mov     byte ptr [ebx+49B161], ah
  call    0042BD60
  mov     word ptr [ebx+49B162], ax
  lea     eax, dword ptr [esp+50]
  push    eax
  mov     ecx, ebx
  call    0042BD60
  mov     word ptr [ebx+49B164], ax
  mov     ecx, dword ptr [esp+54AC]
  mov     dword ptr fs:[0], ecx
  pop     edi
  pop     esi
  pop     ebx
  mov     esp, ebp
  pop     ebp
  retn    4


分析以上代码可以简单得出以下结论
1. 从call  004A0BD0 的调用可以简单分析出二次密文可能也是标准消息结构
2. 通过对比未更新版本与最新版本对3EF的发送情况，未更新版本发送3EF时，消息体是空，命令体其他参数不为0，再细分析，
未更新的版本的3EF其实就是割肉的命令...........
最新版本的客户端收到二次密文后，经过一些处理，以3EF为命令发向服务器
3. 从add edi, 10可以猜测，二次密文的命令体可能是迷惑人用的
4. 从call 0049F770这个调用断定 esp+3F8 就是二次解密后的明文
5. 对于call 0042C440这个调用，可以猜测，这个就是二次解密的函数
6. 服务器发来的密文对于本次解密是没有影响的，只是对它进行了一些操作，生成了4个数并进行如下保存
  mov     byte ptr [ebx+49B160], al
  mov     byte ptr [ebx+49B161], ah
  mov     word ptr [ebx+49B162], ax
  mov     word ptr [ebx+49B164], ax
7. 二次解密函数有2个参数: arg1 = dword ptr [ebx+3CD864] , arg2 = [esp+3F8]
   也就是根据dword ptr [ebx+3CD864]来生成解密明文，并存入地址esp+3F8，于是ebx+3CD864就成了解密的关键



Phrancol Yang 2008-06-01 20:12 发表评论
]]>[原]MIR3G二次加解密反汇编分析（二）——分析http://www.blogjava.net/Phrancol/articles/205127.htmlPhrancol YangPhrancol YangSun, 01 Jun 2008 02:48:00 GMThttp://www.blogjava.net/Phrancol/articles/205127.htmlhttp://www.blogjava.net/Phrancol/comments/205127.htmlhttp://www.blogjava.net/Phrancol/articles/205127.html#Feedback0http://www.blogjava.net/Phrancol/comments/commentRss/205127.htmlhttp://www.blogjava.net/Phrancol/services/trackbacks/205127.html数据发送接收情况:
........客户端与Gateserver,Loginserver的数据互换，省略
1. 客户端向Gameserver发送[**登录用户名/角色名/验证数1/验证数2/版本验证数/1/0]
2. Gameserver向客户端发送密文，类似#eLrBHMNx<F=hgmlYA]X]ENtpGM`X@?PuN`LwT_m>RmleJ_l{PAMHQ?pUCpdbENa<F`pjBllQC=HSC\\pT?LduQ_y=PQM>JptK!
3. 客户端向Gameserver发送解密后密文，类似#3<<<<<Jx?<<<<<<<<A>xZCNLSHoPpAnQRF?ljIaaUPmlSF^L_BmtfFODJA_X\\A]T`GNlq@L!
........欢迎信息，装备信息等省略

数据格式
[#][标识位][指令头][消息体][!]
例如 #3<<<<<B\\<<<<<<<<<mi{EhL!

命令结构体
typedef struct tag_TDEFAULTMESSAGE
{
    int     nRecog;
    WORD    wIdent;  3EF
    WORD    wParam;
    WORD    wTag;
    WORD    wSeries;
} _TDEFAULTMESSAGE, *_LPTDEFAULTMESSAGE;

解密命令体<<<<<Jx?<<<<<<<<得到wIdent值是3EF(1007)，OD打开Mir3.exe，查找常量000003EF，跟踪进入，得到如下代码
>>Method1(未知参数)
  push    esi
  push    edi
  push    0   
  push    0
  push    0
  push    0
  mov     esi, ecx
  push    3EF
  lea     edi, dword ptr [esi+18]  ;esi+18 是命令结构体的首地址
  push    edi         ;命令结构体首地址
  call    004A0D00    ;生成命令结构体 (edi,3ef,0,0,0,0)
  mov     eax, dword ptr [esp+C] ; eax保存第一个参数
  push    0
  push    eax
  push    edi
  mov     ecx, esi    ;传递this指针，
  call    0049E450    ;发送数据，arg3: 0, arg2: 第一个参数, arg1: 命令结构体
  pop     edi
  pop     esi
  retn    4

简单分析，入栈的4个0和3EF,则对应结构体,该函数至少1个参数，目前不知这个参数是什么意思，跟进0049E450看看
>>Method2(命令结构体,未知参数,0)
  mov     eax, dword ptr [esp+4]  ;eax=命令结构体
  push    ebx
  push    ebp
  push    esi
  mov     esi, ecx                ;得到this指针
  push    20
  lea     ebp, dword ptr [esi+24] ;esi+18是命令结构体，加密命令结构体得到的字符串保存在esi+24中
  push    ebp                     
  push    eax
  call    004A0CA0                ;跟进发现是加密命令结构体,arg3: 20(32), arg2: esi+24, arg1: 命令结构体地址
  mov     eax, dword ptr [esi+14] ;eax=esi+14=标识位
  cmp     eax, 9
  jl L015                         ;如果标识位小于9，则跳到L015
  mov     dword ptr [esi+14], 1   ;否则标识位重设为1
  jmp L017
L015:
  inc     eax
  mov     dword ptr [esi+14], eax ;标识位自加1
L017:
  mov     edx, dword ptr [esp+14] ;edx=第2个参数
  test    edx, edx                ;
  je L048                         ;如果第2个参数为0，则跳转到L048
  mov     eax, dword ptr [esp+18] ;eax=第3个参数: 0
  test    eax, eax               
  push    edi                 
  jnz L031                        ;eax不等于0则跳转
  mov     eax, edx                ;eax=第2个参数
  lea     edi, dword ptr [eax+1] 
L026:
  mov     cl, byte ptr [eax]      ;cl=第2个参数第1个字节
  inc     eax                     ;eax                   
  test    cl, cl                  ;循环得到第一个参数的长度
  jnz L026                        ;没到字符串尾则继续循环
  sub     eax, edi               
L031:
  push    2000
  push    eax
  lea     edi, dword ptr [esi+44]
  push    edi
  push    edx
  call    004A0B10                ;调用加密函数，将edx加密，保存在esi+44中
  mov     ecx, dword ptr [esi+14]
  push    edi
  push    ebp
  push    ecx
  lea     ebx, dword ptr [esi+2044]
  push    004CBFE4                 ; #%d%s%s!
  push    ebx
  call    004BB568
  add     esp, 14
  pop     edi
  jmp L056
L048:
  mov     edx, dword ptr [esi+14]
  push    ebp
  push    edx
  lea     ebx, dword ptr [esi+2044]
  push    004CBFC4                   ; #%d%s!
  push    ebx
  call    004BB568                   ;sprintf  格式化发送给服务器端的数据
  add     esp, 10
L056:
  mov     eax, ebx
  lea     edx, dword ptr [eax+1]
L058:
  mov     cl, byte ptr [eax]
  inc     eax                        ;这个循环得到数据长度
  test    cl, cl
  jnz L058
  push    0
  sub     eax, edx
  push    eax                        ; 数据长度
  mov     eax, dword ptr [esi+6044]
  push    ebx                 ; Data ，要发送的数据
  push    eax                 ; Socket对象
  call    <jmp.&WS2_32.#19>   ;这里是调用send(Socket对象, 要发送的数据, 数据长度, 0 (flag));
  pop     esi
  pop     ebp
  pop     ebx
  retn    0C

L017和L031说明Method1和Method2中的未知参数就是明文消息体，Method1只有1个消息体参数


 



Phrancol Yang 2008-06-01 10:48 发表评论
]]>[原]MIR3G二次加解密反汇编分析（一）——初探http://www.blogjava.net/Phrancol/articles/204124.htmlPhrancol YangPhrancol YangFri, 30 May 2008 08:34:00 GMThttp://www.blogjava.net/Phrancol/articles/204124.htmlhttp://www.blogjava.net/Phrancol/comments/204124.htmlhttp://www.blogjava.net/Phrancol/articles/204124.html#Feedback0http://www.blogjava.net/Phrancol/comments/commentRss/204124.htmlhttp://www.blogjava.net/Phrancol/services/trackbacks/204124.html突击了一个星期的汇编，再对照民间流传的传奇源码(C++版本)，基本摸清了这部分的代码

OD打开Mir3.exe(Mir3G_20070108) -> ASCII ->找到**%s/%s/%d/%d/%d/1/%d->双击，得到如下代码


这段代码是将几个参数，使用sprintf生成字符串，然后6BIT加密，以#%d%s!格式发送到服务器端
0049E2D0  mov     eax, dword ptr [esp+14]          ; eax=arg5（第5个参数）
0049E2D4  sub     esp, 600                                    ; 预留1536个存储单元
0049E2DA  push    esi                                           
0049E2DB  push    edi
0049E2DC  mov     edi, dword ptr [<&USER32.wsprint>;  USER32.wsprintfA   
0049E2E2  push    eax                              ; /<%d>      ;eax入栈
**%s/%s/%d/%d/%d/1/arg5
0049E2E3  mov     eax, dword ptr [esp+618]         ; |  eax = arg3
0049E2EA  mov     esi, ecx                         ; |
0049E2EC  mov     ecx, dword ptr [esp+61C]         ; | ecx = arg4
0049E2F3  mov     edx, ecx                         ; |             edx=ecx=arg4
0049E2F5  xor     edx, FA0280AF                    ; |    edx=arg4异或FA0280AF 
0049E2FB  push    edx                              ; |<%d>   edx入栈
**%s/%s/%d/%d/arg4异或FA0280AF/1/arg5
0049E2FC  mov     edx, eax                         ; |          edx=eax=arg3
0049E2FE  xor     edx, ecx                         ; |            edx=arg3异或arg4
0049E300  mov     ecx, dword ptr [esp+614]         ; |   ecx=arg1
0049E307  xor     edx, 5580AF27                    ; |      edx = edx异或5580AF27
0049E30D  push    edx                              ; |<%d>   edx入栈
**%s/%s/%d/arg3异或arg4再异或5580AF27/arg4异或FA0280AF/1/arg5
0049E30E  xor     eax, 3EB2C5CC                    ; |  eax = arg3异或3EB2C5CC
0049E313  push    eax                              ; |<%d>
**%s/%s/arg3异或3EB2C5CC/arg3异或arg4再异或5580AF27/arg4异或FA0280AF/1/arg5
0049E314  mov     eax, dword ptr [esp+620]         ; | eax = arg2
0049E31B  push    eax                              ; |<%s>
**%s/arg2/arg3异或3EB2C5CC/arg3异或arg4再异或5580AF27/arg4异或FA0280AF/1/arg5
0049E31C  push    ecx                              ; |<%s>
**arg1/arg2/arg3异或3EB2C5CC/arg3异或arg4再异或5580AF27/arg4异或FA0280AF/1/arg5
0049E31D  lea     edx, dword ptr [esp+220]         ; |  edx 指向上面预留的1536个存储单元中最后512个单元的首地址
0049E324  push    004CBFCC                         ; |**%s/%s/%d/%d/%d/1/%d
0049E329  push    edx                              ; |s
0049E32A  call    edi                              ; \wsprintfA  edx指向生成的明文字符串首地址
0049E32C  add     esp, 20                      ; 前移32个存储单元
0049E32F  push    1FF                             512入栈  <加密函数第4个参数>
0049E334  lea     eax, dword ptr [esp+20C]  eax =明文字符串
0049E33B  push    eax                              ; /String  
0049E33C  call    dword ptr [<&KERNEL32.lstrlenA>] ; \lstrlenA 得到明文的长度，保存在eax中
0049E342  push    eax                                   eax入栈   明文长度入栈<加密函数第3个参数>
0049E343  lea     ecx, dword ptr [esp+10]     ecx=第一次入栈的edi的值，应该是某个成员变量
0049E347  push    ecx                                   ecx入栈<加密函数第2个参数>
0049E348  lea     edx, dword ptr [esp+214] 
0049E34F  push    edx                                    明文字符串首<加密函数第1个参数>
0049E350  call    004A0B10                           调用加密函数
fnEncode(char *strSrc, char *strDest, int lenSrc, 512)
...................
后面是发送信息



Phrancol Yang 2008-05-30 16:34 发表评论
]]>