【滴水逆向笔记】C语言指针

最新推荐文章于 2022-07-28 19:50:27 发布
最新推荐文章于 2022-07-28 19:50:27 发布
阅读量985 收藏 4
点赞数
分类专栏： 逆向&pwn基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46441427/article/details/114444224
版权

文章目录

一、带*类型变量的赋值

int* x; //把int*看成一种新的数据类型

下面赋值的时候一定要写全

x = (int*)10;

可以加入多个*

int*** x;
x = (int***) = 10;

带‘*’的类型反汇编都是4个字节

带*号的可以直接加减

char* x; 
short* y;
int* z;
x = (char*)100;
y = (short*)100;
z = (int*)100;
x++;
y++;
z++;
printf("%d,%d,%d",x,y,z);

打印结果：101，102，104，也就是说，根据自身类型的宽度来加

char** x; 
short** y;
int** z;
x = (char**)100;
y = (short**)100;
z = (int**)100;
x++;
y++;
z++;
printf("%d,%d,%d",x,y,z);

打印结果：104，104，104
公式：去掉一个“”的长度，就是它加的长度，比如char*，去掉一个就是char，一个字节，比如char**，去掉一个“*”还有一个，只要有一个就是4字节
以前学过的任何一个数据类型都可以加一个星号，这样就是一个完全不同的类型，不管一个星还是几个星，都是四个字节

char* x; 
short* y;
int* z;
x = (char*)100;
y = (short*)100;
z = (int*)100;
x=x+5;
y=y+5;
z=z+5;
printf("%d,%d,%d",x,y,z);

打印结果：105，110，120
公式：砍掉一个后，剩下的乘以5，比如int*，砍掉‘’后是4，4X5=20，所以是120

char***** x; 
short***** y;
int***** z;
x = (char*****)100;
y = (short*****)100;
z = (int*****)100;
x=x+5;
y=y+5;
z=z+5;
printf("%d,%d,%d",x,y,z);

打印结果：120，120，120

char* x; 
short* y;

x = (char*)200;
y = (short*)100;


int a = x-y;
printf("%d",a);

这里必须要类型相同才能减，包括*号数量也必须一样，不然会报错
打印结果：100

char** x; 
short** y;

x = (char**)200;
y = (short**)100;


int a = x-y;
printf("%d",a);

打印结果：25
第一次因为是char，200-100就是100，实际上就是100/4，就是减完以后，砍掉一颗*，然后除以这个数据的长度

带*的可以与一个整数相加相减，还可以求差值

转换类型

char* x; 
int* y;

x = (char*)10;
y = x;

这样直接报错了

char* x; 
int* y;

x = (char*)10;
y = (int*)x;

拓展：char和int为什么可以转？因为char8位，int32位，转int前面填0就行，int转char前面的不要就行，如果是结构体转基本类型的话,他不知道结构体在哪里，转不了

struct student()
{
    int age;
    int level;
};
void Test()
{
    char* x; 
    student* y;

    x = (char*)10;
    y = (student*)x;
}

编译通过，转得了

struct student()
{
    int age;
    int level;
};
void Test()
{
    char* x; 
    char** y;

    x = (char*)10;
    y = (char**)x;//1
    //y = x;这个编译不通过，语句2
}

如图，语句一可以转，语句2不可以

二、&符号

&是地址符，任何一个变量都可以用&来获取地址，比如&a可以获取到a的地址

char x; 
short y;
int* z;
x = 10;
y = 20;
z = 30;

//char x = &a 编译失败，报错不能把char*转成char

也就是说&a的类型就是a的类型加一颗’*’就是char*，&b的类型short*

char x; 
short y;
int* z;
x = 10;
y = 20;
z = 30;
char* px;
px = = &x;//断点

反汇编
在这里插入图片描述
ebp-4就是x，就是10，lea就是取ebp-4的地址，给eax，然后把这个值给ebp-10，就是这个px局部变量

