多线程运行递归函数导致堆栈溢出的问题

目前linux mips 项目，中有DLNA server 在发现有U disk 插入时，创建一个新线程build mata data list，这其中会采用递归函数；而这时如果这时WMP 12 刷新媒体库，会在老线程（主线程）中进行 search / browse mata data list 的动作，这其中也采用了递归函数，为了省事啊 ，往往会造成进程crash。

因而涉及的内容：

1. pthread 线程堆栈

zt -- http://bbs.chinaunix.net/thread-1984755-1-1.html --

pthread之线程堆栈
先来讲说线程内存相关的东西，主要有下面几条：
进程中的所有的线程共享相同的地址空间。任何声明为static/extern的变量或者堆变量可以被进程内所有的线程读写。一个线程真正拥有的唯一私有储存是处理器寄存器。线程栈可以通过暴露栈地址的方式与其它线程进行共享。
     有大数据量处理的应用中，有时我们有必要在栈空间分配一个大的内存块或者要分配很多小的内存块，但是线程的栈空间的最大值在线程创建的时候就已经定下来
了，如果栈的大小超过个了个值，系统将访问未授权的内存块，毫无疑问，再来的肯定是一个段错误。可是没办法，你还是不得不分配这些内存，于是你开会为分配 一个整数值而动用malloc这种超级耗时的操作。当然，在你的需求可以评估的情况下，你的需求还是可以通过修改线程的栈空间的大小来改变的。
下面的我们用pthread_attr_getstacksize和pthread_attr_setstacksize的方法来查看和设置线程的栈空间。

用下面的命令来看linux下面的对系统的一些限制：
$ ulimit -a

stack size              (kbytes, -s) 8196

通过上面的命令， 我们可以清楚的看到一个进程在正常的情况下，最大的栈空间为8M。
那么8M我们够用吗？当你分配大量的static或者auto变量的时候，一般都是放在栈空间的。如果分配一个大于8M的数组，会发生什么呢？当然不行，因为在分配p时，栈中已经放有其它的变量，这样子的话，栈中就没有足够的空间给变量p分配，从而出现段错误。

用下面的命令改变进程栈空间：
ulimit -s 16392

改用超级权限即可成功修改，改完之后，limit -a得到的结果中应该有下面的一行就表示成功了：
stack size (kbytes, -s) 16392

2. 多线程时候的堆栈溢出
zt -- http://hi.baidu.com/hellocworld/blog/item/469210959d8e0414d31b7061.html --

2009-10-27 12:43

系统给一个线程分配的栈空间只有1M的大小，整个1M大小的堆栈几乎已经被用尽，这时如果线程需要提交更多的页面，就会调用另一个函数来提交新的页面，但是系统并不将保护属性应用于这个页面，所以就有可能会引发一个EXCEPTION_STACK_OVERFLOW异常，这个就是结构化异常导致的崩溃了

深度递归申请的空间不释放也会

-------------------------------------------------

序言：

　

通过堆栈溢出来获得root权限是目前使用的相当普遍的一项黑客技术。事实上这是一个黑客在系统

本地已经拥有了一个基本账号后的首选攻击方式。他也被广泛应用于远程攻击。通过对daemon进程

的堆栈溢出来实现远程获得rootshell的技术，已经被很多实例实现。

在windows系统中，同样存在着堆栈溢出的问题。而且，随着internet的普及，win系列平台上 的

internet服务程序越来越多，低水平的win程序就成为你系统上的致命伤。因为它们同样会被远程

堆栈溢出，而且，由于win系统使用者和管理者普遍缺乏安全防范的意识，一台win系统上的堆栈溢

出，如果被恶意利用，将导致整个机器被敌人所控制。进而，可能导致整个局域网落入敌人之手。

本系列讲座将系统的介绍堆栈溢出的机制，原理，应用，以及防范的措施。希望通过我的讲座，大

家可以了解和掌握这项技术。而且，会自己去寻找堆栈溢出漏洞，以提高系统安全。

堆栈溢出系列讲座

入门篇

本讲的预备知识：

首先你应该了解intel汇编语言，熟悉寄存器的组成和功能。你必须有堆栈和存储分配方面的基础

知识，有关这方面的计算机书籍很多，我将只是简单阐述原理，着重在应用。

其次，你应该了解linux，本讲中我们的例子将在linux上开发。

1：首先复习一下基础知识。

从物理上讲，堆栈是就是一段连续分配的内存空间。在一个程序中，会声明各种变量。静态全局变

量是位于数据段并且在程序开始运行的时候被加载。而程序的动态的局部变量则分配在堆栈里面。

从操作上来讲，堆栈是一个先入后出的队列。他的生长方向与内存的生长方向正好相反。我们规定

内存的生长方向为向上，则栈的生长方向为向下。压栈的操作push＝ESP－4，出栈的操作是

pop=ESP+4.换句话说，堆栈中老的值，其内存地址，反而比新的值要大。请牢牢记住这一点，因为

这是堆栈溢出的基本理论依据。

在一次函数调用中，堆栈中将被依次压入：参数，返回地址，EBP。如果函数有局部变量，接下

来，就在堆栈中开辟相应的空间以构造变量。函数执行结束，这些局部变量的内容将被丢失。但是

