linux的堆栈

我在学习linux的堆栈的时候做的一些笔记：

1.一个程序要想运行，首先要由操作系统负责为其创建进程，并在进程的虚拟地址空间中为其代码段和数据段建立映射。光有代码段和数据段是不够的，进程在运行过程中还要有其动态环境，其中最重要的就是堆栈。图1所示为Linux下进程的地址空间布局：

      图1

2.1g为系统空间，3g为用户空间，我们编写的程序分配的一些堆栈就运行在3g里面，代码段、数据段、堆栈什么的各自的位置如图1所示了。linux有虚拟内存管理所以，可以动态分配栈，采用页面异常的形式分配。

3.在Linux平台上，一个进程的数据区分为两个便于使用的部分，即栈（stack）和堆（heap）。为了避免这两个部分冲突，栈从（准确的是接近）可用地址空间的顶端开始并向下扩展，而堆从紧靠代码段上方开始并向上扩展。虽然可以使用mmap在堆和栈之间分配内存，但是这部分空间通常是没有使用的内存的空白地带。

  栈从接近0xC0000000处开始并向下生长，代码从0x8000000处开始，而堆则如前所述扩展。

4.之后我学习了linux内核的mm_struct结构，然后看到了brk，start_stack什么的东东,系统调用brk是一个在C库函数malloc和free底层的原语操作。进程的brk值是一个位于进程堆空间和它的堆、栈中间未映射区域之间的转折点。从另一个角度看，它就是进程的最高有效堆地址。

5.关于内核空间进程堆栈的分配问题，创建一个进程的时候，在分配task_struct的时候不是分配sizeof（task_struct）而是分配的大约8k的物理空间，这就包括了系统堆栈了。以前已网友写的uclinux堆栈溢出检测的程序里面，有段代码怎么看都不明白，后来发现是底子太薄的缘故。呵呵。

6.后来我又学习了linux的堆栈溢出攻击，并通过这样一段代码来熟悉攻击的原理：
#include<stdlib.h>
void attack(){
int attack=1;
printf("hi,attacked!/n");
}
void yaya(){
 int yaya=1;
printf("hi,yaya is my wife/n");
}
void foo(){
 int ret=1;
  *(&ret +2)=(int)attack;
}
void main(){
int i=5;
i=(int)yaya;
foo();

}

声明一点的是，我没有参考任何攻击原理方面的书，我只是拿来他们的代码，gdb出他们的汇编然后自己去分析为什么会被攻击，这样记忆深刻。

我的步骤如下：

• gcc att.c -o att -g
• gdb ./ret
• list foo,as follow:

(gdb) list foo
6       }
7       void yaya(){
8       int yaya=1;
9       printf("hi,yaya is my wife/n");
10      }
11      void foo(){
12        int ret=1;
13        *(&ret +2)=(int)attack;
14      }
15      void main(){
(gdb) 
16      int i=5;
17      i=(int)yaya;
18      foo();
19
20      }(gdb)

 

• break 14
• run

(gdb) r
Starting program: /home/zswan/infect/stack/att 
Reading symbols from shared object read from target memory...done.
Loaded system supplied DSO at 0x7b0000

Breakpoint 1, foo () at ret.c:14
14      }

(gdb) print &ret
$1 = (int *) 0xbfc11678
(gdb) print (&ret+2)
$2 = (int *) 0xbfc11680
(gdb) print /x *(&ret+2)
$3 = 0x8048384=============>这里便是调用函数的返回地址
(gdb)

下面我们可以dump出来攻击程序的汇编来看看程序的地址：

(gdb) disassemble attack
Dump of assembler code for function attack

0x08048384 <attack+0>:  push   %ebp=============>返回到此函数地址
0x08048385 <attack+1>:  mov    %esp,%ebp
0x08048387 <attack+3>:  sub    $0x8,%esp
0x0804838a <attack+6>:  movl   $0x1,0xfffffffc(%ebp)
0x08048391 <attack+13>: movl   $0x80484a0,(%esp)
0x08048398 <attack+20>: call   0x80482a8
0x0804839d <attack+25>: leave  
0x0804839e <attack+26>: ret    
End of assembler dump.

当attack的函数执行完后又是什么情况呢？我们分析一下

首先dump出main和foo来：

Dump of assembler code for function main:
0x080483cf <main+0>:    push   %ebp
0x080483d0 <main+1>:    mov    %esp,%ebp
0x080483d2 <main+3>:    sub    $0x4,%esp
0x080483d5 <main+6>:    movl   $0x5,0xfffffffc(%ebp)
0x080483dc <main+13>:   movl   $0x804839f,0xfffffffc(%ebp)
0x080483e3 <main+20>:   call   0x80483b3 <foo>
0x080483e8 <main+25>:   leave  ==========================〉正常返回地址
0x080483e9 <main+26>:   ret    
End of assembler dump.

(gdb) disassemble foo
0x080483b3 <foo+0>:     push   %ebp
0x080483b4 <foo+1>:     mov    %esp,%ebp
0x080483b6 <foo+3>:     sub    $0x4,%esp
0x080483b9 <foo+6>:     movl   $0x1,0xfffffffc(%ebp)
0x080483c0 <foo+13>:    lea    0xfffffffc(%ebp),%eax
0x080483c3 <foo+16>:    add    $0x8,%eax
0x080483c6 <foo+19>:    mov    $0x8048384,%edx
0x080483cb <foo+24>:    mov    %edx,(%eax)
0x080483cd <foo+26>:    leave  
0x080483ce <foo+27>:    ret    
End of assembler dump.
(gdb) 如果程序正常执行的话，返回后应该跑到正常返回地址，但是由于前面地址改成了attack的地址了，当main调用call后，堆栈的情况从高到低应该是：/返回地址/esp/变量i/返回地址0x080483e8。当执行foo的时候堆栈情况应该是：/返回地址0x08048384/esp/局部变量ret。foo完后，一系列出栈动作，这时候要注意，由于没有返回到正常的主函数中，所以主函数的局部变量i还没有弹出来。只是在出栈的时候把地址弹出返回到attack函数，那么在attack的时候堆栈如何呢？

    为此我把print *(&ret-5)--print *(&ret+5)和print *(&attack-5)--print *(&attack+5)的值都打印了出来，进行比较发现，在原来存放0x08048384地址的堆栈里面现在存放的是esp，esp下面是局部变量attack，完全符合堆栈/返回地址/esp/局部变量/的结构，但是要注意此时的返回地址处是main函数局部变量i的存放处，所以我把yaya这个函数地址给了i，这样yaya也能执行了。

    当然我linux堆栈的知识有很多，我从网上到上图到同事都看了很多书问了很多人，因为我们现在主要用uclinux所以碰到很多堆栈的问题，经常出现莫名其妙的错误，所以我才下决心了解一下linux的堆栈问题。