Windows逆向安全（一）之基础知识（十六）

指针三

通过先前指针的学习，了解了指针和地址以及数据的关系，现在结合先前的知识继续学习巩固

指针遍历数组

有了先前的基础，再来看看如何用指针遍历数组

代码

#include "stdafx.h"
void function(){
    
    
        short arr[5]={
    
    1,2,3,4,5};

        short* p=&arr[0];
        short* p2=arr;

        if(p==p2){
    
    
                printf("equal\n");
        }else{
    
    
                printf("not equal\n");
        }

        int i;
        for(i=0;i<5;i++){
    
    
                int j=*(p+i);
                printf("addr:%x value:%d\n",p+i,j);
        }        
}
int main(int argc, char* argv[])
{
    
    
        function();
        return 0;
}

代码说明

稍微说明的一下代码部分

主要是声明了一个数组，然后用两种方法取得数组的首地址，一种是&arr[0]，另一种则直接是arr

后面则是通过循环配合指针遍历数组成员并输出

按顺序依次涉及先前指针笔记的知识点：

1. 取变量地址
2. 指针赋值
3. 指针之间的比较
4. 取地址中存储数据
5. 指针的加减

运行结果

可以看到通过&arr[0]和arr取数组首地址得到的结果是一致的

并且能够通过指针来输出数组成员的地址和对应的数据

这里还会观察到数组里的每个地址都相差2（short类型的数据宽度），和先前数组的学习又匹配上了

反汇编代码

11:       short arr[5]={
    
    1,2,3,4,5};
0040D7A8   mov         word ptr [ebp-0Ch],offset function+1Ch (0040d7ac)
0040D7AE   mov         word ptr [ebp-0Ah],offset function+22h (0040d7b2)
0040D7B4   mov         word ptr [ebp-8],offset function+28h (0040d7b8)
0040D7BA   mov         word ptr [ebp-6],offset function+2Eh (0040d7be)
0040D7C0   mov         word ptr [ebp-4],offset function+34h (0040d7c4)
12:
13:       short* p=&arr[0];
0040D7C6   lea         eax,[ebp-0Ch]
0040D7C9   mov         dword ptr [ebp-10h],eax
14:       short* p2=arr;
0040D7CC   lea         ecx,[ebp-0Ch]
0040D7CF   mov         dword ptr [ebp-14h],ecx
15:
16:       if(p==p2){
    
    
0040D7D2   mov         edx,dword ptr [ebp-10h]
0040D7D5   cmp         edx,dword ptr [ebp-14h]
0040D7D8   jne         function+59h (0040d7e9)
17:           printf("equal\n");
0040D7DA   push        offset string "equal\n" (00422fbc)
0040D7DF   call        printf (0040d710)
0040D7E4   add         esp,4
18:       }else{
    
    
0040D7E7   jmp         function+66h (0040d7f6)
19:           printf("not equal\n");
0040D7E9   push        offset string "not equal\n" (00422fb0)
0040D7EE   call        printf (0040d710)
0040D7F3   add         esp,4
20:       }
21:
22:       int i;
23:
24:       for(i=0;i<5;i++){
    
    
0040D7F6   mov         dword ptr [ebp-18h],0
0040D7FD   jmp         function+78h (0040d808)
0040D7FF   mov         eax,dword ptr [ebp-18h]
0040D802   add         eax,1
0040D805   mov         dword ptr [ebp-18h],eax
0040D808   cmp         dword ptr [ebp-18h],5
0040D80C   jge         function+0A8h (0040d838)
25:           int j=*(p+i);
0040D80E   mov         ecx,dword ptr [ebp-18h]
0040D811   mov         edx,dword ptr [ebp-10h]
0040D814   movsx       eax,word ptr [edx+ecx*2]
0040D818   mov         dword ptr [j],eax
26:           printf("addr:%x value:%d\n",p+i,j);
0040D81B   mov         ecx,dword ptr [j]
0040D81E   push        ecx
0040D81F   mov         edx,dword ptr [ebp-18h]
0040D822   mov         eax,dword ptr [ebp-10h]
0040D825   lea         ecx,[eax+edx*2]
0040D828   push        ecx
0040D829   push        offset string "addr:%x value%d:\n" (00422f9c)
0040D82E   call        printf (0040d710)
0040D833   add         esp,0Ch
27:       }
0040D836   jmp         function+6Fh (0040d7ff)
28:
29:   }

反汇编分析

由于循环和数组等相关的知识在先前的笔记已经详细学习过了，这里就直接看指针相关的代码

25:           int j=*(p+i);
0040D80E   mov         ecx,dword ptr [ebp-18h]
0040D811   mov         edx,dword ptr [ebp-10h]
0040D814   movsx       eax,word ptr [edx+ecx*2]
0040D818   mov         dword ptr [j],eax

1.将ebp-18h里的值赋值给ecx，这里的[ebp-18h]其实对应的就是 i

0040D80E   mov         ecx,dword ptr [ebp-18h] (i)

2.将ebp-10h里的值赋值给edx，这里的[ebp-10h]其实对应的是p，即数组首地址

0040D811   mov         edx,dword ptr [ebp-10h] (p)

3.movsx是带符号扩展赋值，将edx+ecx2，也就是p+i\数据宽度地址里存储的值赋给eax

