以上程序运行出错.

#include <stdio.h>;  

void overFlow () 

{ 

  int a[] = { 0x78787868 }; 

  *(a + 2) += 7; 

} 



int main () 

{ 

int aa = 3; 

overFlow (); 

  aa = 4; 

printf ("%d\n", aa); 

} 

用vc6.0吧，貌似vs2005以上不行吧？

错在哪里啊？

#include <stdio.h>;  

void overFlow () 

{ 

  int a[] = { 0x78787868 }; 

  *(a + 2) += 7;   //此语句修改了栈结构，本来保存overflow函数下条指令的地址被加上7，由此跳过了aa=4这条指令，因此，aa还是等于3

} 



int main () 

{ 

int aa = 3; 

overFlow (); 

  aa = 4; 

printf ("%d\n", aa); 

} 

1. 栈内从低到高是：本函数局部变量，ebp，ret_addr，参数（你这里没有参数），调用函数局部变量。

2. 本函数的局部变量分配多少空间(esp = esp + X)，这里X是多少是要反汇编来精确确定，因为通常要对齐优化。

我也知道是跳过了执行
但是因为我需要精确的控制返回值，所以我需要知道具体是怎么修改的，4楼的哥们

引用 4 楼 tangshuiling 的回复:

C/C++ code#include<stdio.h>;voidoverFlow () 
{inta[]={0x78787868};*(a+2)+=7;//此语句修改了栈结构，本来保存overflow函数下条指令的地址被加上7，由此跳过了aa=4这条指令，因此，aa还是等于3}intmain () 
{intaa=3; 
overFlow (); 
  aa=4; 
printf ("%d\n", aa); 
}

为什么要加7啊？

引用 5 楼 yutaooo 的回复:

1. 栈内从低到高是：本函数局部变量，ebp，ret_addr，参数（你这里没有参数），调用函数局部变量。 

2. 本函数的局部变量分配多少空间(esp = esp + X)，这里X是多少是要反汇编来精确确定，因为通常要对齐优化。 

5楼的哥们，overFlow的返回点怎么计算，这个我想知道。

本函数局部变量         ebp          
68 78 78 78      80 FF 12 00           这些还能理解

但是这个是什么？
 ret_addr （*(a+2)就是这里）  
CB 10 40 00

剩下的就是16个0

调用函数局部变量
7ffd7000

#include <stdio.h>; 
void overFlow ()
{
  int a[] = { 0x78787868 };
  *(a + 2) += 7;--------------------> a+2 实际上已经是你overFlow()函数在mian函数中调用时的返回地址(a+1 是 保存的ebp)，所以你修改了函数的返回地址。  程序应该是不能正常返回的。结果可能会根据不同的编译器有所不同。 但是这样做事非常危险的，典型的栈溢出。 以前的shellcode就是这么搞，用来编写病毒等。 有兴趣的话可以研究研究。
}

int main ()
{
int aa = 3;
overFlow ();
  aa = 4;
printf ("%d\n", aa);
} 

同楼上的

调用函数局部变量 应该在 0012ff7c 即ebp-sizeof(int)的地方，为什么会是另一个呢

为什么要加7啊？

int main()

{

	int aa;

	aa=4;  //反汇编，查看此条指令的地址，再看return 0；的地址相减得到7

      //汇编指令依赖于不同的平台，产生的代码可能不大相同，这是最直观的方法

	return 0;



}

overflow 的返回点就是，汇编指令 call 的下一条汇编语句的地址。

引用 9 楼 thunderarch 的回复:

#include <stdio.h>; 
void overFlow () 
{ 
  int a[] = { 0x78787868 }; 
  *(a + 2) += 7;--------------------> a+2 实际上已经是你overFlow()函数在mian函数中调用时的返回地址(a+1 是 保存的ebp)，所以你修改了函数的返回地址。  程序应该是不能正常返回的。结果可能会根据不同的编译器有所不同。 但是这样做事非常危险的，典型的栈溢出。 以前的shellcode就是这么搞，用来编写病毒等。 有兴趣的话可以研究研究。 
} …

9楼的哥们，我是故意这么写的，就是需要知道怎么样用溢出覆盖，而改变返回值的！

还想知道为什么+7就能够跳过aa=4的执行而进入printf.
而且给overFlow加上一个参数后就会内存泄露，估计也是+7所导致的。很想知道是不是加上参数后就修改了执行代码在内存中的位置了，所以泄露了

这就是为什么要加7
13:     aa = 4;
004010C4   mov         dword ptr [ebp-4],4
14:    printf ("%d\n", aa);
004010CB   mov         eax,dword ptr [ebp-4]
004010CE   push        eax
004010CF   push        offset string "%d\n" (0042201c)
004010D4   call        printf (00401150)
004010D9   add         esp,8

004010C4+7=004010CB--------------开始执行printf

楼主喜欢这方面的知识，不妨买failwest写的0day安全那本书

专门写这方面的,有所有你想要的知识

根据上面的讨论。小结一下。

1.

  a[0]: 0x78787868

  a[1]: saved_esp

  a[2]: ret_addr -> address of 'aa = 4'

2.

  aa = 4 -> movl $4, %eax -> 5byte

所以，我觉得 *(a + 2) += 5;就好了。为什么要 ＋7 ??

哦 。有汇编代码了。

004010C4  mov        dword ptr [ebp-4],4 

这条指令 7 字节咯。

学习了

感谢上边的哥们们，

本函数局部变量*a         ebp（*(a+1)）       汇编返回地址(*(a+2))           
78787868             0x0012ff80             0x004010C4           +7= printf起始地址    


还有一个问题 ebp存贮的应该是堆栈指针，那么这个指针所指向的堆栈是存储什么的？

ebp 存储的是 帧指针。就是本函数的栈底。

同上楼 

搞懂了一些东西，谢谢各位了。

20楼 的哥们，谢谢了。

建议你看看函数栈的结构。

+7主要看你后面的aa = 4.占用几个字节。 

如果aa=4占9个字节，那么如果你想要跳过它，就需要加 9.

如果加的东西用问题，你的 代码就会崩溃。

你可以反汇编看看aa =4占用几个字节。(不同的指令占用的字节数是不同的。)

我是打酱油的。tangshuiling 才是正规军啊。应该谢谢他呀。^_^

那怎么样将返回位置定为启动command.com 这个shell呢？

看来要研究一下了

mark

引用 19 楼 newstudent_never 的回复:

感谢上边的哥们们， 

本函数局部变量*a        ebp（*(a+1)）      汇编返回地址(*(a+2))          
78787868            0x0012ff80            0x004010C4          +7= printf起始地址    


还有一个问题 ebp存贮的应该是堆栈指针，那么这个指针所指向的堆栈是存储什么的？ 

int a[] = { 0x78787868 }; 
*(a + 2) += 7;
在中间加一个局部变量。结果还是3，为什么呢？

debug一下，看内存就可以明白一切吧？！

结果是为3,我有事下次在做说明

好东西，学习了

引用 27 楼 tianya0609 的回复:

引用 19 楼 newstudent_never 的回复:
感谢上边的哥们们， 

本函数局部变量*a        ebp（*(a+1)）      汇编返回地址(*(a+2))          
78787868            0x0012ff80            0x004010C4          +7= printf起始地址    


还有一个问题 ebp存贮的应该是堆栈指针，那么这个指针所指向的堆栈是存储什么的？ 
 
int a[] = { 0x78787868 }; 
*(a + 2) += 7; 
在中间加一个局部变量。结果还是3，为什么呢？

直接在汇编的层次上跳过了一些执行语句

void overFlow()

{

	int a[] = { 0x78787868 };

	*(a + 2) += 7; //将main函数中的下一条指令地址+7,也就是跳过了aa = 4。为什么+7,看下面的分析.

}

.text:00401020 ; int __cdecl main(int argc, const char **argv, const char *envp)

.text:00401020 _main           proc near               ; CODE XREF: ___tmainCRTStartup+15Ap

.text:00401020

.text:00401020 var_4           = dword ptr -4

.text:00401020 argc            = dword ptr  8

.text:00401020 argv            = dword ptr  0Ch

.text:00401020 envp            = dword ptr  10h

.text:00401020

.text:00401020                 push    ebp

.text:00401021                 mov     ebp, esp

.text:00401023                 push    ecx

.text:00401024                 mov     [ebp+var_4], 3

.text:0040102B                 call    sub_401000      ; 调用overFlow ();

.text:00401030                 mov     [ebp+var_4], 4  ; aa = 4;这条指令占7个字节(00401037-00401030)

.text:00401037                 mov     eax, [ebp+var_4]

.text:0040103A                 push    eax

.text:0040103B                 push    offset unk_40C000

.text:00401040                 call    sub_40104E

.text:00401045                 add     esp, 8

.text:00401048                 xor     eax, eax

.text:0040104A                 mov     esp, ebp

.text:0040104C                 pop     ebp

.text:0040104D                 retn

.text:0040104D _main           endp

int a[] = { 0x78787868 }; 
*(a + 2) += 7; 
在中间加一个局部变量。结果还是3，为什么呢？ 
----------------------------------------
因为在中间加个局部变量也不影响*(a + 2)的指向，如果在int a[] = ... 上加变量的话,*(a + ?) += 7; 问号处就要修改了。