精华内容
下载资源
问答
  • 【转】C语言堆栈入门——堆和栈的区别
    2020-12-23 13:34:13

    数据结构的栈和堆

    首先在数据结构上要知道堆栈,尽管我们这么称呼它,但实际上堆栈是两种数据结构:堆和栈。堆和栈都是一种数据项按序排列的数据结构。

    栈就像装数据的桶或箱子

    我们先从大家比较熟悉的栈说起吧,它是一种具有后进先出性质的数据结构,也就是说后存放的先取,先存放的后取。这就如同我们要取出放在箱子里面底下的东西(放入的比较早的物体),我们首先要移开压在它上面的物体(放入的比较晚的物体)。

    堆像一棵倒过来的树

    而堆就不同了,堆是一种经过排序的树形数据结构,每个结点都有一个值。通常我们所说的堆的数据结构,是指二叉堆。堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆。由于堆的这个特性,常用来实现优先队列,堆的存取是随意,这就如同我们在图书馆的书架上取书,虽然书的摆放是有顺序的,但是我们想取任意一本时不必像栈一样,先取出前面所有的书,书架这种机制不同于箱子,我们可以直接取出我们想要的书。

    内存分配中的栈和堆

    一个由C/C++编译的程序占用的内存分为以下几个部分:

    1. 栈区(stack) ---由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。

    2.堆区(heap) ---一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。注意它与数据结构中的堆是两回事,分配方式类似于链表。

    3.全局区(静态区) ---全局变量和静态变量的存储时放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放。

    4.文字常量区 --- 常量字符串就是放在这里的。程序结束后由系统释放。

    5.程序代码区 --- 存放函数体的二进制。

    然而我要说的重点并不在这,我要说的堆和栈并不是数据结构的堆和栈,之所以要说数据结构的堆和栈是为了和后面我要说的堆区和栈区区别开来,请大家一定要注意。

    下面就说说C语言程序内存分配中的堆和栈,这里有必要把内存分配也提一下,大家不要嫌我啰嗦,一般情况下程序存放在Rom或Flash中,运行时需要拷到内存中执行,内存会分别存储不同的信息,如下图所示:

    堆:一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。注意它数据结构中的堆是两回事,分配方式是类似于链表。可能用到的关键字如下:new、malloc、delete、free等等。

    栈:由编译器Compiler自动分配释放,存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。

    内存中的栈区处于相对较高的地址以地址的增长方向为上的话,栈地址是向下增长的。

    栈中分配局部变量空间,堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量,全局变量空间的;只读区是分配常量和程序代码空间的;以及其他一些分区。

    来看一个网上很流行的经典例子:

    main.cpp

    int a = 0; 全局初始化区

    char *p1; 全局未初始化区

    main()

    {

    int b; 栈

    char s[] = "abc"; 栈

    char *p2; 栈

    char *p3 = "123456"; 123456\0在常量区,p3在栈上。

    static int c =0; 全局(静态)初始化区

    p1 = (char *)malloc(10);  堆

    p2 = (char *)malloc(20);  堆

    }

    0.申请方式和回收方式不同

    堆:需要程序员自己申请,并指明大小。在C中malloc函数如p1 = (char*)malloc(10);在C++中用new运算符,但是注意p1、p2本身是在栈中的。因为他们还是可以认为是局部变量。

    栈:由系统自动分配,例如,声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间。

    不知道你是否有点明白了,堆和栈的第一个区别就是申请方式不同:栈(英文名称是stack)是系统自动分配空间的,例如我们定义一个 char a;系统会自动在栈上为其开辟空间。而堆(英文名称是heap)则是程序员根据需要自己申请的空间,例如malloc(10);开辟十个字节的空间。由于栈上的空间是自动分配自动回收的,所以栈上的数据的生存周期只是在函数的运行过程中,运行后就释放掉,不可以再访问。而堆上的数据只要程序员不释放空间,就一直可以访问到,不过缺点是一旦忘记释放会造成内存泄露。还有其他的一些区别我认为网上的朋友总结的不错这里转述一下:

    1.申请后系统的响应

    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

    堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的 delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

    也就是说堆会在申请后还要做一些后续的工作这就会引出申请效率的问题。

    2.申请效率的比较

    根据第0点和第1点可知。

    栈:由系统自动分配,速度较快。但程序员是无法控制的。

    堆:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。

    3.申请大小的限制

    栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在 WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。

    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

    4.堆和栈中的存储内容

    由于栈的大小有限,所以用子函数还是有物理意义的,而不仅仅是逻辑意义。

    栈: 在函数调用时,第一个进栈的是主函数中函数调用后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。

    当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。

    堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    关于存储内容还可以参考这道题。这道题还涉及到局部变量的存活期。

    5.存取效率的比较

    堆:char *s1 = "Hello World"; 是在编译时就确定的;

    栈:  char s1[] = "Hello World";是在运行时赋值的;用数组比用指针速度要快一些,因为指针在底层汇编中需要用edx寄存器中转一下,而数组在栈上直接读取。

    char s1[] = "aaaaaaaaaaaaaaa";

    char *s2 = "bbbbbbbbbbbbbbbbb";

    aaaaaaaaaaa是在运行时刻赋值的;放在栈中。

    而bbbbbbbbbbb是在编译时就确定的;放在堆中。

    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。

    比如:

    #include

    void main()

    {

    char a = 1;

    char c[] = "1234567890";

    char *p ="1234567890";

    a = c[1];

    a = p[1];

    return;

    }

    对应的汇编代码

    10: a = c[1];

    00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

    0040106A 88 4D FC mov byte ptr [ebp-4],cl

    11: a = p[1];

    0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

    00401070 8A 42 01 mov al,byte ptr [edx+1]

    00401073 88 45 FC mov byte ptr [ebp-4],al

    第一种在读取时直接就把字符串的元素读到寄存器cl中,而第二种则要先把指针读到edx中,在根据edx读取字符,显然慢了。

    关于堆和栈区别的比喻

    堆和栈的区别可以引用一位前辈的比喻来看出:

    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。

    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。比喻很形象,说的很通俗易懂,不知道你是否有点收获。

    Windows进程中的内存结构

    接触过编程的人都知道,高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢?程序又是如何使用这些变量的呢?下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明,默认都使用VC编译的release版。

    首先,来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local),静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码:

    #include 

    int g1=0, g2=0, g3=0;

    int main()

    {

    static int s1=0, s2=0, s3=0;

    int v1=0, v2=0, v3=0;

    //打印出各个变量的内存地址

    printf("0x%08x/n",&v1); //打印各本地变量的内存地址

    printf("0x%08x/n",&v2);

    printf("0x%08x/n/n",&v3);

    printf("0x%08x/n",&g1); //打印各全局变量的内存地址

    printf("0x%08x/n",&g2);

    printf("0x%08x/n/n",&g3);

    printf("0x%08x/n",&s1); //打印各静态变量的内存地址

    printf("0x%08x/n",&s2);

    printf("0x%08x/n/n",&s3);

    return 0;

    }

    编译后的执行结果是:

    0x0012ff78

    0x0012ff7c

    0x0012ff80

    0x004068d0

    0x004068d4

    0x004068d8

    0x004068dc

    0x004068e0

    0x004068e4

    输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量,g1,g2,g3是全局变量,s1,s2,s3是静态变量。你可以看到这些变量在内存是连续分布的,但是本地变量和全局变量分配的内存地址差了十万八千里,而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的结果。对于一个进程的内存空间而言,可以在逻辑上分成3个部份:代码区,静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区,栈是一种线性结构,堆是一种链式结构。进程的每个线程都有私有的“栈”,所以每个线程虽然代码一样,但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区,本地变量分配在动态数据区,即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。

    ├———————┤低端内存区域

    │ …… │

    ├———————┤

    │ 动态数据区 │

    ├———————┤

    │ …… │

    ├———————┤

    │ 代码区 │

    ├———————┤

    │ 静态数据区 │

    ├———————┤

    │ …… │

    ├———————┤高端内存区域

    堆栈是一个先进后出的数据结构,栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程,以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定,这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的,前者由被调函数调整堆栈,后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码:

    #include 

    void __stdcall func(int param1,int param2,int param3)

    {

    int var1=param1;

    int var2=param2;

    int var3=param3;

    printf("0x%08x/n",&param1); //打印出各个变量的内存地址

    printf("0x%08x/n",&param2);

    printf("0x%08x/n/n",&param3);

    printf("0x%08x/n",&var1);

    printf("0x%08x/n",&var2);

    printf("0x%08x/n/n",&var3);

    return;

    }

    int main()

    {

    func(1,2,3);

    return 0;

    }

    编译后的执行结果:

    0x0012ff78

    0x0012ff7c

    0x0012ff80

    0x0012ff68

    0x0012ff6c

    0x0012ff70

    ├———————┤

    │ …… │

    ├———————┤

    │ var 1 │

    ├———————┤

    │ var 2 │

    ├———————┤

    │ var 3 │

    ├———————┤

    │ RET │

    ├———————┤

    │ parameter 1 │

    ├———————┤

    │ parameter 2 │

    ├———————┤

    │ parameter 3 │

    ├———————┤

    │ …… │

    ├———————┤

    上图就是函数调用过程中堆栈的样子了。首先,三个参数以从右到左的次序压入堆栈,先压“param3”,再压“param2”,最后压入“param1”;然后压入函数的返回地址(RET),接着跳转到函数地址接着执行(这里要补充一点,介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后,继续压入当前EBP,然后用当前ESP代替EBP。然而,有一篇介绍windows下函数调用的文章中说,在windows下的函数调用也有这一步骤,但根据我的实际调试,并未发现这一步,这还可以从param3和var1之间只有4字节的间隙这点看出来);第三步,将栈顶(ESP)减去一个数,为本地变量分配内存空间,上例中是减去12字节(ESP=ESP-3*4,每个int变量占用4个字节);接着就初始化本地变量的内存空间。由于“__stdcall”调用由被调函数调整堆栈,所以在函数返回前要恢复堆栈,先回收本地变量占用的内存(ESP=ESP+3*4),然后取出返回地址,填入EIP寄存器,回收先前压入参数占用的内存(ESP=ESP+3*4),继续执行调用者的代码。参见下列汇编代码:

    ;--------------func 函数的汇编代码-------------------

    :00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间

    :00401003 8B442410 mov eax, dword ptr [esp+10]

    :00401007 8B4C2414 mov ecx, dword ptr [esp+14]

    :0040100B 8B542418 mov edx, dword ptr [esp+18]

    :0040100F 89442400 mov dword ptr [esp], eax

    :00401013 8D442410 lea eax, dword ptr [esp+10]

    :00401017 894C2404 mov dword ptr [esp+04], ecx

    ……………………(省略若干代码)

    :00401075 83C43C add esp, 0000003C ;恢复堆栈,回收本地变量的内存空间

    :00401078 C3 ret 000C ;函数返回,恢复参数占用的内存空间

    ;如果是“__cdecl”的话,这里是“ret”,堆栈将由调用者恢复

    ;-------------------函数结束-------------------------

    ;--------------主程序调用func函数的代码--------------

    :00401080 6A03 push 00000003 //压入参数param3

    :00401082 6A02 push 00000002 //压入参数param2

    :00401084 6A01 push 00000001 //压入参数param1

    :00401086 E875FFFFFF call 00401000 //调用func函数

    ;如果是“__cdecl”的话,将在这里恢复堆栈,“add esp, 0000000C”

    聪明的读者看到这里,差不多就明白缓冲溢出的原理了。先来看下面的代码:

    #include 

    #include 

    void __stdcall func()

    {

    char lpBuff[8]="/0";

    strcat(lpBuff,"AAAAAAAAAAA");

    return;

    }

    int main()

    {

    func();

    return 0;

    }

    编译后执行一下回怎么样?哈,“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”,“非法操作”喽!"41"就是"A"的16进制的ASCII码了,那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节,算进结尾的/0,那strcat最多只能写入7个"A",但程序实际写入了11个"A"外加1个/0。再来看看上面那幅图,多出来的4个字节正好覆盖了RET的所在的内存空间,导致函数返回到一个错误的内存地址,执行了错误的指令。如果能精心构造这个字符串,使它分成三部分,前一部份仅仅是填充的无意义数据以达到溢出的目的,接着是一个覆盖RET的数据,紧接着是一段shellcode,那只要着个RET地址能指向这段shellcode的第一个指令,那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置,那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令,使得exploit有更强的通用性。

    ├———————┤

    │ …… │

    ├———————┤

    │ │

    │ buffer │

    │ │

    ├———————┤

    │ RET │

    ├———————┤

    │ NOP │

    │ …… │

    │ NOP │

    ├———————┤

    │ │

    │ shellcode │

    │ │

    ├———————┤

    │ …… │

    ├———————┤

    windows下的动态数据除了可存放在栈中,还可以存放在堆中。了解C++的朋友都知道,C++可以使用new关键字来动态分配内存。来看下面的C++代码:

    #include 

    #include 

    #include 

    void func()

    {

    char *buffer=new char[128];

    char bufflocal[128];

    static char buffstatic[128];

    printf("0x%08x/n",buffer); //打印堆中变量的内存地址

    printf("0x%08x/n",bufflocal); //打印本地变量的内存地址

    printf("0x%08x/n",buffstatic); //打印静态变量的内存地址

    }

    void main()

    {

    func();

    return;

    }

    程序执行结果为:

    0x004107d0

    0x0012ff04

    0x004068c0

    可以发现用new关键字分配的内存即不在栈中,也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前,先来了解一下和“堆”有关的几个API函数:

    HeapAlloc 在堆中申请内存空间

    HeapCreate 创建一个新的堆对象

    HeapDestroy 销毁一个堆对象

    HeapFree 释放申请的内存

    HeapWalk 枚举堆对象的所有内存块

    GetProcessHeap 取得进程的默认堆对象

    GetProcessHeaps 取得进程所有的堆对象

    LocalAlloc

    GlobalAlloc

    当进程初始化时,系统会自动为进程创建一个默认堆,这个堆默认所占内存的大小为1M。堆对象由系统进行管理,它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间:

    HANDLE hHeap=GetProcessHeap();

    char *buff=HeapAlloc(hHeap,0,8);

    其中hHeap是堆对象的句柄,buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢?它的值有什么意义吗?看看下面这段代码吧:

    #pragma comment(linker,"/entry:main") //定义程序的入口

    #include

    _CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf

    /*---------------------------------------------------------------------------

    写到这里,我们顺便来复习一下前面所讲的知识:

    (*注)printf函数是C语言的标准函数库中函数,VC的标准函数库由msvcrt.dll模块实现。

    由函数定义可见,printf的参数个数是可变的,函数内部无法预先知道调用者压入的参数个数,函数只能通过分析第一个参数字符串的格式来获得压入参数的信息,由于这里参数的个数是动态的,所以必须由调用者来平衡堆栈,这里便使用了__cdecl调用规则。BTW,Windows系统的API函数基本上是__stdcall调用形式,只有一个API例外,那就是wsprintf,它使用__cdecl调用规则,同printf函数一样,这是由于它的参数个数是可变的缘故。

    ---------------------------------------------------------------------------*/

    void main()

    {

    HANDLE hHeap=GetProcessHeap();

    char *buff=HeapAlloc(hHeap,0,0x10);

    char *buff2=HeapAlloc(hHeap,0,0x10);

    HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");

    printf=(void *)GetProcAddress(hMsvcrt,"printf");

    printf("0x%08x/n",hHeap);

    printf("0x%08x/n",buff);

    printf("0x%08x/n/n",buff2);

    }

    执行结果为:

    0x00130000

    0x00133100

    0x00133118

    hHeap的值怎么和那个buff的值那么接近呢?其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构,这个结构中存放着一些有关进程的重要信息,其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址,而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据,如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的,同一时刻只能有一个线程访问堆中的数据,当多个线程同时有访问要求时,只能排队等待,这样便造成程序执行效率下降。

    最后来说说内存中的数据对齐。所谓数据对齐,是指数据所在的内存地址必须是该数据长度的整数倍,DWORD数据的内存起始地址能被4除尽,WORD数据的内存起始地址能被2除尽,x86 CPU能直接访问对齐的数据,当他试图访问一个未对齐的数据时,会在内部进行一系列的调整,这些调整对于程序来说是透明的,但是会降低运行速度,所以编译器在编译程序时会尽量保证数据对齐。同样一段代码,我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果:

    #include 

    int main()

    {

    int a;

    char b;

    int c;

    printf("0x%08x/n",&a);

    printf("0x%08x/n",&b);

    printf("0x%08x/n",&c);

    return 0;

    }

    这是用VC编译后的执行结果:

    0x0012ff7c

    0x0012ff7b

    0x0012ff80

    变量在内存中的顺序:b(1字节)-a(4字节)-c(4字节)。

    这是用Dev-C++编译后的执行结果:

    0x0022ff7c

    0x0022ff7b

    0x0022ff74

    变量在内存中的顺序:c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。

    这是用lcc编译后的执行结果:

    0x0012ff6c

    0x0012ff6b

    0x0012ff64

    变量在内存中的顺序:同上。

    三个编译器都做到了数据对齐,但是后两个编译器显然没VC“聪明”,让一个char占了4字节,浪费内存哦。

    基础知识:

    堆栈是一种简单的数据结构,是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶,另一端称为栈底,对堆栈的插入和删除操作被称为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中,POP指令实现出栈操作,PUSH指令实现入栈操作。CPU的ESP寄存器存放当前线程的栈顶指针,EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址,当CPU执行完当前的指令后,从EIP寄存器中读取下一条指令的内存地址,然后继续执行。

    from:https://blog.csdn.net/changexhao/article/details/80708213

    更多相关内容
  • 1.png我们常常说堆栈堆栈,但是堆和栈其实是完全不同的两个概念。栈其实完全是为了函数调用而设计的,那么函数调用如何通过栈实现的呢?不用函数调用方式,栈在行为上有什么区别呢?笔者曾经去京东面试一个高级开发...

    前方高能预警,本文较长,涉及到的原理性东西较多,建议收藏方便后期查看。

    ffe303d96dbd

    1.png

    我们常常说堆栈堆栈,但是堆和栈其实是完全不同的两个概念。栈其实完全是为了函数调用而设计的,那么函数调用如何通过栈实现的呢?不用函数调用方式,栈在行为上有什么区别呢?笔者曾经去京东面试一个高级开发职位,面试官写了一个从1累加到100的C程序,让笔者写出对应的汇编代码,如果你熟悉栈的原理,其实这个题目就并不难,相反,函数通过栈如何实现的,这确实是我们广大开发者必须掌握的基础知识之一,因为也是面试中用于考察一个开发者基础水平的一个常见题型。

    好了,那什么是栈呢?下面是正文:

    系统栈的工作原理:

    1、内存的不同用途:

    如果您关注网络安全问题,那么一定听过缓冲区溢出这个术语。简单说来:缓冲区溢出就是在大缓冲区中的数据向小缓冲区复制的过程中,由于没有注意小缓冲区的边界,“撑爆”了较小的缓冲区,从而冲掉了和小缓冲区相邻内存区域的其他数据而引起的内存问题。缓冲溢出是最常见的内存错误之一,也是攻击者入侵系统时所用到的最强大、最经典的一类漏洞利用方式。

    成功地利用缓冲区溢出漏洞可以修改内存中变量的值,甚至可以劫持进程,执行恶意代码,最终获得主机的控制权。要透彻地理解这种攻击方式,我们需要回顾一些计算机体系架构方面的基础知识,搞淸楚CPU、寄存器、内存是怎样协同工作而让程序流畅执行的。

    根据不同的操作系统,一个进程可能被分配到不同的内存区域去执行。但是不管什么样的操作系统、什么样的计算机架构,进程使用的内存都可以按照功能大致分成以下4个部分。

    (1)代码区:这个区域存储着被装入执行的二进制机器代码,处理器会到这个区域取指令并执行。

    (2)数据区:用于存储全局变量等。

    (3)堆区:进程可以在堆区动态地请求一定大小的内存,并在用完之后归还给堆区。动态分配内存和回收内存是堆区的特点。

    (4)栈区:用于动态地存储函数之间的调用关系,以保证被调用函数在返回时恢复到母函数中继续执行。

    题外话:这种简单的内存划分方式是为了让您能够更容易地理解程序的运行机制入理解计算机系统》一书中有更详细的关于内存使用的论述,如有兴趣可参考之。

    在Windows平台下,高级语言写出的程序经过编译链接,最终会变成所谓的PE文件。当PE文件被装载运行后,就成了所谓的进程。

    PE文件代码段中包含的二进制级别的机器代码会被装入内存的代码区(.text),处理器将到内存的这个区域一条一条地取出指令和操作数,并送入算术逻辑单元进行运算;如果代码中请求开辟动态内存,则会在内存的堆区分配一块大小合适的区域返回给代码区的代码使用;当函数调用发生时,函数的调用关系等信息会动态地保存在内存的栈区,以供处理器在执行完被调用函数的代码时,返冋母函数。这个协作过程如图2.1.1所示。

    ffe303d96dbd

    2.1.1.png

    如果把计算机看成一个有条不紊的1:厂,我们可以得到如下类比。

    CPU是完成工作的工人。

    数据区、堆区、栈区等则是用来存放原料、半成品、成品等各种东西的场所。

    存在代码区的指令则告诉CPU要做什么,怎么做,到哪里去领原材料,用什么工具来做,做完以后把成品放到哪个货舱去。

    值得一提的是,栈除了扮演存放原料、半成品的仓库之外,它还是车间调度主任的办公室。

    程序中所使用的缓冲区可以是堆区、栈区和存放静态变景的数据区。缓冲区溢出的利用方法和缓冲区到底属于上面哪个内存区域密不可分。

    2、栈与系统栈:

    从计算机科学的角度来看,栈指的是一种数据结构,是一种先进后出的数据表。栈的最常见操作有两种:压栈(PUSH)、弹栈(POP):用于标识栈的属性也有两个:栈顶(TOP)、栈底(BASE)。

    可以把栈想象成一摞扑克牌。

    PUSH:为栈增加一个元素的操作叫做PUSH,相当于在这摞扑克牌的最上面再放上—张。

    POP:从栈中取出一个元素的操作叫做POP,相当于从这摞扑克牌取出最上面的一张。

    TOP:标识栈顶位置,并且是动态变化的。每做一次PUSH操作,它都会自增1;相反,每做一次POP操作,它会自减1。栈顶元素相当于扑克牌最上面一张,只有这张牌的花色是当前可以看到的。

    BASE:标识栈底位置,它记录着扑克牌最下面一张的位置。BASE用于防止栈空后继续弹栈(牌发完时就不能再去揭牌了)。很明显,一般情况下,BASE是不会变动的。

    内存的栈区实际上指的就是系统栈。系统栈由系统自动维护,它用于实现高级语言中函数的调用。对于类似C语言这样的高级语言,系统栈的PUSH、POP等堆栈平衡细节是透明的。

    —般说来,只有在使用汇编语言开发程序的时候,才需要和它直接打交道。

    好,下面重点部分来了。

    3、函数调用时发生了什么?

    我们下面就来探究一下高级语言中函数的调用和递归等性质是怎样通过系统栈巧妙实现的。请看如下代码:

    int func_B(int arg_B1, int arg_B2)

    {

    int var_B1;

    int var_B2;

    var_B1 = arg_B1 + arg_B2;

    var_B2 = arg_B1 - arg_B2;

    return var_B1 * var_B2;

    }

    int func_A(int arg_A1, int arg_A2)

    {

    int var_A;

    var_A = func_B(arg_A1, arg_A2) + arg_A1;

    return var_A;

    }

    int main(int argc, char** argv, char** envp)

    {

    int var_main;

    var_main = func_A(3, 4);

    return 0;

    }

    这段代码经过编译器编译后,各个函数对应的机器指令在代码区中可能是这样分布的,如图2.1.2所示:

    ffe303d96dbd

    2.1.2.png

    根据操作系统的不问、编译器和编译选项的不同,同一文件不同函数的代码在内存代码区中的分布可能相邻,也可能相离甚远,可能先后有序,也可能无序;但它们都在同一个PE文件的代码所映射的一个“节”里。我们可以简单地把它们在内存代码区中的分布位置理解成是散乱无关的。

    当CPU在执行调用func_A函数的时候,会从代码区中main函数对应的机器指令的区域跳转到func_A函数对应的机器指令区域,在那里取指并执行;当函数执行完闭,需要返会的时候,又会跳回到main函数对应的指令区域,紧接着调用func_A后面的指令继续执行main函数的代码。在这个过程中,CPU的取指轨迹如图2.1.3所示。

    ffe303d96dbd

    2.1.3.png那么CPU是怎么知道要去func_A的代码区取指,在执行完func_A后又是怎么知道跳回到main函数(而不是func_B的代码区)的呢?这些跳转地址我们在C语言中并没有直接说明,CPU是从哪里获得这些函数的调用及返回的信息的呢?

    原来,这些代码区中精确的跳转都是在与系统栈巧妙地配台过程中完成的。当函数被调用时,系统栈会为这个函数开辟一个新的栈帧,并把它压入栈中。这个栈帧中的内存空间被它所属的函数独占,正常情况下是不会和别的函数共享的。当函数返回时,系统栈会弹出该函数所对应的栈帧。

    如图2.1.4所示,在函数调用的过程中,伴随的系统栈中的操作如下。

    ffe303d96dbd

    2.1.4.png

    在main函数中调用func_A的时候,首先在自己的栈帧中压入函数返回地址,然后为func_A创建新栈帧并压入系统栈。

    在func__A调用func_B的时候,同样先在自己的栈帧中压入函数返回地址,然后为func_B创建新栈帧并压入系统栈。

    在func_B返回时,func_B的栈帧被弹出系统栈,func_A栈帧中的返回地址被“露”在栈顶,此时处理器按照这个返回地址重新跳到func_A代码区中执行。

    在func_A返同时,func_A的栈帧被弹出系统栈.macn函数栈帧中的返回地址被“露” 在栈顶,此时处理器按照这个返回地址跳到main函数代码区中执行。

    4、寄存器与函数栈帧

    每一个函数独占自己的栈帧空间。当前正在运行的函数的栈帧总是在栈顶。CPU系统提供两个特殊的寄存器用于标识位于系统栈顶端的栈帧。

    (1) ESP:栈指针寄存器(extended stack pointer),其内存放着一个指针,该指针永远指向系统栈地上面-个栈帧的栈顶。

    (2) EBP:基址指针寄存器(extended base pointer)-其内存放着一个指针,该指针永远指向系统栈展上面一个栈帧的底部。

    注意:EBP指向当前位于系统栈最上边一个栈帧的底部,而不是系统栈的底部。严格说来,“栈帧底部”和“栈底”是不同的概念,本文在叙述中将坚特使用“栈帧底部”这一提法以示区别;ESP所指的栈帧顶部和系统栈的顶部是同一个位置,所以后面叙述中并不严格区分“栈帧顶部”和“栈顶”的概念。请您注意这里的差异,不要产生概念混淆。

    寄存器对栈帧的标识作用如图2.1.5所示

    ffe303d96dbd

    2.1.5.png函数栈帧:ESP和EBP之间的内存空间为当前栈帧.EBP标识了当前栈帧的底部.ESP标识了当前栈帧的顶部。

    在函数栈帧中,一般包含以下几类重要信息。

    (1) 局部变量:为函数局部变量开辟的内存空间。

    (2)栈帧状态值:保存前栈帧的顶部和底部(实际上只保存前栈帧的底部,前栈帧的顶部可以通过堆栈平衡计算得到),用于在本帧被弹出后恢复出上一个栈帧。

    (3) 函数返回地址:保存当前函数调用前的“断点”信息,也就是函数调用前的指令位置,以便在函数返回时能够恢复到函数被调用前的代码区中继续执行指令。

    除了与栈相关的寄存器外,您还需要记住另一个至关重要的寄存器。

    EIP:指令寄存器(Extended Instruction Pointer),其内存放着一个指针,该指针永远指向下一条等待执行的指令地址,可以说如果控制了EIP寄存器的内容,就控制了进程——我们让EIP指向哪里,CPU就会去执行哪里的指令。

    5、函数调用约定与相关指令

    函数调用约定描述了函数传递参数方式和栈协同工作的技术细节。不同的操作系统、不同的语言、不同的编译器在实现函数调用时的原理虽然基本相同,但具体的调用约定还是有差别的。这包括参数传递方式,参数入栈顺序是从右向左还是从左向古,函数返回时恢复堆栈平衡的操作在子函数中进行还是在母函数中进行。表2-1-1列出了几种调用方式之间的差异。

    ffe303d96dbd

    表2-1-1.png

    具体的,对于Visual C++来说,可支持以下3中函数调用约定,如表2-1-2所示

    ffe303d96dbd

    表2-1-2.png如果要明确使用某一种调用约定,只需要在函数前加上调用约定的声明即可,否则默认情况下会使用__cdecl的调用方式。

    除了上边的参数入栈方向和恢复栈平衡操作位置的不同之外,参数传递有时也会有所不同。例如,每一个c++类成员函数都有一个this指针,在Wndows平台中,这个指针一般是用ECX寄存器来传递的,但如果用GCC编译器编译,这个指针会作为最后一个参数压入栈中。注意:同一段代码用不同的编译选项、不同的编译器编译链接后,得到的可执行文件会有很多不同。

    函数调用大致包括以下几个步骤.

    (1) 参数入栈:将参数从右向左依次压入系统栈中。

    (2)返回地址入栈:将当前代码区调用指令的下一条指令地址压入栈中,供函数返回时继续执行。

    (3) 代码区跳转:处理器从当前代码区跳转到被调用函数的入口处。

    (4)栈帧调整:具体包括。

    保存当前栈帧状态值,已备后面恢复本栈帧时使用(EBP入栈):

    将当前栈帧切换到新栈帧(将ESP值装入EBP.更新栈帧底部):

    给新栈帧分配空间(把ESP减去所需空间的大小,抬高栈顶):

    对于__stdcall调用约定,函数调用时用到的指令序列大致如下。

    ffe303d96dbd

    2.1.6.png上面这段用于函数调用的指令在栈中引起的变化如图2.1.7所示。

    ffe303d96dbd

    2.1.7.png

    ffe303d96dbd

    题外话.png类似地,函数返回的步骤如下:

    (1) 保存返回值:通常将函数的返回值保存在寄存器EAX中。

    (2) 弹出当前栈帧,恢复上一个栈帧。

    具体包括:

    在堆栈平衡的基础上,给ESP加上栈帧的大小,降低栈顶,回收当前栈帧的空间。

    将当前栈帧底部保存的前栈帧EBP值弹入EBP寄存器,恢复出上一个栈帧。

    将函数返回地址弹给EIP寄存器。

    (3) 跳转:按照函数返回地址跳同母函数中继续执行。

    还是以C语言和Win32平台为例,函数返回时的相关的指令序列如下。

    add esp, xxx ;降低栈顶,回收当前的栈帧

    pop ebp ;将上一个栈帧底部位置恢复至ebp.

    retn ;这条指令有两个功能:

    a)弹出当前栈顶元素,即弹出栈帧中的返回地址。栈帧恢复工作完成。

    b)让处理器跳转到弹出的返回地址,恢复调用前的代码区。

    按照这样的函数调用约定组织起来的系统栈结构如图2.1.8所示:

    ffe303d96dbd

    2.1.8.png

    展开全文
  • C语言堆栈的实现

    2021-10-09 16:27:41
    插入数据:入栈(Push) 删除数据:出栈(Pop) 后入先出规则 堆栈的抽象数据类型描述: 类型名称:堆栈 数据对象集:一个有0个或多个元素的有穷线性表。 操作集:长度为MAXSIZE的堆栈S含与Stack,堆栈元素...

    什么是堆栈:堆栈是具有一定操作约束的线性表,只在一端(栈顶,Top)做插入、删除

            插入数据:入栈(Push)

            删除数据:出栈(Pop)

            后入先出规则

    堆栈的抽象数据类型描述:

    类型名称:堆栈

    数据对象集:一个有0个或多个元素的有穷线性表。

    操作集:长度为MAXSIZE的堆栈S含与Stack,堆栈元素item含与ElementType

    1、Stack CreateStack(int MaxSize):生成空堆栈,其最大长度为MaxSize;

    2、int IsFull(Stack S,int MaxSize) : 判断堆栈S是否已经满了;

    3、void Push(Stack S,ElementType item):将元素item压入栈内;

    4、int IsEmpty(Stack S):判断堆栈S是否为空;

    5、ElementType Pop(Stack S);删除并返回栈顶元素;

            栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成 

    数组实现操作实现如下:

    1、创建结构体

    #define MAXSIZE  ....  //存储元素的最大个数
    typedef struct SNode *Stack;
    struct SNode{
        ElementType Data[MaxSize];
        int Top;
    };

    2、入栈

    void Push(Stack PtrS,ElmentType item)
    {
        if(PtrS->Top == MAXSIZE-1){
            printf("堆栈满");
            return;
        }else {
            PtrS->Data[++(PtrS->Top)] = item;
            return;
            }
    }

    2、出栈

    ElementType Pop(Stack PtrS)
    {
        if(PtrS->Top == -1){
            printf("堆栈空");
            return ERROR;      //ERROR是ElementType的特殊值,标志错误
        }else
            return (ptrS->Data[(PtrS->Top)--]);
    )

            用一个数组实现两个堆栈时,使这两个栈分别从数组的两头开始向中间生长;当两个栈顶指针相遇时,表示两个栈都满了,这样可以最大地利用数组空间。使宿主只要有空间入栈操作就可以成功。

    1、创建结构体

    #define MAXSIZE ...
    struct DStack
    {
        ElementType Data[MAXSIZE];
        int Top1;       //堆栈1的栈顶指针
        int Top2;       //堆栈2的栈顶指针
    }S;
    S.Top1 = -1;
    S.Top2 = MAXSIZE;

    2、堆栈

    void Push(struct DStack *PtrS,ElementType item , int Tag)
    {
        if(PtrS->Top2 - PtrS->Top1 == 1){
            printf("堆栈满");
            return;
        }
        if(Tag == 1){
            PtrS->Data[++(PtrS->Top1)] = item;
        else
            PtrS->Data[++(PtrS->Top2)] = item;
    }

    3、出栈

    ElementType Pop(struct DStack *PtrS,int Tag)
    {
        if(Tag == 1){
            if(PtrS->Top1 == -1){
                printf("堆栈1空");
                return NULL;
            }else return PtrS->Data[(PtrS->Top1)--];
        else {
            if(PtrS->Top2 == MAXSIZE){
                printf("堆栈1空");
                return NULL;
            }else return PtrS->Data[(Ptrs->Top2)++];
        }
    }

            堆栈链式存储实现:栈的链式存储结构实际上就是一个单链表,叫做链栈。插入和删除操作只能在链表的栈顶进行。

    1、创建链表

    typedef struct SNode *Stack;
    strcut SNode{
        ElementType Data;
        struct SNode *Next;
    };

    2、堆栈初始化

    Stack CreateStack()
    {
        Stack S;
        S = (Stack)malloc(sizeof(struct SNode));
        s->Next = NULL;
        return S;
    }

    3、判断堆栈S是否为空

    int IsEmpty(Stack S)
    {
        return (S->Next == NULL);//若堆栈S为空则还回1,否则返回0
    }

    4、入栈

    void Push(ElementType item,Stack S)
    {
        struct SNode *TmpCell;
        TmpCell = (struct SNode *)malloc(sizeof(struct SNode));
        TmpCell->Element = item;
        TmpCell->Next = S->Next;
        S->Next = TmpCell;
    } 

    5、出栈

    ElementType Pop(Stack S)
    {
        struct SNode *FirstCell;
        ElementType TopElem;
        if(IsEmpty(S)) {
            printf("堆栈空");
            return NULL;
        } else {
            FirstCell = S->Next;
            S->Next = FirstCell->Next;
            TopElem = FirstCell->Element;
            free(FirstCell);
            return TopElem;
        }
    }
    

    堆栈应用:表达式求值

            应用堆栈实现后缀表达式求值的基本过程:从左到右读入后缀表达式的各项(运算符或运算数)

            1、运算数:入栈;

            2、运算符:从堆栈中弹出适当数量的运算数,计算并结果入栈;

            3、最后,堆栈顶上的元素就是表达式的结果值。

     中缀表达式求值:

            基本策略:将中缀表达式转换为后缀表达式,然后求值

    展开全文
  • 近日聆听了在科锐钱老师上C语言时所讲的函数调用约定,于是将课后笔记整理成此处男贴.虽力求完美,但难免因本人的学识浅薄而存在不足之处,望大神们批评指正...--题记1 函数调用流程函数调用大家都不陌生,调用者向被调...

    近日聆听了在科锐钱老师上C语言时所讲的函数调用约定,于是将课后笔记整理成此处男贴.虽力求完美,但难免因本人的学识浅薄而存在不足之处,望大神们批评指正...

    --题记

    1 函数调用流程

    函数调用大家都不陌生,调用者向被调者传递一些参数,然后执行被调者的函数体代码,最后被调者向调用者返回结果.还有一句话是大家比较熟悉的,就是函数调用是在栈上发生的,那么C语言中的函数调用是如何实现的呢,下面我们一起分析分析...

    1.1 C语言中函数参数的入栈顺序

    为了能有个感官的认识,我们先通过一个小程序看看.

    /*

    *Copyright (c)2015,

    *All rights reserved.

    *文件名称:PushOrder.c

    *作 者:韩逸

    *完成日期:20161020

    *版 本 号:Debug

    *编译环境:Visual Studio 2012

    *问题描述:C语言函数参数入栈的顺序

    */

    #include

    int Fun(int nNumA,int nNumB,int nNumC);

    int main(int argc,char* argv[])

    {

    Fun(100,200,300);

    return 0;

    }

    int Fun(int nNumA,int nNumB,int nNumC)

    {

    printf("nNumA = %d at [0x%p]\r\n",nNumA,&nNumA);

    printf("nNumB = %d at [0x%p]\r\n",nNumB,&nNumB);

    printf("nNumC = %d at [0x%p]\r\n",nNumC,&nNumC);

    return 0;

    }

    运行结果

    nNumA = 100 at [0x010FFDF0]

    nNumB = 200 at [0x010FFDF4]

    nNumC = 300 at [0x010FFDF8]

    总结:

    C语言中栈底为高地址,栈顶为低地址,因此可知上述例子函数入栈顺序是从右往左.通过钱老师的讲解以及百度所查到的文献,参数的入栈顺序是和编译器的调用约定相关的.比如,Pascal语言中参数就是从左往右入栈,而有些语言还可以定义修饰符进行置顶的传参顺序,如VC++就可以两种方式传参,那么C语言为什么要从右往左传参呢?

    进一步发现Pascal语言不支持可变长参数,而C语言支持这种特色,正是因为这个原因使得C语言函数参数入栈顺序是从右往左,具体原因是C方式参数入栈顺序(从右往左)的好处是可以动态变化参数的个数,通过堆栈分析可知,最前面的参数被压在栈底,除非知道参数个数,否则无法通过栈指针的相对位移得到最左边的参数.这样左边的参数就不确定,正好和动态参数的个数方向相反.

    显然,C语言函数参数采用自右向左的入栈顺序,主要原因是为了支持可变长参的形式.换句话说,如果C语言不支持这种特色,那么C语言完全和Pascal一样,采用自左向右的参数入栈.

    1.2 函数调用约定

    C语言中常用的调用方式有: __Cdecl , __Stdcall , __Fastcall

    (VC编译器默认函数调用方式是__Cdecl,Windows API使用的是__Stdcall调用方式)

    1.2.1 如何设置调用约定

    本人所选的编译环境为Visual Studio 2012.有两种方法选择调用约定.

    1.右键项目属性->配置属性->C/C++->所有选项->调用约定

    2.在定义函数名的时候规定调用约定

    int __cdecl Fun(int nNumA,int nNumB,int nNumC)

    {

    printf("nNumA = %d at [0x%p]\r\n",nNumA,&nNumA);

    printf("nNumB = %d at [0x%p]\r\n",nNumB,&nNumB);

    printf("nNumC = %d at [0x%p]\r\n",nNumC,&nNumC);

    return 0;

    }

    或许您会奇怪为什么我们平时写代码的时候一般不写函数调用方式,因为VC++中C/C++缺省调用方式就是__cdecl函数约定,所以即使我们不写,编译器也会默认帮我们选择__cdecl调用方式.

    1.2.2 调用方式详解

    下面咱聊聊3种调用方式,分别分别是__Cdecl,__Stdcall,__Fastcall.

    __Cdecl:

    (1)压栈顺序:函数参数从右往左传递到栈顶

    (2)返回值:返回值在寄存器

    (3)参数空间谁释放:由调用方把参数弹出栈,调用方负责释放参数空间

    备注:正因为如此,实现可变参数(如Printf)只能使用该调用约定

    __Stdcall:

    (1)压栈顺序:函数参数从右往左传递到栈顶

    (2)返回值:返回值在寄存器

    (3)参数空间谁释放:被调方负责释放参数空间(在退出时情况堆栈)

    __Fastcall:

    (1)压栈顺序:用ECX和EDX寄存器传送前两个双字(DWORD)或更小的参数,剩下的参数仍旧

    从右往左传递

    (2)返回值:返回值在寄存器

    (3)参数空间谁释放:被调方负责释放参数空间

    (PS:如果返回值过大,寄存器放不下放栈顶)

    2.函数的运行原理

    很认真的灌水了一大篇,现在咱结合示例代码看看函数如何入栈与出栈吧.

    当函数被调用时,指令指针的地制值增加1,使其指向函数调用后的下一条指令.该地址随后被放入栈中,作为函数返回时的返回地址.

    ( 程序中的所有代码都保存在程序代码区中,也就是将代码编译成二进制形式加载到内存中的程序代码区,其中每行源程序会编译成一条或若干条二进制指令,每行指令都有一个地址,指令指针就是用来存放即将要执行的下一条指令地址.)

    第18行调用FunA函数,假设该指令地址是10086,指令指针先保存该地址,然后将该地址值+1,使其指向下一条指令,也就是第19行语句,该地址随后被放置在栈中,当FunA函数调用结束,将返回到第19行执行.

    将下一条指令的地址保存到栈中是第一步,跳转到FunA函数定义处执行是第二步(跳到第22行去执行).程序又是如何知道应该跳到第22行去执行呢?

    因为函数也有地址,该地址存在目标文件(多以.obj为扩展名)的符号表中(函数名是一个符号,该符号对应着一个标号,这个标号就是函数的地址,一般为相对地址,即函数第一条指令相对于程序代码区起始位置的偏移量),当调用某个函数时,就从符号表中提取该函数的地址,也就是该函数第1条指令地址,然后由寄存器中的指令指针来保存.接着系统将根据符号表中所秒速的函数返回值类型,在栈中开辟一块内存存储返回值,而栈顶的地址被记录下来保存在栈顶指针中.而从这时起,在函数返回之前进入栈的所有数据被视为局部变量.

    调用者会按调用约定传入形参,返回地址,上级调用者栈底(__Cdecl自又往左的顺序将形参压入栈中,栈顶指针始终要指向栈顶,因此栈顶指针不断向上移动),当所有参数都压入栈后,才开始执行函数的第一条指令.

    1.我们先分析分析Main函数的情况.(取Main函数中变量地址拖到内存窗口)

    F10单步走一次

    接下去就开始分析FunA函数的入栈情况了.F10单步,

    可以看到此时形参和返回地址已经入栈,再单步一次应该会压入Main函数栈底地址:9CFAB8,并且为局部变量申请空间(依据局部变量的总大小抬高栈顶)(备注:如果是Debug编译选项组(/ZI+/OD),将局部变量全部初始化为0XCCCCCCCC),以及保存寄存器环境.F10单步

    接下来就开始执行函数体

    函数入栈就已经完成了.

    当函数结束时,栈区中数据要进行清理,以释放内存,因此按照后进先出的原则,后进入的数据先弹出栈,每弹出一个栈,栈顶指针向下移,直到所有数据都弹出栈区.

    函数体执行完后开始出栈,首先还原栈中保存的寄存器信息,然后更新当前栈顶为栈底,并恢复上级调用者栈底,取出栈顶内容,作为返回地址.按返回地址流程回到调用方.值得注意的是,函数出栈数据该还的还,该释放的释放,但不会清零,也没有必要清零,把栈顶降到相应的地址上,如果还有函数调用,再分配再覆盖就完事了.

    总结:

    纵欲知道为什么定义变量要养成初始化的习惯,因为函数入栈出栈只是把栈顶和栈底移位操作,并未将值清空,就像腾空转体360度弹鼻屎,也不知道谁会倒霉.

    思维发散

    突然想到,函数入栈的第二步是要传入返回地址,如果构造一个地址越界覆盖到返回地址,能不能执行代码呢...

    就用上面的例子修改下吧...

    /*

    *Copyright (c)2015,

    *All rights reserved.

    *文件名称:FuncPush.cpp

    *作 者:韩逸

    *完成日期: 20161020

    *版 本 号:Debug

    *编译环境:Visual Studio 2012

    *问题描述:观察函数调用流程

    */

    #include

    #include

    int __cdecl FunA(int nFunANum);

    void fnShellCode();

    int __cdecl main(int argc,char* argv[])

    {

    int nMainNum=8;

    FunA(nMainNum);

    return 0;

    }

    int __cdecl FunA(int nFunANum)

    {

    nFunANum=16;

    char szFunAName[18]="www.51asm.com";

    *((DWORD*)(szFunAName+24))=(DWORD)fnShellCode;

    return 0;

    }

    void fnShellCode()

    {

    system("calc");

    exit(0);

    }

    编译提示失败,提示缓冲区即将溢出...

    我猜测是因为编译器加入了安全机制,将函数返回地址备份,如果发现返回地址与备份地址不一致则...

    但我只是想验证自己的想法是否正确,能否溢出覆盖返回地址然后执行fnShellCode()函数.

    那把编译器的安全机制关闭吧,具体方法如下...

    右键项目->属性->C/C++ –>代码生成 ->安全检查 ->否

    在函数出桟的时候读取返回地址却跳到了我构造的函数中,那么之前的推断成立,函数入栈的时

    候可以用局部变量越界覆盖返回地址执行自己想要的代码.(前提是要关闭安全检查,不然只能

    自娱自乐...)

    上传的附件:

    2.png

    (30.33kb,2次下载)

    3.png

    (80.20kb,10次下载)

    4.png

    (73.84kb,6次下载)

    5.png

    (75.48kb,6次下载)

    6.png

    (75.71kb,4次下载)

    7.png

    (68.95kb,1次下载)

    8.png

    (69.37kb,3次下载)

    9.png

    (41.86kb,6次下载)

    10.png

    (41.86kb,1次下载)

    11.png

    (44.84kb,2次下载)

    12.png

    (43.53kb,5次下载)

    展开全文
  • 近日聆听了在科锐钱老师上C语言时所讲的函数调用约定,于是将课后笔记整理成此处男贴.虽力求完美,但难免因本人的学识浅薄而存在不足之处,望大神们批评指正...--题记1 函数调用流程函数调用大家都不陌生,调用者向被调...
  • C语言中字符串的入栈 写在前面 对于C语言中变量入栈的顺序实际上需要具体情况具体分析,不同操作系统下的编译器可能对此有不同的解释,即使对于同一个C的编译器而言,参数设定的不同也会导致编译器调整局部变量的...
  • C语言堆栈

    2021-05-21 17:12:45
    这其中有很多知识是和操作系统和具体硬件平台相关的,如果你想弄清楚编译程序请学习编译原理,有一本书可以参考《linkers_and_loaders》。我们这里只是说明一下C语言运行的环境以及和栈的关系。让我们从汇编语言和...
  • 堆栈的实现(c语言

    2021-05-21 04:50:35
    #include #define EmptyTOS (-1) //数组堆栈需要#define MinStackSize (5) //数组堆栈需要//堆栈函数的声明struct Node;typedef struct Node *PtrToNode;typedef PtrToNode Stack;typedef int ElementType;bool ...
  • C语言堆栈的理解

    2021-04-03 22:55:26
    C语言堆栈的联系: C语言和栈:必须要先给C语言分配一个可用的栈空间,C语言才能运行,因为C语言里的临时变量都是放在栈空间里的,没有栈C语言是无法运行的。 C语言和堆:堆空间就是我们申请的内存空间,用malloc...
  • 总结 通过学习顺序表模拟栈中数据入栈和出栈的操作,初学者完成了对顺序栈的学习,这里给出顺序栈及对数据基本操作的 C 语言完整代码: #include //元素elem进栈 int push(int* a,int top,int elem){ a[++top]=elem...
  • 堆栈原理

    2020-04-07 16:55:33
    我们常常说堆栈堆栈,但是堆和栈其实是完全不同的两个概念。栈其实完全是为了函数调用而设计的,那么函数调用如何通过栈实现的呢?不同函数调用方式,栈在行为上有什么区别呢? 系统栈的工作原理: 1、内存的不同...
  • 内存分配问题(C语言\C++) C语言 栈(编译器自动分配释放) 堆(程序员分配释放、程序员不释放则程序结束使可能由OS回收,例如malloc,calloc,realloc) 全局、静态区(全局变量和静态变量的存储是放在一起的,...
  • 学习了一位博主的博客:详解堆栈的几种实现方法——C语言版 对链式堆栈有了一些见解,本文就介绍了有关链式堆栈的基础内容。 一、堆栈是什么 首先我们来简单聊聊什么是堆栈堆栈是一种数据结构。堆栈都是一种...
  • 每一个使用c语言的都应该知道栈的重要性,我们能够使用C/C++语言写出诸多复杂的程序,很大功劳一部分有归于栈的实现,因为它可以帮助我们实现函数间的嵌套调用。 汇编程序的运行是不需要栈的,所以注定它函数的嵌套...
  • 堆栈的工作原理

    万次阅读 2016-01-25 14:16:16
    每一个使用c语言的都应该知道栈的重要性,我们能够使用C/C++语言写出诸多复杂的程序,很大功劳一部分有归于栈的实现,因为它可以帮助我们实现函数间的嵌套调用。 汇编程序的运行是不需要栈的,所以注定它函数的...
  • 数据结构的栈和堆首先在数据结构上要知道堆栈,尽管我们这么称呼它,但实际上堆栈是两种数据结构:堆和栈。堆和栈都是一种数据项按序排列的数据结构。栈就像装数据的桶或箱子我们先从大家比较熟悉的栈说起吧,它是一...
  •  值传递(passl-by-value)过程中,被调函数的形式参数作为被调函数的局部变量处理,即在堆栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的...
  • 裸机写的多了自然会对rtos感兴趣,最有意思的莫过于任务切换了,可以在多个死循环里面跳转,很神奇的样子。...而PC的切换也是通过操作SP来完成,程序在进入中断程序时PC也会入栈,这样操作堆栈就间接的操作了P
  • C语言函数调用底层实现原理

    千次阅读 2021-05-26 10:58:36
    C语言程序执行实质上的函数的连续调用。 运行程序时,系统通过程序入口调用main函数,在main函数中又不断调用其它函数。 程序的每个进程都包括一个调用栈结构(Call Stack)。 调用栈的作用: 传递函数参数 保存...
  • 原理很简单,当操作者输入中每遇数字便将数字压入数栈,每遇符号便进行两次弹栈进行该符号的运算,运算结果再次压入数栈。唯一要注意的一点就是进行除法运算时需要判断除数是否为0。 头文件: /*CaptainUniverse_ ...
  • C语言可变参数概述var_list可变参数介绍简单使用可变参数可变参数原理可变参数应用:实现log打印 概述 C语言中没有函数重载,解决不定数目函数参数问题变得比较麻烦; 即使采用C++,如果参数个数不能确定,也很难采用...
  • 进一步发现,Pascal语言不支持可变长参数,而C语言支持这种特色,正是这个原因使得C语言函数参数入栈顺序为从右至左。具体原因为:C方式参数入栈顺序(从右至左)的好处就是可以动态变化参数个数。通过栈堆分析可知,...
  • 单片机原理与应用基于汇编C及混合编程章习题解答精要.doc习题一1.什么是单片机?单片机全称单片微型计算机。它是把计算机中的微处理器、只读存储器(ROM)、随机访问存储器(RAM)、I/O接口、串行接口、中断系统、定时/...
  • c语言中函数调用的原理

    千次阅读 2017-04-17 15:19:31
       ...一、 函数参数传递机制的基本理论  ... 函数参数传递机制问题在本质上是调用函数(过程)... 值传递(passl-by-value)过程中,被调函数的形式参数作为被调函数的局部变量处理,即在堆栈中开辟了内存空
  • 给出一个堆栈的输入序列,试判断一个序列是否能够由这个堆栈输出。如果能,返回总的出栈次数,如果不能,返回0。序列的输入及输出都是从左往右。(输入输出序列皆为整数且没有重复的数字,如果一个数字在输入序列中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,119
精华内容 2,047
关键字:

c语言堆栈的入栈原理