int a; 
int* pa;
a = 10;
pa = &a;//&x需要char*类型的容器,其实就是pa = (int*)&a,不要那个（int*）

反汇编
在这里插入图片描述

struct student()
{
    int age;
    int level;
};
int x = 10;

void Test()
{
    int* y = x;
}

这个地方存的是一个A
在这里插入图片描述
在这里插入图片描述
执行后的效果：
在这里插入图片描述
也就是说&的需要在原来类型的基础上加个*

int x = 10;
int* px = &x;
int x1 = *px

如果在一个变量前用‘*’，比如

int* x   *x == int;

得到的结果就是原来类型砍一棵星
反汇编：
在这里插入图片描述

三、数组指针

void test()
{
    char arr[5] = {1,2,3,4,5,6};
    //用char* x = &arr[0]; == char& px = arr;
    char* px = arr;//px存的就是第一个整数的地址
    printf('%x',px);
}

打印结果：12ff24，如果要打印数组的值

void test()
{
    char arr[5] = {1,2,3,4,5,6};
    //用char* x = &arr[0]; == char* px = arr;
    char* px = arr;//px存的就是第一个整数的地址
    printf('%d',*px);
}

打印出1
如果char* p = 10,那么p+1=11，11指向的就是p[1];
所以要打印出arr所有的值

void test()
{
    char arr[5] = {1,2,3,4,5,6};
    //用char* x = &arr[0]; == char* px = arr;
    char* px = arr;//px存的就是第一个整数的地址
    for(char i =0;i<=5;i++)
    {
        printf('%d\n',*(px+i));
    }
}

打印结果：

1
2
3
4
5

四、CE初探

在这里插入图片描述
如左边，是我们的地址，右边是值
扫描2字节的2：
点击new scan
搜索类型中的bigger than，就是多少个字节比than大
在这里插入图片描述
value between 2~6之间
在这里插入图片描述
现在搜索的是哪些地址的值是2
在这里插入图片描述
现在在游戏里，找一堆数据里可能是血量的值，血量为100

