在C语言中如何访问堆栈

堆栈一般是用来保存变量之类的东西（静态变量在内存中，虽然堆栈就是内存的一部分，但为了防止歧义，还是分成两部分来说），一般情况下没必要去故意读取堆栈的值，变量用变量名就可以直接访问，但我曾经想要读取函数返回后代码继续执行的地址，因此想到了来读取堆栈（函数调用时，会向堆栈中压入参数和下一个代码执行的地址，这样就可以在函数返回后继续执行）。

先来测试一下我们能否读取堆栈（或者说数组越界访问会怎么样）：

#include<stdio.h>
int main()
{
    volatile int a=24;/*设置一个我们要读取的变量,volatile 可以告诉gcc不要优化这行代码，仅对变量有效*/
    volatile int b[2]={1,2};/*建立一个数组，这个数组是关键，这时b作为数组指针，指向第一个元素，即
1在堆栈中的储存位置，因此我们就可以利用b来读取堆栈的任意位置（该程序所拥有的堆栈）*/
    volatile int c=b[2];
    printf("%d\n",c);//打印出指定位置堆栈的值
return 0;
}

当然，如果不设定编译器的参数，这样的代码可能是不会编译通过的（注意：可能，有些编译器会检查代码是否符合规范），命令如下：

gcc -Wno-unused -m32 -S -O0 -o test.s test.c

源文件名为test.c，参数说明：

-Wno-unused：不警告未使用的变量（上面的程序不需要，但为了方便自己分析，放在这里）

-m32：编译为32位程序

-S：编译为汇编文件

-O0：优化等级为0

-o：重命名输出文件

现在让我们看看汇编文件是什么样的：

	.file	"test.c"
	.def	___main;	.scl	2;	.type	32;	.endef
	.section .rdata,"dr"
LC0:
	.ascii "%d\12\0"
	.text
	.globl	_main
	.def	_main;	.scl	2;	.type	32;	.endef
_main:
LFB10:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	pushl	%esi
	pushl	%ebx
	andl	$-16, %esp
	subl	$32, %esp
	.cfi_offset 6, -12
	.cfi_offset 3, -16
	call	___main
	movl	$24, 28(%esp)        //将24存入堆栈，位置是28+esp的值
	movl	$1, %ebx            //1存入ebx
	movl	$2, %esi            //2存入esi
	movl	%ebx, 20(%esp)        //1存入20(%esp)
	movl	%esi, 24(%esp)        //2存入24(%esp)
	movl	28(%esp), %eax        //将28(%esp)的值存入eax，这里对应的代码就是c=b[2],即将24存入了eax
	movl	%eax, 16(%esp)        //剩下的就是将参数压入堆栈，然后调用printf，这里不再解释
	movl	16(%esp), %eax
	movl	%eax, 4(%esp)
	movl	$LC0, (%esp)
	call	_printf
	movl	$0, %eax
	leal	-8(%ebp), %esp
	popl	%ebx
	.cfi_restore 3
	popl	%esi
	.cfi_restore 6
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
LFE10:
	.ident	"GCC: (MinGW.org GCC-6.3.0-1) 6.3.0"
	.def	_printf;	.scl	2;	.type	32;	.endef

通过汇编的内容，我们可以看出可以使用一个数组来访问整个有效堆栈（当前程序的整个堆栈）内的全部内容（超出堆栈界限会引发错误）。输出结果如下，很明显程序访问了并不属于b数组的内容。

当调用一个函数时（使用call指令），压入参数的同时会压下一个指令的地址，使函数返回后可以继续往下执行。现在来尝试获取这个地址，代码如下：

#include<stdio.h>
void fun()
{
	volatile int a[1];/*设置一个数组，使用这个数组来访问堆栈*/
	a[0]=14;
	printf("a[4]=%d\n",a[4]);/*打印出call指令压入的地址，这里很有意思，我之前以为这个地址在
a[2],a[0]=14，a[1]是esp的值（C语言中所有函数的开头都会有push ebp的代码，将ebp的值保存进堆栈，然后
将esp保存进ebp），但实际上发现总会有两个不知名的值占据着a[2],a[3]的位置，具体可以参见汇编代码*/
	goto *(a[4]);/*使用goto语句可以让程序跳向任何合法地址，goto不仅可以用标号或者行号，还可以是任
何void*型的变量（前提是程序可以访问该地址），goto会被程序翻译为jmp指令，而(*(void(*)
(void))0x100000)();这样的跳转方式将会被翻译为call指令，会使堆栈中多出一个地址，具体要使用哪个需要
参考实际。*/
}
int main()
{
fun();
printf("hello");/*理论上如果上面的goto生效，那么hello将会被执行两次（调用fun函数时，堆栈被压入该
地址，然后使用了goto后，跳转到这里执行一次，打印出一个hello，在下面的return 0;语句中，程序会认为当
前还在fun函数，毕竟堆栈中的地址还没有释放，因此重新返回到这里，再执行一次），否则由于地址错误，程
序将被迫退出，不会在控制台看到hello*/
return 0;
}

下面是实际执行的情况，可见我们确实得到了之前压入的那个地址：

以下是上面的那个程序的汇编程序：

	.file	"test.c"
	.section .rdata,"dr"
LC0:
	.ascii "a[4]=%d\12\0"
	.text
	.globl	_fun
	.def	_fun;	.scl	2;	.type	32;	.endef
_fun:
LFB10:
	.cfi_startproc
	pushl	%ebp            //将ebp的值送入堆栈
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	subl	$40, %esp        //空出40字节的位置用来储存变量
	movl	$14, -12(%ebp)    //14存入a[0]，所以a的值即是ebp偏移12个字节，
//可以推断出a[1]在-8(%ebp),a[2]在-4(%ebp),a[3]在0(%esp),所以a[3]是之前保存的ebp的值
//那么a[4]就是call指令保存的值，这里比较令人好奇为什么a[0]在-12(%ebp)
	movl	4(%ebp), %eax    
	movl	%eax, 4(%esp)
	movl	$LC0, (%esp)
	call	_printf
	movl	4(%ebp), %eax
	jmp	*%eax                //goto被翻译为jmp指令，然后跳向了我们指定的地址
	.cfi_endproc
LFE10:
	.def	___main;	.scl	2;	.type	32;	.endef
	.section .rdata,"dr"
LC1:
	.ascii "hello\0"
	.text
	.globl	_main
	.def	_main;	.scl	2;	.type	32;	.endef
_main:
LFB11:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	andl	$-16, %esp
	subl	$16, %esp
	call	___main
	call	_fun
	movl	$LC1, (%esp)
	call	_printf
	movl	$0, %eax
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
LFE11:
	.ident	"GCC: (MinGW.org GCC-6.3.0-1) 6.3.0"
	.def	_printf;	.scl	2;	.type	32;	.endef

所以，这里验证了我们可以通过操作一个数组来读取当前程序整个堆栈的内容。当然C语言理论上也应该是这样。