简单分析某游戏debugport清零

shopbuyme

简单分析，小弟能力有限如果有什么错误的话，欢迎各位牛牛指正，共同进步嘛

第一处清零代码

1. 
   
2. mov     edi, edi
   
3. push    ebp
   
4. mov     ebp, esp
   
5. push    ecx
   
6. push    esi
   
7. mov     [ebp+var_1], 0
   
8. call    ds:KeGetCurrentIrql
   
9. cmp     al, 2 //判断中断级
   
10. mov     esi, offset SpinLock
    
11. mov     ecx, esi      
    
12. jb      short loc_1002660
    
13. call    ds:KefAcquireSpinLockAtDpcLevel
    
14. mov     [ebp+var_1], 1
    
15. jmp     short loc_1002669

复制代码

loc_1002660:

1. 
   
2. call    ds:KfAcquireSpinLock
   
3. mov     [ebp+NewIrql], al

复制代码

loc_1002669:

1. 
   
2. mov     ecx, dword_100D1C0  //这里比较关键啦。 dword_100D1C0 这个全局变量很重要                 
   
3. mov     edx, offset dword_100D1C0
   
4. cmp     ecx, edx
   
5. jz      short loc_10026BA// 这个是个关键比较啦
   
6. push    ebx
   
7. push    edi

复制代码

loc_100267A:

1. 
   
2. mov     edi, dword_100CEDC  //这里存放着EPROCESS的下标
   
3. mov     edi, [edi+4]        //CEDC+4的位置正是BC
   
4. add     edi, [ecx-34h]     //[D1C0-34]的位置存放着EPROCESS结构的地址
   
5. xor     eax, eax
   
6. xchg    eax, [edi]        //清零
   
7. mov     eax, dword_100CEDC
   
8. mov     ebx, [ecx-2Ch]  //存放着EPROCESS+70位置的内容
   
9. mov     eax, [eax+18h]  //CEDC+18位置存放70下标
   
10. mov     edi, [ecx-34h]//EPROCESS结构的地址
    
11. mov     [eax+edi], ebx  //写回去防止修改位置
    
12. mov     ebx, [ecx-28h] //74的内容
    
13. mov     [eax+edi+4], ebx//写回去
    
14. mov     edi, dword_100CEDC
    
15. mov     edi, [edi+1Ch] //取78位置
    
16. add     edi, [ecx-34h]
    
17. xor     eax, eax       //写回去
    
18. stosd
    
19. stosd
    

复制代码

上面这一段把EPROCESS+70,74,78的位置全部封杀了
防止把BC的位置修改为70,74,78，所以曾经某种方法改位置变得无效了               
      
第2段清零位代码，这里有个检测

1. 
   
2.                                mov     edi, edi
   
3.                                push    ebp
   
4.                                mov     ebp, esp
   
5.                                push    ecx
   
6.                                push    ecx
   
7.                                push    ebx
   
8.                                xor     ebx, ebx
   
9.                                push    esi
   
10.                                mov     ecx, offset SpinLock
    
11.                                mov     byte ptr [ebp-1], 1
    
12.                                mov     [ebp-8], ebx
    
13.                                call    ds:KfAcquireSpinLock
    
14.                                mov     esi, dword_100D1C0 //这里同1的注释  这个变量很重要
    
15.                                cmp     esi, offset dword_100D1C0//这里同1的注释一样
    
16.                                mov     [ebp-2], al
    
17.                                jz      loc_1004FE9 //关键跳
    
18.                                mov     [ebp-1], bl
    
19.                                push    edi

复制代码

loc_1004F62:

1. 
   
2.                                mov     eax, dword_100CEDC //这里存放着EPROCESS的下标
   
3.                                mov     eax, [eax+4]      //CEDC+4的位置正是BC   
   
4.                                lea     edi, [esi-34h]  //[D1C0-34]的位置存放着EPROCESS结构的地址 注意这里是取地址
   
5.                                add     eax, [edi]     //指到BC处
   
6.                                xor     ebx, ebx         
   
7.                                xchg    ebx, [eax]  //清零
   
8.                                xor     eax, eax
   
9.                                cmp     [ebp-8], eax
   
10.                                jnz     short loc_1004F83
    
11.                                cmp     ebx, eax
    
12.                                jz      short loc_1004F83
    
13.                                mov     ecx, [edi]
    
14.                                mov     [ebp-8], ecx

复制代码

loc_1004F83:

1. 
   
2.                                mov     ecx, 1505h
   
3.                                movsx   edx, byte ptr [edi+eax] //这段算法主要是检测有没有被修改如果有的话就重启机器
   
4.                                imul    ecx, 21h   //edi存放着EPROCESS的地址，有兴趣的朋友可以逆下
   
5.                                add     ecx, edx
   
6.                               inc     eax
   
7.                               cmp     eax, 18h
   
8.                               jb      short loc_1004F88
   
9.                               cmp     ecx, [edi+1Ch] //1CH处存放着检验值 1CH+4位置存放着进程名
   
10.                               jz      short loc_1004FA1
    
11.                                call    sub_100163C //重启机器

复制代码

其实这里注意dword_100D1C0 变量这里很重要。                                          

这2个都好搞定，关键是有个监控

1.                      mov     edi, edi
   
2.                                push    ebp
   
3.                                mov     ebp, esp
   
4.                                sub     esp, 10h
   
5.                               mov     eax, dword_100CA6C //CA6C=CF;
   
6.                               push    ebx
   
7.                               push    esi
   
8.                               push    edi
   