char data[100] = 
{
0x00,0x64,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
0x00,0x02,0x74,0x0F,0x41,0x00,0x06,0x08,0x00,0x00,
0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
void findblood()
{
    printf('%x\n',&data[0]);
    for(int i = 0;i<100;i++)
    {
        if(data[i] == 100)
        {
            printf('%x\n',&data[i]);
        }
    }
}

这样就能找到地址，有五个0x64的地址，在这前会打印data【0】的地址，而第一个0x64
的地址就是data【0】的地址加上1
如果是int类型的话，下面要改动，用上指针

char data[100] = 
{
0x00,0x64,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
0x00,0x02,0x74,0x0F,0x41,0x00,0x06,0x08,0x00,0x00,
0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
void findblood()
{
    int* p = (int*)&data[0];
    printf('%x\n',&data[0]);
    for(int i = 0;i<25;i++)
    {
        if(*(p+i) == 100)
        {
            printf('%x\n',(p+i));
        }
    }
}

发现报错，这里应该用一种新算法，取出前四个，然后看是不是有等于100的，然后再从第二个往后取，也就是顺序是1，2，3，4然后是2，3，4，5。因为这些数据不一定四个拼在一起的时候刚好是一个int。内存的事情是说不准的，所以上述程序是错的

char data[100] = 
{
0x00,0x64,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
0x00,0x02,0x74,0x0F,0x41,0x00,0x06,0x08,0x00,0x00,
0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
void findblood()
{
    int* p = (int*)&data[0];
    for(int i = 0;i<25;i++)
    {
        printf('%d\n',*(p+i));
    }
}

可以打印出来地址里的值，如果要两个字节地查

char data[100] = 
{
0x00,0x64,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
0x00,0x02,0x74,0x0F,0x41,0x00,0x06,0x08,0x00,0x00,
0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
void findblood()
{
    short* p = (short*)&data[0];
    for(int i = 0;i<50;i++) //现在是两个两个查的，所以小于50
    {
        printf('%d\n',*(p+i));
    }
}

打印结果前两个：6400，302
四个四个查

char data[100] = 
{
0x00,0x64,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
0x00,0x02,0x74,0x0F,0x41,0x00,0x06,0x08,0x00,0x00,
0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
void findblood()
{
    short* p = (short*)&data[0];
    for(int i = 0;i<25;i++) //现在是四个四个查的，所以小于25
    {
        printf('%d\n',*(p+i));
    }
}

3026400，7060504，就是四个字节四个字节遍历，但要注意这里是特殊情况，很有可能是第二个第三个第四个第五个构成第一个int，虽然搜索是从第一个四个四个搜，但是内存分配的情况我们是说不准的

五、字符串指针

exe的内存分布：
在这里插入图片描述
可读可写：可以从里面读出来，可以修改里面的值，提一嘴，全局变量区还有可读可写的
可读不可写：常量区，不能改的
字符串的指针，比如‘china’

char* p = 'china';
这里默认指向的是C，也就是开头

这里看一下两种方法：

char* x = 'china';
char y[] = 'china';
void test()
{
    *(x+1)='A';
    y[1] = 'A';
}

注释掉y[1] = ‘A’
编译时没有问题，但在运行时有问题
在这里插入图片描述
这个报错是内存非法读写
注释掉*（x+1）= ‘A’，没有问题
原因：第一种写法，x存的是china的首地址，x能改，但是x指向的值不能改，因为x就是一个char*的类型，x指向的值不能改，因为指针指向的值存在于常量区，为什么char y[]可以改，因为它是全局变量区
把void function()里面的值都注释掉，给了0x40个空间，如果写char* x,44个空间，那如果写char* x = 'china';呢？
在这里插入图片描述
还是ebp-4，但是这个x存的地址是0042201c，而字符串本身存在常量区
如果是char y[]=‘china’;
在这里插入图片描述
多分了8个
在这里插入图片描述
这样写，也是把china放到常量区
在这里插入图片描述
这里eax存入了china的ascii码
然后给到ebp-8
在这里插入图片描述
但是还是缺少了一个a，就存入到cx，然后放到cx里面，也就是说拷贝到堆栈里
第一条，我们修改的是常量区数据
第二条，它修改的数据已经拷贝到堆栈了，所以可以
出现005的报错可以参考

1.实现strlen判断长度

int strlen(char* s)
{
    int ret = 0;   //定义返回值
    while(*s != 0)   //取S首地址，s！=0时执行循环
    {
        ret++;    //数量加1
        s++;   //指针后移
    }
    return ret;
}

2.实现strcpy复制长度

char strcpy(char* dest,char* src)
{
    
    while(*dest != 0)
    {
        *dest = *src;
        dest++;
        src++;
    }
    char ret = dest;
    return ret;
}

海哥一行代码结束。。。
在这里插入图片描述
如果src是0，那么就把0给了dest，这里就是先赋值再判断，因为已经过去了，所以*dest=0，就会断开循环

3.strcat字符串拼接

char strcat(char*dest,char*src)
{
    char ret;
    while(*dest != 0)
    {
        dest++;
    }
    while(*src != 0)
    {
        *dest = *src
         dest++;
         src++;
    }
}

海哥的写法
在这里插入图片描述
思路也是一样的。。就是让dest指针先移动到末尾，然后就是复制函数的内容了

4.strcmp函数比较，一样返回0，不一样返回1

int strcmp(char* s1, char* s2)
{   
    
    while(*s1++ = *s2++)
    {
       if(*s1 == 0 || *s2==0)
       {
       return 1;
       }
    }
    return 0;
}

5.指针函数，查找wow字符串地址

指针函数就是返回值为带*类型的函数

char arr[] = {
 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x07,0x09,
 0x00,0x20,0x10,0x03,0x03,0x0C,0x00,0x00,0x44,0x00,
 0x00,0x33,0x00,0x47,0x0C,0x0E,0x00,0x0D,0x00,0x11,
 0x00,0x00,0x00,0x02,0x64,0x00,0x00,0x00,0xAA,0x00,
 0x00,0x00,0x64,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x02,0x00,0x74,0x0F,0x41,0x00,0x00,0x00,
 0x01,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0A,0x00,
 0x00,0x02,0x57,0x4F,0x57,0x00,0x06,0x08,0x00,0x00,
 0x00,0x00,0x00,0x64,0x00,0x0F,0x00,0x00,0x0D,0x00,
 0x00,0x00,0x23,0x00,0x00,0x64,0x00,0x00,0x64,0x00
};
char Name = 'WOW'
char* FindRoleNameAddr(char* data, char* RoleName)
{   
    char* start = RoleName;
    for(int i = 0;i<100;i++)
    {
        if(*data == *RoleName)
        {
            data++;
            Name++;
        }
        if(*RoleName == 0)
        {
            return data;
        }
        if(*data != *RoleName;)
        {
            RoleName = start;
            *data++;
        }
    }
    return 0;
}
int main()
{
   printf("%x",FindRoleNameAddr(arr,Name));
   return 0; 
}

六.指针数组

在这里插入图片描述
指针数组在内存中是这样分配的

char arr[] = {'c','h','i','n','a'};
printf('%s\n',arr);

s是给定一个地址，让地址往后打印，直到见到0
出现地址
在这里插入图片描述

char arr[6] = {'c','h','i','n','a'，'\0'};
printf('%s\n',arr);

所以要往后补0
在这里插入图片描述
可以打印

char* p1 = 'if';
char* p2 = 'for';
char* p3 = 'while';
char* p4 = 'switch';
char* keyword[] = {'if','for','while','switch'};

在这里插入图片描述
这就是指针数组

七、结构体指针

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
    Arg* pArg;
    pArg = (Arg*)100;
}

在这里插入图片描述
反汇编是一样，但是运算方法不一样

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
    Arg*** pArg;
    pArg = (Arg***)100;
    pArg++;
    printf("%d\n",pArg)
}

答案为104

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
    Arg* pArg;
    pArg = (Arg*)100;
    pArg++;
    printf("%d\n",pArg)
}

打印结果：112
还是砍星成哪个类型的问题，前面是*，还是104

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
    Arg* pArg;
    pArg = (Arg*)100;
    pArg=pArg+5;
    printf("%d\n",pArg)
}

打印结果：160

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
    Arg* pArg;
    pArg = (Arg*)100;
    pArg2 = (Arg*)20;
    
    pArg-pArg2;
    printf("%d\n",pArg)
}