不被清除。在函数返回的时候，弹出EBP，恢复堆栈到函数调用的地址,弹出返回地址到EIP以继续

执行程序。

在C语言程序中，参数的压栈顺序是反向的。比如func（a,b,c)。在参数入栈的时候，是：先压c，

再压b,最后压a.在取参数的时候，由于栈的先入后出，先取栈顶的a，再取b,最后取c。（PS:如果

你看不懂上面这段概述，请你去看以看关于堆栈的书籍，一般的汇编语言书籍都会详细的讨论堆

栈，必须弄懂它，你才能进行下面的学习）

2:好了，继续,让我们来看一看什么是堆栈溢出。

2.1：运行时的堆栈分配

堆栈溢出就是不顾堆栈中分配的局部数据块大小，向该数据块写入了过多的数据，导致数据越界。

结果覆盖了老的堆栈数据。

比如有下面一段程序：

程序一：
#include
int main ( )
{
char name[8];
printf("Please type your name: ");
gets(name);
printf("Hello, %s!", name);
return 0;
}

编译并且执行，我们输入ipxodi,就会输出Hello,ipxodi!。程序运行中，堆栈是怎么操作的呢？

在main函数开始运行的时候，堆栈里面将被依次放入返回地址，EBP。我们用gcc -S 来获得汇编语

言输出，可以看到main函数的开头部分对应如下语句：

pushl %ebp
movl %esp,%ebp
subl $8,%esp

首先他把EBP保存下来，，然后EBP等于现在的ESP，这样EBP就可以用来访问本函数的局部变量。之

后ESP减8，就是堆栈向上增长8个字节，用来存放name[]数组。现在堆栈的布局如下：

内存底部 内存顶部
name EBP ret
<------ [ ][ ][ ]
^&name
堆栈顶部 堆栈底部

执行完gets(name)之后，堆栈如下：

内存底部 内存顶部
name EBP ret
<------ [ipxodi\0 ][ ][ ]
^&name
堆栈顶部 堆栈底部

最后，main返回，弹出ret里的地址，赋值给EIP，CPU继续执行EIP所指向的指令。

2.2：堆栈溢出

好，看起来一切顺利。我们再执行一次，输入ipxodiAAAAAAAAAAAAAAA,执行完gets（name）之后，堆栈如下：

内存底部 内存顶部
name EBP ret
<------ [ipxodiAA][AAAA][AAAA].......
^&name
堆栈顶部 堆栈底部

由于我们输入的name字符串太长，name数组容纳不下，只好向内存顶部继续写‘A’。由于堆栈的

生长方向与内存的生长方向相反，这些‘A’覆盖了堆栈的老的元素。如图我们可以发现，EBP，

ret都已经被‘A’覆盖了。在main返回的时候，就会把‘AAAA’的ASCII码：0x41414141作为返回

地址，CPU会试图执行0x41414141处的指令，结果出现错误。这就是一次堆栈溢出。

3：如何利用堆栈溢出

我们已经制造了一次堆栈溢出。其原理可以概括为：由于字符串处理函数（gets，strcpy等等）没

有对数组越界加以监视和限制，我们利用字符数组写越界，覆盖堆栈中的老元素的值，就可以修改

返回地址。

在上面的例子中，这导致CPU去访问一个不存在的指令，结果出错。事实上，当堆栈溢出的时候，

我们已经完全的控制了这个程序下一步的动作。如果我们用一个实际存在指令地址来覆盖这个返回

地址，CPU就会转而执行我们的指令。在UINX系统中，我们的指令可以执行一个shell，这个shell

将获得和被我们堆栈溢出的程序相同的权限。如果这个程序是setuid的，那么我们就可以获得root

shell。

3. 递归堆栈溢出

zt -- http://blog.sina.com.cn/s/blog_4b288f230100065o.html --

(2006-10-28 11:26:15)

    
1.
int stack_test(int n)
{
 int x[10000];
 if(n == 1)
  return 1;
 return stack_test(n-1);
}
 
int _tmain(int argc, _TCHAR* argv[])
{
 
 printf("%d\n", stack_test(50));
 getchar();
 return 0;
}
 
上面的程序stack_test()为递归函数，里面声明了一个很大的局部变量。

当调用stack_test(50)时，不会产生堆栈溢出。如果调用stack_test(100)时，则会产生。
 
2.
int stack_test(int n)
{
 
 if(n == 1)
  return 1;
 return stack_test(n-1);
}
int _tmain(int argc, _TCHAR* argv[])
{
 
 printf("%d\n", stack_test(100000));
 getchar();
 return 0;
}
 
stack_test()函数中没有声明很大的局部变量，但是递归次数太多，也会产生堆栈溢出。

3.如何控制堆栈的大小？如果递归次数太大，如何避免产生堆栈溢出？
 
引起堆栈溢出的原因是, 分配了太多的函数指针，变量指针和参数，以致在堆栈里申请的内存数量不够用。

到目前为止，堆栈溢出最平常的原因是无终止的递归。
 
用户可以编写自己的代码以检测和防止堆栈溢出。例如，如果您的应用程序依赖于递归，则可以使用计数器或状态条件来终止递归循环。