9.                               mov     edi, offset unk_100CA68
   
10.                               sub     edi, 0CA68h  //EDI=模块载入地址
    
11.                               lea     ecx, [eax+eax*2]//EAX=CF;
    
12.                               shl     ecx, 2         //这步计算我估计应该是得出了100B268总大小
    
13.                               push    0
    
14.                              mov     [ebp+var_10], edi
    
15.                              mov     [ebp+var_4], ecx
    
16.                              pop     edx
    
17.                              jz      short loc_100422B

复制代码

loc_100420C:

1.                       movzx   esi, byte_100B268[edx]/*
   
2.                            100B268这个变量指向一个结构 这个结构类似 struct{ULONG PY(偏移),INT LEN,ULONG HASH}
   
3.                             CRC检验，估计是黑白名单之类的，我的猜测，如果有错那位朋友知道的话帮我纠正一下
   
4.                          */   
   
5.                           mov     ebx, [ebp+var_4]
   
6.                            shr     ebx, 1Bh
   
7.                            xor     esi, ebx
   
8.                             mov     ebx, [ebp+var_4]
   
9.                            shl     ebx, 5
   
10.                             xor     esi, ebx
    
11.                            inc     edx
    
12.                           cmp     edx, ecx
    
13.                          mov     [ebp+var_4], esi
    
14.                         jb      short loc_100420C

复制代码

loc_100422B:

1.                       cmp     [ebp+var_4], 17606A55h //上面一系列的计算和(17606A55计算后的总大小)比较，如果被修改了就重启
   
2.                       jz      short loc_100423E
   
3.                       call    sub_100163C  //重启
   
4.                       mov     eax, dword_100CA6C

复制代码

loc_100423E:

1.                      and     [ebp+var_C], 0
   
2.                      test    eax, eax
   
3.                      jbe     short loc_100429F //这个跳可以修改
   
4.                      mov     esi, offset unk_100B26C

复制代码

loc_100424B:

1.                     mov     ecx, [esi-4] //ECX==STRUCT结构的PY偏移
   
2.              mov     edx, [esi]
   
3.                     and     [ebp+var_8], 0
   
4.                     add     ecx, edi   //加上模块载入地址址  
   
5.               test    edx, edx
   
6.                     mov     [ebp+var_4], edx
   
7.                     jbe     short loc_1004282

复制代码

loc_100425D:

1.                    mov     edi, [ebp+var_8]
   
2.                    movzx   edi, byte ptr [ecx+edi] //取出PY下面的值来计算HASH
   
3.                    mov     ebx, [ebp+var_4]
   
4.                    shr     ebx, 1Bh
   
5.                    xor     edi, ebx
   
6.                    mov     ebx, [ebp+var_4]
   
7.                    shl     ebx, 5
   
8.                    xor     edi, ebx
   
9.                    inc     [ebp+var_8]
   
10.                    cmp     [ebp+var_8], edx  //edx == STRUCT结构中的LEN
    
11.                    mov     [ebp+var_4], edi
    
12.                    jb      short loc_100425D
    
13.                    mov     edi, [ebp+var_10]
    
14.                    mov     ecx, [ebp+var_4]
    
15.                    cmp     ecx, [esi+4]   //经过一系列运算比较是不是STRUCT中的HASH
    
16.                    jz      short loc_1004294 //相同就跳
    
17.             call    sub_100163C //不同就重启
    
18.             mov     eax, dword_100CA6C

复制代码

loc_1004294:

1.                   inc     [ebp+var_C]
   
2.                   add     esi, 0Ch
   
3.                   cmp     [ebp+var_C], eax
   
4.                   jb      short loc_100424B
   
5.                   pop     edi
   
6.                   pop     esi
   
7.                   pop     ebx
   
8.                   leave
   
9.                  retn

复制代码

重启代码

1.           in      al, 64h      
   
2.                mov     bl, al
   
3.                test    bl, 1
   
4.                jz      short loc_1001660
   
5.                in      al, 60h         
   
6.                test    bl, 2
   
7.                jnz     short loc_1001655
   
8.                mov     al, 0FEh
   
9.                out     64h, al         
   
10.                popa
    
11.                retn

复制代码

解决方法很多，我说几种

第一种是我以前用的一种比较挫的，其实最重要的是解决监控哪里，
     分2步 1。在监控哪里 跳走或者直接返回         
           2.注意我标的清零的2段代码
           mov     ecx, dword_100D1C0  //这里比较关键啦。                  
           mov     edx, offset dword_100D1C0
                cmp     ecx, edx
                 jz      short loc_10026BA// 这个是个关键比较啦
           在函数开头钩钩一下跳到我们的函数
           处理一下先查找到模块加载地址(Modulebase)。
          伪代码
           ULONG D1C0=Modulebase+0XD1C0;
            _asm{
                mov edi,edi
                push ebp
                mov ebp,esp
                mov eax,D1C0
                mov [eax],eax
                mov eax,Ret(返回地址)
          add eax,5
          jmp eax
   }                    
      jz      short loc_10026BA相等就跳啦

第二种方法 前天看到的，好像更加简便 查看
感谢这位朋友的共享精神;
第三种没尝试
直接修改
       jz      short loc_10026BA   
           jz      loc_1004FE9
           jbe     short loc_100429F

第三种没实践过只是大概估计，有兴趣的朋友可以尝试一下。多实践总不会错
至于那些SSDT HOOK呀inline-hook要我相信大部分人都能解决的。
本人能力有限。此文章如果有什么不正确的地方，希望大家指正一下，共同学习，共同进步嘛。