打印结果：6，因为80

打印结果6
反汇编：
在这里插入图片描述
结构体指针不能用点，用箭头

struct Arg	
{	
   int a;	
   int b;	
   int c;	
}	
int main()
{
Arg s;
s.a = 10;
s.b = 20;
s.c = 30;
Arg* px = &S;
printf("%d\n",px->a);
return 0;
}

打印结果：10

struct Arg	
{	
   int a;	
   char b;	
   int c;	
}	
int main()
{
Arg s;
s.a = 10;
s.b = 20;
s.c = 30;
Arg* px = &S;
printf("%d %d %d\n",px->a,px->b,px->c);
return 0;
}

打印结果：10，20，30
也可以修改

struct Arg	
{	
   int a;	
   char b;	
   int c;	
}	
int main()
{
Arg s;
s.a = 10;
s.b = 20;
s.c = 30;
Arg* px = &S;
printf("%d %d %d\n",px->a,px->b,px->c);
px->a = 100;
px->b = 200;
px->c = 300;
printf("%d %d %d\n",px->a,px->b,px->c);
return 0;
}

打印结果：

10 20 30
100 -56 300

因为这个char，越界了，char最多127

int x = 10;
Arg* px = (Arg*)&x;
printf("%d %d %d\n",px->a,px->b,px->c);