0040D814   movsx       eax,word ptr [edx+ecx*2]

为什么要使用movsx指令？

内存对齐的结果，先前的笔记就提到过：char short 在计算时都会转变为dword宽度来进行计算

4.将前面暂存在寄存器中的值赋给变量j

0040D818   mov         dword ptr [j],eax

指针翻转数组

翻转数组思想

翻转数组的思想就是从数组两端（数组首部和数组尾部）开始然后逐渐向中间靠拢，相互交换数组中的内容

代码

#include "stdafx.h"
void function(){
    
    
        int arr[5]={
    
    1,2,3,4,5};

        int* begin=&arr[0];
        int* end=begin+4;

        while(begin<end){
    
    
                int tmp=*begin;
                *begin=*end;
                *end=tmp;
                begin++;
                end--;
        }

        int i;
        for(i=0;i<5;i++){
    
    
                printf("%d\n",arr[i]);
        }        

}
int main(int argc, char* argv[])
{
    
    
        function();
        return 0;
}

代码分析

数组翻转的关键代码是：

int* begin=&arr[0];
int* end=begin+4;

while(begin<end){
    
    
        int tmp=*begin;
        *begin=*end;
        *end=tmp;
        begin++;
        end--;
}

1.获取数组首地址和尾地址

int* begin=&arr[0];
int* end=begin+4;

2.循环直到所有数组成员交换结束

while(begin<end){
    
    
}

3.取出begin中的数据放在临时变量中

int tmp=*begin;

4.用end里存储的值覆盖begin

*begin=*end;

5.将原本备份的begin的变量tmp赋值给end，此时已经完成了交换

*end=tmp;

6.继续交换，让指针向数组中间靠拢

begin++;
end--;

运行结果

可以看到，数组成功翻转了

反汇编实现翻转数组

前面使用指针实现了数组的翻转，为进一步了解其本质，自己手写汇编代码实现翻转数组

下面的汇编代码中省略了 dword ptr ds:[]，默认就是取dword

代码

#include "stdafx.h"
void function(){
    
    
        int arr[5]={
    
    1,2,3,4,5};        
        int len=sizeof(arr)/sizeof(int)-1;        
        __asm{
    
    
                xor ecx,ecx
_begin:
                mov eax,len
                sub eax,ecx

                lea edx,[arr+ecx*4]        
                push edx
                mov edx,[edx]
                lea ebx,[arr+4*eax]
                push ebx
                mov ebx,[ebx]
                xchg [arr+ecx*4],ebx
                pop ebx

                mov [ebx],edx
                pop edx
                inc ecx

                cmp edx,ebx
                jb _begin

        }
        int i;
        for(i=0;i<5;i++){
    
    
                printf("%d\n",arr[i]);
        }        

}
int main(int argc, char* argv[])
{
    
    
        function();
        return 0;
}

运行结果

能够正确地实现相同的功能

反汇编代码分析

__asm{
    
    
                xor ecx,ecx
_begin:
                mov eax,len
                sub eax,ecx

                lea edx,[arr+ecx*4]        
                push edx
                mov edx,[edx]
                lea ebx,[arr+4*eax]
                push ebx
                mov ebx,[ebx]
                xchg [arr+ecx*4],ebx
                pop ebx

                mov [ebx],edx
                pop edx
                inc ecx

                cmp edx,ebx
                jb _begin

        }

1.将ecx清零，初始化ecx，ecx在这里是作为偏移量来使用的（刚开始为首地址的偏移，后来慢慢往中间靠拢）

xor ecx,ecx

2.声明一个程序段，后续跳转会用到

_begin:

3.将数组的长度减1的值赋给eax，因为数组从0开始，所以要减1

mov eax,len

4.用先前的eax减去ecx获得偏移（刚开始为尾地址的偏移，后来慢慢往中间靠拢）

sub eax,ecx

5.通过数组首地址加上ecx偏移取得地址，刚开始取得的为首地址，相当于edx=begin

lea edx,[arr+ecx*4]        

6.将前面获得的地址edx放入堆栈中

push edx

7.取出edx中的值，这里相当于edx=*begin=tmp

mov edx,[edx]

8.通过数组首地址加上偏移eax取得地址，刚开始取得的为尾地址，相当于ebx=end

lea ebx,[arr+4*eax]

9.将前面获得的地址ebx放入堆栈中

push ebx

10.取出ebx中的值，这里对相当于ebx=*end

mov ebx,[ebx]

11.交换arr+ecx*4（*begin）和ebx（end）里存储的值，这里相当于begin=*end

xchg [arr+ecx*4],ebx

12.将先前的push的end的地址恢复到ebx，使得ebx=end

pop ebx

13.这里相当于*end=tmp，此时数组中的两个成员就已经交换完毕了

mov [ebx],edx

14.将先前push的begin的地址恢复到edx，使得edx=begin

pop edx

15.让ecx自增一，这里相当于begin++;end–; 因为这里end的偏移是通过len-begin的偏移得到的

inc ecx

16.比较edx和ebx

jb：jump below，小于则跳转（无符号），这里相当于while(begin<end)中的比较

如果begin<end则继续跳回去执行

cmp edx,ebx
jb _begin