国内网站域名,2345网址大全浏览器,ppt模板下载免费完整版简约,北京网站搭建多少钱公开视频 - 链接点击跳转公开课程博客首页 - 链接点击跳转博客主页
目录
1. 指针特性
1.1 指针的优点
1.2 指针的缺点
2. 智能指针
2.1 智能指针的优点
2.2 智能指针的缺点
3. 指针的安全攻防
3.1 指针使用
3.2 指针运算
3.3 指针引用
3.4 参数传递 …公开视频 - 链接点击跳转公开课程博客首页 - 链接点击跳转博客主页
目录
1. 指针特性
1.1 指针的优点
1.2 指针的缺点
2. 智能指针
2.1 智能指针的优点
2.2 智能指针的缺点
3. 指针的安全攻防
3.1 指针使用
3.2 指针运算
3.3 指针引用
3.4 参数传递
3.5 多级指针
3.6 指针数组
3.7 数组指针
3.8 函数指针
5. 逆向工程中的指针分析
6. 拓展知识点
6.1 指针与内存布局 1. 指针特性
1.1 指针的优点
灵活性 指针可以动态分配和管理内存提供了更高的灵活性。通过指针可以实现数据的共享和动态扩展。 高效性 使用指针传递参数可以避免数据的复制节省内存空间并提高效率。指针操作直接作用于内存地址速度更快。
1.2 指针的缺点
安全性 指针的误用容易导致内存泄漏、悬挂指针指向已释放的内存和野指针指向未分配的内存。 复杂性 大量使用指针会增加代码的复杂性容易出错。 维护性 指针操作使代码的可读性下降维护困难。 2. 智能指针
2.1 智能指针的优点 自动化 智能指针在脱离作用域时会自动释放内存避免内存泄漏。常见的智能指针包括std::unique_ptr、std::shared_ptr和std::weak_ptr。 安全性 智能指针通过引用计数和自动管理内存避免了悬挂指针和野指针的问题。
2.2 智能指针的缺点
性能开销 智能指针的实现需要额外的引用计数和内存管理逻辑相比普通指针开销更大。 复杂性 智能指针的使用需要遵循一定的规则如避免循环引用。 3. 指针的安全攻防
在逆向工程中指针的操作是分析程序行为的重要线索同时也是漏洞攻击的关键点。以下是指针的常见操作及其在逆向工程中的表现。
3.1 指针使用
指针的声明和初始化
int a 10; int* ptr a; // 指针ptr指向变量a的地址
在汇编中表现为
mov eax, dword ptr [ebp-4] ; 取变量a的地址
mov dword ptr [ebp-8], eax ; 将地址存储到指针ptr
3.2 指针运算
指针支持算术运算例如
int arr[] {1, 2, 3, 4, 5};
int* ptr arr; // 指向数组首地址
ptr; // 指针移动到下一个元素
在汇编中表现为
mov eax, dword ptr [ebp-8] ; 取指针值
add eax, 4 ; 指针移动4字节sizeof(int)
mov dword ptr [ebp-8], eax ; 更新指针值
3.3 指针引用
通过指针访问和修改变量
*ptr 20; // 修改ptr指向的地址的值
在汇编中表现为
mov eax, dword ptr [ebp-8] ; 取指针值
mov dword ptr [eax], 20 ; 修改指针指向地址的值
3.4 参数传递
指针可以作为函数参数用于传递数据地址。例如
void Fun(int* ptr) { *ptr 20; }
在汇编中表现为
mov eax, dword ptr [ebp8] ; 获取函数参数指针
mov dword ptr [eax], 20 ; 修改指针指向的值
3.5 多级指针
多级指针是指向指针的指针。例如
int a 10; int* ptr1 a;
int** ptr2 ptr1;
在汇编中表现为
lea eax, dword ptr [ebp-4] ; 取ptr1的地址
mov dword ptr [ebp-8], eax ; 将地址存储到ptr2
3.6 指针数组
指针数组是存储指针的数组。例如
const char* strArr[] {Hello, World};
在汇编中表现为
mov dword ptr [ebp-10], offset Hello
mov dword ptr [ebp-0C], offset World
3.7 数组指针
数组指针是指向数组的指针。例如
int arr[3][3] { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int (*parr)[3] arr; // 指向二维数组
在汇编中表现为
mov eax, offset arr ; 取数组首地址
mov dword ptr [ebp-4], eax ; 存储到数组指针
3.8 函数指针
函数指针用于存储函数的地址。例如
int Add(int a, int b) { return a b; } int (*pFun)(int, int) Add; int result pFun(1, 2);
在汇编中表现为
mov eax, offset Add ; 取函数地址
mov dword ptr [ebp-4], eax ; 存储到函数指针
call dword ptr [ebp-4] ; 调用函数指针 #include iostreamvoid Fun1(int* a)
{//mov eax, dword ptr[a]//mov dword ptr[eax], 2*a 2;printf(Fun1 - a - %d \r\n, *a);a NULL;
}void Fun2(int a)
{//mov eax, dword ptr[a]//mov dword ptr[eax], 3a 3;printf(Fun2 - a - %d \r\n, a);a NULL;
}int* Fun3()
{// 禁止返回局部变量的指针或引用// malloc// new// virtualalloc//int a 1;//return a;return NULL;
}int Add(int num1, int num2)
{int ret num1 num2;return ret;
}int aaaaaaa;int main()
{aaaaaaa 1;/*segment regcs0008 ss0010 ds0023 es0023 fs0030 gs0000段选择子RPL 2 请求特权级别TI 1 查询寄存器 0 - GDTR / 1 - LDTRINDEXcs0008 0000 0000 0000 1000RPL 00 TI 0 INDEX 0000 0000 0000 1 00cf9b000000ffffss0010 0000 0000 0001 0000RPL 00TI 0 INDEX 0000 0000 0001 000cf93000000ffff0: kd reax00000001 ebxaa173600 ecxaa173600 edx00000031 esi81a4c060 edi926d1428eip81945dc4 espaa1735f8 ebpaa1736d0 iopl0 nv up ei pl zr na pe nccs0008 ss0010 ds0023 es0023 fs0030 gs0000 efl00000246nt!RtlpBreakWithStatusInstruction:81945dc4 cc int 30: kd r ldtrldtr000000000: kd r gdtrgdtr80d0a0000: kd dq 80d0a000ReadVirtual: 80d0a000 not properly sign extended80d0a000 0000000000000000 00cf9b000000ffff80d0a010 00cf93000000ffff 00cffb000000ffff80d0a020 00cff3000000ffff 80008bd0700020ab80d0a030 804093d0c0004a60 0040f30000000fff80d0a040 0000f2000400ffff 000000000000000080d0a050 810089a500600068 810089a500c8006880d0a060 00cff2000000ffff 000000000000000080d0a070 800092d0a00003ff 00000000000000000: kd dg csP Si Gr Pr LoSel Base Limit Type l ze an es ng Flags---- -------- -------- ---------- - -- -- -- -- --------0008 00000000 ffffffff Code RE Ac 0 Bg Pg P Nl 00000c9b0: kd dg ssP Si Gr Pr LoSel Base Limit Type l ze an es ng Flags---- -------- -------- ---------- - -- -- -- -- --------0010 00000000 ffffffff Data RW Ac 0 Bg Pg P Nl 00000c930: kd dg fsP Si Gr Pr LoSel Base Limit Type l ze an es ng Flags---- -------- -------- ---------- - -- -- -- -- --------0030 80d0c000 00004a60 Data RW Ac 0 Bg By P Nl 00000493*/ __asm{mov eax, dword ptr ds:[0x400000] // ds.Base 0x400000mov eax, dword ptr fs:[0] // fs.Base(80d0c000) 0x0xor eax, eax}/*指针 - 引用指针变量也是变量的一种 - 通常用于存储变量的内存地址数据类型 变量名 初始值;数据类型* 变量名 初始值;空指针int* ptr NULL;int* ptr nullptr;指向变量的指针int a 1;int b 2;int* ptr a;解引用ptr b;*ptr b;指针运算int arr[] {1, 2, 3};int* ptr arr;ptr[2];ptr;多级指针int* ptr1;int** ptr11;int*** ptr111;函数指针CALL*/int num1 NULL;int num2 NULL;// 空指针int* ptr1 NULL;int* ptr2 nullptr;/*005E443F C7 45 F4 00 00 00 00 mov dword ptr [ebp-0Ch],0005E4446 C7 45 E8 00 00 00 00 mov dword ptr [ebp-18h],0005E444D C7 45 DC 00 00 00 00 mov dword ptr [ebp-24h],0005E4454 C7 45 D0 00 00 00 00 mov dword ptr [ebp-30h],0*/// 指向变量的指针ptr1 num1;ptr2 num2;/*005E445B 8D 45 F4 lea eax,[ebp-0Ch]005E445E 89 45 DC mov dword ptr [ebp-24h],eax005E4461 8D 45 E8 lea eax,[ebp-18h]005E4464 89 45 D0 mov dword ptr [ebp-30h],eaxptr20x0113F884 9c f8 13 01 ??..ptr10x0113F890 a8 f8 13 01 ??..num20x0113F89C 00 00 00 00 ....num10x0113F8A8 00 00 00 00 ....*/// 解引用*ptr1 1;*ptr2 2;/*003A4467 8B 45 DC mov eax,dword ptr [ebp-24h] 003A446A C7 00 01 00 00 00 mov dword ptr [eax],1 003A4470 8B 45 D0 mov eax,dword ptr [ebp-30h] 003A4473 C7 00 02 00 00 00 mov dword ptr [eax],2*/// 指针运算//printf(%d \r\n, sizeof(char)); -1//printf(%d \r\n, sizeof(short)); -2//printf(%d \r\n, sizeof(int)); -4//printf(%d \r\n, sizeof(long)); -4//printf(%d \r\n, sizeof(long long)); -8//printf(%d \r\n, sizeof(char*)); -4//printf(%d \r\n, sizeof(short*)); -4//printf(%d \r\n, sizeof(int*)); -4//printf(%d \r\n, sizeof(long*)); -4//printf(%d \r\n, sizeof(long long*)); -4int arr[] { 1,2,3,4,5 };int* ptr3 arr;ptr3;ptr3 ptr3 4;//srand(time(NULL));////for (size_t i 0; i 50; i)//{// if (i % 10 0)// {// printf(\r\n);// }//// printf(0x%02x, , rand() % 50 1);//}// 0x2d082e30char arrp[] {0x16, 0x2b, 0x04, 0x17, 0x2e, 0x19, 0x15, 0x2d, 0x08, 0x2e,0x30, 0x0e, 0x25, 0x23, 0x1b, 0x01, 0x0f, 0x09, 0x05, 0x24,0x1b, 0x26, 0x16, 0x28, 0x2b, 0x32, 0x1a, 0x0c, 0x1a, 0x0c,0x2e, 0x30, 0x2f, 0x1c, 0x02, 0x1c, 0x19, 0x0c, 0x17, 0x16,0x06, 0x0e, 0x31, 0x06, 0x09, 0x0b, 0x1a, 0x09, 0x0f, 0x26,};char* arrp1 arrp;*(arrp1 2) 1;arrp1[2] 2;short* arrp2 (short*)arrp;*(arrp2 2) 1;arrp2[2] 2;int* arrp3 (int*)arrp;*(arrp3 2) 1;arrp3[2] 2;/*指针占用内存大小为x86 - 4Bytex64 - 8Bytechar* ptr1 arr;ptr1; // ptr1 ptr1 (sizeof(char) * 1);short* ptr2 arr;ptr2; // ptr2 ptr2 sizeof(short);int* ptr3 arr;ptr3; // ptr3 ptr3 sizeof(int);ptr3 ptr3 4; // ptr3 ptr3 (sizeof(int) * 4);*/// 引用int a 10;int b 20;int ref a;ref 2;int* p a;*p 3;// 指针常量int* const p1 a;//p1 b;*p1 1;// 常量指针const int* p2 a;p2 b;//*p2 2;/*00465314 C7 45 9C 0A 00 00 00 mov dword ptr [a],0Ah 0046531B 8D 45 9C lea eax,[a] 0046531E 89 45 90 mov dword ptr [ref],eax 00465321 8B 45 90 mov eax,dword ptr [ref] 00465324 C7 00 02 00 00 00 mov dword ptr [eax],2 0046532A 8D 45 9C lea eax,[a] 0046532D 89 45 84 mov dword ptr [p],eax 00465330 8B 45 84 mov eax,dword ptr [p] 00465333 C7 00 03 00 00 00 mov dword ptr [eax],3 */// 参数传递a 1;//mov eax, dword ptr[a]//push eaxprintf(main - a - %d \r\n, a);//lea eax, [a]//push eaxFun1(a);printf(main - a - %d \r\n, a);//lea eax, [a]//push eaxFun2(a);printf(main - a - %d \r\n, a);// 多级指针int num_1 0xCC; int* ptr_1 num_1;int** ptr_2 ptr_1;int*** ptr_3 ptr_2;*ptr_1 0xFF;**ptr_2 0xCC;***ptr_3 0xAA;/*ptr_30x0019FE14 20 fe 19 00 ?..ptr_20x0019FE20 2c fe 19 00 ,?..ptr_10x0019FE2C 38 fe 19 00 8?..num_10x0019FE38 cc 00 00 00 ?...00411BE2 mov dword ptr [ebpFFFFFF54h],0CCh00411BEC lea eax,[ebpFFFFFF54h]00411BF2 mov dword ptr [ebpFFFFFF48h],eax00411BF8 lea eax,[ebpFFFFFF48h]00411BFE mov dword ptr [ebpFFFFFF3Ch],eax00411C04 lea eax,[ebpFFFFFF3Ch]00411C0A mov dword ptr [ebpFFFFFF30h],eax00411C10 mov eax,dword ptr [ebpFFFFFF48h]00411C16 mov dword ptr [eax],0FFh00411C1C mov eax,dword ptr [ebpFFFFFF3Ch]00411C22 mov ecx,dword ptr [eax]00411C24 mov dword ptr [ecx],0CCh00411C2A mov eax,dword ptr [ebpFFFFFF30h]00411C30 mov ecx,dword ptr [eax]00411C32 mov edx,dword ptr [ecx]00411C34 mov dword ptr [edx],0AAh*/// 指针数组const char* strArr[] { Hello, World };// 数组指针int Arr_int[3][3] {{1,2,3},{4,5,6},{7,8,9},};int(*parr_int)[3] Arr_int;parr_int[1][2] 0xCC;/*00411E6A B8 0C 00 00 00 mov eax,0Ch 00411E6F C1 E0 00 shl eax,0 00411E72 03 85 88 FE FF FF add eax,dword ptr [parr_int] 00411E78 B9 04 00 00 00 mov ecx,4 00411E7D D1 E1 shl ecx,1 00411E7F C7 04 08 CC 00 00 00 mov dword ptr [eaxecx],0CCh */*(*(parr_int 1) 2) 0xAA;/*00411E86 8B 85 88 FE FF FF mov eax,dword ptr [parr_int]00411E8C C7 40 14 AA 00 00 00 mov dword ptr [eax14h],0AAh*/// 函数指针int ret Add(1, 2);/*00415DF3 6A 02 push 2 00415DF5 6A 01 push 1 00415DF7 E8 D3 B5 FF FF call Add (04113CFh) 00415DFC 83 C4 08 add esp,8 00415DFF 89 85 7C FE FF FF mov dword ptr [ret],eax CALL指令执行地址 00415DF7CALL指令返回地址 00415DFCCALL指令跳转地址 04113CFhCALL指令内存数据 E8 XX XX XX XXCALL指令内存数据 CALL指令跳转地址 - CALL指令返回地址0FFFFB5D3h 04113CFh - 00415DFChCALL指令跳转地址 CALL指令内存数据 CALL指令返回地址04113CFh 0FFFFB5D3h 00415DFChCALL指令执行地址 00401EC0CALL指令返回地址 00401EC5CALL指令跳转地址 00401E80CALL指令内存数据 FFFFFFBB*/int (*pFun)(int num1, int num2) Add;ret pFun(2, 2);/*00415E11 6A 02 push 2 00415E13 6A 02 push 2 00415E15 FF 95 70 FE FF FF call dword ptr [pFun] 00415E1B 83 C4 08 add esp,8 00415E25 89 85 7C FE FF FF mov dword ptr [ret],eax*/return 0;
} 5. 逆向工程中的指针分析
在逆向工程中指针的使用是分析程序逻辑和定位漏洞的关键。以下是常见的分析场景 动态内存分配 分析malloc、new、VirtualAlloc等内存分配函数的调用。识别内存泄漏和未释放的指针。 函数调用 通过函数指针的调用分析程序的动态行为。识别虚函数表和多态行为。 漏洞利用 分析指针越界、悬挂指针和野指针的使用场景。识别栈溢出和堆溢出等安全漏洞。 6. 拓展知识点
6.1 指针与内存布局 指针的大小依赖于系统架构 32位系统指针大小为4字节。64位系统指针大小为8字节。 指针在内存中的存储 指针本身存储在栈或堆中。指针指向的内容存储在对应的内存区域如全局区、栈区或堆区。