如果是这样的话，可能在内存中是10 00 00 00，所以第一个值会打印10，但是后面可能是一堆乱码

八.函数指针


#include "stdafx.h"
#include<stdlib.h>

int Function(int x,int y)
{
	return x+y;
}
int main(int argc, char* argv[])
{
    int(*pfun)(int,int);

	Function(1,2);
	return 0;
}

查看反汇编
在这里插入图片描述

如图，把硬编码转换成汇编
刚开始function存在代码区，而这个undesigned存在数据区，把前面的硬编码取出来，放到arr

#include "stdafx.h"
#include<stdlib.h>

unsigned char arr[] = 		
{		
		0x55,
		0x8B, 0xEC,
		0x83, 0xEC, 0x40,
		0x53,
		0x56,
		0x57,
		0x8D, 0x7D, 0xC0,
		0xB9, 0x10, 0x00, 0x00, 0x00,
		0xB8, 0xCC, 0xCC, 0xCC, 0xCC,
		0xF3, 0xAB,
		0x8B, 0x45, 0x08,
		0x03, 0x45, 0x0C,
		0x5F,
		0x5E,
		0x5B,
		0x8B, 0xE5,
		0x5D,
		0xC3
};		


int main(int argc, char* argv[])
{
    int(*pfun)(int,int);
	pfun = (int(*) (int,int))&arr;
	int x = pfun(2,3);
	printf("%d\n",x);
	system("pause");
	return 0;
}

在这里插入图片描述
执行了之前function的函数
用处：把所有保护的函数，从生成完的文件抠出来，放到自己定义的一个数组里，然后在数组上做一些手脚，隐藏起来，把所有存储函数的地方全部存0

总结

实际上记住三点
1.指针别看成指针，就是一些新的数据类型
2.掌握指针的加加减减
3.指针可以指向任何数据类型，不是说一定指针就只能指向本身的类型

Akura@lan
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
滴水逆向 指针1
v_3483608762的博客
12-01 655
char类型占几字节？char * 类型占几字节？int * ****占几字节？ 1 4 4 char * *arr[10] 占多少个字节？ 40 自定义结构体如下： struct Student { int x; int y; }; 第一步： Student**** s; s = (Student****)100; s++; //s的值是多少？ 108 s = s + 2; //s的值是多少？ 116 s = s - 3; //s的值是多少？ 76 第二步： Studen..
滴水逆向指针部分几个实验
qq_52442096的博客
11-03 95
【代码】滴水逆向指针部分几个实验。
滴水逆向——This指针课堂随笔
weixin_44584614的博客
03-21 359
文章目录 数组传递时，传递的是指针；结构体传递的时候，传递的是副本。
滴水逆向学习笔记2
BL_zshaom的博客
01-18 500
1是反汇编窗口；2是寄存器窗口；3是数据窗口；4是堆栈窗口 反汇编窗口和寄存器窗口顺序都是从高到低，而数据窗口里是倒过来的（高位在后低位在前）
滴水逆向（作业4）
weixin_52437902的博客
07-28 394
代码】滴水逆向（作业4）
培训基础教程滴水逆向-C语言笔记
06-01
培训基础教程滴水逆向-C语言笔记
滴水逆向中级课件源码
08-06
《滴水逆向中级课件源码》是一个专注于软件安全和逆向分析技术的学习资源，包含了一系列相关的课程材料。逆向工程是信息安全领域中的一个重要分支，它涉及到对软件的二进制代码进行分析，以理解其功能、逻辑和潜在的...
编程达人-滴水逆向全套课件.zip
06-10
滴水逆向课程的数据，PDF及程序
滴水逆向三期课件,滴水逆向三期课件下载
09-10
逆向进阶，进一步深刻了解逆向及其原理，在b站等可以搜到课程，这是相对应课件
滴水逆向三期课件.zip
07-09
滴水逆向三期全部课件(海东老师讲),全套包括 EXE 练手文件 配套电子书,源码 滴水逆向三期全部课件(海东老师讲),全套包括 EXE 练手文件 配套电子书,源码
海哥通讯录_asp.netC＃_
09-29
通讯录，没有用数据库，用txt记录数据，适合大学.net课程大作业参考
滴水逆向3期初级和中级课件(海东老师讲)
09-04
滴水逆向3期初级和中级课件(海东老师讲) 全套包括 EXE 练手文件 配套电子书......
滴水逆向笔记（九）
m0_51295934的博客
02-21 294
1.DTDebug中的按键操作 F2下断点 F7单步步入（call指令使用） F8单步步过 2.下断点 在断点处，如上标识的中间一列的十六进制会变为0xCC，右一列相当于int 3
【滴水逆向笔记】第二章 数据宽度与逻辑运算
qq_46441427的博客
01-10 309
目录前言一、数据宽度1.设计算机只能存储4位2进制数2.设计算机只能存储8位2进制数3.设计算机只能存储16位2进制数4.设计算机只能存储16位2进制数二、逻辑运算本质1.或运算2.与运算3.异或运算4.非运算三、逻辑运算应用1.如何利用CPU进行2+3的运算？2.获取某个值的第N位3.加密算法 前言 需要进制转换的基础 Byte 字节 8bit Word 字 16Bit 2字节 DWord 双字 32Bit 4字节 一、数据宽度 计算机中由于受到硬件条件的制约，数据长度有限制，超过最多宽度的数据会
逆向工程学习笔记（7）：ret 8
嵌云阁
03-30 2231
最后一条指令： 0x40002050 ret 8 因为是__stdcall，所以在返回指令中带上了栈的大小，8个字节。 由于是返回double类型，因此我们直接将ST0中的结果返回： /* 0x40002050 */ return st0_2; 最终逆向分析得到的C++代码： double __stdcall DegToRad(double param1) { double st0_0 = 0; uint32_t esp_0 = 0; ...
c语言逆向 指针逆向小案例
qq_45951598的博客
07-01 386
1、列出每一行的反汇编代码： char a = 10; mov byte ptr [a],0Ah short b = 20; mov eax,14h mov word ptr [b],ax int c = 30; mov dword ptr [c],1Eh char* pa = &a; lea eax,[a] mov dword ptr [pa],eax
Cherno C++ P16 C++指针
weixin_44452626的博客
01-19 343
Cherno C++学习笔记
reversing逆向分析技术总结-(1)
fa1c4的blog
01-14 355
32位软件逆向 1 启动函数 winmain函数, 初始化后调用. 2 函数 2.1 函数识别 call, ret区分函数调用和跳转指令 通过call识别函数首地址 2.2 函数参数 (1) 栈传递参数 常用调用约定 | 约定类型 | __cdecl | pascal | stdcall | Fastcall | |—|---|—|---|—| ...
滴水逆向三期 win10 ASLR UnmapViewOfSection傀儡进程 加密壳项目
四位的博客
12-27 1961
特意加了一个win10标题, 碰到0xc0000005的朋友就不要再浪费时间了, 我在这个问题上花了整整一天 概要 利用挂起创建进程, 然后卸载源程序(以下统称src)镜像(ps: 非必须选项),
滴水逆向ncknafxcw.pdb
最新发布
11-18
滴水逆向是一个指的是液体水珠从接触面开始逆向移动的现象。由于水分子间的相互作用力，水珠通常会在水中向着重力方向下落。然而，在特定的情况下，我们可以通过一些特殊的手段使水珠逆向移动。 滴水逆向的实现主要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值